psyc, multicast: join decision

5 files changed, 215 insertions, 51 deletions

diff --git a/src/multicast/Makefile.am b/src/multicast/Makefile.am
index 752736c49..b2c1702e4 100644
--- a/src/multicast/Makefile.am
+++ b/src/multicast/Makefile.am
@@ -54,15 +54,15 @@ gnunet_service_multicast_DEPENDENCIES = \
 
 
 check_PROGRAMS = \
- test_multicast_api
+ test_multicast
 
 if ENABLE_TEST_RUN
 AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;
 TESTS = $(check_PROGRAMS)
 endif
 
-test_multicast_api_SOURCES = \
- test_multicast_api.c
-test_multicast_api_LDADD = \
+test_multicast_SOURCES = \
+ test_multicast.c
+test_multicast_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la
 
diff --git a/src/multicast/gnunet-service-multicast.c b/src/multicast/gnunet-service-multicast.c
index 0394ee19e..bd6616589 100644
--- a/src/multicast/gnunet-service-multicast.c
+++ b/src/multicast/gnunet-service-multicast.c
@@ -147,7 +147,7 @@ struct Member
   /**
    * Join request sent to the origin / members.
    */
-  struct GNUNET_MULTICAST_JoinRequest *join_request;
+  struct MulticastJoinRequestMessage *join_request;
 
   /**
    * Join decision sent in reply to our request.
@@ -206,6 +206,8 @@ cleanup_member (struct Member *mem)
                                           grp_mem);
     GNUNET_CONTAINER_multihashmap_destroy (grp_mem);
   }
+  if (NULL != mem->join_decision)
+    GNUNET_free (mem->join_decision);
   GNUNET_CONTAINER_multihashmap_remove (members, &grp->pub_key_hash, mem);
 }
 
@@ -425,8 +427,8 @@ static void
 handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
                      const struct GNUNET_MessageHeader *m)
 {
-  struct MulticastMemberJoinMessage *
-    msg = (struct MulticastMemberJoinMessage *) m;
+  const struct MulticastMemberJoinMessage *
+    msg = (const struct MulticastMemberJoinMessage *) m;
 
   struct GNUNET_CRYPTO_EddsaPublicKey mem_pub_key;
   struct GNUNET_HashCode pub_key_hash, mem_pub_key_hash;
@@ -440,17 +442,10 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
   struct Member *mem = NULL;
   struct Group *grp;
 
-  if (NULL == grp_mem)
-  {
-    grp_mem = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
-    GNUNET_CONTAINER_multihashmap_put (group_members, &pub_key_hash, grp_mem,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  }
-  else
+  if (NULL != grp_mem)
   {
     mem = GNUNET_CONTAINER_multihashmap_get (grp_mem, &mem_pub_key_hash);
   }
-
   if (NULL == mem)
   {
     mem = GNUNET_new (struct Member);
@@ -463,7 +458,13 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
     grp->pub_key = msg->group_key;
     grp->pub_key_hash = pub_key_hash;
 
-    GNUNET_CONTAINER_multihashmap_put (grp_mem, &mem_pub_key_hash, mem,
+    if (NULL == grp_mem)
+    {
+      grp_mem = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
+      GNUNET_CONTAINER_multihashmap_put (group_members, &grp->pub_key_hash, grp_mem,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    }
+    GNUNET_CONTAINER_multihashmap_put (grp_mem, &mem->pub_key_hash, mem,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
     GNUNET_CONTAINER_multihashmap_put (members, &grp->pub_key_hash, mem,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
@@ -478,8 +479,11 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
   GNUNET_CONTAINER_DLL_insert (grp->clients_head, grp->clients_tail, cl);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Client connected as member to group %s.\n",
+              "%p Client connected to group %s..\n",
               mem, GNUNET_h2s (&grp->pub_key_hash));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p ..as member %s.\n",
+              mem, GNUNET_h2s (&mem_pub_key_hash));
 
   GNUNET_SERVER_client_set_user_context (client, grp);
 
@@ -496,19 +500,19 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
     struct GNUNET_PeerIdentity *relays = (struct GNUNET_PeerIdentity *) &msg[1];
     uint32_t relay_count = ntohs (msg->relay_count);
     struct GNUNET_MessageHeader *
-      join_req = ((struct GNUNET_MessageHeader *)
+      join_msg = ((struct GNUNET_MessageHeader *)
                   ((char *) &msg[1]) + relay_count * sizeof (*relays));
-    uint16_t join_req_size = ntohs (join_req->size);
+    uint16_t join_msg_size = ntohs (join_msg->size);
 
     struct MulticastJoinRequestMessage *
-      req = GNUNET_malloc (sizeof (*req) + join_req_size);
-    req->header.size = htons (sizeof (*req) + join_req_size);
+      req = GNUNET_malloc (sizeof (*req) + join_msg_size);
+    req->header.size = htons (sizeof (*req) + join_msg_size);
     req->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST);
     req->group_key = grp->pub_key;
     GNUNET_CRYPTO_eddsa_key_get_public (&mem->priv_key, &req->member_key);
-    memcpy (&req[1], join_req, join_req_size);
+    memcpy (&req[1], join_msg, join_msg_size);
 
-    req->purpose.size = htonl (sizeof (*req) + join_req_size
+    req->purpose.size = htonl (sizeof (*req) + join_msg_size
                                - sizeof (req->header)
                                - sizeof (req->signature));
     req->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_MULTICAST_REQUEST);
@@ -531,7 +535,7 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
     }
     else
     {
-      /* FIXME: send join request to remote origin / members */
+      /* FIXME: send join request to remote peers */
     }
   }
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -539,6 +543,85 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
 
 
 /**
+ * Join decision from client.
+ */
+static void
+handle_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
+                      const struct GNUNET_MessageHeader *m)
+{
+  struct Group *
+    grp = GNUNET_SERVER_client_get_user_context (client, struct Group);
+  const struct MulticastClientJoinDecisionMessage *
+    cl_dcsn = (const struct MulticastClientJoinDecisionMessage *) m;
+
+  struct GNUNET_PeerIdentity *relays = (struct GNUNET_PeerIdentity *) &cl_dcsn[1];
+  uint32_t relay_count = ntohs (cl_dcsn->relay_count);
+
+  struct GNUNET_MessageHeader *join_msg = NULL;
+  uint16_t join_msg_size = 0;
+  if (sizeof (*cl_dcsn) + relay_count * sizeof (*relays) + sizeof (*m)
+      <= ntohs (m->size))
+  {
+    join_msg = ((struct GNUNET_MessageHeader *)
+                ((char *) &cl_dcsn[1]) + relay_count * sizeof (*relays));
+    join_msg_size = ntohs (join_msg->size);
+  }
+
+  struct MulticastJoinDecisionMessage *
+    dcsn = GNUNET_malloc (sizeof (*dcsn) + join_msg_size);
+  dcsn->header.size = htons (sizeof (*dcsn) + join_msg_size);
+  dcsn->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION);
+  dcsn->is_admitted = cl_dcsn->is_admitted;
+  memcpy (&dcsn[1], join_msg, join_msg_size);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Got join decision from client for group %s..\n",
+              grp, GNUNET_h2s (&grp->pub_key_hash));
+
+  if (GNUNET_YES
+      == GNUNET_CONTAINER_multihashmap_contains (origins, &grp->pub_key_hash))
+  { /* Local origin */
+    struct GNUNET_CONTAINER_MultiHashMap *
+      grp_mem = GNUNET_CONTAINER_multihashmap_get (group_members,
+                                                   &grp->pub_key_hash);
+    if (NULL != grp_mem)
+    {
+      struct GNUNET_HashCode member_key_hash;
+      GNUNET_CRYPTO_hash (&cl_dcsn->member_key, sizeof (cl_dcsn->member_key),
+                          &member_key_hash);
+      struct Member *
+        mem = GNUNET_CONTAINER_multihashmap_get (grp_mem, &member_key_hash);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "%p ..and member %s: %p\n",
+                  grp, GNUNET_h2s (&member_key_hash), mem);
+      if (NULL != mem)
+      {
+        message_to_clients (grp, (struct GNUNET_MessageHeader *) dcsn);
+        if (GNUNET_YES == dcsn->is_admitted)
+        { /* Member admitted, store join_decision. */
+          mem->join_decision = dcsn;
+        }
+        else
+        { /* Refused entry, disconnect clients. */
+          GNUNET_free (dcsn);
+          struct ClientList *cl = mem->grp.clients_head;
+          while (NULL != cl)
+          {
+            GNUNET_SERVER_client_disconnect (cl->client);
+            cl = cl->next;
+          }
+        }
+      }
+    }
+  }
+  else
+  {
+    /* FIXME: send join decision to remote peers */
+  }
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+/**
  * Incoming message from a client.
  */
 static void
