cleaning up scalar product client API

4 files changed, 482 insertions, 538 deletions

diff --git a/src/scalarproduct/gnunet-scalarproduct.c b/src/scalarproduct/gnunet-scalarproduct.c
index 2bb708fc9..88069d41d 100644
--- a/src/scalarproduct/gnunet-scalarproduct.c
+++ b/src/scalarproduct/gnunet-scalarproduct.c
@@ -261,22 +261,22 @@ run (void *cls,
          _ ("Need elements to compute the vectorproduct, got none.\n"));
     return;
   }
-  
-  elements = (struct GNUNET_SCALARPRODUCT_Element *) 
+
+  elements = (struct GNUNET_SCALARPRODUCT_Element *)
           GNUNET_malloc(sizeof(struct GNUNET_SCALARPRODUCT_Element)*element_count);
-  
+
   for (i = 0; i < element_count;i++)
   {
     struct GNUNET_SCALARPRODUCT_Element element;
     char* separator=NULL;
-    
+
     // get the length of the current key,value; tupel
     for (end = begin; *end != ';'; end++)
       if (*end == ',')
         separator = end;
-    
+
     // final element
-    if ((NULL == separator) 
+    if ((NULL == separator)
          || (begin == separator)
              || (separator == end - 1 )) {
       LOG (GNUNET_ERROR_TYPE_ERROR,
@@ -284,20 +284,20 @@ run (void *cls,
       GNUNET_free(elements);
       return;
     }
-    
+
     // read the element's key
     *separator = 0;
     GNUNET_CRYPTO_hash (begin, strlen (begin), &element.key);
-    
+
     // read the element's value
-    if (1 != sscanf (separator+1, "%" SCNd32 ";", &element.value))
+    if (1 != sscanf (separator+1, "%" SCNd64 ";", &element.value))
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Could not convert `%s' to int32_t.\n"), begin);
+           _ ("Could not convert `%s' to int64_t.\n"), begin);
       GNUNET_free(elements);
       return;
     }
-    
+
     elements[i]=element;
     begin = end+1;
   }
diff --git a/src/scalarproduct/gnunet-service-scalarproduct.c b/src/scalarproduct/gnunet-service-scalarproduct.c
index 568f68ffc..7758d7046 100644
--- a/src/scalarproduct/gnunet-service-scalarproduct.c
+++ b/src/scalarproduct/gnunet-service-scalarproduct.c
@@ -37,9 +37,119 @@
 
 #define LOG(kind,...) GNUNET_log_from (kind, "scalarproduct", __VA_ARGS__)
 
-///////////////////////////////////////////////////////////////////////////////
-//                     Service Structure Definitions
-///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Maximum count of elements we can put into a multipart message
+ */
+#define MULTIPART_ELEMENT_CAPACITY ((GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct MultipartMessage)) / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext))
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message type passed from requesting service Alice to responding
+ * service Bob to initiate a request and make Bob participate in our
+ * protocol
+ */
+struct ServiceRequestMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * the transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Alice's public key
+   */
+  struct GNUNET_CRYPTO_PaillierPublicKey public_key;
+
+};
+
+
+/**
+ * FIXME.
+ */
+struct AliceCryptodataMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * how many elements we appended to this message
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * struct GNUNET_CRYPTO_PaillierCiphertext[contained_element_count]
+   */
+};
+
+
+/**
+ * Multipart Message type passed between to supply additional elements
+ * for the peer
+ */
+struct MultipartMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * how many elements we supply within this message
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  // struct GNUNET_CRYPTO_PaillierCiphertext[multipart_element_count]
+};
+
+
+/**
+ * Message type passed from responding service Bob to responding service Alice
+ * to complete a request and allow Alice to compute the result
+ */
+struct ServiceResponseMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * how many elements the session input had
+   */
+  uint32_t total_element_count GNUNET_PACKED;
+
+  /**
+   * how many elements were included after the mask was applied
+   * including all multipart msgs.
+   */
+  uint32_t used_element_count GNUNET_PACKED;
+
+  /**
+   * how many elements this individual message delivers
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * the transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * followed by s | s' | k[i][perm]
+   */
+};
+
+GNUNET_NETWORK_STRUCT_END
 
 
 /**
@@ -599,15 +709,13 @@ prepare_client_end_notification (void * cls,
                                  const struct GNUNET_SCHEDULER_TaskContext * tc)
 {
   struct ServiceSession * s = cls;
-  struct GNUNET_SCALARPRODUCT_client_response * msg;
+  struct ClientResponseMessage * msg;
 
   s->client_notification_task = GNUNET_SCHEDULER_NO_TASK;
 
-  msg = GNUNET_new (struct GNUNET_SCALARPRODUCT_client_response);
+  msg = GNUNET_new (struct ClientResponseMessage);
+  msg->header.size = htons (sizeof (struct ClientResponseMessage));
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
-  memcpy (&msg->key, &s->session_id, sizeof (struct GNUNET_HashCode));
-  memcpy (&msg->peer, &s->peer, sizeof ( struct GNUNET_PeerIdentity));
-  msg->header.size = htons (sizeof (struct GNUNET_SCALARPRODUCT_client_response));
   // signal error if not signalized, positive result-range field but zero length.
   msg->product_length = htonl (0);
   msg->status = htonl(s->active);
@@ -615,23 +723,28 @@ prepare_client_end_notification (void * cls,
   s->msg = &msg->header;
 
   //transmit this message to our client
-  s->client_transmit_handle =
-          GNUNET_SERVER_notify_transmit_ready (s->client,
-                                               sizeof (struct GNUNET_SCALARPRODUCT_client_response),
-                                               GNUNET_TIME_UNIT_FOREVER_REL,
-                                               &cb_transfer_message,
-                                               s);
+  s->client_transmit_handle
+    = GNUNET_SERVER_notify_transmit_ready (s->client,
+                                           sizeof (struct ClientResponseMessage),
+                                           GNUNET_TIME_UNIT_FOREVER_REL,
+                                           &cb_transfer_message,
+                                           s);
 
   // if we could not even queue our request, something is wrong
-  if (NULL == s->client_transmit_handle) {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Could not send message to client (%p)!\n"), s->client);
+  if (NULL == s->client_transmit_handle)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Could not send message to client (%p)!\n"), s->client);
     GNUNET_SERVER_client_disconnect(s->client);
     free_session_variables(s);
     GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, s);
     GNUNET_free(s);
   }
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Sending session-end notification to client (%p) for session %s\n"), &s->client, GNUNET_h2s (&s->session_id));
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Sending session-end notification to client (%p) for session %s\n"),
+                s->client,
+                GNUNET_h2s (&s->session_id));
 }
 
 
@@ -644,15 +757,17 @@ static void
 prepare_alices_cyrptodata_message (void *cls)
 {
   struct ServiceSession * s = cls;
-  struct GNUNET_SCALARPRODUCT_alices_cryptodata_message * msg;
+  struct AliceCryptodataMessage * msg;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
   unsigned int i;
   uint32_t msg_length;
   gcry_mpi_t a;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Successfully created new channel to peer (%s)!\n"), GNUNET_i2s (&s->peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              _ ("Successfully created new channel to peer (%s)!\n"),
+              GNUNET_i2s (&s->peer));
 
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_alices_cryptodata_message)
+  msg_length = sizeof (struct AliceCryptodataMessage)
           +s->used_element_count * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
 
   if (GNUNET_SERVER_MAX_MESSAGE_SIZE > msg_length) {
@@ -660,9 +775,9 @@ prepare_alices_cyrptodata_message (void *cls)
   }
   else {
     //create a multipart msg, first we calculate a new msg size for the head msg
-    s->transferred_element_count = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_alices_cryptodata_message))
+    s->transferred_element_count = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct AliceCryptodataMessage))
             / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
-    msg_length = sizeof (struct GNUNET_SCALARPRODUCT_alices_cryptodata_message)
+    msg_length = sizeof (struct AliceCryptodataMessage)
             +s->transferred_element_count * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
   }
 
@@ -715,13 +830,13 @@ prepare_bobs_cryptodata_message_multipart (void *cls)
 {
   struct ServiceSession * s = cls;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
-  struct GNUNET_SCALARPRODUCT_multipart_message * msg;
+  struct MultipartMessage * msg;
   unsigned int i;
   unsigned int j;
   uint32_t msg_length;
   uint32_t todo_count;
 
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message);
+  msg_length = sizeof (struct MultipartMessage);
   todo_count = s->used_element_count - s->transferred_element_count;
 
   if (todo_count > MULTIPART_ELEMENT_CAPACITY / 2)
@@ -793,13 +908,13 @@ prepare_bobs_cryptodata_message (void *cls,
                           const struct GNUNET_SCHEDULER_TaskContext
                           * tc)
 {
-  struct ServiceSession * s = (struct ServiceSession *) cls;
-  struct GNUNET_SCALARPRODUCT_service_response * msg;
+  struct ServiceSession * s = cls;
+  struct ServiceResponseMessage * msg;
   uint32_t msg_length = 0;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
   int i;
 
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
+  msg_length = sizeof (struct ServiceResponseMessage)
           + 2 * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext); // s, stick
 
   if (GNUNET_SERVER_MAX_MESSAGE_SIZE >
@@ -885,7 +1000,7 @@ prepare_bobs_cryptodata_message (void *cls,
  * @param request the requesting session + bob's requesting peer
  */
 static void
