update secretsharing to new MQ API

diff --git a/src/secretsharing/secretsharing.h b/src/secretsharing/secretsharing.h
index 4e725198aee1cd2ea9d76c8bc3faa55725f640b4..5936b6ab94701bfd7ad34265c6e32952afad2174 100644 (file)
--- a/src/secretsharing/secretsharing.h
+++ b/src/secretsharing/secretsharing.h
@@ -157,7 +157,7 @@ struct GNUNET_SECRETSHARING_DecryptRequestMessage
 struct GNUNET_SECRETSHARING_DecryptResponseMessage
 {
   /**
-   * Type: GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE
+   * Type: #GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE
    */
   struct GNUNET_MessageHeader header;
 
@@ -165,7 +165,7 @@ struct GNUNET_SECRETSHARING_DecryptResponseMessage
    * Zero if decryption failed, non-zero if decryption succeeded.
    * If the decryption failed, plaintext is also zero.
    */
-  uint32_t success;
+  uint32_t success GNUNET_PACKED;
 
   /**
    * Decrypted plaintext.

diff --git a/src/secretsharing/secretsharing_api.c b/src/secretsharing/secretsharing_api.c
index 78c444810804f1c52f081ba633e5497332186794..441164850029542d477886a4549770be8ea9dd2d 100644 (file)
--- a/src/secretsharing/secretsharing_api.c
+++ b/src/secretsharing/secretsharing_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2012 GNUnet e.V.
+     Copyright (C) 2012, 2016 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -166,38 +166,51 @@ handle_decrypt_client_error (void *cls,
  * result to the application.
  *
  * @param cls the `struct GNUNET_SECRETSHARING_Session`
- * @param msg message with the result
+ * @param m message with the result
+ */
+static int
+check_secret_ready (void *cls,
+                    const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
+{
+  /* FIXME: actually check m is well-formed here! */
+  return GNUNET_OK;
+}
+
+
+/**
+ * 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 m message with the result
  */
 static void
 handle_secret_ready (void *cls,
-                     const struct GNUNET_MessageHeader *msg)
+                     const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
 {
   struct GNUNET_SECRETSHARING_Session *s = cls;
-  const struct GNUNET_SECRETSHARING_SecretReadyMessage *m;
   struct GNUNET_SECRETSHARING_Share *share;
   size_t share_size;
 
   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;
+       ntohs (m->header.size));
   share_size = ntohs (m->header.size) - sizeof (struct GNUNET_SECRETSHARING_SecretReadyMessage);
 
   share = GNUNET_SECRETSHARING_share_read (&m[1],
                                            share_size,
                                            NULL);
+  GNUNET_assert (NULL != share); // FIXME: this can fail!
+  // should have been checked in #check_secret_ready!
+  // FIXME: below we never check &m[1] is valid!
+  // FIXME: do we leak 'share' here?
   s->secret_ready_cb (s->secret_ready_cls,
                       share, /* FIXME */
                       &share->public_key,
                       share->num_peers,
-                      (struct GNUNET_PeerIdentity *) &m[1]);
+                      (const struct GNUNET_PeerIdentity *) &m[1]);
+
   GNUNET_SECRETSHARING_session_destroy (s);
 }
 
@@ -246,16 +259,18 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c
                                      GNUNET_SECRETSHARING_SecretReadyCallback cb,
                                      void *cls)
 {
-  struct GNUNET_SECRETSHARING_Session *s;
+  GNUNET_MQ_hd_var_size (secret_ready,
+                         GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY,
+                         struct GNUNET_SECRETSHARING_SecretReadyMessage);
+  struct GNUNET_SECRETSHARING_Session *s
+    = GNUNET_new (struct GNUNET_SECRETSHARING_Session);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    make_secret_ready_handler (s),
+    GNUNET_MQ_handler_end ()
+  };
   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},
-    GNUNET_MQ_HANDLERS_END
-  };
 
-  s = GNUNET_new (struct GNUNET_SECRETSHARING_Session);
   s->client = GNUNET_CLIENT_connect ("secretsharing", cfg);
   if (NULL == s->client)
   {
@@ -293,20 +308,16 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c
 
 static void
 handle_decrypt_done (void *cls,
-                     const struct GNUNET_MessageHeader *msg)
+                     const struct GNUNET_SECRETSHARING_DecryptResponseMessage *m)
 {
   struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
-  const struct GNUNET_SECRETSHARING_DecryptResponseMessage *m =
-    (const void *) msg; // FIXME: size check!?
   const struct GNUNET_SECRETSHARING_Plaintext *plaintext;
 
   if (m->success == 0)
     plaintext = NULL;
   else
     plaintext = (void *) &m->plaintext;
-
   dh->decrypt_cb (dh->decrypt_cls, plaintext);
-
   GNUNET_SECRETSHARING_decrypt_cancel (dh);
 }
 
@@ -333,17 +344,19 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               GNUNET_SECRETSHARING_DecryptCallback decrypt_cb,
                               void *decrypt_cb_cls)
 {
-  struct GNUNET_SECRETSHARING_DecryptionHandle *s;
+  GNUNET_MQ_hd_fixed_size (decrypt_done,
+                           GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE,
+                           struct GNUNET_SECRETSHARING_DecryptResponseMessage);
+  struct GNUNET_SECRETSHARING_DecryptionHandle *s
+    = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    make_decrypt_done_handler (s),
+    GNUNET_MQ_handler_end ()
+  };
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_SECRETSHARING_DecryptRequestMessage *msg;
-  static const struct GNUNET_MQ_MessageHandler mq_handlers[] = {
-    {handle_decrypt_done, GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE, 0},
-    GNUNET_MQ_HANDLERS_END
-  };
   size_t share_size;
 
