/**
* The client this request is related to.
*/
- struct GNUNET_SERVER_Client *client;
+ struct GNUNET_SERVICE_Client *client;
/**
* The message queue for the client.
if (GNUNET_YES == s->in_destroy)
return;
s->in_destroy = GNUNET_YES;
- if (NULL != s->client_mq)
- {
- GNUNET_MQ_destroy (s->client_mq);
- s->client_mq = NULL;
- }
if (NULL != s->cadet_mq)
{
GNUNET_MQ_destroy (s->cadet_mq);
}
if (NULL != s->client)
{
- GNUNET_SERVER_client_set_user_context (s->client,
- NULL);
- GNUNET_SERVER_client_disconnect (s->client);
+ struct GNUNET_SERVICE_Client *c = s->client;
+
s->client = NULL;
+ GNUNET_SERVICE_client_drop (c);
}
if (NULL != s->channel)
{
/**
- * We're receiving additional set data. Add it to our
- * set and if we are done, initiate the transaction.
+ * We're receiving additional set data. Check if
+ * @a msg is well-formed.
*
- * @param cls closure
- * @param client identification of the client
- * @param message the actual message
+ * @param cls client identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
*/
-static void
-GSS_handle_alice_client_message_multipart (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+static int
+check_alice_client_message_multipart (void *cls,
+ const struct ComputationBobCryptodataMultipartMessage *msg)
{
- const struct ComputationBobCryptodataMultipartMessage * msg;
- struct AliceServiceSession *s;
+ struct AliceServiceSession *s = cls;
uint32_t contained_count;
- const struct GNUNET_SCALARPRODUCT_Element *elements;
- uint32_t i;
uint16_t msize;
- struct GNUNET_SET_Element set_elem;
- struct GNUNET_SCALARPRODUCT_Element *elem;
- s = GNUNET_SERVER_client_get_user_context (client,
- struct AliceServiceSession);
- if (NULL == s)
- {
- /* session needs to already exist */
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
- msize = ntohs (message->size);
- if (msize < sizeof (struct ComputationBobCryptodataMultipartMessage))
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
- msg = (const struct ComputationBobCryptodataMultipartMessage *) message;
+ msize = ntohs (msg->header.size);
contained_count = ntohl (msg->element_count_contained);
-
if ( (msize != (sizeof (struct ComputationBobCryptodataMultipartMessage) +
contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) ||
(0 == contained_count) ||
(s->total < s->client_received_element_count + contained_count) )
{
GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
+ return GNUNET_SYSERR;
}
+ return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls client identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message_multipart (void *cls,
+ const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+ struct AliceServiceSession *s = cls;
+ uint32_t contained_count;
+ const struct GNUNET_SCALARPRODUCT_Element *elements;
+ struct GNUNET_SET_Element set_elem;
+ struct GNUNET_SCALARPRODUCT_Element *elem;
+
+ contained_count = ntohl (msg->element_count_contained);
s->client_received_element_count += contained_count;
elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
- for (i = 0; i < contained_count; i++)
+ for (uint32_t i = 0; i < contained_count; i++)
{
elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
GNUNET_memcpy (elem,
- &elements[i],
- sizeof (struct GNUNET_SCALARPRODUCT_Element));
+ &elements[i],
+ sizeof (struct GNUNET_SCALARPRODUCT_Element));
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
&elem->key,
NULL, NULL);
s->used_element_count++;
}
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* more to come */
/**
* Handler for Alice's client request message.
- * We are doing request-initiation to compute a scalar product with a peer.
+ * Check that @a msg is well-formed.
*
- * @param cls closure
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
*/
-static void
-GSS_handle_alice_client_message (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+static int
+check_alice_client_message (void *cls,
+ const struct AliceComputationMessage *msg)
{
- const struct AliceComputationMessage *msg;
- struct AliceServiceSession *s;
- uint32_t contained_count;
- uint32_t total_count;
- const struct GNUNET_SCALARPRODUCT_Element *elements;
- uint32_t i;
+ struct AliceServiceSession *s = cls;
uint16_t msize;
- struct GNUNET_SET_Element set_elem;
- struct GNUNET_SCALARPRODUCT_Element *elem;
+ uint32_t total_count;
+ uint32_t contained_count;
- s = GNUNET_SERVER_client_get_user_context (client,
- struct AliceServiceSession);
- if (NULL != s)
+ if (NULL != s->intersected_elements)
{
/* only one concurrent session per client connection allowed,
simplifies logic a lot... */
GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
- }
- msize = ntohs (message->size);
- if (msize < sizeof (struct AliceComputationMessage))
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
+ return GNUNET_SYSERR;
}
- msg = (const struct AliceComputationMessage *) message;
+ msize = ntohs (msg->header.size);
total_count = ntohl (msg->element_count_total);
contained_count = ntohl (msg->element_count_contained);
if ( (0 == total_count) ||
contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) )
{
GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
+ return GNUNET_SYSERR;
}
+ return GNUNET_OK;
+}
- s = GNUNET_new (struct AliceServiceSession);
+
+/**
+ * Handler for Alice's client request message.
+ * We are doing request-initiation to compute a scalar product with a peer.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message (void *cls,
+ const struct AliceComputationMessage *msg)
+{
+ struct AliceServiceSession *s = cls;
+ uint32_t contained_count;
+ uint32_t total_count;
+ const struct GNUNET_SCALARPRODUCT_Element *elements;
+ struct GNUNET_SET_Element set_elem;
+ struct GNUNET_SCALARPRODUCT_Element *elem;
+
+ total_count = ntohl (msg->element_count_total);
+ contained_count = ntohl (msg->element_count_contained);
s->peer = msg->peer;
s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
- s->client = client;
- s->client_mq = GNUNET_MQ_queue_for_server_client (client);
s->total = total_count;
s->client_received_element_count = contained_count;
s->session_id = msg->session_key;
GNUNET_YES);
s->intersection_set = GNUNET_SET_create (cfg,
GNUNET_SET_OPERATION_INTERSECTION);
- for (i = 0; i < contained_count; i++)
+
+ for (uint32_t i = 0; i < contained_count; i++)
{
if (0 == GNUNET_ntohll (elements[i].value))
continue;
NULL, NULL);
s->used_element_count++;
}
- GNUNET_SERVER_client_set_user_context (client,
- s);
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* wait for multipart msg */
}
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct AliceServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
+{
+ struct AliceServiceSession *s;
+
+ s = GNUNET_new (struct AliceServiceSession);
+ s->client = client;
+ s->client_mq = mq;
+ return s;
+}
+
+
/**
* A client disconnected.
*
*
* @param cls closure, NULL
* @param client identification of the client
+ * @param app_cls our `struct AliceServiceSession`
*/
static void
-handle_client_disconnect (void *cls,
- struct GNUNET_SERVER_Client *client)
+client_disconnect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ void *app_cls)
{
- struct AliceServiceSession *s;
+ struct AliceServiceSession *s = app_cls;
- if (NULL == client)
- return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client %p disconnected from us.\n",
client);
- s = GNUNET_SERVER_client_get_user_context (client,
- struct AliceServiceSession);
- if (NULL == s)
- return;
s->client = NULL;
- GNUNET_SERVER_client_set_user_context (client,
- NULL);
+ s->client_mq = NULL;
destroy_service_session (s);
}
* Initialization of the program and message handlers
*
* @param cls closure
- * @param server the initialized server
* @param c configuration to use
+ * @param service the initialized service
*/
static void
run (void *cls,
- struct GNUNET_SERVER_Handle *server,
- const struct GNUNET_CONFIGURATION_Handle *c)
+ const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_SERVICE_Handle *service)
{
static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
{ &handle_bobs_cryptodata_message,
0},
{ NULL, 0, 0}
};
- static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
- { &GSS_handle_alice_client_message, NULL,
- GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE,
- 0},
- { &GSS_handle_alice_client_message_multipart, NULL,
- GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE,
- 0},
- { NULL, NULL, 0, 0}
- };
cfg = c;
/*
GNUNET_CRYPTO_paillier_create (&my_pubkey,
&my_privkey);
- GNUNET_SERVER_add_handlers (server,
- server_handlers);
- GNUNET_SERVER_disconnect_notify (server,
- &handle_client_disconnect,
- NULL);
- my_cadet = GNUNET_CADET_connect (cfg, NULL,
+ my_cadet = GNUNET_CADET_connect (cfg,
+ NULL,
&cb_channel_destruction,
cadet_handlers);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+ NULL);
if (NULL == my_cadet)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
GNUNET_SCHEDULER_shutdown ();
return;
}
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
-
}
/**
- * The main function for the scalarproduct service.
- *
- * @param argc number of arguments from the command line
- * @param argv command line arguments
- * @return 0 ok, 1 on error
+ * Define "main" method using service macro.
*/
-int
-main (int argc,
- char *const *argv)
-{
- return (GNUNET_OK ==
- GNUNET_SERVICE_run (argc, argv,
- "scalarproduct-alice",
- GNUNET_SERVICE_OPTION_NONE,
- &run, NULL)) ? 0 : 1;
-}
+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 ());
+
/* end of gnunet-service-scalarproduct_alice.c */
/**
* The client this request is related to.
*/
- struct GNUNET_SERVER_Client *client;
+ struct GNUNET_SERVICE_Client *client;
/**
* Client message queue.
s->cadet = NULL;
destroy_cadet_session (in);
}
- if (NULL != s->client_mq)
- {
- GNUNET_MQ_destroy (s->client_mq);
- s->client_mq = NULL;
- }
if (NULL != s->client)
{
- GNUNET_SERVER_client_disconnect (s->client);
+ struct GNUNET_SERVICE_Client *c = s->client;
+
s->client = NULL;
+ GNUNET_SERVICE_client_drop (c);
}
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (client_sessions,
payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
GNUNET_memcpy (&payload[0],
- &s->s,
- sizeof (struct GNUNET_CRYPTO_PaillierCiphertext));
+ &s->s,
+ sizeof (struct GNUNET_CRYPTO_PaillierCiphertext));
GNUNET_memcpy (&payload[1],
- &s->s_prime,
- sizeof (struct GNUNET_CRYPTO_PaillierCiphertext));
+ &s->s_prime,
+ sizeof (struct GNUNET_CRYPTO_PaillierCiphertext));
payload = &payload[2];
// convert k[][]
s->e_a = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) *
max);
GNUNET_memcpy (&s->e_a[s->cadet_received_element_count],
- payload,
- sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * contained_elements);
+ payload,
+ sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * contained_elements);
s->cadet_received_element_count += contained_elements;
if ( (s->cadet_received_element_count == max) &&
}
+
/**
- * We're receiving additional set data. Add it to our
- * set and if we are done, initiate the transaction.
+ * We're receiving additional set data. Check it is well-formed.
*
- * @param cls closure
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
*/
-static void
-GSS_handle_bob_client_message_multipart (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+static int
+check_bob_client_message_multipart (void *cls,
+ const struct ComputationBobCryptodataMultipartMessage *msg)
{
- const struct ComputationBobCryptodataMultipartMessage * msg;
- struct BobServiceSession *s;
+ struct BobServiceSession *s = cls;
uint32_t contained_count;
- const struct GNUNET_SCALARPRODUCT_Element *elements;
- uint32_t i;
uint16_t msize;
- struct GNUNET_SET_Element set_elem;
- struct GNUNET_SCALARPRODUCT_Element *elem;
- s = GNUNET_SERVER_client_get_user_context (client,
- struct BobServiceSession);
- if (NULL == s)
- {
- /* session needs to already exist */
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
- msize = ntohs (message->size);
- if (msize < sizeof (struct ComputationBobCryptodataMultipartMessage))
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
- msg = (const struct ComputationBobCryptodataMultipartMessage *) message;
+ msize = ntohs (msg->header.size);
contained_count = ntohl (msg->element_count_contained);
-
if ( (msize != (sizeof (struct ComputationBobCryptodataMultipartMessage) +
contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) ||
(0 == contained_count) ||
(s->total == s->client_received_element_count) ||
(s->total < s->client_received_element_count + contained_count) )
{
- GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
}
+ return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message_multipart (void *cls,
+ const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+ struct BobServiceSession *s = cls;
+ uint32_t contained_count;
+ const struct GNUNET_SCALARPRODUCT_Element *elements;
+ struct GNUNET_SET_Element set_elem;
+ struct GNUNET_SCALARPRODUCT_Element *elem;
+
+ contained_count = ntohl (msg->element_count_contained);
elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
- for (i = 0; i < contained_count; i++)
+ for (uint32_t i = 0; i < contained_count; i++)
{
elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
GNUNET_memcpy (elem,
- &elements[i],
- sizeof (struct GNUNET_SCALARPRODUCT_Element));
+ &elements[i],
+ sizeof (struct GNUNET_SCALARPRODUCT_Element));
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
&elem->key,
NULL, NULL);
}
s->client_received_element_count += contained_count;
- GNUNET_SERVER_receive_done (client,
- GNUNET_OK);
+ GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* more to come */
/**
- * 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.
+ * Handler for Bob's a client request message. Check @a msg is
+ * well-formed.
*
- * @param cls closure
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
*/
-static void
-GSS_handle_bob_client_message (void *cls,
- struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+static int
+check_bob_client_message (void *cls,
+ const struct BobComputationMessage *msg)
{
- const struct BobComputationMessage *msg;
- struct BobServiceSession *s;
- struct CadetIncomingSession *in;
+ struct BobServiceSession *s = cls;
uint32_t contained_count;
uint32_t total_count;
- const struct GNUNET_SCALARPRODUCT_Element *elements;
- uint32_t i;
- struct GNUNET_SET_Element set_elem;
- struct GNUNET_SCALARPRODUCT_Element *elem;
uint16_t msize;
- s = GNUNET_SERVER_client_get_user_context (client,
- struct BobServiceSession);
- if (NULL != s)
+ if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
{
- /* only one concurrent session per client connection allowed,
- simplifies logic a lot... */
GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
- }
- msize = ntohs (message->size);
- if (msize < sizeof (struct BobComputationMessage))
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
+ return GNUNET_SYSERR;
}
- msg = (const struct BobComputationMessage *) message;
+ msize = ntohs (msg->header.size);
total_count = ntohl (msg->element_count_total);
contained_count = ntohl (msg->element_count_contained);
if ( (0 == total_count) ||
contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) )
{
GNUNET_break_op (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- return;
+ return GNUNET_SYSERR;
}
+ if (NULL != find_matching_client_session (&msg->session_key))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ * 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.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message (void *cls,
+ const struct BobComputationMessage *msg)
+{
+ struct BobServiceSession *s = cls;
+ struct CadetIncomingSession *in;
+ uint32_t contained_count;
+ uint32_t total_count;
+ const struct GNUNET_SCALARPRODUCT_Element *elements;
+ struct GNUNET_SET_Element set_elem;
+ struct GNUNET_SCALARPRODUCT_Element *elem;
+
+ total_count = ntohl (msg->element_count_total);
+ contained_count = ntohl (msg->element_count_contained);
- s = GNUNET_new (struct BobServiceSession);
s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
- s->client = client;
- s->client_mq = GNUNET_MQ_queue_for_server_client (client);
s->total = total_count;
s->client_received_element_count = contained_count;
s->session_id = msg->session_key;
if (NULL == s->port)
{
GNUNET_break (0);
- GNUNET_SERVER_receive_done (client,
- GNUNET_SYSERR);
- GNUNET_free (s);
+ GNUNET_SERVICE_client_drop (s->client);
return;
}
-
GNUNET_break (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_put (client_sessions,
&s->session_id,
s,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
- s->intersected_elements = GNUNET_CONTAINER_multihashmap_create (s->total,
- GNUNET_YES);
- s->intersection_set = GNUNET_SET_create (cfg,
- GNUNET_SET_OPERATION_INTERSECTION);
- for (i = 0; i < contained_count; i++)
+ s->intersected_elements
+ = GNUNET_CONTAINER_multihashmap_create (s->total,
+ GNUNET_YES);
+ s->intersection_set
+ = GNUNET_SET_create (cfg,
+ GNUNET_SET_OPERATION_INTERSECTION);
+ for (uint32_t i = 0; i < contained_count; i++)
{
if (0 == GNUNET_ntohll (elements[i].value))
continue;
NULL, NULL);
s->used_element_count++;
}
- GNUNET_SERVER_client_set_user_context (client,
- s);
- GNUNET_SERVER_receive_done (client,
- GNUNET_YES);
+ GNUNET_SERVICE_client_continue (s->client);
if (s->total != s->client_received_element_count)
{
/* multipart msg */
}
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct BobServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
+{
+ struct BobServiceSession *s;
+
+ s = GNUNET_new (struct BobServiceSession);
+ s->client = client;
+ s->client_mq = mq;
+ return s;
+}
+
+
/**
* A client disconnected.
*
*
* @param cls closure, NULL
* @param client identification of the client
+ * @param app_cls our `struct BobServiceSession`
*/
static void
-handle_client_disconnect (void *cls,
- struct GNUNET_SERVER_Client *client)
+client_disconnect_cb (void *cls,
+ struct GNUNET_SERVICE_Client *client,
+ void *app_cls)
{
- struct BobServiceSession *s;
+ struct BobServiceSession *s = app_cls;
- if (NULL == client)
- return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client disconnected from us.\n");
- s = GNUNET_SERVER_client_get_user_context (client,
- struct BobServiceSession);
- if (NULL == s)
- return;
s->client = NULL;
destroy_service_session (s);
}
* Initialization of the program and message handlers
*
* @param cls closure
- * @param server the initialized server
* @param c configuration to use
+ * @param service the initialized service
*/
static void
run (void *cls,
- struct GNUNET_SERVER_Handle *server,
- const struct GNUNET_CONFIGURATION_Handle *c)
+ const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_SERVICE_Handle *service)
{
- static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
- { &GSS_handle_bob_client_message, NULL,
- GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB,
- 0},
- { &GSS_handle_bob_client_message_multipart, NULL,
- GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB,
- 0},
- { NULL, NULL, 0, 0}
- };
static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
{ &handle_alices_computation_request,
GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION,
GNUNET_CRYPTO_paillier_create (&my_pubkey,
&my_privkey);
- GNUNET_SERVER_add_handlers (server,
- server_handlers);
- GNUNET_SERVER_disconnect_notify (server,
- &handle_client_disconnect,
- NULL);
client_sessions = GNUNET_CONTAINER_multihashmap_create (128,
GNUNET_YES);
cadet_sessions = GNUNET_CONTAINER_multihashmap_create (128,
my_cadet = GNUNET_CADET_connect (cfg, NULL,
&cb_channel_destruction,
cadet_handlers);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+ NULL);
if (NULL == my_cadet)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
GNUNET_SCHEDULER_shutdown ();
return;
}
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
}
/**
- * The main function for the scalarproduct service.
- *
- * @param argc number of arguments from the command line
- * @param argv command line arguments
- * @return 0 ok, 1 on error
+ * Define "main" method using service macro.
*/
-int
-main (int argc,
- char *const *argv)
-{
- return (GNUNET_OK ==
- GNUNET_SERVICE_run (argc, argv,
- "scalarproduct-bob",
- GNUNET_SERVICE_OPTION_NONE,
- &run, NULL)) ? 0 : 1;
-}
+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 ());
+
/* end of gnunet-service-scalarproduct_bob.c */
projects / oweals / gnunet.git / commitdiff