-compute_service_response (struct ServiceSession * session)
+compute_service_response (struct ServiceSession *session)
 {
   int i;
   unsigned int * p;
@@ -1022,13 +1137,15 @@ cb_insert_element_sorted (void *cls,
   struct ServiceSession * s = (struct ServiceSession*) cls;
   struct SortedValue * e = GNUNET_new (struct SortedValue);
   struct SortedValue * o = s->a_head;
+  int64_t val;
 
   e->elem = value;
   e->val = gcry_mpi_new (0);
-  if (0 > e->elem->value)
-    gcry_mpi_sub_ui (e->val, e->val, abs (e->elem->value));
+  val = (int64_t) GNUNET_ntohll (e->elem->value);
+  if (0 > val)
+    gcry_mpi_sub_ui (e->val, e->val, - val);
   else
-    gcry_mpi_add_ui (e->val, e->val, e->elem->value);
+    gcry_mpi_add_ui (e->val, e->val, val);
 
   // insert as first element with the lowest key
   if (NULL == s->a_head
@@ -1208,7 +1325,7 @@ prepare_client_response (void *cls,
                          const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ServiceSession * s = cls;
-  struct GNUNET_SCALARPRODUCT_client_response * msg;
+  struct ClientResponseMessage *msg;
   unsigned char * product_exported = NULL;
   size_t product_length = 0;
   uint32_t msg_length = 0;
@@ -1250,10 +1367,8 @@ prepare_client_response (void *cls,
     gcry_mpi_release (value);
   }
 
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_client_response) +product_length;
+  msg_length = sizeof (struct ClientResponseMessage) + product_length;
   msg = GNUNET_malloc (msg_length);
-  msg->key = s->session_id;
-  msg->peer = s->peer;
   if (product_exported != NULL) {
     memcpy (&msg[1], product_exported, product_length);
     GNUNET_free (product_exported);
@@ -1285,27 +1400,31 @@ prepare_client_response (void *cls,
 static void
 prepare_alices_computation_request (struct ServiceSession * s)
 {
-  struct GNUNET_SCALARPRODUCT_service_request * msg;
+  struct ServiceRequestMessage * msg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Successfully created new channel to peer (%s)!\n"), GNUNET_i2s (&s->peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              _("Successfully created new channel to peer (%s)!\n"),
+              GNUNET_i2s (&s->peer));
 
-  msg = GNUNET_new (struct GNUNET_SCALARPRODUCT_service_request);
+  msg = GNUNET_new (struct ServiceRequestMessage);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA);
   memcpy (&msg->session_id, &s->session_id, sizeof (struct GNUNET_HashCode));
-  msg->header.size = htons (sizeof (struct GNUNET_SCALARPRODUCT_service_request));
+  msg->header.size = htons (sizeof (struct ServiceRequestMessage));
 
   s->msg = (struct GNUNET_MessageHeader *) msg;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Transmitting service request.\n"));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Transmitting service request.\n"));
 
   //transmit via cadet messaging
-  s->service_transmit_handle = GNUNET_CADET_notify_transmit_ready (s->channel, GNUNET_YES,
-                                                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                                                        sizeof (struct GNUNET_SCALARPRODUCT_service_request),
-                                                                        &cb_transfer_message,
-                                                                        s);
+  s->service_transmit_handle
+    = GNUNET_CADET_notify_transmit_ready (s->channel, GNUNET_YES,
+                                          GNUNET_TIME_UNIT_FOREVER_REL,
+                                          sizeof (struct ServiceRequestMessage),
+                                          &cb_transfer_message,
+                                          s);
   if (!s->service_transmit_handle) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not send message to channel!\n"));
+                _("Could not send message to channel!\n"));
     GNUNET_free (msg);
     s->msg = NULL;
     s->active = GNUNET_SYSERR;
@@ -1330,14 +1449,14 @@ static void
 prepare_alices_cyrptodata_message_multipart (void *cls)
 {
   struct ServiceSession * s = cls;
-  struct GNUNET_SCALARPRODUCT_multipart_message * msg;
+  struct MultipartMessage * msg;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
   unsigned int i;
   uint32_t msg_length;
   uint32_t todo_count;
   gcry_mpi_t a;
 
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message);
+  msg_length = sizeof (struct MultipartMessage);
   todo_count = s->used_element_count - s->transferred_element_count;
 
   if (todo_count > MULTIPART_ELEMENT_CAPACITY)
@@ -1472,7 +1591,7 @@ handle_client_message_multipart (void *cls,
                                  struct GNUNET_SERVER_Client *client,
                                  const struct GNUNET_MessageHeader *message)
 {
-  const struct GNUNET_SCALARPRODUCT_computation_message_multipart * msg = (const struct GNUNET_SCALARPRODUCT_computation_message_multipart *) message;
+  const struct ComputationMultipartMessage * msg = (const struct ComputationMultipartMessage *) message;
   struct ServiceSession * s;
   uint32_t contained_count;
   struct GNUNET_SCALARPRODUCT_Element * elements;
@@ -1488,8 +1607,9 @@ handle_client_message_multipart (void *cls,
   contained_count = ntohl (msg->element_count_contained);
 
   //sanity check: is the message as long as the message_count fields suggests?
-  if ((ntohs (msg->header.size) != (sizeof (struct GNUNET_SCALARPRODUCT_computation_message_multipart) +contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element)))
-      || (0 == contained_count) || (s->total < s->transferred_element_count + contained_count)) {
+  if ((ntohs (msg->header.size) != (sizeof (struct ComputationMultipartMessage) +contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element)))
+      || (0 == contained_count) || (s->total < s->transferred_element_count + contained_count))
+  {
     GNUNET_break_op (0);
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
@@ -1501,7 +1621,7 @@ handle_client_message_multipart (void *cls,
     struct GNUNET_SET_Element set_elem;
     struct GNUNET_SCALARPRODUCT_Element * elem;
 
-    if (0 == ntohl (elements[i].value))
+    if (0 == GNUNET_ntohll (elements[i].value))
       continue;
 
     elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
@@ -1549,7 +1669,7 @@ handle_client_message (void *cls,
                        struct GNUNET_SERVER_Client *client,
                        const struct GNUNET_MessageHeader *message)
 {
-  const struct GNUNET_SCALARPRODUCT_computation_message * msg = (const struct GNUNET_SCALARPRODUCT_computation_message *) message;
+  const struct ComputationMessage * msg = (const struct ComputationMessage *) message;
   struct ServiceSession * s;
   uint32_t contained_count;
   uint32_t total_count;
@@ -1577,8 +1697,10 @@ handle_client_message (void *cls,
   }
 
   //sanity check: is the message as long as the message_count fields suggests?
-  if ((ntohs (msg->header.size) != (sizeof (struct GNUNET_SCALARPRODUCT_computation_message) +contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element)))
-      || (0 == total_count)) {
+  if ((ntohs (msg->header.size) !=
+       (sizeof (struct ComputationMessage) + contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element)))
+      || (0 == total_count))
+  {
     GNUNET_break_op (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
@@ -1611,7 +1733,7 @@ handle_client_message (void *cls,
     struct GNUNET_SET_Element set_elem;
     struct GNUNET_SCALARPRODUCT_Element * elem;
 
-    if (0 == ntohl (elements[i].value))
+    if (0 == GNUNET_ntohll (elements[i].value))
       continue;
 
     elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
@@ -1862,7 +1984,7 @@ handle_alices_cyrptodata_message_multipart (void *cls,
                                             const struct GNUNET_MessageHeader * message)
 {
   struct ServiceSession * s;
-  const struct GNUNET_SCALARPRODUCT_multipart_message * msg = (const struct GNUNET_SCALARPRODUCT_multipart_message *) message;
+  const struct MultipartMessage * msg = (const struct MultipartMessage *) message;
   struct GNUNET_CRYPTO_PaillierCiphertext *payload;
   uint32_t contained_elements;
   uint32_t msg_length;
@@ -1875,11 +1997,11 @@ handle_alices_cyrptodata_message_multipart (void *cls,
     goto except;
   }
   // shorter than minimum?
-  if (ntohs (msg->header.size) <= sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)) {
+  if (ntohs (msg->header.size) <= sizeof (struct MultipartMessage)) {
     goto except;
   }
   contained_elements = ntohl (msg->contained_element_count);
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)
+  msg_length = sizeof (struct MultipartMessage)
           +contained_elements * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
   //sanity check
   if ((ntohs (msg->header.size) != msg_length)
@@ -1946,7 +2068,7 @@ handle_alices_cyrptodata_message (void *cls,
                                   const struct GNUNET_MessageHeader * message)
 {
   struct ServiceSession * s;
-  const struct GNUNET_SCALARPRODUCT_alices_cryptodata_message * msg = (const struct GNUNET_SCALARPRODUCT_alices_cryptodata_message *) message;
+  const struct AliceCryptodataMessage * msg = (const struct AliceCryptodataMessage *) message;
   struct GNUNET_CRYPTO_PaillierCiphertext *payload;
   uint32_t contained_elements = 0;
   uint32_t msg_length;
@@ -1966,12 +2088,13 @@ handle_alices_cyrptodata_message (void *cls,
   }
 
   // shorter than minimum?
-  if (ntohs (msg->header.size) <= sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)) {
+  if (ntohs (msg->header.size) <= sizeof (struct MultipartMessage))
+  {
     goto invalid_msg;
   }
 
   contained_elements = ntohl (msg->contained_element_count);
-  msg_length = sizeof (struct GNUNET_SCALARPRODUCT_alices_cryptodata_message)
+  msg_length = sizeof (struct AliceCryptodataMessage)
           +contained_elements * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
 
   //sanity check: is the message as long as the message_count fields suggests?
@@ -2039,7 +2162,7 @@ handle_alices_computation_request (void *cls,
 {
   struct ServiceSession * s;
   struct ServiceSession * client_session;
-  const struct GNUNET_SCALARPRODUCT_service_request * msg = (const struct GNUNET_SCALARPRODUCT_service_request *) message;
+  const struct ServiceRequestMessage * msg = (const struct ServiceRequestMessage *) message;
 
   s = (struct ServiceSession *) * channel_ctx;
   if ((BOB != s->role) || (s->total != 0)) {
@@ -2053,7 +2176,7 @@ handle_alices_computation_request (void *cls,
     return GNUNET_SYSERR;
   }
   // shorter than expected?
-  if (ntohs (msg->header.size) != sizeof (struct GNUNET_SCALARPRODUCT_service_request)) {
+  if (ntohs (msg->header.size) != sizeof (struct ServiceRequestMessage)) {
     GNUNET_free (s);
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
@@ -2155,7 +2278,7 @@ handle_bobs_cryptodata_multipart (void *cls,
                                    const struct GNUNET_MessageHeader * message)
 {
   struct ServiceSession * s;
-  const struct GNUNET_SCALARPRODUCT_multipart_message * msg = (const struct GNUNET_SCALARPRODUCT_multipart_message *) message;
+  const struct MultipartMessage * msg = (const struct MultipartMessage *) message;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
   size_t i;
   uint32_t contained = 0;
@@ -2169,14 +2292,14 @@ handle_bobs_cryptodata_multipart (void *cls,
     goto invalid_msg;
   }
   msg_size = ntohs (msg->header.size);
-  required_size = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)
+  required_size = sizeof (struct MultipartMessage)
           + 2 * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
   // shorter than minimum?
   if (required_size > msg_size) {
     goto invalid_msg;
   }
   contained = ntohl (msg->contained_element_count);
-  required_size = sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)
+  required_size = sizeof (struct MultipartMessage)
           + 2 * contained * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
   //sanity check: is the message as long as the message_count fields suggests?
   if ((required_size != msg_size) || (s->used_element_count < s->transferred_element_count + contained)) {
@@ -2239,12 +2362,12 @@ invalid_msg:
  */
 static int
 handle_bobs_cryptodata_message (void *cls,
-                         struct GNUNET_CADET_Channel * channel,
+                         struct GNUNET_CADET_Channel *channel,
                          void **channel_ctx,
-                         const struct GNUNET_MessageHeader * message)
+                         const struct GNUNET_MessageHeader *message)
 {
   struct ServiceSession * s;
-  const struct GNUNET_SCALARPRODUCT_service_response * msg = (const struct GNUNET_SCALARPRODUCT_service_response *) message;
+  const struct ServiceResponseMessage *msg = (const struct ServiceResponseMessage *) message;
   struct GNUNET_CRYPTO_PaillierCiphertext * payload;
   size_t i;
   uint32_t contained = 0;
@@ -2261,13 +2384,13 @@ handle_bobs_cryptodata_message (void *cls,
   }
   //we need at least a full message without elements attached
   msg_size = ntohs (msg->header.size);
-  required_size = sizeof (struct GNUNET_SCALARPRODUCT_service_response) + 2 * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
+  required_size = sizeof (struct ServiceResponseMessage) + 2 * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
 
   if (required_size > msg_size) {
     goto invalid_msg;
   }
   contained = ntohl (msg->contained_element_count);
-  required_size = sizeof (struct GNUNET_SCALARPRODUCT_service_response)
+  required_size = sizeof (struct ServiceResponseMessage)
           + 2 * contained * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext)
           + 2 * sizeof (struct GNUNET_CRYPTO_PaillierCiphertext);
   //sanity check: is the message as long as the message_count fields suggests?
diff --git a/src/scalarproduct/scalarproduct.h b/src/scalarproduct/scalarproduct.h
index 6837b3abc..4bafb18fb 100644
--- a/src/scalarproduct/scalarproduct.h
+++ b/src/scalarproduct/scalarproduct.h
@@ -33,14 +33,8 @@
 extern "C"
 {
 #endif
-///////////////////////////////////////////////////////////////////////////////
-//                      Defines
-///////////////////////////////////////////////////////////////////////////////
 
-/**
- * Maximum count of elements we can put into a multipart message
- */
-#define MULTIPART_ELEMENT_CAPACITY ((GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_multipart_message)) / sizeof (struct GNUNET_CRYPTO_PaillierCiphertext))
+GNUNET_NETWORK_STRUCT_BEGIN
 
 /**
  * Log an error message at log-level 'level' that indicates
@@ -49,15 +43,12 @@ extern "C"
  */
 #define LOG_GCRY(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0)
 
-///////////////////////////////////////////////////////////////////////////////
-//                     Scalar Product Message Types
-///////////////////////////////////////////////////////////////////////////////
 
 /**
  * Message type passed from client to service
  * to initiate a request or responder role
  */
-struct GNUNET_SCALARPRODUCT_computation_message
+struct ComputationMessage
 {
   /**
    * GNUNET message header
@@ -68,13 +59,18 @@ struct GNUNET_SCALARPRODUCT_computation_message
    * how many elements the vector in payload contains
    */
   uint32_t element_count_total GNUNET_PACKED;
-  
+
   /**
    * contained elements the vector in payload contains
    */
   uint32_t element_count_contained GNUNET_PACKED;
 
   /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
    * the transaction/session key used to identify a session
    */
   struct GNUNET_HashCode session_key;
@@ -89,16 +85,17 @@ struct GNUNET_SCALARPRODUCT_computation_message
    */
 };
 
+
 /**
- * multipart messages following GNUNET_SCALARPRODUCT_client_request
+ * multipart messages following `struct ComputationMessage`
  */
-struct GNUNET_SCALARPRODUCT_computation_message_multipart
+struct ComputationMultipartMessage
 {
   /**
    * GNUNET message header
    */
   struct GNUNET_MessageHeader header;
-  
+
   /**
    * contained elements the vector in payload contains
    */
@@ -111,105 +108,10 @@ struct GNUNET_SCALARPRODUCT_computation_message_multipart
 
 
 /**
- * Message type passed from requesting service Alice to responding service Bob
- * to initiate a request and make bob participate in our protocol
- */
-struct GNUNET_SCALARPRODUCT_service_request {
-  /**
-   * GNUNET message header
-   */
-  struct GNUNET_MessageHeader header;
-
-  /**
-   * the transaction/session key used to identify a session
-   */
-  struct GNUNET_HashCode session_id;
-
-  /**
-   * Alice's public key
-   */
-  struct GNUNET_CRYPTO_PaillierPublicKey public_key;
-
-};
-
-
-/**
- * Message type passed from requesting service Alice to responding service Bob
- * to initiate a request and make bob participate in our protocol
- */
-struct GNUNET_SCALARPRODUCT_alices_cryptodata_message {
-  /**
-   * GNUNET message header
-   */
-  struct GNUNET_MessageHeader header;
-
-  /**
-   * how many elements we appended to this message
-   */
-  uint32_t contained_element_count GNUNET_PACKED;
-
-  /**
-   * struct GNUNET_CRYPTO_PaillierCiphertext[contained_element_count]
-   */
-};
-
-/**
- * Multipart Message type passed between to supply additional elements for the peer
- */
-struct GNUNET_SCALARPRODUCT_multipart_message {
-  /**
-   * GNUNET message header
-   */
-  struct GNUNET_MessageHeader header;
-
-  /**
-   * how many elements we supply within this message
-   */
-  uint32_t contained_element_count GNUNET_PACKED;
-
-  // struct GNUNET_CRYPTO_PaillierCiphertext[multipart_element_count]
-};
-
-/**
- * Message type passed from responding service Bob to responding service Alice
- * to complete a request and allow Alice to compute the result
- */
-struct GNUNET_SCALARPRODUCT_service_response {
-  /**
-   * GNUNET message header
-   */
-  struct GNUNET_MessageHeader header;
-
-  /**
-   * how many elements the session input had
-   */
-  uint32_t total_element_count GNUNET_PACKED;
-
-  /**
-   * how many elements were included after the mask was applied including all multipart msgs.
-   */
-  uint32_t used_element_count GNUNET_PACKED;
-
-  /**
-   * how many elements this individual message delivers
-   */
-  uint32_t contained_element_count GNUNET_PACKED;
-
-  /**
-   * the transaction/session key used to identify a session
-   */
-  struct GNUNET_HashCode key;
-
-  /**
-   * followed by s | s' | k[i][perm]
-   */
-};
-
-/**
  * Message type passed from service client
  * to finalize a session as requester or responder
  */
-struct GNUNET_SCALARPRODUCT_client_response
+struct ClientResponseMessage
 {
   /**
    * GNUNET message header
@@ -222,30 +124,22 @@ struct GNUNET_SCALARPRODUCT_client_response
   uint32_t product_length GNUNET_PACKED;
 
   /**
-   * the transaction/session key used to identify a session
-   */
-  struct GNUNET_HashCode key;
-
-  /**
-   * the identity of a remote peer we want to communicate with
-   */
-  struct GNUNET_PeerIdentity peer;
-
-  /**
    * status information about the outcome of this session
    */
-  int32_t status;
-  
+  int32_t status GNUNET_PACKED;
+
   /**
    * Workaround for libgcrypt: -1 if negative, 0 if zero, else 1
    */
-  int8_t range;
+  int32_t range GNUNET_PACKED;
 
   /**
    * followed by product of length product_length (or nothing)
    */
 };
 
+GNUNET_NETWORK_STRUCT_END
+
 #ifdef  __cplusplus
 }
 #endif
diff --git a/src/scalarproduct/scalarproduct_api.c b/src/scalarproduct/scalarproduct_api.c
index 3b92af579..ea62027ab 100644
--- a/src/scalarproduct/scalarproduct_api.c
+++ b/src/scalarproduct/scalarproduct_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2013 Christian Grothoff (and other contributing authors)
+     (C) 2013, 2014 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -23,7 +23,7 @@
  * @brief API for the scalarproduct
  * @author Christian Fuchs
  * @author Gaurav Kukreja
- *
+ * @author Christian Grothoff
  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
@@ -34,16 +34,19 @@
 
 #define LOG(kind,...) GNUNET_log_from (kind, "scalarproduct-api",__VA_ARGS__)
 
-/**************************************************************
- ***  Datatype Declarations                          **********
- **************************************************************/
 
 /**
- * the abstraction function for our internal callback
+ * The abstraction function for our internal callback
+ *
+ * @param h computation handle
+ * @param msg response we got, NULL on errors
+ * @param status processing status code
  */
-typedef void (*GNUNET_SCALARPRODUCT_ResponseMessageHandler) (void *cls,
-                                                             const struct GNUNET_MessageHeader *msg,
-                                                             enum GNUNET_SCALARPRODUCT_ResponseStatus status);
+typedef void
+(*GNUNET_SCALARPRODUCT_ResponseMessageHandler) (struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+                                                const struct ClientResponseMessage *msg,
+                                                enum GNUNET_SCALARPRODUCT_ResponseStatus status);
+
 
 /**
  * A handle returned for each computation
@@ -61,11 +64,6 @@ struct GNUNET_SCALARPRODUCT_ComputationHandle
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * Handle for statistics.
-   */
-  struct GNUNET_STATISTICS_Handle *stats;
-
-  /**
    * The shared session key identifying this computation
    */
   struct GNUNET_HashCode key;
@@ -76,31 +74,26 @@ struct GNUNET_SCALARPRODUCT_ComputationHandle
   struct GNUNET_CLIENT_TransmitHandle *th;
 
   /**
-   * count of all elements we offer for computation
+   * count of all @e elements we offer for computation
    */
   uint32_t element_count_total;
 
   /**
-   * count of the transfered elements we offer for computation
+   * count of the transfered @e elements we offer for computation
    */
   uint32_t element_count_transfered;
-  
+
   /**
-   * the client's elements which 
+   * the client's elements which
    */
-  struct GNUNET_SCALARPRODUCT_Element * elements;
-  
+  struct GNUNET_SCALARPRODUCT_Element *elements;
+
   /**
    * Message to be sent to the scalarproduct service
    */
-  void * msg;
+  struct GNUNET_MessageHeader *msg;
 
   /**
-   * The client's msg handler callback
-   */
-  union
-  {
-  /**
    * Function to call after transmission of the request (Bob).
    */
   GNUNET_SCALARPRODUCT_ContinuationWithStatus cont_status;
@@ -109,101 +102,99 @@ struct GNUNET_SCALARPRODUCT_ComputationHandle
    * Function to call after transmission of the request (Alice).
    */
   GNUNET_SCALARPRODUCT_DatumProcessor cont_datum;
-  };
 
   /**
-   * Closure for 'cont'.
+   * Closure for @e cont_status or @e cont_datum.
    */
   void *cont_cls;
 
   /**
-   * API internal callback for results and failures to be forwarded to the client
+   * API internal callback for results and failures to be forwarded to
+   * the client.
    */
   GNUNET_SCALARPRODUCT_ResponseMessageHandler response_proc;
-  
-  /**
-   * 
-   */
-  GNUNET_SCHEDULER_TaskIdentifier cont_multipart;
-};
-
-/**************************************************************
- ***  Forward Function Declarations                          **********
- **************************************************************/
-
-void
-GNUNET_SCALARPRODUCT_cancel (struct GNUNET_SCALARPRODUCT_ComputationHandle * h);
 
-static size_t do_send_message (void *cls, size_t size, void *buf);
-/**************************************************************
- ***  Static Function Declarations                   **********
- **************************************************************/
+};
 
 
 /**
- * Handles the STATUS received from the service for a response, does not contain a payload
+ * Handles the STATUS received from the service for a response, does
+ * not contain a payload.
  *
- * @param cls our Handle
+ * @param h our Handle
  * @param msg Pointer to the response received
  * @param status the condition the request was terminated with (eg: disconnect)
  */
 static void
-process_status_message (void *cls,
-                        const struct GNUNET_MessageHeader *msg,
+process_status_message (struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+                        const struct ClientResponseMessage *msg,
                         enum GNUNET_SCALARPRODUCT_ResponseStatus status)
 {
-  struct GNUNET_SCALARPRODUCT_ComputationHandle *qe = cls;
-
-  qe->cont_status (qe->cont_cls, status);
+  if (NULL != h->cont_status)
+    h->cont_status (h->cont_cls,
+                    status);
+  GNUNET_SCALARPRODUCT_cancel (h);
 }
 
 
 /**
- * Handles the RESULT received from the service for a request, should contain a result MPI value
+ * Handles the RESULT received from the service for a request, should
+ * contain a result MPI value
  *
- * @param cls our Handle
+ * @param h our Handle
  * @param msg Pointer to the response received
  * @param status the condition the request was terminated with (eg: disconnect)
  */
 static void
-process_result_message (void *cls,
-                        const struct GNUNET_MessageHeader *msg,
+process_result_message (struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+                        const struct ClientResponseMessage *msg,
                         enum GNUNET_SCALARPRODUCT_ResponseStatus status)
 {
-  struct GNUNET_SCALARPRODUCT_ComputationHandle *qe = cls;
-  const struct GNUNET_SCALARPRODUCT_client_response *message =
-          (const struct GNUNET_SCALARPRODUCT_client_response *) msg;
+  size_t product_len = ntohl (msg->product_length);
   gcry_mpi_t result = NULL;
   gcry_error_t rc;
+  gcry_mpi_t num;
+  size_t rsize;
 
+  if (ntohs (msg->header.size) - sizeof (struct ClientResponseMessage)
+      != product_len)
+  {
+    GNUNET_break (0);
+    status = GNUNET_SCALARPRODUCT_Status_InvalidResponse;
+  }
   if (GNUNET_SCALARPRODUCT_Status_Success == status)
+  {
+    result = gcry_mpi_new (0);
+
+    if (0 < product_len)
     {
-      size_t product_len = ntohl (message->product_length);
-      result = gcry_mpi_new (0);
-
-      if (0 < product_len)
-        {
-          gcry_mpi_t num;
-          size_t read = 0;
-
-          if (0 != (rc = gcry_mpi_scan (&num, GCRYMPI_FMT_STD, &message[1], product_len, &read)))
-            {
-              LOG_GCRY(GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
-              gcry_mpi_release (result);
-              result = NULL;
-              status = GNUNET_SCALARPRODUCT_Status_InvalidResponse;
-            }
-          else
-            {
-              if (0 < message->range)
-                gcry_mpi_add (result, result, num);
-              else if (0 > message->range)
-                gcry_mpi_sub (result, result, num);
-              gcry_mpi_release (num);
-            }
-        }
+      rsize = 0;
+      if (0 != (rc = gcry_mpi_scan (&num, GCRYMPI_FMT_STD,
+                                    &msg[1],
+                                    product_len,
+                                    &rsize)))
+      {
+        LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
+                  "gcry_mpi_scan",
+                  rc);
+        gcry_mpi_release (result);
+        result = NULL;
+        status = GNUNET_SCALARPRODUCT_Status_InvalidResponse;
+      }
+      else
+      {
+        if (0 < ntohl (msg->range))
+          gcry_mpi_add (result, result, num);
+        else if (0 > ntohl (msg->range))
+          gcry_mpi_sub (result, result, num);
+        gcry_mpi_release (num);
+      }
     }
-  qe->cont_datum (qe->cont_cls, status, result);
+  }
+  h->cont_datum (h->cont_cls, status, result);
+  if (NULL != result)
+    gcry_mpi_release (result);
+  GNUNET_SCALARPRODUCT_cancel (h);
 }
 
 
@@ -216,144 +207,114 @@ process_result_message (void *cls,
  * @param msg Pointer to the data received in response
  */
 static void
-receive_cb (void *cls, const struct GNUNET_MessageHeader *msg)
+receive_cb (void *cls,
+            const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_SCALARPRODUCT_ComputationHandle *h = cls;
-  const struct GNUNET_SCALARPRODUCT_client_response *message =
-          (const struct GNUNET_SCALARPRODUCT_client_response *) msg;
-  enum GNUNET_SCALARPRODUCT_ResponseStatus status = GNUNET_SCALARPRODUCT_Status_InvalidResponse;
+  const struct ClientResponseMessage *message;
 
   if (NULL == msg)
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING, "Disconnected by Service.\n");
-      status = GNUNET_SCALARPRODUCT_Status_ServiceDisconnected;
-    }
-  else if ((GNUNET_SYSERR != message->status) && (0 < message->product_length ))
-    {
-      // response for the responder client, successful
-      GNUNET_STATISTICS_update (h->stats,
-                                gettext_noop ("# SUC responder result messages received"), 1,
-                                GNUNET_NO);
-
-      status = GNUNET_SCALARPRODUCT_Status_Success;
-    }
-  else if (message->status == GNUNET_SYSERR){
-      // service signaled an error
-      status = GNUNET_SCALARPRODUCT_Status_Failure;
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Disconnected from SCALARPRODUCT service.\n");
+    h->response_proc (h,
+                      NULL,
+                      GNUNET_SCALARPRODUCT_Status_ServiceDisconnected);
+    return;
   }
-  
-  if (h->cont_status != NULL)
-    h->response_proc (h, msg, status);
-
-  GNUNET_free (h);
-}
-
-
-static void
-send_multipart (void * cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
-{
-  struct GNUNET_SCALARPRODUCT_ComputationHandle *h = (struct GNUNET_SCALARPRODUCT_ComputationHandle *) cls;
-  struct GNUNET_SCALARPRODUCT_computation_message_multipart *msg;
-  uint32_t size;
-  uint32_t todo;
-
-  h->cont_multipart = GNUNET_SCHEDULER_NO_TASK;
-
-  todo = h->element_count_total - h->element_count_transfered;
-  size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message_multipart) +todo * sizeof (struct GNUNET_SCALARPRODUCT_Element);
-  if (GNUNET_SERVER_MAX_MESSAGE_SIZE <= size) {
-    //create a multipart msg, first we calculate a new msg size for the head msg
-    todo = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_computation_message_multipart)) / sizeof (struct GNUNET_SCALARPRODUCT_Element);
-    size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message_multipart) +todo * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  if (ntohs (msg->size) != sizeof (struct ClientResponseMessage))
+  {
+    GNUNET_break (0);
+    h->response_proc (h,
+                      NULL,
+                      GNUNET_SCALARPRODUCT_Status_InvalidResponse);
+    return;
   }
-
-  msg = (struct GNUNET_SCALARPRODUCT_computation_message_multipart*) GNUNET_malloc (size);
-  h->msg = msg;
-  msg->header.size = htons (size);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MUTLIPART);
-  msg->element_count_contained = htonl (todo);
-
-  memcpy (&msg[1], &h->elements[h->element_count_transfered], todo * sizeof (struct GNUNET_SCALARPRODUCT_Element));
-  h->element_count_transfered += todo;
-
-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, size,
-                                               GNUNET_TIME_UNIT_FOREVER_REL,
-                                               GNUNET_YES, // retry is OK in the initial stage
-                                               &do_send_message, h);
-
-  if (!h->th) {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _ ("Failed to send a multipart message to the scalarproduct service\n"));
-    GNUNET_STATISTICS_update (h->stats,
-                              gettext_noop ("# transmission request failures"),
-                              1, GNUNET_NO);
-    GNUNET_STATISTICS_destroy (h->stats, GNUNET_YES);
-    GNUNET_CLIENT_disconnect (h->client);
-    GNUNET_free (h->msg);
-    h->msg = NULL;
-    if (h->cont_status != NULL)
-      h->response_proc (h, NULL, GNUNET_SCALARPRODUCT_Status_Failure);
-
-    GNUNET_SCALARPRODUCT_cancel (cls);
+  message = (const struct ClientResponseMessage *) msg;
+  if (GNUNET_SYSERR == ntohl (message->status))
+  {
+    h->response_proc (h,
+                      NULL,
+                      GNUNET_SCALARPRODUCT_Status_Failure);
+    return;
   }
+  h->response_proc (h,
+                    message,
+                    GNUNET_SCALARPRODUCT_Status_Success);
 }
 
+
 /**
- * Transmits the request to the VectorProduct Service
+ * Transmits the request to the SCALARPRODUCT service
  *
- * @param cls Closure
- * @param size Size of the buffer
+ * @param cls Closure with the `struct GNUNET_SCALARPRODUCT_ComputationHandle`
+ * @param size Size of the buffer @a buf
  * @param buf Pointer to the buffer
- *
  * @return Size of the message sent
  */
 static size_t
-do_send_message (void *cls, size_t size,
+do_send_message (void *cls,
+                 size_t size,
                  void *buf)
 {
   struct GNUNET_SCALARPRODUCT_ComputationHandle *h = cls;
+  struct ComputationMultipartMessage *msg;
+  size_t ret;
+  uint32_t nsize;
+  uint32_t todo;
 
-  if (NULL == buf) {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to transmit request to SCALARPRODUCT.\n");
-    GNUNET_STATISTICS_update (h->stats,
-                              gettext_noop ("# transmission request failures"),
-                              1, GNUNET_NO);
-
-    // notify caller about the error, done here.
-    if (h->cont_status != NULL)
-      h->response_proc (h, NULL, GNUNET_SCALARPRODUCT_Status_Failure);
-
-    GNUNET_SCALARPRODUCT_cancel (cls);
+  h->th = NULL;
+  if (NULL == buf)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Failed to transmit request to SCALARPRODUCT.\n");
+    /* notify caller about the error, done here */
+    h->response_proc (h, NULL,
+                      GNUNET_SCALARPRODUCT_Status_Failure);
     return 0;
   }
-  memcpy (buf, h->msg, size);
-
+  ret = ntohs (h->msg->size);
+  memcpy (buf, h->msg, ret);
   GNUNET_free (h->msg);
   h->msg = NULL;
-  h->th = NULL;
-
-#if INSANE_STATISTICS
-  GNUNET_STATISTICS_update (h->stats,
-                            gettext_noop ("# bytes sent to scalarproduct"), 1,
-                            GNUNET_NO);
-#endif
 
-  /* done sending */
-  if (h->element_count_total == h->element_count_transfered) {
-    GNUNET_CLIENT_receive (h->client, &receive_cb, h,
+  /* done sending? */
+  if (h->element_count_total == h->element_count_transfered)
+  {
+    GNUNET_CLIENT_receive (h->client,
+                           &receive_cb, h,
                            GNUNET_TIME_UNIT_FOREVER_REL);
-    return size;
+    return ret;
   }
-  
-  h->cont_multipart = GNUNET_SCHEDULER_add_now (&send_multipart, h);
-  
-  return size;
-}
 
+  todo = h->element_count_total - h->element_count_transfered;
+  nsize = sizeof (struct ComputationMultipartMessage)
+    + todo * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  if (GNUNET_SERVER_MAX_MESSAGE_SIZE <= size)
+  {
+    /* cannot do all of them, limit to what is possible in one message */
+    todo = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct ComputationMultipartMessage))
+      / sizeof (struct GNUNET_SCALARPRODUCT_Element);
+    nsize = sizeof (struct ComputationMultipartMessage)
+      + todo * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  }
 
-/**************************************************************
- ***  API                                            **********
- **************************************************************/
+  msg = GNUNET_malloc (nsize);
+  h->msg = &msg->header;
+  msg->header.size = htons (nsize);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MUTLIPART);
+  msg->element_count_contained = htonl (todo);
+  memcpy (&msg[1],
+          &h->elements[h->element_count_transfered],
+          todo * sizeof (struct GNUNET_SCALARPRODUCT_Element));
+  h->element_count_transfered += todo;
+  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, nsize,
+                                               GNUNET_TIME_UNIT_FOREVER_REL,
+                                               GNUNET_NO,
+                                               &do_send_message, h);
+  GNUNET_assert (NULL != h->th);
+  return ret;
+}
 
 
 /**
@@ -362,96 +323,75 @@ do_send_message (void *cls, size_t size,
  * @param cfg the gnunet configuration handle
  * @param key Session key unique to the requesting client
  * @param elements Array of elements of the vector
- * @param element_count Number of elements in the vector
+ * @param element_count Number of elements in the @a elements vector
  * @param cont Callback function
- * @param cont_cls Closure for the callback function
- *
+ * @param cont_cls Closure for @a cont
  * @return a new handle for this computation
  */
 struct GNUNET_SCALARPRODUCT_ComputationHandle *
-GNUNET_SCALARPRODUCT_accept_computation (const struct GNUNET_CONFIGURATION_Handle * cfg,
-                               const struct GNUNET_HashCode * session_key,
-                               const struct GNUNET_SCALARPRODUCT_Element * elements,
-                               uint32_t element_count,
-                               GNUNET_SCALARPRODUCT_ContinuationWithStatus cont,
-                               void * cont_cls)
+GNUNET_SCALARPRODUCT_accept_computation (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                         const struct GNUNET_HashCode *session_key,
+                                         const struct GNUNET_SCALARPRODUCT_Element *elements,
+                                         uint32_t element_count,
+                                         GNUNET_SCALARPRODUCT_ContinuationWithStatus cont,
+                                         void *cont_cls)
 {
   struct GNUNET_SCALARPRODUCT_ComputationHandle *h;
-  struct GNUNET_SCALARPRODUCT_computation_message *msg;
+  struct ComputationMessage *msg;
   uint32_t size;
   uint16_t possible;
 
-  GNUNET_assert (GNUNET_SERVER_MAX_MESSAGE_SIZE >= sizeof (struct GNUNET_SCALARPRODUCT_computation_message)
-                 + element_count * sizeof (int32_t));
   h = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle);
+  h->cont_status = cont;
+  h->cont_cls = cont_cls;
+  h->response_proc = &process_status_message;
+  h->cfg = cfg;
+  h->key = *session_key;
   h->client = GNUNET_CLIENT_connect ("scalarproduct", cfg);
-  if (!h->client)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to connect to the scalarproduct service\n"));
-      GNUNET_free (h);
-      return NULL;
-    }
-  h->stats = GNUNET_STATISTICS_create ("scalarproduct-api", cfg);
-  if (!h->stats)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to send a message to the statistics service\n"));
-      GNUNET_CLIENT_disconnect (h->client);
-      GNUNET_free (h);
-      return NULL;
-    }
-
   h->element_count_total = element_count;
-  size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message) + element_count * sizeof (struct GNUNET_SCALARPRODUCT_Element);
-  if (GNUNET_SERVER_MAX_MESSAGE_SIZE > size) {
+  if (NULL == h->client)
+  {
+    /* scalarproduct configuration error */
+    GNUNET_break (0);
+    GNUNET_free (h);
+    return NULL;
+  }
+  size = sizeof (struct ComputationMessage)
+    + element_count * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  if (GNUNET_SERVER_MAX_MESSAGE_SIZE > size)
+  {
     possible = element_count;
     h->element_count_transfered = element_count;
   }
-  else {
-    //create a multipart msg, first we calculate a new msg size for the head msg
-    possible = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_computation_message)) / sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  else
+  {
+    /* create a multipart msg, first we calculate a new msg size for the head msg */
+    possible = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct ComputationMessage))
+      / sizeof (struct GNUNET_SCALARPRODUCT_Element);
     h->element_count_transfered = possible;
-    size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message) + possible*sizeof (struct GNUNET_SCALARPRODUCT_Element);
-    h->elements = (struct GNUNET_SCALARPRODUCT_Element*) 
-            GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element) * element_count);
-    memcpy (h->elements, elements, sizeof (struct GNUNET_SCALARPRODUCT_Element)*element_count);
+    size = sizeof (struct ComputationMessage)
+      + possible * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+    h->elements = GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element) * element_count);
+    memcpy (h->elements,
+            elements,
+            sizeof (struct GNUNET_SCALARPRODUCT_Element) * element_count);
   }
 