-
-  s = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle);
   s->client = GNUNET_CLIENT_connect ("secretsharing", cfg);
   s->decrypt_cb = decrypt_cb;
   s->decrypt_cls = decrypt_cb_cls;
@@ -354,13 +367,19 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                                  s);
   GNUNET_assert (NULL != s->mq);
 
-  GNUNET_assert (GNUNET_OK == GNUNET_SECRETSHARING_share_write (share, NULL, 0, &share_size));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SECRETSHARING_share_write (share, NULL, 0,
+                                                   &share_size));
 
   ev = GNUNET_MQ_msg_extra (msg,
                             share_size,
                             GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT);
 
-  GNUNET_assert (GNUNET_OK == GNUNET_SECRETSHARING_share_write (share, &msg[1], share_size, NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SECRETSHARING_share_write (share,
+                                                   &msg[1],
+                                                   share_size,
+                                                   NULL));
 
   msg->start = GNUNET_TIME_absolute_hton (start);
   msg->deadline = GNUNET_TIME_absolute_hton (deadline);
@@ -368,7 +387,8 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   GNUNET_MQ_send (s->mq, ev);
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "decrypt session created\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "decrypt session created\n");
   return s;
 }
 
@@ -403,7 +423,9 @@ GNUNET_SECRETSHARING_plaintext_generate_i (struct GNUNET_SECRETSHARING_Plaintext
       return GNUNET_SYSERR;
   }
 
-  GNUNET_CRYPTO_mpi_print_unsigned (plaintext, sizeof (struct GNUNET_SECRETSHARING_Plaintext), x);
+  GNUNET_CRYPTO_mpi_print_unsigned (plaintext,
+                                    sizeof (struct GNUNET_SECRETSHARING_Plaintext),
+                                    x);
 
   return GNUNET_OK;
 }

diff --git a/src/secretsharing/secretsharing_common.c b/src/secretsharing/secretsharing_common.c
index 8fcba96d4d51cc204582fa05d982de6115469a56..121e1975f195d04f4163d487292bd5f8d0fc28d2 100644 (file)
--- a/src/secretsharing/secretsharing_common.c
+++ b/src/secretsharing/secretsharing_common.c
@@ -36,7 +36,7 @@ GNUNET_SECRETSHARING_share_read (const void *data,
 {
   struct GNUNET_SECRETSHARING_Share *share;
   const struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh = data;
-  char *p;
+  const char *p;
   size_t n;
   uint16_t payload_size;
 
@@ -47,7 +47,7 @@ GNUNET_SECRETSHARING_share_read (const void *data,
   if (NULL != readlen)
     *readlen = payload_size + sizeof *sh;
 
-  share = GNUNET_malloc (sizeof *share);
+  share = GNUNET_new (struct GNUNET_SECRETSHARING_Share);
 
   share->threshold = ntohs (sh->threshold);
   share->num_peers = ntohs (sh->num_peers);
@@ -56,20 +56,23 @@ GNUNET_SECRETSHARING_share_read (const void *data,
   share->my_share = sh->my_share;
   share->public_key = sh->public_key;
 
-  p = (void *) &sh[1];
+  p = (const char *) &sh[1];
 
   n = share->num_peers * sizeof (struct GNUNET_PeerIdentity);
-  share->peers = GNUNET_malloc (n);
+  share->peers = GNUNET_new_array (share->num_peers,
+                                   struct GNUNET_PeerIdentity);
   memcpy (share->peers, p, n);
   p += n;
 
   n = share->num_peers * sizeof (struct GNUNET_SECRETSHARING_FieldElement);
-  share->sigmas = GNUNET_malloc (n);
+  share->sigmas = GNUNET_new_array (share->num_peers,
+                                    struct GNUNET_SECRETSHARING_FieldElement);
   memcpy (share->sigmas, p, n);
   p += n;
 
   n = share->num_peers * sizeof (uint16_t);
-  share->original_indices = GNUNET_malloc (n);
+  share->original_indices = GNUNET_new_array (share->num_peers,
+                                              uint16_t);
   memcpy (share->original_indices, p, n);
 
   return share;
@@ -148,5 +151,3 @@ GNUNET_SECRETSHARING_share_destroy (struct GNUNET_SECRETSHARING_Share *share)
   share->peers = NULL;
   GNUNET_free (share);
 }
-
-

diff --git a/src/secretsharing/test_secretsharing_api.c b/src/secretsharing/test_secretsharing_api.c
index 341a33b847b8d0289c15254430ffbb589a9422ff..c0d527f133a5ded14b734fd13eb8a4703a3ab3de 100644 (file)
--- a/src/secretsharing/test_secretsharing_api.c
+++ b/src/secretsharing/test_secretsharing_api.c
@@ -33,11 +33,12 @@ static int success;
 static struct GNUNET_SECRETSHARING_Session *keygen;
 
 
-static void secret_ready_cb (void *cls,
-                             struct GNUNET_SECRETSHARING_Share *my_share,
-                             struct GNUNET_SECRETSHARING_PublicKey *public_key,
-                             unsigned int num_ready_peers,
-                             struct GNUNET_PeerIdentity *ready_peers)
+static void
+secret_ready_cb (void *cls,
+                 struct GNUNET_SECRETSHARING_Share *my_share,
+                 struct GNUNET_SECRETSHARING_PublicKey *public_key,
+                 unsigned int num_ready_peers,
+                 const struct GNUNET_PeerIdentity *ready_peers)
 {
   keygen = NULL;
   if (num_ready_peers == 1)