-doxygen, some additional error checking

4 files changed, 168 insertions, 99 deletions

diff --git a/src/include/gnunet_secretsharing_service.h b/src/include/gnunet_secretsharing_service.h
index 3673ca0fe..98e270e84 100644
--- a/src/include/gnunet_secretsharing_service.h
+++ b/src/include/gnunet_secretsharing_service.h
@@ -187,7 +187,7 @@ typedef void (*GNUNET_SECRETSHARING_DecryptCallback) (void *cls,
  * with the other peers.
  *
  * @param cfg configuration to use
- * @param num_peers number of peers in 'peers'
+ * @param num_peers number of peers in @a peers
  * @param peers array of peers that we will share secrets with, can optionally contain the local peer
  * @param session_id unique session id
  * @param start When should all peers be available for sharing the secret?
@@ -196,7 +196,7 @@ typedef void (*GNUNET_SECRETSHARING_DecryptCallback) (void *cls,
  *                 by underlying consensus sessions
  * @param threshold minimum number of peers that must cooperate to decrypt a value
  * @param cb called when the secret has been established
- * @param cls closure for cb
+ * @param cls closure for @a cb
  */
 struct GNUNET_SECRETSHARING_Session *
 GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *cfg,
@@ -214,10 +214,10 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c
  * Destroy a secret sharing session.
  * The secret ready callback will not be called.
  *
- * @param session session to destroy
+ * @param s session to destroy
  */
 void
-GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *session);
+GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s);
 
 
 /**
@@ -271,10 +271,10 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * The decrypt_cb is not called anymore, but the calling
  * peer may already have irrevocably contributed his share for the decryption of the value.
  *
- * @param decryption_handle decryption to cancel
+ * @param dh to cancel
  */
 void
-GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *decryption_handle);
+GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *dh);
 
 
 /**
diff --git a/src/scalarproduct/gnunet-service-scalarproduct.c b/src/scalarproduct/gnunet-service-scalarproduct.c
index b133bb325..568f68ffc 100644
--- a/src/scalarproduct/gnunet-service-scalarproduct.c
+++ b/src/scalarproduct/gnunet-service-scalarproduct.c
@@ -60,17 +60,17 @@ struct SortedValue
    * Sorted Values are kept in a DLL
    */
   struct SortedValue * next;
-  
+
   /**
    * Sorted Values are kept in a DLL
    */
   struct SortedValue * prev;
-  
+
   /**
    * The element's id+integer-value
    */
   struct GNUNET_SCALARPRODUCT_Element * elem;
-  
+
   /**
    * the element's value converted to MPI
    */
@@ -91,7 +91,7 @@ struct ServiceSession
    * Is this session active(GNUNET_YES), Concluded(GNUNET_NO), (GNUNET_SYSERR)
    */
   int32_t active;
-  
+
   /**
    * the role this peer has
    */
@@ -116,7 +116,7 @@ struct ServiceSession
    * Alice or Bob's peerID
    */
   struct GNUNET_PeerIdentity peer;
-  
+
   /**
    * the client this request is related to
    */
@@ -148,13 +148,13 @@ struct ServiceSession
   uint32_t transferred_element_count;
 
   /**
-   * Set of elements for which will conduction an intersection. 
+   * Set of elements for which will conduction an intersection.
    * the resulting elements are then used for computing the scalar product.
    */
   struct GNUNET_SET_Handle * intersection_set;
 
   /**
-   * Set of elements for which will conduction an intersection. 
+   * Set of elements for which will conduction an intersection.
    * the resulting elements are then used for computing the scalar product.
    */
   struct GNUNET_SET_OperationHandle * intersection_op;
@@ -561,7 +561,7 @@ cb_client_disconnect (void *cls,
   s = GNUNET_SERVER_client_get_user_context (client, struct ServiceSession);
   if (NULL == s)
     return;
-  
+
   GNUNET_CONTAINER_DLL_remove (from_client_head, from_client_tail, s);
 
   if (NULL != s->service_transmit_handle){
@@ -751,14 +751,14 @@ prepare_bobs_cryptodata_message_multipart (void *cls)
                                              s);
   if (NULL == s->service_transmit_handle) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-response message via cadet!)\n"));
-    
+
     GNUNET_free (msg);
     s->msg = NULL;
     GNUNET_CADET_channel_destroy(s->channel);
     s->response->active = GNUNET_SYSERR;
-    
+
     GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, s);
-    
+
     s->response->client_notification_task =
             GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
                                       s->response);
