From d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb Mon Sep 17 00:00:00 2001 From: ng0 Date: Sun, 8 Sep 2019 12:33:09 +0000 Subject: uncrustify as demanded. --- .../gnunet-service-scalarproduct_bob.c | 1140 ++++++++++---------- 1 file changed, 570 insertions(+), 570 deletions(-) (limited to 'src/scalarproduct/gnunet-service-scalarproduct_bob.c') diff --git a/src/scalarproduct/gnunet-service-scalarproduct_bob.c b/src/scalarproduct/gnunet-service-scalarproduct_bob.c index 0b95f3a00..f787cdd2e 100644 --- a/src/scalarproduct/gnunet-service-scalarproduct_bob.c +++ b/src/scalarproduct/gnunet-service-scalarproduct_bob.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -36,14 +36,13 @@ #include "scalarproduct.h" #include "gnunet-service-scalarproduct.h" -#define LOG(kind,...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from(kind, "scalarproduct-bob", __VA_ARGS__) /** * An encrypted element key-value pair. */ -struct MpiElement -{ +struct MpiElement { /** * Key used to identify matching pairs of values to multiply. * Points into an existing data structure, to avoid copying @@ -62,9 +61,7 @@ struct MpiElement * A scalarproduct session which tracks an offer for a * multiplication service by a local client. */ -struct BobServiceSession -{ - +struct BobServiceSession { /** * (hopefully) unique transaction ID */ @@ -200,7 +197,6 @@ struct BobServiceSession * The message queue for this channel. */ struct GNUNET_MQ_Handle *cadet_mq; - }; @@ -239,13 +235,13 @@ static struct GNUNET_CADET_Handle *my_cadet; * @param value the value to free */ static int -free_element_cb (void *cls, - const struct GNUNET_HashCode *key, - void *value) +free_element_cb(void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct GNUNET_SCALARPRODUCT_Element *element = value; - GNUNET_free (element); + GNUNET_free(element); return GNUNET_OK; } @@ -256,7 +252,7 @@ free_element_cb (void *cls, * @param session the session to free elements from */ static void -destroy_service_session (struct BobServiceSession *s) +destroy_service_session(struct BobServiceSession *s) { unsigned int i; @@ -264,63 +260,63 @@ destroy_service_session (struct BobServiceSession *s) return; s->in_destroy = GNUNET_YES; if (NULL != s->client) - { - struct GNUNET_SERVICE_Client *c = s->client; + { + struct GNUNET_SERVICE_Client *c = s->client; - s->client = NULL; - GNUNET_SERVICE_client_drop (c); - } + s->client = NULL; + GNUNET_SERVICE_client_drop(c); + } if (NULL != s->intersected_elements) - { - GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements, - &free_element_cb, - NULL); - GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements); - s->intersected_elements = NULL; - } + { + GNUNET_CONTAINER_multihashmap_iterate(s->intersected_elements, + &free_element_cb, + NULL); + GNUNET_CONTAINER_multihashmap_destroy(s->intersected_elements); + s->intersected_elements = NULL; + } if (NULL != s->intersection_op) - { - GNUNET_SET_operation_cancel (s->intersection_op); - s->intersection_op = NULL; - } + { + GNUNET_SET_operation_cancel(s->intersection_op); + s->intersection_op = NULL; + } if (NULL != s->intersection_set) - { - GNUNET_SET_destroy (s->intersection_set); - s->intersection_set = NULL; - } + { + GNUNET_SET_destroy(s->intersection_set); + s->intersection_set = NULL; + } if (NULL != s->e_a) - { - GNUNET_free (s->e_a); - s->e_a = NULL; - } + { + GNUNET_free(s->e_a); + s->e_a = NULL; + } if (NULL != s->sorted_elements) - { - for (i=0;iused_element_count;i++) - gcry_mpi_release (s->sorted_elements[i].value); - GNUNET_free (s->sorted_elements); - s->sorted_elements = NULL; - } + { + for (i = 0; i < s->used_element_count; i++) + gcry_mpi_release(s->sorted_elements[i].value); + GNUNET_free(s->sorted_elements); + s->sorted_elements = NULL; + } if (NULL != s->r) - { - GNUNET_free (s->r); - s->r = NULL; - } + { + GNUNET_free(s->r); + s->r = NULL; + } if (NULL != s->r_prime) - { - GNUNET_free (s->r_prime); - s->r_prime = NULL; - } + { + GNUNET_free(s->r_prime); + s->r_prime = NULL; + } if (NULL != s->port) - { - GNUNET_CADET_close_port (s->port); - s->port = NULL; - } + { + GNUNET_CADET_close_port(s->port); + s->port = NULL; + } if (NULL != s->channel) - { - GNUNET_CADET_channel_destroy (s->channel); - s->channel = NULL; - } - GNUNET_free (s); + { + GNUNET_CADET_channel_destroy(s->channel); + s->channel = NULL; + } + GNUNET_free(s); } @@ -332,24 +328,24 @@ destroy_service_session (struct BobServiceSession *s) * @param session the associated client session to fail or succeed */ static void -prepare_client_end_notification (struct BobServiceSession *session) +prepare_client_end_notification(struct BobServiceSession *session) { struct ClientResponseMessage *msg; struct GNUNET_MQ_Envelope *e; if (NULL == session->client_mq) return; /* no client left to be notified */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sending session-end notification with status %d to client for session %s\n", - session->status, - GNUNET_h2s (&session->session_id)); - e = GNUNET_MQ_msg (msg, - GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending session-end notification with status %d to client for session %s\n", + session->status, + GNUNET_h2s(&session->session_id)); + e = GNUNET_MQ_msg(msg, + GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT); msg->range = 0; - msg->product_length = htonl (0); - msg->status = htonl (session->status); - GNUNET_MQ_send (session->client_mq, - e); + msg->product_length = htonl(0); + msg->status = htonl(session->status); + GNUNET_MQ_send(session->client_mq, + e); } @@ -363,22 +359,22 @@ prepare_client_end_notification (struct BobServiceSession *session) * @param channel connection to the other end (henceforth invalid) */ static void -cb_channel_destruction (void *cls, - const struct GNUNET_CADET_Channel *channel) +cb_channel_destruction(void *cls, + const struct GNUNET_CADET_Channel *channel) { struct BobServiceSession *s = cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Peer disconnected, terminating session %s with peer %s\n", - GNUNET_h2s (&s->session_id), - GNUNET_i2s (&s->peer)); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Peer disconnected, terminating session %s with peer %s\n", + GNUNET_h2s(&s->session_id), + GNUNET_i2s(&s->peer)); if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status) - { - s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; - prepare_client_end_notification (s); - } + { + s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; + prepare_client_end_notification(s); + } s->channel = NULL; - destroy_service_session (s); + destroy_service_session(s); } @@ -387,19 +383,19 @@ cb_channel_destruction (void *cls, * the client that we are finished. */ static void -bob_cadet_done_cb (void *cls) +bob_cadet_done_cb(void *cls) { struct BobServiceSession *session = cls; session->status = GNUNET_SCALARPRODUCT_STATUS_SUCCESS; - prepare_client_end_notification (session); + prepare_client_end_notification(session); } /** * Maximum count of elements we can put into a multipart message */ -#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof (struct BobCryptodataMultipartMessage)) / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)) +#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct BobCryptodataMultipartMessage)) / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)) /** @@ -409,7 +405,7 @@ bob_cadet_done_cb (void *cls) * @param s the associated service session */ static void -transmit_bobs_cryptodata_message_multipart (struct BobServiceSession *s) +transmit_bobs_cryptodata_message_multipart(struct BobServiceSession *s) { struct GNUNET_CRYPTO_PaillierCiphertext *payload; struct BobCryptodataMultipartMessage *msg; @@ -419,39 +415,39 @@ transmit_bobs_cryptodata_message_multipart (struct BobServiceSession *s) uint32_t todo_count; while (s->cadet_transmitted_element_count != s->used_element_count) - { - todo_count = s->used_element_count - s->cadet_transmitted_element_count; - if (todo_count > ELEMENT_CAPACITY / 2) - todo_count = ELEMENT_CAPACITY / 2; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sending %u additional crypto values to Alice\n", - (unsigned int) todo_count); - e = GNUNET_MQ_msg_extra (msg, - todo_count * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * 2, - GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART); - msg->contained_element_count = htonl (todo_count); - payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1]; - for (i = s->cadet_transmitted_element_count, j = 0; i < s->cadet_transmitted_element_count + todo_count; i++) { - //r[i][p] and r[i][q] - GNUNET_memcpy (&payload[j++], - &s->r[i], - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); - GNUNET_memcpy (&payload[j++], - &s->r_prime[i], - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); + todo_count = s->used_element_count - s->cadet_transmitted_element_count; + if (todo_count > ELEMENT_CAPACITY / 2) + todo_count = ELEMENT_CAPACITY / 2; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending %u additional crypto values to Alice\n", + (unsigned int)todo_count); + e = GNUNET_MQ_msg_extra(msg, + todo_count * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * 2, + GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART); + msg->contained_element_count = htonl(todo_count); + payload = (struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1]; + for (i = s->cadet_transmitted_element_count, j = 0; i < s->cadet_transmitted_element_count + todo_count; i++) + { + //r[i][p] and r[i][q] + GNUNET_memcpy(&payload[j++], + &s->r[i], + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); + GNUNET_memcpy(&payload[j++], + &s->r_prime[i], + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); + } + s->cadet_transmitted_element_count += todo_count; + if (s->cadet_transmitted_element_count == s->used_element_count) + GNUNET_MQ_notify_sent(e, + &bob_cadet_done_cb, + s); + GNUNET_MQ_send(s->cadet_mq, + e); } - s->cadet_transmitted_element_count += todo_count; - if (s->cadet_transmitted_element_count == s->used_element_count) - GNUNET_MQ_notify_sent (e, - &bob_cadet_done_cb, - s); - GNUNET_MQ_send (s->cadet_mq, - e); - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "All values queued for Alice, Bob is done\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "All values queued for Alice, Bob is done\n"); } @@ -467,7 +463,7 @@ transmit_bobs_cryptodata_message_multipart (struct BobServiceSession *s) * @param s the associated requesting session with Alice */ static void -transmit_bobs_cryptodata_message (struct BobServiceSession *s) +transmit_bobs_cryptodata_message(struct BobServiceSession *s) { struct BobCryptodataMessage *msg; struct GNUNET_MQ_Envelope *e; @@ -475,49 +471,49 @@ transmit_bobs_cryptodata_message (struct BobServiceSession *s) unsigned int i; s->cadet_transmitted_element_count - = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof (struct BobCryptodataMessage)) - / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1; + = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct BobCryptodataMessage)) + / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1; if (s->cadet_transmitted_element_count > s->used_element_count) s->cadet_transmitted_element_count = s->used_element_count; - e = GNUNET_MQ_msg_extra (msg, - (2 + s->cadet_transmitted_element_count * 2) - * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext), - GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA); - msg->contained_element_count = htonl (s->cadet_transmitted_element_count); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Sending %u/%u crypto values to Alice\n", - (unsigned int) s->cadet_transmitted_element_count, - (unsigned int) s->used_element_count); - - payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1]; - GNUNET_memcpy (&payload[0], - &s->s, - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); - GNUNET_memcpy (&payload[1], - &s->s_prime, - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); + e = GNUNET_MQ_msg_extra(msg, + (2 + s->cadet_transmitted_element_count * 2) + * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext), + GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA); + msg->contained_element_count = htonl(s->cadet_transmitted_element_count); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Sending %u/%u crypto values to Alice\n", + (unsigned int)s->cadet_transmitted_element_count, + (unsigned int)s->used_element_count); + + payload = (struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1]; + GNUNET_memcpy(&payload[0], + &s->s, + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); + GNUNET_memcpy(&payload[1], + &s->s_prime, + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); payload = &payload[2]; // convert k[][] for (i = 0; i < s->cadet_transmitted_element_count; i++) - { - //k[i][p] and k[i][q] - GNUNET_memcpy (&payload[i * 2], - &s->r[i], - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); - GNUNET_memcpy (&payload[i * 2 + 1], - &s->r_prime[i], - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)); - } + { + //k[i][p] and k[i][q] + GNUNET_memcpy(&payload[i * 2], + &s->r[i], + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); + GNUNET_memcpy(&payload[i * 2 + 1], + &s->r_prime[i], + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)); + } if (s->cadet_transmitted_element_count == s->used_element_count) - GNUNET_MQ_notify_sent (e, - &bob_cadet_done_cb, - s); - GNUNET_MQ_send (s->cadet_mq, - e); - transmit_bobs_cryptodata_message_multipart (s); + GNUNET_MQ_notify_sent(e, + &bob_cadet_done_cb, + s); + GNUNET_MQ_send(s->cadet_mq, + e); + transmit_bobs_cryptodata_message_multipart(s); } #undef ELEMENT_CAPACITY @@ -531,21 +527,21 @@ transmit_bobs_cryptodata_message (struct BobServiceSession *s) * TODO: code duplication with Alice! */ static gcry_mpi_t -compute_square_sum (const gcry_mpi_t *vector, - uint32_t length) +compute_square_sum(const gcry_mpi_t *vector, + uint32_t length) { gcry_mpi_t elem; gcry_mpi_t sum; uint32_t i; - GNUNET_assert (NULL != (sum = gcry_mpi_new (0))); - GNUNET_assert (NULL != (elem = gcry_mpi_new (0))); + GNUNET_assert(NULL != (sum = gcry_mpi_new(0))); + GNUNET_assert(NULL != (elem = gcry_mpi_new(0))); for (i = 0; i < length; i++) - { - gcry_mpi_mul (elem, vector[i], vector[i]); - gcry_mpi_add (sum, sum, elem); - } - gcry_mpi_release (elem); + { + gcry_mpi_mul(elem, vector[i], vector[i]); + gcry_mpi_add(sum, sum, elem); + } + gcry_mpi_release(elem); return sum; } @@ -561,7 +557,7 @@ compute_square_sum (const gcry_mpi_t *vector, * @return #GNUNET_OK on success */ static int -compute_service_response (struct BobServiceSession *session) +compute_service_response(struct BobServiceSession *session) { uint32_t i; unsigned int *p; @@ -577,125 +573,125 @@ compute_service_response (struct BobServiceSession *session) count = session->used_element_count; a = session->e_a; b = session->sorted_elements; - q = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK, - count); - p = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK, - count); - rand = GNUNET_malloc (sizeof (gcry_mpi_t) * count); + q = GNUNET_CRYPTO_random_permute(GNUNET_CRYPTO_QUALITY_WEAK, + count); + p = GNUNET_CRYPTO_random_permute(GNUNET_CRYPTO_QUALITY_WEAK, + count); + rand = GNUNET_malloc(sizeof(gcry_mpi_t) * count); for (i = 0; i < count; i++) - GNUNET_assert (NULL != (rand[i] = gcry_mpi_new (0))); - r = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * count); - r_prime = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * count); + GNUNET_assert(NULL != (rand[i] = gcry_mpi_new(0))); + r = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count); + r_prime = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count); for (i = 0; i < count; i++) - { - int32_t svalue; + { + int32_t svalue; - svalue = (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, + svalue = (int32_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX); - // long to gcry_mpi_t - if (svalue < 0) - gcry_mpi_sub_ui (rand[i], - rand[i], - - svalue); - else - rand[i] = gcry_mpi_set_ui (rand[i], svalue); - } - - tmp = gcry_mpi_new (0); + // long to gcry_mpi_t + if (svalue < 0) + gcry_mpi_sub_ui(rand[i], + rand[i], + -svalue); + else + rand[i] = gcry_mpi_set_ui(rand[i], svalue); + } + + tmp = gcry_mpi_new(0); // encrypt the element // for the sake of readability I decided to have dedicated permutation // 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++) - { - // E(S - r_pi - b_pi) - gcry_mpi_sub (tmp, my_offset, rand[p[i]]); - gcry_mpi_sub (tmp, tmp, b[p[i]].value); - GNUNET_assert (2 == - GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey, + { + // E(S - r_pi - b_pi) + gcry_mpi_sub(tmp, my_offset, rand[p[i]]); + gcry_mpi_sub(tmp, tmp, b[p[i]].value); + GNUNET_assert(2 == + GNUNET_CRYPTO_paillier_encrypt(&session->remote_pubkey, tmp, 2, &r[i])); - // E(S - r_pi - b_pi) * E(S + a_pi) == E(2*S + a - r - b) - if (GNUNET_OK != - GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey, - &r[i], - &a[p[i]], - &r[i])) - { - GNUNET_break_op (0); - goto error_cleanup; + // E(S - r_pi - b_pi) * E(S + a_pi) == E(2*S + a - r - b) + if (GNUNET_OK != + GNUNET_CRYPTO_paillier_hom_add(&session->remote_pubkey, + &r[i], + &a[p[i]], + &r[i])) + { + GNUNET_break_op(0); + goto error_cleanup; + } } - } // Calculate Kq = E(S + a_qi) (+) E(S - r_qi) for (i = 0; i < count; i++) - { - // E(S - r_qi) - gcry_mpi_sub (tmp, my_offset, rand[q[i]]); - GNUNET_assert (2 == - GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey, + { + // E(S - r_qi) + gcry_mpi_sub(tmp, my_offset, rand[q[i]]); + GNUNET_assert(2 == + GNUNET_CRYPTO_paillier_encrypt(&session->remote_pubkey, tmp, 2, &r_prime[i])); - // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi) - if (GNUNET_OK != - GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey, - &r_prime[i], - &a[q[i]], - &r_prime[i])) - { - GNUNET_break_op (0); - goto error_cleanup; + // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi) + if (GNUNET_OK != + GNUNET_CRYPTO_paillier_hom_add(&session->remote_pubkey, + &r_prime[i], + &a[q[i]], + &r_prime[i])) + { + GNUNET_break_op(0); + goto error_cleanup; + } } - } - gcry_mpi_release (tmp); + gcry_mpi_release(tmp); // Calculate S' = E(SUM( r_i^2 )) - tmp = compute_square_sum (rand, count); - GNUNET_assert (1 == - GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey, - tmp, - 1, - &session->s_prime)); - gcry_mpi_release (tmp); + tmp = compute_square_sum(rand, count); + GNUNET_assert(1 == + GNUNET_CRYPTO_paillier_encrypt(&session->remote_pubkey, + tmp, + 1, + &session->s_prime)); + gcry_mpi_release(tmp); // Calculate S = E(SUM( (r_i + b_i)^2 )) for (i = 0; i < count; i++) - gcry_mpi_add (rand[i], rand[i], b[i].value); - tmp = compute_square_sum (rand, count); - GNUNET_assert (1 == - GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey, - tmp, - 1, - &session->s)); - gcry_mpi_release (tmp); + gcry_mpi_add(rand[i], rand[i], b[i].value); + tmp = compute_square_sum(rand, count); + GNUNET_assert(1 == + GNUNET_CRYPTO_paillier_encrypt(&session->remote_pubkey, + tmp, + 1, + &session->s)); + gcry_mpi_release(tmp); session->r = r; session->r_prime = r_prime; for (i = 0; i < count; i++) - gcry_mpi_release (rand[i]); - GNUNET_free (session->e_a); + gcry_mpi_release(rand[i]); + GNUNET_free(session->e_a); session->e_a = NULL; - GNUNET_free (p); - GNUNET_free (q); - GNUNET_free (rand); + GNUNET_free(p); + GNUNET_free(q); + GNUNET_free(rand); return GNUNET_OK; - error_cleanup: - GNUNET_free (r); - GNUNET_free (r_prime); - gcry_mpi_release (tmp); - GNUNET_free (p); - GNUNET_free (q); +error_cleanup: + GNUNET_free(r); + GNUNET_free(r_prime); + gcry_mpi_release(tmp); + GNUNET_free(p); + GNUNET_free(q); for (i = 0; i < count; i++) - gcry_mpi_release (rand[i]); - GNUNET_free (rand); + gcry_mpi_release(rand[i]); + GNUNET_free(rand); return GNUNET_SYSERR; } @@ -710,21 +706,21 @@ compute_service_response (struct BobServiceSession *session) * TODO: code duplication with Alice! */ static int -copy_element_cb (void *cls, - const struct GNUNET_HashCode *key, - void *value) +copy_element_cb(void *cls, + const struct GNUNET_HashCode *key, + void *value) { struct BobServiceSession *s = cls; struct GNUNET_SCALARPRODUCT_Element *e = value; gcry_mpi_t mval; int64_t val; - mval = gcry_mpi_new (0); - val = (int64_t) GNUNET_ntohll (e->value); + mval = gcry_mpi_new(0); + val = (int64_t)GNUNET_ntohll(e->value); if (0 > val) - gcry_mpi_sub_ui (mval, mval, -val); + gcry_mpi_sub_ui(mval, mval, -val); else - gcry_mpi_add_ui (mval, mval, val); + gcry_mpi_add_ui(mval, mval, val); s->sorted_elements [s->used_element_count].value = mval; s->sorted_elements [s->used_element_count].key = &e->key; s->used_element_count++; @@ -741,14 +737,14 @@ copy_element_cb (void *cls, * TODO: code duplication with Alice! */ static int -element_cmp (const void *a, - const void *b) +element_cmp(const void *a, + const void *b) { const struct MpiElement *ma = a; const struct MpiElement *mb = b; - return GNUNET_CRYPTO_hash_cmp (ma->key, - mb->key); + return GNUNET_CRYPTO_hash_cmp(ma->key, + mb->key); } @@ -760,33 +756,33 @@ element_cmp (const void *a, * @param s session to transmit reply for. */ static void -transmit_cryptographic_reply (struct BobServiceSession *s) +transmit_cryptographic_reply(struct BobServiceSession *s) { struct GNUNET_CADET_Channel *channel; /* TODO: code duplication with Alice! */ - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Received everything, building reply for Alice\n"); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Received everything, building reply for Alice\n"); s->sorted_elements - = GNUNET_malloc (GNUNET_CONTAINER_multihashmap_size (s->intersected_elements) * - sizeof (struct MpiElement)); + = GNUNET_malloc(GNUNET_CONTAINER_multihashmap_size(s->intersected_elements) * + sizeof(struct MpiElement)); s->used_element_count = 0; - GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements, - ©_element_cb, - s); - qsort (s->sorted_elements, - s->used_element_count, - sizeof (struct MpiElement), - &element_cmp); + GNUNET_CONTAINER_multihashmap_iterate(s->intersected_elements, + ©_element_cb, + s); + qsort(s->sorted_elements, + s->used_element_count, + sizeof(struct MpiElement), + &element_cmp); if (GNUNET_OK != - compute_service_response (s)) - { - channel = s->channel; - s->channel = NULL; - GNUNET_CADET_channel_destroy (channel); - return; - } - transmit_bobs_cryptodata_message (s); + compute_service_response(s)) + { + channel = s->channel; + s->channel = NULL; + GNUNET_CADET_channel_destroy(channel); + return; + } + transmit_bobs_cryptodata_message(s); } @@ -800,8 +796,8 @@ transmit_cryptographic_reply (struct BobServiceSession *s) * #GNUNET_SYSERR to close it (signal serious error) */ static int -check_alices_cryptodata_message (void *cls, - const struct AliceCryptodataMessage *msg) +check_alices_cryptodata_message(void *cls, + const struct AliceCryptodataMessage *msg) { struct BobServiceSession *s = cls; uint32_t contained_elements; @@ -809,21 +805,21 @@ check_alices_cryptodata_message (void *cls, uint16_t msize; unsigned int max; - msize = ntohs (msg->header.size); - contained_elements = ntohl (msg->contained_element_count); + msize = ntohs(msg->header.size); + contained_elements = ntohl(msg->contained_element_count); /* Our intersection may still be ongoing, but this is nevertheless an upper bound on the required array size */ - max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements); - msg_length = sizeof (struct AliceCryptodataMessage) - + contained_elements * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext); - if ( (msize != msg_length) || - (0 == contained_elements) || - (contained_elements > UINT16_MAX) || - (max < contained_elements + s->cadet_received_element_count) ) - { - GNUNET_break_op (0); - return GNUNET_SYSERR; - } + max = GNUNET_CONTAINER_multihashmap_size(s->intersected_elements); + msg_length = sizeof(struct AliceCryptodataMessage) + + contained_elements * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext); + if ((msize != msg_length) || + (0 == contained_elements) || + (contained_elements > UINT16_MAX) || + (max < contained_elements + s->cadet_received_element_count)) + { + GNUNET_break_op(0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -836,40 +832,40 @@ check_alices_cryptodata_message (void *cls, * @param msg the actual message */ static void -handle_alices_cryptodata_message (void *cls, - const struct AliceCryptodataMessage *msg) +handle_alices_cryptodata_message(void *cls, + const struct AliceCryptodataMessage *msg) { struct BobServiceSession *s = cls; const struct GNUNET_CRYPTO_PaillierCiphertext *payload; uint32_t contained_elements; unsigned int max; - contained_elements = ntohl (msg->contained_element_count); + contained_elements = ntohl(msg->contained_element_count); /* Our intersection may still be ongoing, but this is nevertheless an upper bound on the required array size */ - max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received %u crypto values from Alice\n", - (unsigned int) contained_elements); + max = GNUNET_CONTAINER_multihashmap_size(s->intersected_elements); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Received %u crypto values from Alice\n", + (unsigned int)contained_elements); - payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1]; + payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *)&msg[1]; if (NULL == s->e_a) - s->e_a = GNUNET_new_array (max, - struct GNUNET_CRYPTO_PaillierCiphertext); - GNUNET_memcpy (&s->e_a[s->cadet_received_element_count], - payload, - sizeof (struct GNUNET_CRYPTO_PaillierCiphertext) * contained_elements); + s->e_a = GNUNET_new_array(max, + struct GNUNET_CRYPTO_PaillierCiphertext); + GNUNET_memcpy(&s->e_a[s->cadet_received_element_count], + payload, + sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * contained_elements); s->cadet_received_element_count += contained_elements; - if ( (s->cadet_received_element_count == max) && - (NULL == s->intersection_op) ) - { - /* intersection has finished also on our side, and - we got the full set, so we can proceed with the - CADET response(s) */ - transmit_cryptographic_reply (s); - } - GNUNET_CADET_receive_done (s->channel); + if ((s->cadet_received_element_count == max) && + (NULL == s->intersection_op)) + { + /* intersection has finished also on our side, and + we got the full set, so we can proceed with the + CADET response(s) */ + transmit_cryptographic_reply(s); + } + GNUNET_CADET_receive_done(s->channel); } @@ -883,67 +879,71 @@ handle_alices_cryptodata_message (void *cls, * @param status what has happened with the set intersection? */ static void -cb_intersection_element_removed (void *cls, - const struct GNUNET_SET_Element *element, - uint64_t current_size, - enum GNUNET_SET_Status status) +cb_intersection_element_removed(void *cls, + const struct GNUNET_SET_Element *element, + uint64_t current_size, + enum GNUNET_SET_Status status) { struct BobServiceSession *s = cls; struct GNUNET_SCALARPRODUCT_Element *se; switch (status) - { - case GNUNET_SET_STATUS_OK: - /* this element has been removed from the set */ - se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements, - element->data); - GNUNET_assert (NULL != se); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Removed element with key %s and value %lld\n", - GNUNET_h2s (&se->key), - (long long) GNUNET_ntohll (se->value)); - GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove (s->intersected_elements, + { + case GNUNET_SET_STATUS_OK: + /* this element has been removed from the set */ + se = GNUNET_CONTAINER_multihashmap_get(s->intersected_elements, + element->data); + GNUNET_assert(NULL != se); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Removed element with key %s and value %lld\n", + GNUNET_h2s(&se->key), + (long long)GNUNET_ntohll(se->value)); + GNUNET_assert(GNUNET_YES == + GNUNET_CONTAINER_multihashmap_remove(s->intersected_elements, element->data, se)); - GNUNET_free (se); - return; - case GNUNET_SET_STATUS_DONE: - s->intersection_op = NULL; - GNUNET_break (NULL == s->intersection_set); - GNUNET_CADET_receive_done (s->channel); - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Finished intersection, %d items remain\n", - GNUNET_CONTAINER_multihashmap_size (s->intersected_elements)); - if (s->client_received_element_count == - GNUNET_CONTAINER_multihashmap_size (s->intersected_elements)) - { - /* CADET transmission from Alice is also already done, - start with our own reply */ - transmit_cryptographic_reply (s); + GNUNET_free(se); + return; + + case GNUNET_SET_STATUS_DONE: + s->intersection_op = NULL; + GNUNET_break(NULL == s->intersection_set); + GNUNET_CADET_receive_done(s->channel); + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Finished intersection, %d items remain\n", + GNUNET_CONTAINER_multihashmap_size(s->intersected_elements)); + if (s->client_received_element_count == + GNUNET_CONTAINER_multihashmap_size(s->intersected_elements)) + { + /* CADET transmission from Alice is also already done, + start with our own reply */ + transmit_cryptographic_reply(s); + } + return; + + case GNUNET_SET_STATUS_HALF_DONE: + /* unexpected for intersection */ + GNUNET_break(0); + return; + + case GNUNET_SET_STATUS_FAILURE: + /* unhandled status code */ + LOG(GNUNET_ERROR_TYPE_DEBUG, + "Set intersection failed!\n"); + s->intersection_op = NULL; + if (NULL != s->intersection_set) + { + GNUNET_SET_destroy(s->intersection_set); + s->intersection_set = NULL; + } + s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; + prepare_client_end_notification(s); + return; + + default: + GNUNET_break(0); + return; } - return; - case GNUNET_SET_STATUS_HALF_DONE: - /* unexpected for intersection */ - GNUNET_break (0); - return; - case GNUNET_SET_STATUS_FAILURE: - /* unhandled status code */ - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Set intersection failed!\n"); - s->intersection_op = NULL; - if (NULL != s->intersection_set) - { - GNUNET_SET_destroy (s->intersection_set); - s->intersection_set = NULL; - } - s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; - prepare_client_end_notification (s); - return; - default: - GNUNET_break (0); - return; - } } @@ -954,31 +954,31 @@ cb_intersection_element_removed (void *cls, * @param s client session to start intersection for */ static void -start_intersection (struct BobServiceSession *s) +start_intersection(struct BobServiceSession *s) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Got session with key %s and %u elements, starting intersection.\n", - GNUNET_h2s (&s->session_id), - (unsigned int) s->total); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Got session with key %s and %u elements, starting intersection.\n", + GNUNET_h2s(&s->session_id), + (unsigned int)s->total); s->intersection_op - = GNUNET_SET_prepare (&s->peer, - &s->session_id, - NULL, - GNUNET_SET_RESULT_REMOVED, - (struct GNUNET_SET_Option[]) {{ 0 }}, - &cb_intersection_element_removed, - s); + = GNUNET_SET_prepare(&s->peer, + &s->session_id, + NULL, + GNUNET_SET_RESULT_REMOVED, + (struct GNUNET_SET_Option[]) { { 0 } }, + &cb_intersection_element_removed, + s); if (GNUNET_OK != - GNUNET_SET_commit (s->intersection_op, - s->intersection_set)) - { - GNUNET_break (0); - s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; - prepare_client_end_notification (s); - return; - } - GNUNET_SET_destroy (s->intersection_set); + GNUNET_SET_commit(s->intersection_op, + s->intersection_set)) + { + GNUNET_break(0); + s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE; + prepare_client_end_notification(s); + return; + } + GNUNET_SET_destroy(s->intersection_set); s->intersection_set = NULL; } @@ -990,15 +990,15 @@ start_intersection (struct BobServiceSession *s) * @param msg the actual message */ static void -handle_alices_computation_request (void *cls, - const struct ServiceRequestMessage *msg) +handle_alices_computation_request(void *cls, + const struct ServiceRequestMessage *msg) { struct BobServiceSession *s = cls; s->session_id = msg->session_id; // ?? s->remote_pubkey = msg->public_key; if (s->client_received_element_count == s->total) - start_intersection (s); + start_intersection(s); } @@ -1013,20 +1013,20 @@ handle_alices_computation_request (void *cls, * @return session associated with the channel */ static void * -cb_channel_incoming (void *cls, - struct GNUNET_CADET_Channel *channel, - const struct GNUNET_PeerIdentity *initiator) +cb_channel_incoming(void *cls, + struct GNUNET_CADET_Channel *channel, + const struct GNUNET_PeerIdentity *initiator) { struct BobServiceSession *s = cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "New incoming channel from peer %s.\n", - GNUNET_i2s (initiator)); - GNUNET_CADET_close_port (s->port); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "New incoming channel from peer %s.\n", + GNUNET_i2s(initiator)); + GNUNET_CADET_close_port(s->port); s->port = NULL; s->channel = channel; s->peer = *initiator; - s->cadet_mq = GNUNET_CADET_get_mq (s->channel); + s->cadet_mq = GNUNET_CADET_get_mq(s->channel); return s; } @@ -1039,25 +1039,25 @@ cb_channel_incoming (void *cls, * @return #GNUNET_OK if @a msg is well-formed */ static int -check_bob_client_message_multipart (void *cls, - const struct ComputationBobCryptodataMultipartMessage *msg) +check_bob_client_message_multipart(void *cls, + const struct ComputationBobCryptodataMultipartMessage *msg) { struct BobServiceSession *s = cls; uint32_t contained_count; uint16_t msize; - msize = ntohs (msg->header.size); - contained_count = ntohl (msg->element_count_contained); - if ( (msize != (sizeof (struct ComputationBobCryptodataMultipartMessage) + - contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) || - (0 == contained_count) || - (UINT16_MAX < contained_count) || - (s->total == s->client_received_element_count) || - (s->total < s->client_received_element_count + contained_count) ) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } + 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) || + (UINT16_MAX < contained_count) || + (s->total == s->client_received_element_count) || + (s->total < s->client_received_element_count + contained_count)) + { + GNUNET_break(0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -1070,8 +1070,8 @@ check_bob_client_message_multipart (void *cls, * @param msg the actual message */ static void -handle_bob_client_message_multipart (void *cls, - const struct ComputationBobCryptodataMultipartMessage *msg) +handle_bob_client_message_multipart(void *cls, + const struct ComputationBobCryptodataMultipartMessage *msg) { struct BobServiceSession *s = cls; uint32_t contained_count; @@ -1079,44 +1079,44 @@ handle_bob_client_message_multipart (void *cls, 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]; + contained_count = ntohl(msg->element_count_contained); + elements = (const struct GNUNET_SCALARPRODUCT_Element *)&msg[1]; for (uint32_t i = 0; i < contained_count; i++) - { - elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element); - GNUNET_memcpy (elem, - &elements[i], - sizeof (struct GNUNET_SCALARPRODUCT_Element)); - if (GNUNET_SYSERR == - GNUNET_CONTAINER_multihashmap_put (s->intersected_elements, - &elem->key, - elem, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) { - GNUNET_break (0); - GNUNET_free (elem); - continue; + elem = GNUNET_new(struct GNUNET_SCALARPRODUCT_Element); + GNUNET_memcpy(elem, + &elements[i], + sizeof(struct GNUNET_SCALARPRODUCT_Element)); + if (GNUNET_SYSERR == + GNUNET_CONTAINER_multihashmap_put(s->intersected_elements, + &elem->key, + elem, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) + { + GNUNET_break(0); + GNUNET_free(elem); + continue; + } + set_elem.data = &elem->key; + set_elem.size = sizeof(elem->key); + set_elem.element_type = 0; + GNUNET_SET_add_element(s->intersection_set, + &set_elem, + NULL, NULL); } - set_elem.data = &elem->key; - set_elem.size = sizeof (elem->key); - set_elem.element_type = 0; - GNUNET_SET_add_element (s->intersection_set, - &set_elem, - NULL, NULL); - } s->client_received_element_count += contained_count; - GNUNET_SERVICE_client_continue (s->client); + GNUNET_SERVICE_client_continue(s->client); if (s->total != s->client_received_element_count) - { - /* more to come */ - return; - } + { + /* more to come */ + return; + } if (NULL == s->channel) - { - /* no Alice waiting for this request, wait for Alice */ - return; - } - start_intersection (s); + { + /* no Alice waiting for this request, wait for Alice */ + return; + } + start_intersection(s); } @@ -1129,8 +1129,8 @@ handle_bob_client_message_multipart (void *cls, * @return #GNUNET_OK if @a msg is well-formed */ static int -check_bob_client_message (void *cls, - const struct BobComputationMessage *msg) +check_bob_client_message(void *cls, + const struct BobComputationMessage *msg) { struct BobServiceSession *s = cls; uint32_t contained_count; @@ -1138,22 +1138,22 @@ check_bob_client_message (void *cls, uint16_t msize; if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } - msize = ntohs (msg->header.size); - total_count = ntohl (msg->element_count_total); - contained_count = ntohl (msg->element_count_contained); - if ( (0 == total_count) || - (0 == contained_count) || - (UINT16_MAX < contained_count) || - (msize != (sizeof (struct BobComputationMessage) + - contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) ) - { - GNUNET_break_op (0); - return GNUNET_SYSERR; - } + { + GNUNET_break(0); + return GNUNET_SYSERR; + } + msize = ntohs(msg->header.size); + total_count = ntohl(msg->element_count_total); + contained_count = ntohl(msg->element_count_contained); + if ((0 == total_count) || + (0 == contained_count) || + (UINT16_MAX < contained_count) || + (msize != (sizeof(struct BobComputationMessage) + + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element)))) + { + GNUNET_break_op(0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -1167,20 +1167,20 @@ check_bob_client_message (void *cls, * @param msg the actual message */ static void -handle_bob_client_message (void *cls, - const struct BobComputationMessage *msg) +handle_bob_client_message(void *cls, + const struct BobComputationMessage *msg) { struct BobServiceSession *s = cls; struct GNUNET_MQ_MessageHandler cadet_handlers[] = { - GNUNET_MQ_hd_fixed_size (alices_computation_request, - GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION, - struct ServiceRequestMessage, - NULL), - GNUNET_MQ_hd_var_size (alices_cryptodata_message, - GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA, - struct AliceCryptodataMessage, - NULL), - GNUNET_MQ_handler_end () + GNUNET_MQ_hd_fixed_size(alices_computation_request, + GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION, + struct ServiceRequestMessage, + NULL), + GNUNET_MQ_hd_var_size(alices_cryptodata_message, + GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA, + struct AliceCryptodataMessage, + NULL), + GNUNET_MQ_handler_end() }; uint32_t contained_count; uint32_t total_count; @@ -1188,61 +1188,61 @@ handle_bob_client_message (void *cls, 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); + total_count = ntohl(msg->element_count_total); + contained_count = ntohl(msg->element_count_contained); s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE; s->total = total_count; s->client_received_element_count = contained_count; s->session_id = msg->session_key; - elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1]; + elements = (const struct GNUNET_SCALARPRODUCT_Element *)&msg[1]; s->intersected_elements - = GNUNET_CONTAINER_multihashmap_create (s->total, - GNUNET_YES); + = GNUNET_CONTAINER_multihashmap_create(s->total, + GNUNET_YES); s->intersection_set - = GNUNET_SET_create (cfg, - GNUNET_SET_OPERATION_INTERSECTION); + = 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; - elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element); - GNUNET_memcpy (elem, - &elements[i], - sizeof (struct GNUNET_SCALARPRODUCT_Element)); - if (GNUNET_SYSERR == - GNUNET_CONTAINER_multihashmap_put (s->intersected_elements, - &elem->key, - elem, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) { - GNUNET_break (0); - GNUNET_free (elem); - continue; + if (0 == GNUNET_ntohll(elements[i].value)) + continue; + elem = GNUNET_new(struct GNUNET_SCALARPRODUCT_Element); + GNUNET_memcpy(elem, + &elements[i], + sizeof(struct GNUNET_SCALARPRODUCT_Element)); + if (GNUNET_SYSERR == + GNUNET_CONTAINER_multihashmap_put(s->intersected_elements, + &elem->key, + elem, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) + { + GNUNET_break(0); + GNUNET_free(elem); + continue; + } + set_elem.data = &elem->key; + set_elem.size = sizeof(elem->key); + set_elem.element_type = 0; + GNUNET_SET_add_element(s->intersection_set, + &set_elem, + NULL, NULL); + s->used_element_count++; } - set_elem.data = &elem->key; - set_elem.size = sizeof (elem->key); - set_elem.element_type = 0; - GNUNET_SET_add_element (s->intersection_set, - &set_elem, - NULL, NULL); - s->used_element_count++; - } - GNUNET_SERVICE_client_continue (s->client); + GNUNET_SERVICE_client_continue(s->client); /* We're ready, open the port */ - s->port = GNUNET_CADET_open_port (my_cadet, - &msg->session_key, - &cb_channel_incoming, - s, - NULL, - &cb_channel_destruction, - cadet_handlers); + s->port = GNUNET_CADET_open_port(my_cadet, + &msg->session_key, + &cb_channel_incoming, + s, + NULL, + &cb_channel_destruction, + cadet_handlers); if (NULL == s->port) - { - GNUNET_break (0); - GNUNET_SERVICE_client_drop (s->client); - return; - } + { + GNUNET_break(0); + GNUNET_SERVICE_client_drop(s->client); + return; + } } @@ -1252,16 +1252,16 @@ handle_bob_client_message (void *cls, * @param cls unused */ static void -shutdown_task (void *cls) +shutdown_task(void *cls) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Shutting down, initiating cleanup.\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Shutting down, initiating cleanup.\n"); // FIXME: we have to cut our connections to CADET first! if (NULL != my_cadet) - { - GNUNET_CADET_disconnect (my_cadet); - my_cadet = NULL; - } + { + GNUNET_CADET_disconnect(my_cadet); + my_cadet = NULL; + } } @@ -1276,13 +1276,13 @@ shutdown_task (void *cls) * @return our `struct BobServiceSession` */ static void * -client_connect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) +client_connect_cb(void *cls, + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct BobServiceSession *s; - s = GNUNET_new (struct BobServiceSession); + s = GNUNET_new(struct BobServiceSession); s->client = client; s->client_mq = mq; return s; @@ -1300,16 +1300,16 @@ client_connect_cb (void *cls, * @param app_cls our `struct BobServiceSession` */ static void -client_disconnect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_cls) +client_disconnect_cb(void *cls, + struct GNUNET_SERVICE_Client *client, + void *app_cls) { struct BobServiceSession *s = app_cls; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client disconnected from us.\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Client disconnected from us.\n"); s->client = NULL; - destroy_service_session (s); + destroy_service_session(s); } @@ -1321,31 +1321,31 @@ client_disconnect_cb (void *cls, * @param service the initialized service */ static void -run (void *cls, - const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_SERVICE_Handle *service) +run(void *cls, + const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_SERVICE_Handle *service) { cfg = c; /* - offset has to be sufficiently small to allow computation of: - m1+m2 mod n == (S + a) + (S + b) mod n, - if we have more complex operations, this factor needs to be lowered */ - my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3); - gcry_mpi_set_bit (my_offset, - GNUNET_CRYPTO_PAILLIER_BITS / 3); - - GNUNET_CRYPTO_paillier_create (&my_pubkey, - &my_privkey); - my_cadet = GNUNET_CADET_connect (cfg); - GNUNET_SCHEDULER_add_shutdown (&shutdown_task, - NULL); + offset has to be sufficiently small to allow computation of: + m1+m2 mod n == (S + a) + (S + b) mod n, + if we have more complex operations, this factor needs to be lowered */ + my_offset = gcry_mpi_new(GNUNET_CRYPTO_PAILLIER_BITS / 3); + gcry_mpi_set_bit(my_offset, + GNUNET_CRYPTO_PAILLIER_BITS / 3); + + GNUNET_CRYPTO_paillier_create(&my_pubkey, + &my_privkey); + my_cadet = GNUNET_CADET_connect(cfg); + GNUNET_SCHEDULER_add_shutdown(&shutdown_task, + NULL); if (NULL == my_cadet) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("Connect to CADET failed\n")); - GNUNET_SCHEDULER_shutdown (); - return; - } + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + _("Connect to CADET failed\n")); + GNUNET_SCHEDULER_shutdown(); + return; + } } @@ -1353,21 +1353,21 @@ run (void *cls, * Define "main" method using service macro. */ 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 ()); + ("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 */ -- cgit v1.2.3