@@ -633,6 +716,9 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
     { &handle_member_join, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_MEMBER_JOIN, 0 },
 
+    { &handle_join_decision, NULL,
+      GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION, 0 },
+
     { &handle_multicast_message, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, 0 },
 
diff --git a/src/multicast/multicast.h b/src/multicast/multicast.h
index 5b0fc647c..85c5714e6 100644
--- a/src/multicast/multicast.h
+++ b/src/multicast/multicast.h
@@ -36,11 +36,16 @@ GNUNET_NETWORK_STRUCT_BEGIN
 struct MulticastJoinRequestMessage
 {
   /**
-   * Header for the join request.
+   * Type: GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST
    */
   struct GNUNET_MessageHeader header;
 
   /**
+   * Always zero.
+   */
+  uint32_t reserved;
+
+  /**
    * ECC signature of the rest of the fields of the join request.
    *
    * Signature must match the public key of the joining member.
@@ -72,31 +77,55 @@ struct MulticastJoinRequestMessage
 
 
 /**
- * Message sent from the client to the service to notify the service
- * about a join decision.
+ * Header of a join decision sent to a remote peer.
  */
 struct MulticastJoinDecisionMessage
 {
   /**
-   *
+   * Type: GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION
    */
   struct GNUNET_MessageHeader header;
 
   /**
-   * Unique ID that identifies the associated join test.
+   * #GNUNET_YES if the peer was admitted.
    */
-  uint32_t uid;
+  uint8_t is_admitted;
 
+  /* Followed by the join response message */
+};
+
+
+/**
+ * Message sent from the client to the service to notify the service
+ * about a join decision.
+ */
+struct MulticastClientJoinDecisionMessage
+{
   /**
-   * #GNUNET_YES if the peer was admitted.
+   * Type: GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION
    */
-  int32_t is_admitted;
+  struct GNUNET_MessageHeader header;
 
   /**
    * Number of relays given.
    */
   uint32_t relay_count;
 
+  /**
+   * Public key of the joining member.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey member_key;
+
+  /**
+   * Peer identity of the joining member.
+   */
+  struct GNUNET_PeerIdentity member_peer;
+
+  /**
+   * #GNUNET_YES if the peer was admitted.
+   */
+  uint8_t is_admitted;
+
   /* Followed by relay_count peer identities */
 
   /* Followed by the join response message */
@@ -108,11 +137,11 @@ struct MulticastJoinDecisionMessage
  * Message sent from the client to the service to notify the service
  * about the result of a membership test.
  */
-struct MulticastMembershipTestResponseMessage
+struct MulticastMembershipTestResultMessage
 {
 
   /**
-   *
+   * Type: GNUNET_MESSAGE_TYPE_MULTICAST_MEMBERSHIP_TEST_RESULT
    */
   struct GNUNET_MessageHeader header;
 
diff --git a/src/multicast/multicast_api.c b/src/multicast/multicast_api.c
index 84dac0545..477cb1f2c 100644
--- a/src/multicast/multicast_api.c
+++ b/src/multicast/multicast_api.c
@@ -182,8 +182,6 @@ struct GNUNET_MULTICAST_Member
   struct GNUNET_PeerIdentity relays;
   uint32_t relay_count;
 
-  struct GNUNET_MessageHeader *join_request;
-
   uint64_t next_fragment_id;
 };
 
@@ -501,7 +499,7 @@ join_request_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
 
   const struct GNUNET_MessageHeader *msg = NULL;
   if (sizeof (*req) + sizeof (*msg) <= ntohs (req->header.size))
-    msg =(const struct GNUNET_MessageHeader *) &req[1];
+    msg = (const struct GNUNET_MessageHeader *) &req[1];
 
   grp->join_cb (grp->cb_cls, &req->member_key, msg, jh);
   return GNUNET_YES;
@@ -509,6 +507,25 @@ join_request_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
 
 
 /**
+ * Iterator callback for calling join decision callbacks of members.
+ */
+static int
+join_decision_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
+                  void *member)
+{
+  const struct MulticastJoinDecisionMessage *dcsn = cls;
+  struct GNUNET_MULTICAST_Member *mem = member;
+  struct GNUNET_MULTICAST_Group *grp = &mem->grp;
+
+  const struct GNUNET_MessageHeader *msg = NULL;
+  if (sizeof (*dcsn) + sizeof (*msg) <= ntohs (dcsn->header.size))
+    msg = (const struct GNUNET_MessageHeader *) &dcsn[1];
+
+  // FIXME: grp->join_decision_cb (grp->cb_cls, msg);
+  return GNUNET_YES;
+}
+
+/**
  * Function called when we receive a message from the service.
  *
  * @param cls   struct GNUNET_MULTICAST_Group
@@ -549,6 +566,10 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     size_min = sizeof (struct MulticastJoinRequestMessage);
     break;
 
+  case GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION:
+    size_min = sizeof (struct MulticastJoinDecisionMessage);
+    break;
+
   default:
     GNUNET_break_op (0);
     type = 0;
@@ -592,6 +613,15 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_CONTAINER_multihashmap_get_multiple (members, &grp->pub_key_hash,
                                                   join_request_cb, (void *) msg);
     break;
+
+  case GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION:
+    if (NULL != origins)
+      GNUNET_CONTAINER_multihashmap_get_multiple (origins, &grp->pub_key_hash,
+                                                  join_decision_cb, (void *) msg);
+    if (NULL != members)
+      GNUNET_CONTAINER_multihashmap_get_multiple (members, &grp->pub_key_hash,
+                                                  join_decision_cb, (void *) msg);
+    break;
   }
 
   if (NULL != grp->client)
@@ -619,7 +649,7 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
  *        be the multicast origin) is a good candidate for building the
  *        multicast tree.  Note that it is unnecessary to specify our own
  *        peer identity in this array.
- * @param join_response Message to send in response to the joining peer;
+ * @param join_resp  Message to send in response to the joining peer;
  *        can also be used to redirect the peer to a different group at the
  *        application layer; this response is to be transmitted to the
  *        peer that issued the request even if admission is denied.
@@ -629,8 +659,29 @@ GNUNET_MULTICAST_join_decision (struct GNUNET_MULTICAST_JoinHandle *jh,
                                 int is_admitted,
                                 unsigned int relay_count,
                                 const struct GNUNET_PeerIdentity *relays,
-                                const struct GNUNET_MessageHeader *join_response)
+                                const struct GNUNET_MessageHeader *join_resp)
 {
+  struct GNUNET_MULTICAST_Group *grp = jh->group;
+  uint16_t join_resp_size = (NULL != join_resp) ? ntohs (join_resp->size) : 0;
+  uint16_t relay_size = relay_count * sizeof (*relays);
+  struct MulticastClientJoinDecisionMessage * dcsn;
+  struct MessageQueue *
+    mq = GNUNET_malloc (sizeof (*mq) + sizeof (*dcsn)
+                        + relay_size + join_resp_size);
+
+  dcsn = (struct MulticastClientJoinDecisionMessage *) &mq[1];
+  dcsn->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION);
+  dcsn->header.size = htons (sizeof (*dcsn) + relay_size + join_resp_size);
+  dcsn->member_key = jh->member_key;
+  dcsn->member_peer = jh->member_peer;
+  dcsn->is_admitted = is_admitted;
+  dcsn->relay_count = relay_count;
+  memcpy (&dcsn[1], relays, relay_size);
+  memcpy (((char *) &dcsn[1]) + relay_size, join_resp, join_resp_size);
+
+  GNUNET_CONTAINER_DLL_insert_tail (grp->tmit_head, grp->tmit_tail, mq);
+  transmit_next (grp);
+
   GNUNET_free (jh);
   return NULL;
 }
@@ -908,10 +959,8 @@ GNUNET_MULTICAST_origin_to_all_cancel (struct GNUNET_MULTICAST_OriginTransmitHan
  * @param relays Peer identities of members of the group, which serve as relays
  *        and can be used to join the group at. and send the @a join_request to.
  *        If empty, the @a join_request is sent directly to the @a origin.
- * @param join_req  Application-dependent join request to be passed to the peer
- *        @a relay (might, for example, contain a user, bind user
- *        identity/pseudonym to peer identity, application-level message to
- *        origin, etc.).
+ * @param join_msg  Application-dependent join message to be passed to the peer
+ *        @a origin.
  * @param join_cb Function called to approve / disapprove joining of a peer.
  * @param member_test_cb Function multicast can use to test group membership.
  * @param replay_frag_cb Function that can be called to replay message fragments
@@ -933,7 +982,7 @@ GNUNET_MULTICAST_member_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               const struct GNUNET_PeerIdentity *origin,
                               uint32_t relay_count,
                               const struct GNUNET_PeerIdentity *relays,
-                              const struct GNUNET_MessageHeader *join_req,
+                              const struct GNUNET_MessageHeader *join_msg,
                               GNUNET_MULTICAST_JoinCallback join_cb,
                               GNUNET_MULTICAST_MembershipTestCallback member_test_cb,
                               GNUNET_MULTICAST_ReplayFragmentCallback replay_frag_cb,
@@ -945,16 +994,16 @@ GNUNET_MULTICAST_member_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
   struct GNUNET_MULTICAST_Group *grp = &mem->grp;
 
   uint16_t relay_size = relay_count * sizeof (*relays);
-  uint16_t join_req_size = (NULL != join_req) ? ntohs (join_req->size) : 0;
+  uint16_t join_msg_size = (NULL != join_msg) ? ntohs (join_msg->size) : 0;
   struct MulticastMemberJoinMessage *
-    join = GNUNET_malloc (sizeof (*join) + relay_size + join_req_size);
+    join = GNUNET_malloc (sizeof (*join) + relay_size + join_msg_size);
   join->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_MEMBER_JOIN);
-  join->header.size = htons (sizeof (*join) + relay_size + join_req_size);
+  join->header.size = htons (sizeof (*join) + relay_size + join_msg_size);
   join->group_key = *group_key;
   join->member_key = *member_key;
   join->origin = *origin;
   memcpy (&join[1], relays, relay_size);
-  memcpy (((char *) &join[1]) + relay_size, join_req, join_req_size);
+  memcpy (((char *) &join[1]) + relay_size, join_msg, join_msg_size);
 
   grp->reconnect_msg = (struct GNUNET_MessageHeader *) join;
   grp->is_origin = GNUNET_NO;
diff --git a/src/multicast/test_multicast_api.c b/src/multicast/test_multicast.c
index 25224f043..244634c64 100644
--- a/src/multicast/test_multicast_api.c
+++ b/src/multicast/test_multicast.c
@@ -18,8 +18,8 @@
      Boston, MA 02111-1307, USA.
 */
 /**
- * @file multicast/test_multicast_api.c
- * @brief testcase for multicast.c
+ * @file multicast/test_multicast.c
+ * @brief testcase for multicast_api.c
  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
@@ -41,4 +41,4 @@ main (int argc, char *argv[])
   return ret;
 }
 
-/* end of test_multicast_api.c */
+/* end of test_multicast.c */