-  h->cont_status = cont;
-  h->cont_cls = cont_cls;
-  h->response_proc = &process_status_message;
-  h->cfg = cfg;
-  memcpy (&h->key, session_key, sizeof (struct GNUNET_HashCode));
-
-  msg = (struct GNUNET_SCALARPRODUCT_computation_message*) GNUNET_malloc (size);
-  h->msg = msg;
+  msg = GNUNET_malloc (size);
+  h->msg = &msg->header;
   msg->header.size = htons (size);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB);
   msg->element_count_total = htonl (element_count);
   msg->element_count_contained = htonl (possible);
-
-  memcpy (&msg->session_key, session_key, sizeof (struct GNUNET_HashCode));
-  memcpy (&msg[1], elements, possible);
-
+  msg->session_key = *session_key;
+  memcpy (&msg[1],
+          elements,
+          possible);
   h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, size,
                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                               GNUNET_YES, // retry is OK in the initial stage
+                                               GNUNET_YES, /* retry is OK in the initial stage */
                                                &do_send_message, h);
-  if (!h->th)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to send a message to the scalarproduct service\n"));
-      GNUNET_STATISTICS_update (h->stats,
-                              gettext_noop ("# transmission request failures"),
-                              1, GNUNET_NO);
-      GNUNET_STATISTICS_destroy (h->stats, GNUNET_YES);
-      GNUNET_CLIENT_disconnect (h->client);
-      GNUNET_free (h->msg);
-      GNUNET_free_non_null (h->elements);
-      GNUNET_free (h);
-      return NULL;
-    }
+  GNUNET_assert (NULL != h->th);
   return h;
 }
 
