From 31cc9c3182ef5ac01edcdd4c4e4dc9c312fc8c9c Mon Sep 17 00:00:00 2001 From: Christian Fuchs Date: Tue, 8 Oct 2013 08:32:47 +0000 Subject: work on multipart request receiving --- src/scalarproduct/gnunet-service-scalarproduct.c | 687 ++++++++++------------- 1 file changed, 287 insertions(+), 400 deletions(-) (limited to 'src') diff --git a/src/scalarproduct/gnunet-service-scalarproduct.c b/src/scalarproduct/gnunet-service-scalarproduct.c index bdec7ebd8..518ff5f3d 100644 --- a/src/scalarproduct/gnunet-service-scalarproduct.c +++ b/src/scalarproduct/gnunet-service-scalarproduct.c @@ -44,15 +44,15 @@ */ enum SessionState { - CLIENT_REQUEST_RECEIVED, - WAITING_FOR_BOBS_CONNECT, - CLIENT_RESPONSE_RECEIVED, - WAITING_FOR_SERVICE_REQUEST, - WAITING_FOR_MULTIPART_TRANSMISSION, - WAITING_FOR_SERVICE_RESPONSE, - SERVICE_REQUEST_RECEIVED, - SERVICE_RESPONSE_RECEIVED, - FINALIZED + CLIENT_REQUEST_RECEIVED, + WAITING_FOR_BOBS_CONNECT, + CLIENT_RESPONSE_RECEIVED, + WAITING_FOR_SERVICE_REQUEST, + WAITING_FOR_MULTIPART_TRANSMISSION, + WAITING_FOR_SERVICE_RESPONSE, + SERVICE_REQUEST_RECEIVED, + SERVICE_RESPONSE_RECEIVED, + FINALIZED }; /** @@ -60,8 +60,8 @@ enum SessionState */ enum PeerRole { - ALICE, - BOB + ALICE, + BOB }; /** @@ -73,130 +73,130 @@ enum PeerRole */ struct ServiceSession { - /** - * the role this peer has - */ - enum PeerRole role; - - /** - * session information is kept in a DLL - */ - struct ServiceSession *next; - - /** - * session information is kept in a DLL - */ - struct ServiceSession *prev; - - /** - * (hopefully) unique transaction ID - */ - struct GNUNET_HashCode key; - - /** - * state of the session - */ - enum SessionState state; - - /** - * Alice or Bob's peerID - */ - struct GNUNET_PeerIdentity peer; - - /** - * the client this request is related to - */ - struct GNUNET_SERVER_Client * client; - - /** - * The message to send - */ - struct GNUNET_MessageHeader * msg; - - /** - * how many elements we were supplied with from the client - */ - uint32_t element_count; - - /** - * how many elements actually are used after applying the mask - */ - uint32_t used_element_count; - - /** - * already transferred elements (sent/received) for multipart messages, less or equal than used_element_count for - */ - uint32_t transferred_element_count; - - /** - * index of the last transferred element for multipart messages - */ - uint32_t last_processed_element; - - /** - * how many bytes the mask is long. - * just for convenience so we don't have to re-re-re calculate it each time - */ - uint32_t mask_length; - - /** - * all the vector elements we received - */ - int32_t * vector; - - /** - * mask of which elements to check - */ - unsigned char * mask; - - /** - * Public key of the remote service, only used by bob - */ - gcry_sexp_t remote_pubkey; - - /** - * E(ai)(Bob) or ai(Alice) after applying the mask - */ - gcry_mpi_t * a; - - /** - * Bob's permutation p of R - */ - gcry_mpi_t * r; - - /** - * Bob's permutation q of R - */ - gcry_mpi_t * r_prime; - - /** - * Bobs matching response session from the client - */ - struct ServiceSession * response; - - /** - * The computed scalar - */ - gcry_mpi_t product; - - /** - * My transmit handle for the current message to a alice/bob - */ - struct GNUNET_MESH_TransmitHandle * service_transmit_handle; - - /** - * My transmit handle for the current message to the client - */ - struct GNUNET_SERVER_TransmitHandle * client_transmit_handle; - - /** - * tunnel-handle associated with our mesh handle - */ - struct GNUNET_MESH_Tunnel * tunnel; - - GNUNET_SCHEDULER_TaskIdentifier client_notification_task; - - GNUNET_SCHEDULER_TaskIdentifier service_request_task; + /** + * the role this peer has + */ + enum PeerRole role; + + /** + * session information is kept in a DLL + */ + struct ServiceSession *next; + + /** + * session information is kept in a DLL + */ + struct ServiceSession *prev; + + /** + * (hopefully) unique transaction ID + */ + struct GNUNET_HashCode key; + + /** + * state of the session + */ + enum SessionState state; + + /** + * Alice or Bob's peerID + */ + struct GNUNET_PeerIdentity peer; + + /** + * the client this request is related to + */ + struct GNUNET_SERVER_Client * client; + + /** + * The message to send + */ + struct GNUNET_MessageHeader * msg; + + /** + * how many elements we were supplied with from the client + */ + uint32_t element_count; + + /** + * how many elements actually are used after applying the mask + */ + uint32_t used_element_count; + + /** + * already transferred elements (sent/received) for multipart messages, less or equal than used_element_count for + */ + uint32_t transferred_element_count; + + /** + * index of the last transferred element for multipart messages + */ + uint32_t last_processed_element; + + /** + * how many bytes the mask is long. + * just for convenience so we don't have to re-re-re calculate it each time + */ + uint32_t mask_length; + + /** + * all the vector elements we received + */ + int32_t * vector; + + /** + * mask of which elements to check + */ + unsigned char * mask; + + /** + * Public key of the remote service, only used by bob + */ + gcry_sexp_t remote_pubkey; + + /** + * E(ai)(Bob) or ai(Alice) after applying the mask + */ + gcry_mpi_t * a; + + /** + * Bob's permutation p of R + */ + gcry_mpi_t * r; + + /** + * Bob's permutation q of R + */ + gcry_mpi_t * r_prime; + + /** + * Bobs matching response session from the client + */ + struct ServiceSession * response; + + /** + * The computed scalar + */ + gcry_mpi_t product; + + /** + * My transmit handle for the current message to a alice/bob + */ + struct GNUNET_MESH_TransmitHandle * service_transmit_handle; + + /** + * My transmit handle for the current message to the client + */ + struct GNUNET_SERVER_TransmitHandle * client_transmit_handle; + + /** + * tunnel-handle associated with our mesh handle + */ + struct GNUNET_MESH_Tunnel * tunnel; + + GNUNET_SCHEDULER_TaskIdentifier client_notification_task; + + GNUNET_SCHEDULER_TaskIdentifier service_request_task; }; /////////////////////////////////////////////////////////////////////////////// @@ -290,7 +290,6 @@ static int do_shutdown; // Helper Functions /////////////////////////////////////////////////////////////////////////////// - /** * Generates an Paillier private/public keyset and extracts the values using libgrcypt only */ @@ -349,11 +348,9 @@ generate_keyset () // generate a g gcry_mpi_mul (my_nsquare, my_n, my_n); - do - { + do { // find a matching g - do - { + do { gcry_mpi_randomize (my_g, KEYBITS * 2, GCRY_WEAK_RANDOM); // g must be smaller than n^2 if (0 >= gcry_mpi_cmp (my_g, my_nsquare)) @@ -407,7 +404,6 @@ generate_keyset () GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Generated key set with key length %d bits.\n"), KEYBITS); } - /** * If target != size, move target bytes to the * end of the size-sized buffer and zero out the @@ -420,14 +416,12 @@ generate_keyset () static void adjust (unsigned char *buf, size_t size, size_t target) { - if (size < target) - { + if (size < target) { memmove (&buf[target - size], buf, size); memset (buf, 0, target - size); } } - /** * encrypts an element using the paillier crypto system * @@ -444,8 +438,7 @@ encrypt_element (gcry_mpi_t c, gcry_mpi_t m, gcry_mpi_t g, gcry_mpi_t n, gcry_mp GNUNET_assert (tmp = gcry_mpi_new (0)); - while (0 >= gcry_mpi_cmp_ui (tmp, 1)) - { + while (0 >= gcry_mpi_cmp_ui (tmp, 1)) { gcry_mpi_randomize (tmp, KEYBITS / 3, GCRY_WEAK_RANDOM); // r must be 1 < r < n } @@ -457,7 +450,6 @@ encrypt_element (gcry_mpi_t c, gcry_mpi_t m, gcry_mpi_t g, gcry_mpi_t n, gcry_mp gcry_mpi_release (tmp); } - /** * decrypts an element using the paillier crypto system * @@ -477,7 +469,6 @@ decrypt_element (gcry_mpi_t m, gcry_mpi_t c, gcry_mpi_t mu, gcry_mpi_t lambda, g gcry_mpi_mulm (m, m, mu, n); } - /** * computes the square sum over a vector of a given length. * @@ -496,8 +487,7 @@ compute_square_sum (gcry_mpi_t * vector, uint32_t length) GNUNET_assert (elem = gcry_mpi_new (0)); // calculare E(sum (ai ^ 2), publickey) - for (i = 0; i < length; i++) - { + for (i = 0; i < length; i++) { gcry_mpi_mul (elem, vector[i], vector[i]); gcry_mpi_add (sum, sum, elem); } @@ -509,10 +499,10 @@ compute_square_sum (gcry_mpi_t * vector, uint32_t length) static void prepare_service_request_multipart (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc); + const struct GNUNET_SCHEDULER_TaskContext *tc); static void prepare_service_response_multipart (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc); + const struct GNUNET_SCHEDULER_TaskContext *tc); /** * Primitive callback for copying over a message, as they @@ -532,8 +522,7 @@ do_send_message (void *cls, size_t size, void *buf) GNUNET_assert (buf); - if (ntohs (session->msg->size) == size) - { + if (ntohs (session->msg->size) == size) { memcpy (buf, session->msg, size); written = size; } @@ -550,7 +539,7 @@ do_send_message (void *cls, size_t size, void *buf) session->service_transmit_handle = NULL; // reset flags for sending if ((session->state != WAITING_FOR_MULTIPART_TRANSMISSION) && (session->used_element_count != session->transferred_element_count)) - prepare_service_request_multipart(session, NULL); + prepare_service_request_multipart (session, NULL); //TODO we have sent a message and now need to trigger trigger the next multipart message sending break; case GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_TO_ALICE: @@ -558,7 +547,7 @@ do_send_message (void *cls, size_t size, void *buf) //else session->service_transmit_handle = NULL; if ((session->state != WAITING_FOR_MULTIPART_TRANSMISSION) && (session->used_element_count != session->transferred_element_count)) - prepare_service_response_multipart(session, NULL); + prepare_service_response_multipart (session, NULL); break; default: session->service_transmit_handle = NULL; @@ -573,7 +562,6 @@ do_send_message (void *cls, size_t size, void *buf) return written; } - /** * initializes a new vector with fresh MPI values (=0) of a given length * @@ -591,7 +579,6 @@ initialize_mpi_vector (uint32_t length) return output; } - /** * permutes an MPI vector according to the given permutation vector * @@ -620,7 +607,6 @@ permute_vector (gcry_mpi_t * vector, return vector; } - /** * Populate a vector with random integer values and convert them to * @@ -635,8 +621,7 @@ generate_random_vector (uint32_t length) uint32_t i; random_vector = initialize_mpi_vector (length); - for (i = 0; i < length; i++) - { + for (i = 0; i < length; i++) { value = (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX); // long to gcry_mpi_t @@ -651,7 +636,6 @@ generate_random_vector (uint32_t length) return random_vector; } - /** * Finds a not terminated client/service session in the * given DLL based on session key, element count and state. @@ -670,15 +654,12 @@ find_matching_session (struct ServiceSession * tail, { struct ServiceSession * curr; - for (curr = tail; NULL != curr; curr = curr->prev) - { + for (curr = tail; NULL != curr; curr = curr->prev) { // if the key matches, and the element_count is same if ((!memcmp (&curr->key, key, sizeof (struct GNUNET_HashCode))) - && (curr->element_count == element_count)) - { + && (curr->element_count == element_count)) { // if incoming state is NULL OR is same as state of the queued request - if ((NULL == state) || (curr->state == *state)) - { + if ((NULL == state) || (curr->state == *state)) { // if peerid is NULL OR same as the peer Id in the queued request if ((NULL == peerid) || (!memcmp (&curr->peer, peerid, sizeof (struct GNUNET_PeerIdentity)))) @@ -691,14 +672,12 @@ find_matching_session (struct ServiceSession * tail, return NULL; } - static void free_session (struct ServiceSession * session) { unsigned int i; - if (session->a) - { + if (session->a) { for (i = 0; i < session->used_element_count; i++) gcry_mpi_release (session->a[i]); @@ -717,7 +696,6 @@ free_session (struct ServiceSession * session) // Event and Message Handlers /////////////////////////////////////////////////////////////////////////////// - /** * A client disconnected. * @@ -743,33 +721,28 @@ handle_client_disconnect (void *cls, _ ("Client (%p) disconnected from us.\n"), client); GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, session); - if (!(session->role == BOB && session->state == FINALIZED)) - { + if (!(session->role == BOB && session->state == FINALIZED)) { //we MUST terminate any client message underway if (session->service_transmit_handle && session->tunnel) GNUNET_MESH_notify_transmit_ready_cancel (session->service_transmit_handle); if (session->tunnel && session->state == WAITING_FOR_SERVICE_RESPONSE) GNUNET_MESH_tunnel_destroy (session->tunnel); } - if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task) - { + if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task) { GNUNET_SCHEDULER_cancel (session->client_notification_task); session->client_notification_task = GNUNET_SCHEDULER_NO_TASK; } - if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task) - { + if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task) { GNUNET_SCHEDULER_cancel (session->service_request_task); session->service_request_task = GNUNET_SCHEDULER_NO_TASK; } - if (NULL != session->client_transmit_handle) - { + if (NULL != session->client_transmit_handle) { GNUNET_SERVER_notify_transmit_ready_cancel (session->client_transmit_handle); session->client_transmit_handle = NULL; } free_session (session); } - /** * Notify the client that the session has succeeded or failed completely. * This message gets sent to @@ -809,8 +782,7 @@ prepare_client_end_notification (void * cls, session); // if we could not even queue our request, something is wrong - if (NULL == session->client_transmit_handle) - { + if (NULL == session->client_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not send message to client (%p)!\n"), session->client); // usually gets freed by do_send_message session->msg = NULL; @@ -823,7 +795,7 @@ prepare_client_end_notification (void * cls, static void prepare_service_response_multipart (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct ServiceSession * session = cls; unsigned char * current; @@ -833,25 +805,24 @@ prepare_service_response_multipart (void *cls, uint32_t msg_length; uint32_t todo_count; size_t element_length = 0; // initialized by gcry_mpi_print, but the compiler doesn't know that - + msg_length = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message); todo_count = session->used_element_count - session->transferred_element_count; - if (todo_count > MULTIPART_ELEMENT_CAPACITY/2) + if (todo_count > MULTIPART_ELEMENT_CAPACITY / 2) // send the currently possible maximum chunk, we always transfer both permutations - todo_count = MULTIPART_ELEMENT_CAPACITY/2; - + todo_count = MULTIPART_ELEMENT_CAPACITY / 2; + msg_length += todo_count * PAILLIER_ELEMENT_LENGTH * 2; msg = GNUNET_malloc (msg_length); msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB_MULTIPART); msg->header.size = htons (msg_length); msg->multipart_element_count = htonl (todo_count); - + element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH); current = (unsigned char *) &msg[1]; // convert k[][] - for (i = session->transferred_element_count; i < session->transferred_element_count + todo_count; i++) - { + for (i = session->transferred_element_count; i < session->transferred_element_count + todo_count; i++) { //k[i][p] memset (element_exported, 0, PAILLIER_ELEMENT_LENGTH); GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG, @@ -872,12 +843,11 @@ prepare_service_response_multipart (void *cls, current += PAILLIER_ELEMENT_LENGTH; } GNUNET_free (element_exported); - for (i = session->transferred_element_count; i < session->transferred_element_count; i++) - { + for (i = session->transferred_element_count; i < session->transferred_element_count; i++) { gcry_mpi_release (session->r_prime[i]); gcry_mpi_release (session->r[i]); } - session->transferred_element_count+=todo_count; + session->transferred_element_count += todo_count; session->msg = (struct GNUNET_MessageHeader *) msg; session->service_transmit_handle = GNUNET_MESH_notify_transmit_ready (session->tunnel, @@ -887,8 +857,7 @@ prepare_service_response_multipart (void *cls, &do_send_message, session); //disconnect our client - if (NULL == session->service_transmit_handle) - { + if (NULL == session->service_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-response message via mesh!)\n")); session->state = FINALIZED; @@ -935,8 +904,8 @@ prepare_service_response (gcry_mpi_t s, msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_response) + 2 * PAILLIER_ELEMENT_LENGTH; // s, stick - if (GNUNET_SERVER_MAX_MESSAGE_SIZE > msg_length + 2 * session->used_element_count * PAILLIER_ELEMENT_LENGTH){ //kp, kq - msg_length += + 2 * session->used_element_count * PAILLIER_ELEMENT_LENGTH; + if (GNUNET_SERVER_MAX_MESSAGE_SIZE > msg_length + 2 * session->used_element_count * PAILLIER_ELEMENT_LENGTH) { //kp, kq + msg_length += +2 * session->used_element_count * PAILLIER_ELEMENT_LENGTH; session->transferred_element_count = session->used_element_count; } else { @@ -978,8 +947,7 @@ prepare_service_response (gcry_mpi_t s, current += PAILLIER_ELEMENT_LENGTH; // convert k[][] - for (i = 0; i < session->transferred_element_count; i++) - { + for (i = 0; i < session->transferred_element_count; i++) { //k[i][p] memset (element_exported, 0, PAILLIER_ELEMENT_LENGTH); GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG, @@ -1001,8 +969,7 @@ prepare_service_response (gcry_mpi_t s, } GNUNET_free (element_exported); - for (i = 0; i < session->transferred_element_count; i++) - { + for (i = 0; i < session->transferred_element_count; i++) { gcry_mpi_release (session->r_prime[i]); gcry_mpi_release (session->r[i]); } @@ -1018,8 +985,7 @@ prepare_service_response (gcry_mpi_t s, &do_send_message, session); //disconnect our client - if (NULL == session->service_transmit_handle) - { + if (NULL == session->service_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-response message via mesh!)\n")); session->state = FINALIZED; @@ -1038,7 +1004,6 @@ prepare_service_response (gcry_mpi_t s, return GNUNET_OK; } - /** * executed by bob: * compute the values @@ -1089,19 +1054,15 @@ compute_service_response (struct ServiceSession * request, rand_pi_prime = GNUNET_malloc (sizeof (gcry_mpi_t) * count); // convert responder session to from long to mpi - for (i = 0, j = 0; i < response->element_count && j < count; i++) - { - if (request->mask[i / 8] & (1 << (i % 8))) - { + for (i = 0, j = 0; i < response->element_count && j < count; i++) { + if (request->mask[i / 8] & (1 << (i % 8))) { value = response->vector[i] >= 0 ? response->vector[i] : -response->vector[i]; // long to gcry_mpi_t - if (0 > response->vector[i]) - { + if (0 > response->vector[i]) { b[j] = gcry_mpi_new (0); gcry_mpi_sub_ui (b[j], b[j], value); } - else - { + else { b[j] = gcry_mpi_set_ui (NULL, value); } j++; @@ -1111,16 +1072,14 @@ compute_service_response (struct ServiceSession * request, response->vector = NULL; tmp_exp = gcry_sexp_find_token (request->remote_pubkey, "n", 0); - if (!tmp_exp) - { + if (!tmp_exp) { GNUNET_break_op (0); gcry_sexp_release (request->remote_pubkey); request->remote_pubkey = NULL; goto except; } remote_n = gcry_sexp_nth_mpi (tmp_exp, 1, GCRYMPI_FMT_USG); - if (!remote_n) - { + if (!remote_n) { GNUNET_break (0); gcry_sexp_release (tmp_exp); goto except; @@ -1131,15 +1090,13 @@ compute_service_response (struct ServiceSession * request, tmp_exp = gcry_sexp_find_token (request->remote_pubkey, "g", 0); gcry_sexp_release (request->remote_pubkey); request->remote_pubkey = NULL; - if (!tmp_exp) - { + if (!tmp_exp) { GNUNET_break_op (0); gcry_mpi_release (remote_n); goto except; } remote_g = gcry_sexp_nth_mpi (tmp_exp, 1, GCRYMPI_FMT_USG); - if (!remote_g) - { + if (!remote_g) { GNUNET_break (0); gcry_mpi_release (remote_n); gcry_sexp_release (tmp_exp); @@ -1175,8 +1132,7 @@ compute_service_response (struct ServiceSession * request, // vectors, which get rid of all the lookups in p/q. // however, ap/aq are not absolutely necessary but are just abstraction // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi) - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { // E(S - r_pi - b_pi) gcry_mpi_sub (r[i], my_offset, rand_pi[i]); gcry_mpi_sub (r[i], r[i], b_pi[i]); @@ -1190,8 +1146,7 @@ compute_service_response (struct ServiceSession * request, GNUNET_free (rand_pi); // Calculate Kq = E(S + a_qi) (+) E(S - r_qi) - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { // E(S - r_qi) gcry_mpi_sub (r_prime[i], my_offset, rand_pi_prime[i]); encrypt_element (r_prime[i], r_prime[i], remote_g, remote_n, remote_nsquare); @@ -1211,8 +1166,7 @@ compute_service_response (struct ServiceSession * request, encrypt_element (s_prime, s_prime, remote_g, remote_n, remote_nsquare); // Calculate S = E(SUM( (r_i + b_i)^2 )) - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { gcry_mpi_add (rand[i], rand[i], b[i]); } s = compute_square_sum (rand, count); @@ -1234,8 +1188,7 @@ compute_service_response (struct ServiceSession * request, ret = GNUNET_OK; except: - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { gcry_mpi_release (b[i]); gcry_mpi_release (request->a[i]); } @@ -1249,7 +1202,7 @@ except: static void prepare_service_request_multipart (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) + const struct GNUNET_SCHEDULER_TaskContext *tc) { struct ServiceSession * session = cls; unsigned char * current; @@ -1262,33 +1215,31 @@ prepare_service_request_multipart (void *cls, size_t element_length = 0; // initialized by gcry_mpi_print, but the compiler doesn't know that gcry_mpi_t a; uint32_t value; - + msg_length = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message); todo_count = session->used_element_count - session->transferred_element_count; if (todo_count > MULTIPART_ELEMENT_CAPACITY) // send the currently possible maximum chunk todo_count = MULTIPART_ELEMENT_CAPACITY; - + msg_length += todo_count * PAILLIER_ELEMENT_LENGTH; msg = GNUNET_malloc (msg_length); msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB_MULTIPART); msg->header.size = htons (msg_length); msg->multipart_element_count = htonl (todo_count); - + element_exported = GNUNET_malloc (PAILLIER_ELEMENT_LENGTH); a = gcry_mpi_new (KEYBITS * 2); current = (unsigned char *) &msg[1]; // encrypt our vector and generate string representations - for (i = session->last_processed_element, j = 0; i < session->element_count; i++) - { + for (i = session->last_processed_element, j = 0; i < session->element_count; i++) { // is this a used element? - if (session->mask[i / 8] & 1 << (i % 8)) - { + if (session->mask[i / 8] & 1 << (i % 8)) { if (todo_count <= j) break; //reached end of this message, can't include more - memset(element_exported, 0, PAILLIER_ELEMENT_LENGTH); + memset (element_exported, 0, PAILLIER_ELEMENT_LENGTH); value = session->vector[i] >= 0 ? session->vector[i] : -session->vector[i]; a = gcry_mpi_set_ui (a, 0); @@ -1318,9 +1269,9 @@ prepare_service_request_multipart (void *cls, } } gcry_mpi_release (a); - GNUNET_free(element_exported); - session->transferred_element_count+=todo_count; - + GNUNET_free (element_exported); + session->transferred_element_count += todo_count; + session->msg = (struct GNUNET_MessageHeader *) msg; GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Transmitting service request.\n")); @@ -1330,8 +1281,7 @@ prepare_service_request_multipart (void *cls, msg_length, &do_send_message, session); - if (!session->service_transmit_handle) - { + if (!session->service_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-request multipart message to tunnel!\n")); GNUNET_free (msg); session->msg = NULL; @@ -1340,7 +1290,7 @@ prepare_service_request_multipart (void *cls, session); return; } - if (session->transferred_element_count != session->used_element_count){ + if (session->transferred_element_count != session->used_element_count) { session->last_processed_element = i; } else @@ -1376,10 +1326,10 @@ prepare_service_request (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Successfully created new tunnel to peer (%s)!\n"), GNUNET_i2s (&session->peer)); msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request) - + session->mask_length + +session->mask_length + my_pubkey_external_length; - if (GNUNET_SERVER_MAX_MESSAGE_SIZE > msg_length + session->used_element_count * PAILLIER_ELEMENT_LENGTH){ + if (GNUNET_SERVER_MAX_MESSAGE_SIZE > msg_length + session->used_element_count * PAILLIER_ELEMENT_LENGTH) { msg_length += session->used_element_count * PAILLIER_ELEMENT_LENGTH; session->transferred_element_count = session->used_element_count; } @@ -1390,7 +1340,7 @@ prepare_service_request (void *cls, msg = GNUNET_malloc (msg_length); msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_TO_BOB); - msg->total_element_count = htonl(session->used_element_count); + msg->total_element_count = htonl (session->used_element_count); msg->contained_element_count = htonl (session->transferred_element_count); memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode)); msg->mask_length = htonl (session->mask_length); @@ -1412,15 +1362,13 @@ prepare_service_request (void *cls, session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * session->used_element_count); a = gcry_mpi_new (KEYBITS * 2); // encrypt our vector and generate string representations - for (i = 0, j = 0; i < session->element_count; i++) - { + for (i = 0, j = 0; i < session->element_count; i++) { // if this is a used element... - if (session->mask[i / 8] & 1 << (i % 8)) - { + if (session->mask[i / 8] & 1 << (i % 8)) { if (session->transferred_element_count <= j) break; //reached end of this message, can't include more - memset(element_exported, 0, PAILLIER_ELEMENT_LENGTH); + memset (element_exported, 0, PAILLIER_ELEMENT_LENGTH); value = session->vector[i] >= 0 ? session->vector[i] : -session->vector[i]; a = gcry_mpi_set_ui (a, 0); @@ -1450,7 +1398,7 @@ prepare_service_request (void *cls, } } gcry_mpi_release (a); - GNUNET_free(element_exported); + GNUNET_free (element_exported); session->msg = (struct GNUNET_MessageHeader *) msg; GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Transmitting service request.\n")); @@ -1461,8 +1409,7 @@ prepare_service_request (void *cls, msg_length, &do_send_message, session); - if (!session->service_transmit_handle) - { + if (!session->service_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send message to tunnel!\n")); GNUNET_free (msg); session->msg = NULL; @@ -1471,7 +1418,7 @@ prepare_service_request (void *cls, session); return; } - if (session->transferred_element_count != session->used_element_count){ + if (session->transferred_element_count != session->used_element_count) { session->state = WAITING_FOR_MULTIPART_TRANSMISSION; session->last_processed_element = i; } @@ -1480,7 +1427,6 @@ prepare_service_request (void *cls, session->state = WAITING_FOR_SERVICE_RESPONSE; } - /** * Handler for a client request message. * Can either be type A or B @@ -1506,21 +1452,18 @@ handle_client_request (void *cls, // only one concurrent session per client connection allowed, simplifies logics a lot... session = GNUNET_SERVER_client_get_user_context (client, struct ServiceSession); - if ((NULL != session) && (session->state != FINALIZED)) - { + if ((NULL != session) && (session->state != FINALIZED)) { GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } - else if (NULL != session) - { + else if (NULL != session) { // old session is already completed, clean it up GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, session); free_session (session); } //we need at least a peer and one message id to compare - if (sizeof (struct GNUNET_SCALARPRODUCT_client_request) > ntohs (msg->header.size)) - { + if (sizeof (struct GNUNET_SCALARPRODUCT_client_request) > ntohs (msg->header.size)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Too short message received from client!\n")); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); @@ -1533,8 +1476,7 @@ handle_client_request (void *cls, //sanity check: is the message as long as the message_count fields suggests? if ((ntohs (msg->header.size) != (sizeof (struct GNUNET_SCALARPRODUCT_client_request) +element_count * sizeof (int32_t) + mask_length)) - || (0 == element_count)) - { + || (0 == element_count)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Invalid message received from client, session information incorrect!\n")); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); @@ -1545,8 +1487,7 @@ handle_client_request (void *cls, if (NULL != find_matching_session (from_client_tail, &msg->key, element_count, - NULL, NULL)) - { + NULL, NULL)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Duplicate session information received, cannot create new session with key `%s'\n"), GNUNET_h2s (&msg->key)); @@ -1566,8 +1507,7 @@ handle_client_request (void *cls, session->vector = GNUNET_malloc (sizeof (int32_t) * element_count); vector = (int32_t *) & msg[1]; - if (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE == msg_type) - { + if (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE == msg_type) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Got client-request-session with key %s, preparing tunnel to remote service.\n"), GNUNET_h2s (&session->key)); @@ -1579,8 +1519,7 @@ handle_client_request (void *cls, // copy over the elements session->used_element_count = 0; - for (i = 0; i < element_count; i++) - { + for (i = 0; i < element_count; i++) { session->vector[i] = ntohl (vector[i]); if (session->vector[i] == 0) session->mask[i / 8] &= ~(1 << (i % 8)); @@ -1588,8 +1527,7 @@ handle_client_request (void *cls, session->used_element_count++; } - if (0 == session->used_element_count) - { + if (0 == session->used_element_count) { GNUNET_break_op (0); GNUNET_free (session->vector); GNUNET_free (session); @@ -1597,8 +1535,7 @@ handle_client_request (void *cls, return; } //session with ourself makes no sense! - if (!memcmp (&msg->peer, &me, sizeof (struct GNUNET_PeerIdentity))) - { + if (!memcmp (&msg->peer, &me, sizeof (struct GNUNET_PeerIdentity))) { GNUNET_break (0); GNUNET_free (session->vector); GNUNET_free (session); @@ -1616,8 +1553,7 @@ handle_client_request (void *cls, GNUNET_NO, GNUNET_YES); //prepare_service_request, tunnel_peer_disconnect_handler, - if (!session->tunnel) - { + if (!session->tunnel) { GNUNET_break (0); GNUNET_free (session->vector); GNUNET_free (session); @@ -1633,8 +1569,7 @@ handle_client_request (void *cls, session); } - else - { + else { struct ServiceSession * requesting_session; enum SessionState needed_state = SERVICE_REQUEST_RECEIVED; @@ -1654,8 +1589,7 @@ handle_client_request (void *cls, &session->key, session->element_count, &needed_state, NULL); - if (NULL != requesting_session) - { + if (NULL != requesting_session) { GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got client-responder-session with key %s and a matching service-request-session set, processing.\n"), GNUNET_h2s (&session->key)); if (GNUNET_OK != compute_service_response (requesting_session, session)) session->client_notification_task = @@ -1663,8 +1597,7 @@ handle_client_request (void *cls, session); } - else - { + else { GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got client-responder-session with key %s but NO matching service-request-session set, queuing element for later use.\n"), GNUNET_h2s (&session->key)); // no matching session exists yet, store the response // for later processing by handle_service_request() @@ -1673,7 +1606,6 @@ handle_client_request (void *cls, GNUNET_SERVER_receive_done (client, GNUNET_YES); } - /** * Function called for inbound tunnels. * @@ -1699,7 +1631,6 @@ tunnel_incoming_handler (void *cls, return c; } - /** * Function called whenever a tunnel is destroyed. Should clean up * any associated state. @@ -1724,12 +1655,10 @@ tunnel_destruction_handler (void *cls, _ ("Peer disconnected, terminating session %s with peer (%s)\n"), GNUNET_h2s (&session->key), GNUNET_i2s (&session->peer)); - if (ALICE == session->role) - { + if (ALICE == session->role) { // as we have only one peer connected in each session, just remove the session - if ((SERVICE_RESPONSE_RECEIVED > session->state) && (!do_shutdown)) - { + if ((SERVICE_RESPONSE_RECEIVED > session->state) && (!do_shutdown)) { session->tunnel = NULL; // if this happened before we received the answer, we must terminate the session session->client_notification_task = @@ -1737,14 +1666,12 @@ tunnel_destruction_handler (void *cls, session); } } - else - { //(BOB == session->role) service session + else { //(BOB == session->role) service session // remove the session, unless it has already been dequeued, but somehow still active // this could bug without the IF in case the queue is empty and the service session was the only one know to the service // scenario: disconnect before alice can send her message to bob. for (curr = from_service_head; NULL != curr; curr = curr->next) - if (curr == session) - { + if (curr == session) { GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, curr); break; } @@ -1758,8 +1685,7 @@ tunnel_destruction_handler (void *cls, // the client has to check if it was waiting for a result // or if it was a responder, no point in adding more statefulness - if (client_session && (!do_shutdown)) - { + if (client_session && (!do_shutdown)) { client_session->state = FINALIZED; client_session->client_notification_task = GNUNET_SCHEDULER_add_now (&prepare_client_end_notification, @@ -1768,7 +1694,6 @@ tunnel_destruction_handler (void *cls, } } - /** * Compute our scalar product, done by Alice * @@ -1801,8 +1726,7 @@ compute_scalar_product (struct ServiceSession * session, // due to the introduced static offset S, we now also have to remove this // from the E(a_pi)(+)E(-b_pi-r_pi) and E(a_qi)(+)E(-r_qi) twice each, // the result is E((S + a_pi) + (S -b_pi-r_pi)) and E(S + a_qi + S - r_qi) - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { decrypt_element (r[i], r[i], my_mu, my_lambda, my_n, my_nsquare); gcry_mpi_sub (r[i], r[i], my_offset); gcry_mpi_sub (r[i], r[i], my_offset); @@ -1859,7 +1783,6 @@ compute_scalar_product (struct ServiceSession * session, return p; } - /** * prepare the response we will send to alice or bobs' clients. * in Bobs case the product will be NULL. @@ -1881,19 +1804,16 @@ prepare_client_response (void *cls, session->client_notification_task = GNUNET_SCHEDULER_NO_TASK; - if (session->product) - { + if (session->product) { gcry_mpi_t value = gcry_mpi_new (0); sign = gcry_mpi_cmp_ui (session->product, 0); // libgcrypt can not handle a print of a negative number // if (a->sign) return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet. */ - if (0 > sign) - { + if (0 > sign) { gcry_mpi_sub (value, value, session->product); } - else if (0 < sign) - { + else if (0 < sign) { range = 1; gcry_mpi_add (value, value, session->product); } @@ -1908,8 +1828,7 @@ prepare_client_response (void *cls, && (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD, &product_exported, &product_length, - value)))) - { + value)))) { LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc); product_length = 0; range = -1; // signal error with product-length = 0 and range = -1 @@ -1921,8 +1840,7 @@ prepare_client_response (void *cls, msg = GNUNET_malloc (msg_length); memcpy (&msg->key, &session->key, sizeof (struct GNUNET_HashCode)); memcpy (&msg->peer, &session->peer, sizeof ( struct GNUNET_PeerIdentity)); - if (product_exported != NULL) - { + if (product_exported != NULL) { memcpy (&msg[1], product_exported, product_length); GNUNET_free (product_exported); } @@ -1939,8 +1857,7 @@ prepare_client_response (void *cls, GNUNET_TIME_UNIT_FOREVER_REL, &do_send_message, session); - if (NULL == session->client_transmit_handle) - { + if (NULL == session->client_transmit_handle) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not send message to client (%p)!\n"), session->client); @@ -1971,11 +1888,11 @@ prepare_client_response (void *cls, */ static int handle_service_request_multipart (void *cls, - struct GNUNET_MESH_Tunnel * tunnel, - void **tunnel_ctx, - const struct GNUNET_MessageHeader * message) + struct GNUNET_MESH_Tunnel * tunnel, + void **tunnel_ctx, + const struct GNUNET_MessageHeader * message) { - return GNUNET_SYSERR; + return GNUNET_SYSERR; } /** @@ -2001,6 +1918,7 @@ handle_service_request (void *cls, uint32_t mask_length; uint32_t pk_length; uint32_t used_elements; + uint32_t contained_elements; uint32_t element_count; uint32_t msg_length; unsigned char * current; @@ -2009,44 +1927,39 @@ handle_service_request (void *cls, enum SessionState needed_state; session = (struct ServiceSession *) * tunnel_ctx; - if (BOB != session->role) - { + if (BOB != session->role) { GNUNET_break_op (0); return GNUNET_SYSERR; } // is this tunnel already in use? - if ((session->next) || (from_service_head == session)) - { + if ((session->next) || (from_service_head == session)) { GNUNET_break_op (0); return GNUNET_SYSERR; } // Check if message was sent by me, which would be bad! - if (!memcmp (&session->peer, &me, sizeof (struct GNUNET_PeerIdentity))) - { + if (!memcmp (&session->peer, &me, sizeof (struct GNUNET_PeerIdentity))) { GNUNET_free (session); GNUNET_break (0); return GNUNET_SYSERR; } - - //we need at least a peer and one message id to compare - if (ntohs (msg->header.size) < sizeof (struct GNUNET_SCALARPRODUCT_service_request)) - { + // shorter than expected? + if (ntohs (msg->header.size) < sizeof (struct GNUNET_SCALARPRODUCT_service_request)) { GNUNET_free (session); GNUNET_break_op (0); return GNUNET_SYSERR; } mask_length = ntohl (msg->mask_length); pk_length = ntohl (msg->pk_length); - used_elements = ntohl (msg->contained_element_count); + used_elements = ntohl (msg->total_element_count); + contained_elements = ntohl (msg->contained_element_count); element_count = ntohl (msg->element_count); msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_request) - +mask_length + pk_length + used_elements * PAILLIER_ELEMENT_LENGTH; + +mask_length + pk_length + contained_elements * PAILLIER_ELEMENT_LENGTH; //sanity check: is the message as long as the message_count fields suggests? - if ((ntohs (msg->header.size) != msg_length) || (element_count < used_elements) + if ((ntohs (msg->header.size) != msg_length) || (element_count < used_elements) || (used_elements < contained_elements) || (used_elements == 0) || (mask_length != (element_count / 8 + (element_count % 8 ? 1 : 0))) - ) - { + ) { GNUNET_free (session); GNUNET_break_op (0); return GNUNET_SYSERR; @@ -2055,8 +1968,7 @@ handle_service_request (void *cls, &msg->key, element_count, NULL, - NULL)) - { + NULL)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Got message with duplicate session key (`%s'), ignoring service request.\n"), (const char *) &(msg->key)); GNUNET_free (session); return GNUNET_SYSERR; @@ -2066,6 +1978,7 @@ handle_service_request (void *cls, session->state = SERVICE_REQUEST_RECEIVED; session->element_count = ntohl (msg->element_count); session->used_element_count = used_elements; + session->transferred_element_count = contained_elements; session->tunnel = tunnel; // session key @@ -2078,8 +1991,7 @@ handle_service_request (void *cls, current += mask_length; //convert the publickey to sexp - if (gcry_sexp_new (&session->remote_pubkey, current, pk_length, 1)) - { + if (gcry_sexp_new (&session->remote_pubkey, current, pk_length, 1)) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not translate remote public key to sexpression!\n")); GNUNET_free (session->mask); GNUNET_free (session); @@ -2097,16 +2009,11 @@ handle_service_request (void *cls, session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * used_elements); - if (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_service_request) - +pk_length - + mask_length - + used_elements * PAILLIER_ELEMENT_LENGTH) - { + if (contained_elements != 0) { gcry_error_t ret = 0; session->a = GNUNET_malloc (sizeof (gcry_mpi_t) * used_elements); // Convert each vector element to MPI_value - for (i = 0; i < used_elements; i++) - { + for (i = 0; i < used_elements; i++) { size_t read = 0; ret = gcry_mpi_scan (&session->a[i], @@ -2114,35 +2021,34 @@ handle_service_request (void *cls, ¤t[i * PAILLIER_ELEMENT_LENGTH], PAILLIER_ELEMENT_LENGTH, &read); - if (ret) - { + if (ret) { GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not translate E[a%d] to MPI!\n%s/%s\n"), i, gcry_strsource (ret), gcry_strerror (ret)); goto except; } } GNUNET_CONTAINER_DLL_insert (from_service_head, from_service_tail, session); - if (responder_session) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s and a matching element set, processing.\n"), GNUNET_h2s (&session->key)); - if (GNUNET_OK != compute_service_response (session, responder_session)) - { - //something went wrong, remove it again... - GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, session); - goto except; + + if (contained_elements == used_elements) { + // single part finished + if (responder_session) { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s and a matching element set, processing.\n"), GNUNET_h2s (&session->key)); + if (GNUNET_OK != compute_service_response (session, responder_session)) { + //something went wrong, remove it again... + GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, session); + goto except; + } } + else + GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s without a matching element set, queueing.\n"), GNUNET_h2s (&session->key)); + } + else{ + // multipart message + } - else - GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Got session with key %s without a matching element set, queueing.\n"), GNUNET_h2s (&session->key)); return GNUNET_OK; } - else - { - // TODO FEATURE: fallback to fragmentation, in case the message is too long - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Message too large, fragmentation is currently not supported!\n")); - goto except; - } except: for (i = 0; i < used_elements; i++) if (session->a[i]) @@ -2161,7 +2067,6 @@ except: return GNUNET_SYSERR; } - /** * Handle a multipart chunk of a response we got from another service we wanted to calculate a scalarproduct with. * @@ -2176,11 +2081,11 @@ except: */ static int handle_service_response_multipart (void *cls, - struct GNUNET_MESH_Tunnel * tunnel, - void **tunnel_ctx, - const struct GNUNET_MessageHeader * message) + struct GNUNET_MESH_Tunnel * tunnel, + void **tunnel_ctx, + const struct GNUNET_MessageHeader * message) { - return GNUNET_SYSERR; + return GNUNET_SYSERR; } /** @@ -2217,8 +2122,7 @@ handle_service_response (void *cls, GNUNET_assert (NULL != message); session = (struct ServiceSession *) * tunnel_ctx; - if (ALICE != session->role) - { + if (ALICE != session->role) { GNUNET_break_op (0); return GNUNET_SYSERR; } @@ -2228,8 +2132,7 @@ handle_service_response (void *cls, session->state = SERVICE_RESPONSE_RECEIVED; //we need at least a peer and one message id to compare - if (sizeof (struct GNUNET_SCALARPRODUCT_service_response) > ntohs (msg->header.size)) - { + if (sizeof (struct GNUNET_SCALARPRODUCT_service_response) > ntohs (msg->header.size)) { GNUNET_break_op (0); goto invalid_msg; } @@ -2238,8 +2141,7 @@ handle_service_response (void *cls, + 2 * contained_element_count * PAILLIER_ELEMENT_LENGTH + 2 * PAILLIER_ELEMENT_LENGTH; //sanity check: is the message as long as the message_count fields suggests? - if ((ntohs (msg->header.size) != msg_size) || (count != contained_element_count)) - { + if ((ntohs (msg->header.size) != msg_size) || (count != contained_element_count)) { GNUNET_break_op (0); goto invalid_msg; } @@ -2247,8 +2149,7 @@ handle_service_response (void *cls, //convert s current = (unsigned char *) &msg[1]; if (0 != (rc = gcry_mpi_scan (&s, GCRYMPI_FMT_USG, current, - PAILLIER_ELEMENT_LENGTH, &read))) - { + PAILLIER_ELEMENT_LENGTH, &read))) { LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc); GNUNET_break_op (0); goto invalid_msg; @@ -2256,8 +2157,7 @@ handle_service_response (void *cls, current += PAILLIER_ELEMENT_LENGTH; //convert stick if (0 != (rc = gcry_mpi_scan (&s_prime, GCRYMPI_FMT_USG, current, - PAILLIER_ELEMENT_LENGTH, &read))) - { + PAILLIER_ELEMENT_LENGTH, &read))) { LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc); GNUNET_break_op (0); goto invalid_msg; @@ -2266,11 +2166,9 @@ handle_service_response (void *cls, r = GNUNET_malloc (sizeof (gcry_mpi_t) * count); // Convert each kp[] to its MPI_value - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { if (0 != (rc = gcry_mpi_scan (&r[i], GCRYMPI_FMT_USG, current, - PAILLIER_ELEMENT_LENGTH, &read))) - { + PAILLIER_ELEMENT_LENGTH, &read))) { LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc); GNUNET_break_op (0); goto invalid_msg; @@ -2281,11 +2179,9 @@ handle_service_response (void *cls, r_prime = GNUNET_malloc (sizeof (gcry_mpi_t) * count); // Convert each kq[] to its MPI_value - for (i = 0; i < count; i++) - { + for (i = 0; i < count; i++) { if (0 != (rc = gcry_mpi_scan (&r_prime[i], GCRYMPI_FMT_USG, current, - PAILLIER_ELEMENT_LENGTH, &read))) - { + PAILLIER_ELEMENT_LENGTH, &read))) { LOG_GCRY (GNUNET_ERROR_TYPE_DEBUG, "gcry_mpi_scan", rc); GNUNET_break_op (0); goto invalid_msg; @@ -2317,7 +2213,6 @@ invalid_msg: return GNUNET_SYSERR; } - /** * Task run during shutdown. * @@ -2334,42 +2229,36 @@ shutdown_task (void *cls, do_shutdown = GNUNET_YES; // terminate all owned open tunnels. - for (session = from_client_head; NULL != session; session = session->next) - { - if ((FINALIZED != session->state) && (NULL != session->tunnel)){ + for (session = from_client_head; NULL != session; session = session->next) { + if ((FINALIZED != session->state) && (NULL != session->tunnel)) { GNUNET_MESH_tunnel_destroy (session->tunnel); session->tunnel = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task) - { + if (GNUNET_SCHEDULER_NO_TASK != session->client_notification_task) { GNUNET_SCHEDULER_cancel (session->client_notification_task); session->client_notification_task = GNUNET_SCHEDULER_NO_TASK; } - if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task) - { + if (GNUNET_SCHEDULER_NO_TASK != session->service_request_task) { GNUNET_SCHEDULER_cancel (session->service_request_task); session->service_request_task = GNUNET_SCHEDULER_NO_TASK; } - if (NULL != session->client) - { + if (NULL != session->client) { GNUNET_SERVER_client_disconnect (session->client); session->client = NULL; } } for (session = from_service_head; NULL != session; session = session->next) - if (NULL != session->tunnel){ + if (NULL != session->tunnel) { GNUNET_MESH_tunnel_destroy (session->tunnel); - session->tunnel = NULL; + session->tunnel = NULL; } - if (my_mesh) - { + if (my_mesh) { GNUNET_MESH_disconnect (my_mesh); my_mesh = NULL; } } - /** * Initialization of the program and message handlers * @@ -2413,8 +2302,7 @@ run (void *cls, &tunnel_incoming_handler, &tunnel_destruction_handler, mesh_handlers, ports); - if (!my_mesh) - { + if (!my_mesh) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Connect to MESH failed\n")); GNUNET_SCHEDULER_shutdown (); return; @@ -2425,7 +2313,6 @@ run (void *cls, NULL); } - /** * The main function for the scalarproduct service. * -- cgit v1.2.3