1 files changed, 570 insertions, 570 deletions

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 <http://www.gnu.org/licenses/>.
 
@@ -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;i<s->used_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,
-                                         &copy_element_cb,
-                                         s);
-  qsort (s->sorted_elements,
-         s->used_element_count,
-         sizeof (struct MpiElement),
-         &element_cmp);
+  GNUNET_CONTAINER_multihashmap_iterate(s->intersected_elements,
+                                        &copy_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 */