@@ -463,99 +403,82 @@ GNUNET_SCALARPRODUCT_accept_computation (const struct GNUNET_CONFIGURATION_Handl
  * @param session_key Session key should be unique to the requesting client
  * @param peer PeerID of the other peer
  * @param elements Array of elements of the vector
- * @param element_count Number of elements in the vector
+ * @param element_count Number of elements in the @a elements vector
  * @param cont Callback function
- * @param cont_cls Closure for the callback function
- *
+ * @param cont_cls Closure for @a cont
  * @return a new handle for this computation
  */
 struct GNUNET_SCALARPRODUCT_ComputationHandle *
-GNUNET_SCALARPRODUCT_start_computation (const struct GNUNET_CONFIGURATION_Handle * cfg,
-                              const struct GNUNET_HashCode * session_key,
-                              const struct GNUNET_PeerIdentity *peer,
-                              const struct GNUNET_SCALARPRODUCT_Element * elements,
-                              uint32_t element_count,
-                              GNUNET_SCALARPRODUCT_DatumProcessor cont,
-                              void * cont_cls)
+GNUNET_SCALARPRODUCT_start_computation (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                        const struct GNUNET_HashCode *session_key,
+                                        const struct GNUNET_PeerIdentity *peer,
+                                        const struct GNUNET_SCALARPRODUCT_Element *elements,
+                                        uint32_t element_count,
+                                        GNUNET_SCALARPRODUCT_DatumProcessor cont,
+                                        void *cont_cls)
 {
   struct GNUNET_SCALARPRODUCT_ComputationHandle *h;
-  struct GNUNET_SCALARPRODUCT_computation_message *msg;
+  struct ComputationMessage *msg;
   uint32_t size;
-  uint16_t possible;
+  uint32_t possible;
 
   h = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle);
   h->client = GNUNET_CLIENT_connect ("scalarproduct", cfg);
-  if (!h->client)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to connect to the scalarproduct service\n"));
-      GNUNET_free (h);
-      return NULL;
-    }
-  h->stats = GNUNET_STATISTICS_create ("scalarproduct-api", cfg);
-  if (!h->stats)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to send a message to the statistics service\n"));
-      GNUNET_CLIENT_disconnect (h->client);
-      GNUNET_free (h);
-      return NULL;
-    }
-
+  if (NULL == h->client)
+  {
+    /* missconfigured scalarproduct service */
+    GNUNET_break (0);
+    GNUNET_free (h);
+    return NULL;
+  }
   h->element_count_total = element_count;