@@ -852,7 +852,7 @@ prepare_bobs_cryptodata_message (void *cls,
     GNUNET_CONTAINER_DLL_remove (from_service_head, from_service_tail, s);
     GNUNET_CADET_channel_destroy(s->channel);
     s->response->active = GNUNET_SYSERR;
-    
+
     s->response->client_notification_task =
             GNUNET_SCHEDULER_add_now (&prepare_client_end_notification,
                                       s->response);
@@ -1087,7 +1087,7 @@ cb_intersection_element_removed (void *cls,
 
   case GNUNET_SET_STATUS_DONE:
     s->intersection_op = NULL;
-    
+
     if (2 > s->used_element_count) {
       // failed! do not leak information about our single remaining element!
       // continue after the loop
@@ -1102,7 +1102,7 @@ cb_intersection_element_removed (void *cls,
     for (i = 0; NULL != s->a_head; i++) {
       struct SortedValue* a = s->a_head;
       GNUNET_assert (i < s->used_element_count);
-      
+
       s->sorted_elements[i] = a->val;
       GNUNET_CONTAINER_DLL_remove (s->a_head, s->a_tail, a);
       GNUNET_free (a->elem);
@@ -1129,7 +1129,7 @@ cb_intersection_element_removed (void *cls,
 
   //failed if we go here
   GNUNET_break_op (0);
-  
+
 
   // and notify our client-session that we could not complete the session
   if (ALICE == s->role) {
@@ -1262,31 +1262,18 @@ prepare_client_response (void *cls,
   msg->header.size = htons (msg_length);
   msg->range = range;
   msg->product_length = htonl (product_length);
-
   s->msg = (struct GNUNET_MessageHeader *) msg;
-  //transmit this message to our client
   s->client_transmit_handle =
           GNUNET_SERVER_notify_transmit_ready (s->client,
                                                msg_length,
                                                GNUNET_TIME_UNIT_FOREVER_REL,
                                                &cb_transfer_message,
                                                s);
-  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
-    // gracefully sent message, just terminate session structure
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _ ("Sent result to client (%p), this session (%s) has ended!\n"),
-                s->client,
-                GNUNET_h2s (&s->session_id));
-  free_session_variables (s);
+  GNUNET_break (NULL != s->client_transmit_handle);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Sent result to client (%p), this session (%s) has ended!\n"),
+              s->client,
+              GNUNET_h2s (&s->session_id));
 }
 
 
@@ -1317,7 +1304,8 @@ prepare_alices_computation_request (struct ServiceSession * s)
                                                                         &cb_transfer_message,
                                                                         s);
   if (!s->service_transmit_handle) {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send message to channel!\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not send message to channel!\n"));
     GNUNET_free (msg);
     s->msg = NULL;
     s->active = GNUNET_SYSERR;
@@ -1383,7 +1371,8 @@ prepare_alices_cyrptodata_message_multipart (void *cls)
                                                                         &cb_transfer_message,
                                                                         s);
   if (!s->service_transmit_handle) {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Could not send service-request multipart message to channel!\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not send service-request multipart message to channel!\n"));
     GNUNET_free (msg);
     s->msg = NULL;
     s->active = GNUNET_SYSERR;
@@ -1397,7 +1386,7 @@ prepare_alices_cyrptodata_message_multipart (void *cls)
 
 /**
  * Our client has finished sending us its multipart message.
- * 
+ *
  * @param session the service session context
  */
 static void
@@ -1442,7 +1431,7 @@ client_request_complete_bob (struct ServiceSession * client_session)
 
 /**
  * Our client has finished sending us its multipart message.
- * 
+ *
  * @param session the service session context
  */
 static void
@@ -1719,7 +1708,7 @@ cb_channel_destruction (void *cls,
               _ ("Peer disconnected, terminating session %s with peer (%s)\n"),
               GNUNET_h2s (&s->session_id),
               GNUNET_i2s (&s->peer));
-  
+
   // as we have only one peer connected in each session, just remove the session
   s->channel = NULL;
 
@@ -1881,7 +1870,7 @@ handle_alices_cyrptodata_message_multipart (void *cls,
   // are we in the correct state?
   s = (struct ServiceSession *) * channel_ctx;
   //we are not bob
-  if ((NULL == s->e_a) || //or we did not expect this message yet 
+  if ((NULL == s->e_a) || //or we did not expect this message yet
       (s->used_element_count == s->transferred_element_count)) { //we are not expecting multipart messages
     goto except;
   }
@@ -2265,8 +2254,8 @@ handle_bobs_cryptodata_message (void *cls,
   GNUNET_assert (NULL != message);
   s = (struct ServiceSession *) * channel_ctx;
   // are we in the correct state?
-  if (NULL == s->sorted_elements 
-      || NULL != s->msg 
+  if (NULL == s->sorted_elements
+      || NULL != s->msg
       || s->used_element_count != s->transferred_element_count) {
     goto invalid_msg;
   }
@@ -2411,7 +2400,7 @@ run (void *cls,
     0
   };
   cfg = c;
-  
+
   //generate private/public key set
   GNUNET_CRYPTO_paillier_create (&my_pubkey, &my_privkey);
 
diff --git a/src/secretsharing/secretsharing_api.c b/src/secretsharing/secretsharing_api.c
index 6e347f6da..a1f5c336e 100644
--- a/src/secretsharing/secretsharing_api.c
+++ b/src/secretsharing/secretsharing_api.c
@@ -44,7 +44,7 @@ struct GNUNET_SECRETSHARING_Session
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * Message queue for 'client'.
+   * Message queue for @e client.
    */
   struct GNUNET_MQ_Handle *mq;
 
@@ -54,12 +54,15 @@ struct GNUNET_SECRETSHARING_Session
   GNUNET_SECRETSHARING_SecretReadyCallback secret_ready_cb;
 
   /**
-   * Closure for 'secret_ready_cb'.
+   * Closure for @e secret_ready_cb.
    */
   void *secret_ready_cls;
 };
 
 
+/**
+ * Handle to cancel a cooperative decryption operation.
+ */
 struct GNUNET_SECRETSHARING_DecryptionHandle
 {
   /**
@@ -68,7 +71,7 @@ struct GNUNET_SECRETSHARING_DecryptionHandle
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * Message queue for 'client'.
+   * Message queue for @e client.
    */
   struct GNUNET_MQ_Handle *mq;
 
@@ -78,7 +81,7 @@ struct GNUNET_SECRETSHARING_DecryptionHandle
   GNUNET_SECRETSHARING_DecryptCallback decrypt_cb;
 
   /**
-   * Closure for 'decrypt_cb'.
+   * Closure for @e decrypt_cb.
    */
   void *decrypt_cls;
 };
@@ -103,6 +106,9 @@ static gcry_mpi_t elgamal_p;
 static gcry_mpi_t elgamal_g;
 
 
+/**
+ * Function to initialize #elgamal_q, #egamal_p and #elgamal_g.
+ */
 static void
 ensure_elgamal_initialized (void)
 {
@@ -118,60 +124,117 @@ ensure_elgamal_initialized (void)
 }
 
 
+/**
+ * Callback invoked when there is an error communicating with
+ * the service.  Notifies the application about the error.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_Session`
+ * @param error error code
+ */
 static void
-handle_session_client_error (void *cls, enum GNUNET_MQ_Error error)
+handle_session_client_error (void *cls,
+                             enum GNUNET_MQ_Error error)
 {
   struct GNUNET_SECRETSHARING_Session *s = cls;
 
   s->secret_ready_cb (s->secret_ready_cls, NULL, NULL, 0, NULL);
+  GNUNET_SECRETSHARING_session_destroy (s);
 }
 
 
+/**
+ * Callback invoked when there is an error communicating with
+ * the service.  Notifies the application about the error.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_DecryptionHandle`
+ * @param error error code
+ */
 static void
-handle_decrypt_client_error (void *cls, enum GNUNET_MQ_Error error)
+handle_decrypt_client_error (void *cls,
+                             enum GNUNET_MQ_Error error)
 {
   struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
-  
+
   dh->decrypt_cb (dh->decrypt_cls, NULL);
+  GNUNET_SECRETSHARING_decrypt_cancel (dh);
 }
 
 
+/**
+ * Handler invoked with the final result message from
+ * secret sharing.  Decodes the message and passes the
+ * result to the application.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_Session`
+ * @param msg message with the result
+ */
 static void
-handle_secret_ready (void *cls, const struct GNUNET_MessageHeader *msg)
+handle_secret_ready (void *cls,
+                     const struct GNUNET_MessageHeader *msg)
 {
-  struct GNUNET_SECRETSHARING_Session *session = cls;
+  struct GNUNET_SECRETSHARING_Session *s = cls;
+  const struct GNUNET_SECRETSHARING_SecretReadyMessage *m;
   struct GNUNET_SECRETSHARING_Share *share;
-  const struct GNUNET_SECRETSHARING_SecretReadyMessage *m = (const void *) msg;
   size_t share_size;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "got secret ready message of size %u\n",
-       ntohs (m->header.size));
-
-  share_size = ntohs (m->header.size) - sizeof *m;
-
-  share = GNUNET_SECRETSHARING_share_read (&m[1], share_size, NULL);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got secret ready message of size %u\n",
+       ntohs (msg->size));
+  if (ntohs (msg->size) < sizeof (struct GNUNET_SECRETSHARING_SecretReadyMessage))
+  {
+    GNUNET_break (0);
+    s->secret_ready_cb (s->secret_ready_cls, NULL, NULL, 0, NULL);
+    GNUNET_SECRETSHARING_session_destroy (s);
+    return;
+  }
+  m = (const struct GNUNET_SECRETSHARING_SecretReadyMessage *) msg;
+  share_size = ntohs (m->header.size) - sizeof (struct GNUNET_SECRETSHARING_SecretReadyMessage);
 
-  session->secret_ready_cb (session->secret_ready_cls,
+  share = GNUNET_SECRETSHARING_share_read (&m[1],
+                                           share_size,
+                                           NULL);
+  s->secret_ready_cb (s->secret_ready_cls,
                       share, /* FIXME */
                       &share->public_key,
                       share->num_peers,
                       (struct GNUNET_PeerIdentity *) &m[1]);
-
-  GNUNET_SECRETSHARING_session_destroy (session);
+  GNUNET_SECRETSHARING_session_destroy (s);
 }
 
 
+/**
+ * Destroy a secret sharing session.
+ * The secret ready callback will not be called.
+ *
+ * @param s session to destroy
+ */
 void
-GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *session)
+GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s)
 {
-  GNUNET_MQ_destroy (session->mq);
-  session->mq = NULL;
-  GNUNET_CLIENT_disconnect (session->client);
-  session->client = NULL;
-  GNUNET_free (session);
+  GNUNET_MQ_destroy (s->mq);
+  s->mq = NULL;
+  GNUNET_CLIENT_disconnect (s->client);
+  s->client = NULL;
+  GNUNET_free (s);
 }
 
 
+/**
+ * Create a session that will eventually establish a shared secret
+ * with the other peers.
+ *
+ * @param cfg configuration to use
+ * @param num_peers number of peers in @a peers
+ * @param peers array of peers that we will share secrets with, can optionally contain the local peer
+ * @param session_id unique session id
+ * @param start When should all peers be available for sharing the secret?
+ *              Random number generation can take place before the start time.
+ * @param deadline point in time where the session must be established; taken as hint
+ *                 by underlying consensus sessions
+ * @param threshold minimum number of peers that must cooperate to decrypt a value
+ * @param cb called when the secret has been established
+ * @param cls closure for @a cb
+ */
 struct GNUNET_SECRETSHARING_Session *
 GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                      unsigned int num_peers,
@@ -187,19 +250,25 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_SECRETSHARING_CreateMessage *msg;
   static const struct GNUNET_MQ_MessageHandler mq_handlers[] = {
-    {handle_secret_ready, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, 0},
+    { &handle_secret_ready,
+      GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, 0},
     GNUNET_MQ_HANDLERS_END
   };
 
-
   s = GNUNET_new (struct GNUNET_SECRETSHARING_Session);
   s->client = GNUNET_CLIENT_connect ("secretsharing", cfg);
+  if (NULL == s->client)
+  {
+    /* secretsharing not configured correctly */
+    GNUNET_break (0);
+    GNUNET_free (s);
+    return NULL;
+  }
   s->secret_ready_cb = cb;
   s->secret_ready_cls = cls;
-  GNUNET_assert (NULL != s->client);
-
   s->mq = GNUNET_MQ_queue_for_connection_client (s->client, mq_handlers,
-                                                   handle_session_client_error, s);
+                                                 &handle_session_client_error,
+                                                 s);
   GNUNET_assert (NULL != s->mq);
 
   ev = GNUNET_MQ_msg_extra (msg,
@@ -215,19 +284,20 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c
 
   GNUNET_MQ_send (s->mq, ev);
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "secretsharing session created with %u peers\n",
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Secretsharing session created with %u peers\n",
        num_peers);
   return s;
 }
 
 
 static void
-handle_decrypt_done (void *cls, const struct GNUNET_MessageHeader *msg)
+handle_decrypt_done (void *cls,
+                     const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
   const struct GNUNET_SECRETSHARING_DecryptResponseMessage *m =
-      (const void *) msg;
-
+    (const void *) msg; // FIXME: size check!?
   const struct GNUNET_SECRETSHARING_Plaintext *plaintext;
 
   if (m->success == 0)
@@ -280,7 +350,8 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_assert (NULL != s->client);
 
   s->mq = GNUNET_MQ_queue_for_connection_client (s->client, mq_handlers,
-                                                 handle_decrypt_client_error, s);
+                                                 &handle_decrypt_client_error,
+                                                 s);
   GNUNET_assert (NULL != s->mq);
 
   GNUNET_assert (GNUNET_OK == GNUNET_SECRETSHARING_share_write (share, NULL, 0, &share_size));
@@ -376,7 +447,7 @@ GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *publi
 
   // Randomize y such that 0 < y < elgamal_q.
   // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1.
-  do 
+  do
   {
     gcry_mpi_randomize (y, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1, GCRY_WEAK_RANDOM);
   } while ((gcry_mpi_cmp_ui (y, 0) == 0) || (gcry_mpi_cmp (y, elgamal_q) >= 0));
@@ -386,10 +457,10 @@ GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *publi
   // write tmp to c1
   GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c1_bits,
                                     GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
-  
+
   // tmp <- h^y
   gcry_mpi_powm (tmp, h, y, elgamal_p);
-  // tmp <- tmp * m 
+  // tmp <- tmp * m
   gcry_mpi_mulm (tmp, tmp, m, elgamal_p);
   // write tmp to c2
   GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c2_bits,
@@ -399,15 +470,22 @@ GNUNET_SECRETSHARING_encrypt (const struct GNUNET_SECRETSHARING_PublicKey *publi
 }
 
 
+/**
+ * Cancel a decryption.
+ *
+ * The decrypt_cb is not called anymore, but the calling
+ * peer may already have irrevocably contributed his share for the decryption of the value.
+ *
+ * @param dh to cancel
+ */
 void
-GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *h)
+GNUNET_SECRETSHARING_decrypt_cancel (struct GNUNET_SECRETSHARING_DecryptionHandle *dh)
 {
-  GNUNET_MQ_destroy (h->mq);
-  h->mq = NULL;
-  GNUNET_CLIENT_disconnect (h->client);
-  h->client = NULL;
-  GNUNET_free (h);
+  GNUNET_MQ_destroy (dh->mq);
+  dh->mq = NULL;
+  GNUNET_CLIENT_disconnect (dh->client);
+  dh->client = NULL;
+  GNUNET_free (dh);
 }
 
-
-
+/* end of secretsharing_api.c */
diff --git a/src/secretsharing/secretsharing_common.c b/src/secretsharing/secretsharing_common.c
index c1e5acb9c..5b5d13b62 100644
--- a/src/secretsharing/secretsharing_common.c
+++ b/src/secretsharing/secretsharing_common.c
@@ -30,7 +30,9 @@
  * @return The share, or NULL on error.
  */
 struct GNUNET_SECRETSHARING_Share *
-GNUNET_SECRETSHARING_share_read (const void *data, size_t len, size_t *readlen)
+GNUNET_SECRETSHARING_share_read (const void *data,
+                                 size_t len,
+                                 size_t *readlen)
 {
   struct GNUNET_SECRETSHARING_Share *share;
   const struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh = data;
@@ -38,8 +40,8 @@ GNUNET_SECRETSHARING_share_read (const void *data, size_t len, size_t *readlen)
   size_t n;
   uint16_t payload_size;
 
-  payload_size = ntohs (sh->num_peers) * 
-      (sizeof (uint16_t) + sizeof (struct GNUNET_SECRETSHARING_FieldElement) + 
+  payload_size = ntohs (sh->num_peers) *
+      (sizeof (uint16_t) + sizeof (struct GNUNET_SECRETSHARING_FieldElement) +
        sizeof (struct GNUNET_PeerIdentity));
 
   if (NULL != readlen)
@@ -94,8 +96,8 @@ GNUNET_SECRETSHARING_share_write (const struct GNUNET_SECRETSHARING_Share *share
   char *p;
   int n;
 
-  payload_size = share->num_peers * 
-      (sizeof (uint16_t) + sizeof (struct GNUNET_SECRETSHARING_FieldElement) + 
+  payload_size = share->num_peers *
+      (sizeof (uint16_t) + sizeof (struct GNUNET_SECRETSHARING_FieldElement) +
        sizeof (struct GNUNET_PeerIdentity));
 
   if (NULL != writelen)