-  size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message) + element_count * sizeof (struct GNUNET_SCALARPRODUCT_Element);
-  if (GNUNET_SERVER_MAX_MESSAGE_SIZE > size) {
+  h->cont_datum = cont;
+  h->cont_cls = cont_cls;
+  h->response_proc = &process_result_message;
+  h->cfg = cfg;
+  h->key = *session_key;
+  size = sizeof (struct ComputationMessage)
+    + element_count * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  if (GNUNET_SERVER_MAX_MESSAGE_SIZE > size)
+  {
     possible = element_count;
     h->element_count_transfered = element_count;
   }
-  else {
-    //create a multipart msg, first we calculate a new msg size for the head msg
-    possible = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct GNUNET_SCALARPRODUCT_computation_message)) / sizeof (struct GNUNET_SCALARPRODUCT_Element);
+  else
+  {
+    /* create a multipart msg, first we calculate a new msg size for the head msg */
+    possible = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - sizeof (struct ComputationMessage))
+      / sizeof (struct GNUNET_SCALARPRODUCT_Element);
     h->element_count_transfered = possible;
-    size = sizeof (struct GNUNET_SCALARPRODUCT_computation_message) + possible*sizeof (struct GNUNET_SCALARPRODUCT_Element);
-    h->elements = (struct GNUNET_SCALARPRODUCT_Element*) 
-            GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element) * element_count);
-    memcpy (h->elements, elements, sizeof (struct GNUNET_SCALARPRODUCT_Element) * element_count);
+    size = sizeof (struct ComputationMessage)
+      + possible * sizeof (struct GNUNET_SCALARPRODUCT_Element);
+    h->elements = GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element) * element_count);
+    memcpy (h->elements,
+            elements,
+            sizeof (struct GNUNET_SCALARPRODUCT_Element) * element_count);
   }
-  
-  h->cont_datum = cont;
-  h->cont_cls = cont_cls;
-  h->response_proc = &process_result_message;
-  h->cfg = cfg;
-  memcpy (&h->key, session_key, sizeof (struct GNUNET_HashCode));
 
-  msg = (struct GNUNET_SCALARPRODUCT_computation_message*) GNUNET_malloc (size);
-  h->msg = msg;
+  msg = GNUNET_malloc (size);
+  h->msg = &msg->header;
   msg->header.size = htons (size);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE);
   msg->element_count_total = htonl (element_count);
   msg->element_count_contained = htonl (possible);
-
-  memcpy (&msg->peer, peer, sizeof (struct GNUNET_PeerIdentity));
-  memcpy (&msg->session_key, session_key, sizeof (struct GNUNET_HashCode));
-  memcpy (&msg[1], elements, sizeof (struct GNUNET_SCALARPRODUCT_Element) * possible);
-
+  msg->reserved = htonl (0);
+  msg->peer = *peer;
+  msg->session_key = *session_key;
+  memcpy (&msg[1],
+          elements,
+          sizeof (struct GNUNET_SCALARPRODUCT_Element) * possible);
   h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, size,
                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                               GNUNET_YES, // retry is OK in the initial stage
+                                               GNUNET_YES, /* retry is OK in the initial stage */
                                                &do_send_message, h);
-  if (!h->th)
-    {
-      LOG (GNUNET_ERROR_TYPE_ERROR,
-           _ ("Failed to send a message to the scalarproduct service\n"));
-      GNUNET_STATISTICS_update (h->stats,
-                              gettext_noop ("# transmission request failures"),
-                              1, GNUNET_NO);
-      GNUNET_STATISTICS_destroy (h->stats, GNUNET_YES);
-      GNUNET_CLIENT_disconnect (h->client);
-      GNUNET_free (h->msg);
-      GNUNET_free_non_null (h->elements);
-      GNUNET_free (h);
-      return NULL;
-    }
+  GNUNET_assert (NULL != h->th);
   return h;
 }
 
+
 /**
  * Cancel an ongoing computation or revoke our collaboration offer.
  * Closes the connection to the service
@@ -563,16 +486,20 @@ GNUNET_SCALARPRODUCT_start_computation (const struct GNUNET_CONFIGURATION_Handle
  * @param h computation handle to terminate
  */
 void
-GNUNET_SCALARPRODUCT_cancel (struct GNUNET_SCALARPRODUCT_ComputationHandle * h)
+GNUNET_SCALARPRODUCT_cancel (struct GNUNET_SCALARPRODUCT_ComputationHandle *h)
 {
   if (NULL != h->th)
+  {
     GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-  if (GNUNET_SCHEDULER_NO_TASK != h->cont_multipart)
-    GNUNET_SCHEDULER_cancel (h->cont_multipart);
+    h->th = NULL;
+  }
   GNUNET_free_non_null (h->elements);
   GNUNET_free_non_null (h->msg);
-  GNUNET_CLIENT_disconnect (h->client);
-  GNUNET_STATISTICS_destroy (h->stats, GNUNET_YES);
+  if (NULL != h->client)
+  {
+    GNUNET_CLIENT_disconnect (h->client);
+    h->client = NULL;
+  }
   GNUNET_free (h);
 }