psyc, multicast: join decision, tests

4 files changed, 196 insertions, 137 deletions

diff --git a/src/multicast/Makefile.am b/src/multicast/Makefile.am
index b2c1702e4..8ccc7b88a 100644
--- a/src/multicast/Makefile.am
+++ b/src/multicast/Makefile.am
@@ -46,10 +46,12 @@ gnunet_service_multicast_SOURCES = \
  gnunet-service-multicast.c
 gnunet_service_multicast_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/core/libgnunetcore.la \
   $(top_builddir)/src/statistics/libgnunetstatistics.la \
   $(GN_LIBINTL)
 gnunet_service_multicast_DEPENDENCIES = \
   $(top_builddir)/src/util/libgnunetutil.la \
+  $(top_builddir)/src/core/libgnunetcore.la \
   $(top_builddir)/src/statistics/libgnunetstatistics.la
 
 
diff --git a/src/multicast/gnunet-service-multicast.c b/src/multicast/gnunet-service-multicast.c
index d412d3f8e..5421c1b2b 100644
--- a/src/multicast/gnunet-service-multicast.c
+++ b/src/multicast/gnunet-service-multicast.c
@@ -27,6 +27,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_signatures.h"
 #include "gnunet_statistics_service.h"
+#include "gnunet_core_service.h"
 #include "gnunet_multicast_service.h"
 #include "multicast.h"
 
@@ -36,6 +37,22 @@
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
+ * Server handle.
+ */
+static struct GNUNET_SERVER_Handle *server;
+
+/**
+ * Core handle.
+ * Only used during initialization.
+ */
+static struct GNUNET_CORE_Handle *core;
+
+/**
+ * Identity of this peer.
+ */
+static struct GNUNET_PeerIdentity this_peer;
+
+/**
  * Handle to the statistics service.
  */
 static struct GNUNET_STATISTICS_Handle *stats;
@@ -62,7 +79,6 @@ static struct GNUNET_CONTAINER_MultiHashMap *members;
  */
 static struct GNUNET_CONTAINER_MultiHashMap *group_members;
 
-
 /**
  * List of connected clients.
  */
@@ -147,7 +163,7 @@ struct Member
   /**
    * Join request sent to the origin / members.
    */
-  struct MulticastJoinRequestMessage *join_request;
+  struct MulticastJoinRequestMessage *join_req;
 
   /**
    * Join decision sent in reply to our request.
@@ -155,7 +171,7 @@ struct Member
    * Only a positive decision is stored here, in case of a negative decision the
    * client is disconnected.
    */
-  struct MulticastJoinDecisionMessage *join_decision;
+  struct MulticastJoinDecisionMessageHeader *join_dcsn;
 
   /**
    * Last request fragment ID sent to the origin.
@@ -171,9 +187,19 @@ struct Member
  * @param tc unused
  */
 static void
-cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  /* FIXME: do clean up here */
+  if (NULL != core)
+  {
+    GNUNET_CORE_disconnect (core);
+    core = NULL;
+  }
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
+    stats = NULL;
+  }
+  /* FIXME: do more clean up here */
 }
 
 /**
@@ -206,8 +232,11 @@ cleanup_member (struct Member *mem)
                                           grp_mem);
     GNUNET_CONTAINER_multihashmap_destroy (grp_mem);
   }
-  if (NULL != mem->join_decision)
-    GNUNET_free (mem->join_decision);
+  if (NULL != mem->join_dcsn)
+  {
+    GNUNET_free (mem->join_dcsn);
+    mem->join_dcsn = NULL;
+  }
   GNUNET_CONTAINER_multihashmap_remove (members, &grp->pub_key_hash, mem);
 }
 
@@ -329,7 +358,7 @@ member_message_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
   const struct GNUNET_MessageHeader *msg = cls;
   struct Member *mem = member;
 
-  if (NULL != mem->join_decision)
+  if (NULL != mem->join_dcsn)
   { /* Only send message to admitted members */
     message_to_clients (&mem->grp, msg);
   }
@@ -374,7 +403,7 @@ message_to_origin (struct Group *grp, const struct GNUNET_MessageHeader *msg)
  * Handle a connecting client starting an origin.
  */
 static void
-handle_origin_start (void *cls, struct GNUNET_SERVER_Client *client,
+client_origin_start (void *cls, struct GNUNET_SERVER_Client *client,
                      const struct GNUNET_MessageHeader *m)
 {
   const struct MulticastOriginStartMessage *
@@ -424,8 +453,8 @@ handle_origin_start (void *cls, struct GNUNET_SERVER_Client *client,
  * Handle a connecting client joining a group.
  */
 static void
-handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *m)
+client_member_join (void *cls, struct GNUNET_SERVER_Client *client,
+                    const struct GNUNET_MessageHeader *m)
 {
   const struct MulticastMemberJoinMessage *
     msg = (const struct MulticastMemberJoinMessage *) m;
@@ -487,16 +516,16 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
 
   GNUNET_SERVER_client_set_user_context (client, grp);
 
-  if (NULL != mem->join_decision)
+  if (NULL != mem->join_dcsn)
   { /* Already got a join decision, send it to client. */
     GNUNET_SERVER_notification_context_add (nc, client);
     GNUNET_SERVER_notification_context_unicast (nc, client,
                                                 (struct GNUNET_MessageHeader *)
-                                                mem->join_decision,
+                                                mem->join_dcsn,
                                                 GNUNET_NO);
   }
   else if (grp->clients_head == grp->clients_tail)
-  { /* First client, send join request. */
+  { /* First client of the group, send join request. */
     struct GNUNET_PeerIdentity *relays = (struct GNUNET_PeerIdentity *) &msg[1];
     uint32_t relay_count = ntohs (msg->relay_count);
     uint16_t relay_size = relay_count * sizeof (*relays);
@@ -515,6 +544,7 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
     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;
+    req->member_peer = this_peer;
     GNUNET_CRYPTO_eddsa_key_get_public (&mem->priv_key, &req->member_key);
     if (0 < join_msg_size)
       memcpy (&req[1], join_msg, join_msg_size);
@@ -531,14 +561,14 @@ handle_member_join (void *cls, struct GNUNET_SERVER_Client *client,
       GNUNET_assert (0);
     }
 
-    if (NULL != mem->join_request)
-      GNUNET_free (mem->join_request);
-    mem->join_request = req;
+    if (NULL != mem->join_req)
+      GNUNET_free (mem->join_req);
+    mem->join_req = req;
 
     if (GNUNET_YES
         == GNUNET_CONTAINER_multihashmap_contains (origins, &grp->pub_key_hash))
     { /* Local origin */
-      message_to_origin (grp, (struct GNUNET_MessageHeader *) mem->join_request);
+      message_to_origin (grp, (struct GNUNET_MessageHeader *) mem->join_req);
     }
     else
     {
@@ -553,34 +583,15 @@ 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,
+client_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);
-  uint16_t relay_size = relay_count * sizeof (*relays);
-
-  struct GNUNET_MessageHeader *join_msg = NULL;
-  uint16_t join_msg_size = 0;
-  if (sizeof (*cl_dcsn) + relay_size + sizeof (*m) <= ntohs (m->size))
-  {
-    join_msg = (struct GNUNET_MessageHeader *)
-      (((char *) &cl_dcsn[1]) + relay_size);
-    join_msg_size = ntohs (join_msg->size);
-  }
-
-  int keep_dcsn = GNUNET_NO;
-  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);
+  const struct MulticastJoinDecisionMessageHeader *
+    hdcsn = (const struct MulticastJoinDecisionMessageHeader *) m;
+  const struct MulticastJoinDecisionMessage *
+    dcsn = (const struct MulticastJoinDecisionMessage *) &hdcsn[1];
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Got join decision from client for group %s..\n",
@@ -595,7 +606,7 @@ handle_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
     if (NULL != grp_mem)
     {
       struct GNUNET_HashCode member_key_hash;
-      GNUNET_CRYPTO_hash (&cl_dcsn->member_key, sizeof (cl_dcsn->member_key),
+      GNUNET_CRYPTO_hash (&hdcsn->member_key, sizeof (hdcsn->member_key),
                           &member_key_hash);
       struct Member *
         mem = GNUNET_CONTAINER_multihashmap_get (grp_mem, &member_key_hash);
@@ -604,19 +615,21 @@ handle_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
                   grp, GNUNET_h2s (&member_key_hash), mem);
       if (NULL != mem)
       {
-        message_to_clients (grp, (struct GNUNET_MessageHeader *) dcsn);
-        if (GNUNET_YES == dcsn->is_admitted)
+        message_to_clients (&mem->grp, (struct GNUNET_MessageHeader *) hdcsn);
+        if (GNUNET_YES == ntohl (dcsn->is_admitted))
         { /* Member admitted, store join_decision. */
-          mem->join_decision = dcsn;
-          keep_dcsn = GNUNET_YES;
+          uint16_t dcsn_size = ntohs (dcsn->header.size);
+          mem->join_dcsn = GNUNET_malloc (dcsn_size);
+          memcpy (mem->join_dcsn, dcsn, dcsn_size);
         }
         else
         { /* Refused entry, disconnect clients. */
           struct ClientList *cl = mem->grp.clients_head;
           while (NULL != cl)
           {
-            GNUNET_SERVER_client_disconnect (cl->client);
+            struct GNUNET_SERVER_Client *client = cl->client;
             cl = cl->next;
+            GNUNET_SERVER_client_disconnect (client);
           }
         }
       }
@@ -624,10 +637,8 @@ handle_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
   }
   else
   {
-    /* FIXME: send join decision to remote peers */
+    /* FIXME: send join decision to hdcsn->peer */
   }
-  if (GNUNET_NO == keep_dcsn)
-    GNUNET_free (dcsn);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -635,7 +646,7 @@ handle_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
  * Incoming message from a client.
  */
 static void
-handle_multicast_message (void *cls, struct GNUNET_SERVER_Client *client,
+client_multicast_message (void *cls, struct GNUNET_SERVER_Client *client,
                           const struct GNUNET_MessageHeader *m)
 {
   struct Group *
@@ -670,7 +681,7 @@ handle_multicast_message (void *cls, struct GNUNET_SERVER_Client *client,
  * Incoming request from a client.
  */
 static void
-handle_multicast_request (void *cls, struct GNUNET_SERVER_Client *client,
+client_multicast_request (void *cls, struct GNUNET_SERVER_Client *client,
                           const struct GNUNET_MessageHeader *m)
 {
   struct Group *
@@ -708,37 +719,34 @@ handle_multicast_request (void *cls, struct GNUNET_SERVER_Client *client,
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
+
 /**
- * Process multicast requests.
- *
- * @param cls closure
- * @param server the initialized server
- * @param cfg configuration to use
+ * Core connected.
  */
 static void
-run (void *cls, struct GNUNET_SERVER_Handle *server,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+core_connected_cb  (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 {
+  this_peer = *my_identity;
+
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    { &handle_origin_start, NULL,
+    { &client_origin_start, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_ORIGIN_START, 0 },
 
-    { &handle_member_join, NULL,
+    { &client_member_join, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_MEMBER_JOIN, 0 },
 
-    { &handle_join_decision, NULL,
+    { &client_join_decision, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION, 0 },
 
-    { &handle_multicast_message, NULL,
+    { &client_multicast_message, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, 0 },
 
-    { &handle_multicast_request, NULL,
+    { &client_multicast_request, NULL,
       GNUNET_MESSAGE_TYPE_MULTICAST_REQUEST, 0 },
 
     {NULL, NULL, 0, 0}
   };
 
-  cfg = c;
   stats = GNUNET_STATISTICS_create ("multicast", cfg);
   origins = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
   members = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
@@ -747,12 +755,30 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
 
   GNUNET_SERVER_add_handlers (server, handlers);
   GNUNET_SERVER_disconnect_notify (server, &client_disconnect, NULL);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task,
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
                                 NULL);
 }
 
 
 /**
+ * Service started.
+ *
+ * @param cls closure
+ * @param server the initialized server
+ * @param cfg configuration to use
+ */
+static void
+run (void *cls, struct GNUNET_SERVER_Handle *srv,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  cfg = c;
+  server = srv;
+  core = GNUNET_CORE_connect (cfg, NULL, core_connected_cb, NULL, NULL,
+                              NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
+}
+
+
+/**
  * The main function for the multicast service.
  *
  * @param argc number of arguments from the command line
diff --git a/src/multicast/multicast.h b/src/multicast/multicast.h
index 85c5714e6..76492e868 100644
--- a/src/multicast/multicast.h
+++ b/src/multicast/multicast.h
@@ -77,7 +77,7 @@ struct MulticastJoinRequestMessage
 
 
 /**
- * Header of a join decision sent to a remote peer.
+ * Header of a join decision message sent to a peer requesting join.
  */
 struct MulticastJoinDecisionMessage
 {
@@ -87,19 +87,28 @@ struct MulticastJoinDecisionMessage
   struct GNUNET_MessageHeader header;
 
   /**
-   * #GNUNET_YES if the peer was admitted.
+   * #GNUNET_YES    if the peer was admitted
+   * #GNUNET_NO     if entry was refused,
+   * #GNUNET_SYSERR if the request could not be answered.
    */
-  uint8_t is_admitted;
+  int32_t is_admitted;
+
+  /**
+   * Number of relays given.
+   */
+  uint32_t relay_count;
+
+  /* Followed by relay_count peer identities */
 
   /* Followed by the join response message */
 };
 
 
 /**
- * Message sent from the client to the service to notify the service
- * about a join decision.
+ * Header added to a struct MulticastJoinDecisionMessage
+ * when sent between the client and service.
  */
-struct MulticastClientJoinDecisionMessage
+struct MulticastJoinDecisionMessageHeader
 {
   /**
    * Type: GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION
@@ -107,29 +116,18 @@ struct MulticastClientJoinDecisionMessage
   struct GNUNET_MessageHeader header;
 
   /**
-   * Number of relays given.
+   * C->S: Peer to send the join decision to.
+   * S->C: Peer we received the join decision from.
    */
-  uint32_t relay_count;
+  struct GNUNET_PeerIdentity peer;
 
   /**
-   * Public key of the joining member.
+   * C->S: Public key of the member requesting join.
+   * S->C: Unused.
    */
   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 */
-
+  /* Followed by struct MulticastJoinDecisionMessage */
 };
 
 
@@ -139,7 +137,6 @@ struct MulticastClientJoinDecisionMessage
  */
 struct MulticastMembershipTestResultMessage
 {
-
   /**
    * Type: GNUNET_MESSAGE_TYPE_MULTICAST_MEMBERSHIP_TEST_RESULT
    */
@@ -151,11 +148,11 @@ struct MulticastMembershipTestResultMessage
   uint32_t uid;
 
   /**
-   * #GNUNET_YES if the peer is a member, #GNUNET_NO if peer was not a member,
-   * #GNUNET_SYSERR if we cannot answer the test.
+   * #GNUNET_YES    if the peer is a member
+   * #GNUNET_NO     if peer is not a member,
+   * #GNUNET_SYSERR if the test could not be answered.
    */
   int32_t is_admitted;
-
 };
 
 
diff --git a/src/multicast/multicast_api.c b/src/multicast/multicast_api.c
index 501ff4b70..e568e77ee 100644
--- a/src/multicast/multicast_api.c
+++ b/src/multicast/multicast_api.c
@@ -132,7 +132,7 @@ struct GNUNET_MULTICAST_Group
   struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
   struct GNUNET_HashCode pub_key_hash;
 
-  GNUNET_MULTICAST_JoinCallback join_cb;
+  GNUNET_MULTICAST_JoinRequestCallback join_req_cb;
   GNUNET_MULTICAST_MembershipTestCallback member_test_cb;
   GNUNET_MULTICAST_ReplayFragmentCallback replay_frag_cb;
   GNUNET_MULTICAST_ReplayMessageCallback replay_msg_cb;
@@ -177,10 +177,7 @@ struct GNUNET_MULTICAST_Member
   struct GNUNET_MULTICAST_Group grp;
   struct GNUNET_MULTICAST_MemberTransmitHandle tmit;
 
-  struct GNUNET_CRYPTO_EddsaPrivateKey priv_key;
-  struct GNUNET_PeerIdentity origin;
-  struct GNUNET_PeerIdentity relays;
-  uint32_t relay_count;
+  GNUNET_MULTICAST_JoinDecisionCallback join_dcsn_cb;
 
   uint64_t next_fragment_id;
 };
@@ -197,12 +194,12 @@ struct GNUNET_MULTICAST_JoinHandle
   struct GNUNET_MULTICAST_Group *group;
 
   /**
-   * Public key of the joining member.
+   * Public key of the member requesting join.
    */
   struct GNUNET_CRYPTO_EddsaPublicKey member_key;
 
   /**
-   * Peer identity of the joining member.
+   * Peer identity of the member requesting join.
    */
   struct GNUNET_PeerIdentity member_peer;
 };
@@ -476,8 +473,9 @@ request_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash, void *origin)
               "Calling request callback for a request of type %u and size %u.\n",
               ntohs (req->header.type), ntohs (req->header.size));
 
-  orig->request_cb (orig->grp.cb_cls, &req->member_key,
-                    (const struct GNUNET_MessageHeader *) req, 0);
+  if (NULL != orig->request_cb)
+    orig->request_cb (orig->grp.cb_cls, &req->member_key,
+                      (const struct GNUNET_MessageHeader *) req, 0);
   return GNUNET_YES;
 }
 
@@ -501,7 +499,8 @@ join_request_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
   if (sizeof (*req) + sizeof (*msg) <= ntohs (req->header.size))
     msg = (const struct GNUNET_MessageHeader *) &req[1];
 
-  grp->join_cb (grp->cb_cls, &req->member_key, msg, jh);
+  if (NULL != grp->join_req_cb)
+    grp->join_req_cb (grp->cb_cls, &req->member_key, msg, jh);
   return GNUNET_YES;
 }
 
@@ -513,15 +512,44 @@ static int
 join_decision_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
                   void *member)
 {
-  const struct MulticastJoinDecisionMessage *dcsn = cls;
+  const struct MulticastJoinDecisionMessageHeader *hdcsn = cls;
+  const struct MulticastJoinDecisionMessage *
+    dcsn = (const struct MulticastJoinDecisionMessage *) &hdcsn[1];
   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];
+  uint16_t dcsn_size = ntohs (dcsn->header.size);
+  int is_admitted = ntohl (dcsn->is_admitted);
+
+  const struct GNUNET_MessageHeader *join_resp = NULL;
+  uint16_t join_resp_size = 0;
+
+  uint16_t relay_count = ntohl (dcsn->relay_count);
+  const struct GNUNET_PeerIdentity *relays = NULL;
+  uint16_t relay_size = relay_count * sizeof (*relays);
+  if (0 < relay_count && dcsn_size < sizeof (*dcsn) + relay_size)
+    relays = (struct GNUNET_PeerIdentity *) &dcsn[1];
+
+  if (sizeof (*dcsn) + relay_size + sizeof (*join_resp) <= dcsn_size)
+  {
+    join_resp = (const struct GNUNET_MessageHeader *) &dcsn[1];
+    join_resp_size = ntohs (join_resp->size);
+  }
+  if (dcsn_size < sizeof (*dcsn) + relay_size + join_resp_size)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Received invalid join decision message from multicast.\n");
+    GNUNET_break_op (0);
+    is_admitted = GNUNET_SYSERR;
+  }
+
+  if (NULL != mem->join_dcsn_cb)
+    mem->join_dcsn_cb (grp->cb_cls, is_admitted, &hdcsn->peer,
+                       relay_count, relays, join_resp);
+
+  if (GNUNET_YES != is_admitted)
+    GNUNET_MULTICAST_member_part (mem);
 
-  // FIXME: grp->join_decision_cb (grp->cb_cls, msg);
   return GNUNET_YES;
 }
 
@@ -599,7 +627,6 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_break (0);
       break;
     }
-
     if (NULL != origins)
       GNUNET_CONTAINER_multihashmap_get_multiple (origins, &grp->pub_key_hash,
                                                   request_cb, (void *) msg);
@@ -615,9 +642,11 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *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 (GNUNET_NO != grp->is_origin)
+    {
+      GNUNET_break (0);
+      break;
+    }
     if (NULL != members)
       GNUNET_CONTAINER_multihashmap_get_multiple (members, &grp->pub_key_hash,
                                                   join_decision_cb, (void *) msg);
@@ -636,11 +665,12 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
  * Function to call with the decision made for a join request.
  *
  * Must be called once and only once in response to an invocation of the
- * #GNUNET_MULTICAST_JoinCallback.
+ * #GNUNET_MULTICAST_JoinRequestCallback.
  *
  * @param jh Join request handle.
- * @param is_admitted #GNUNET_YES if joining is approved,
- *        #GNUNET_NO if it is disapproved
+ * @param is_admitted  #GNUNET_YES    if the join is approved,
+ *                     #GNUNET_NO     if it is disapproved,
+ *                     #GNUNET_SYSERR if we cannot answer the request.
  * @param relay_count Number of relays given.
  * @param relays Array of suggested peers that might be useful relays to use
  *        when joining the multicast group (essentially a list of peers that
@@ -657,25 +687,31 @@ message_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 struct GNUNET_MULTICAST_ReplayHandle *
 GNUNET_MULTICAST_join_decision (struct GNUNET_MULTICAST_JoinHandle *jh,
                                 int is_admitted,
-                                unsigned int relay_count,
+                                uint16_t relay_count,
                                 const struct GNUNET_PeerIdentity *relays,
                                 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 MulticastJoinDecisionMessageHeader * hdcsn;
+  struct MulticastJoinDecisionMessage *dcsn;
   struct MessageQueue *
-    mq = GNUNET_malloc (sizeof (*mq) + sizeof (*dcsn)
+    mq = GNUNET_malloc (sizeof (*mq) + sizeof (*hdcsn) + sizeof (*dcsn)
                         + relay_size + join_resp_size);
 
-  dcsn = (struct MulticastClientJoinDecisionMessage *) &mq[1];
+  hdcsn = (struct MulticastJoinDecisionMessageHeader *) &mq[1];
+  hdcsn->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION);
+  hdcsn->header.size = htons (sizeof (*hdcsn) + sizeof (*dcsn)
+                                + relay_size + join_resp_size);
+  hdcsn->member_key = jh->member_key;
+  hdcsn->peer = jh->member_peer;
+
+  dcsn = (struct MulticastJoinDecisionMessage *) &hdcsn[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;
+  dcsn->is_admitted = htonl (is_admitted);
+  dcsn->relay_count = htonl (relay_count);
   if (0 < relay_size)
     memcpy (&dcsn[1], relays, relay_size);
   if (0 < join_resp_size)
@@ -763,7 +799,7 @@ GNUNET_MULTICAST_replay_response2 (struct GNUNET_MULTICAST_ReplayHandle *rh,
  *        multicast session; public key is used to identify the multicast group;
  * @param max_fragment_id  Maximum fragment ID already sent to the group.
  *        0 for a new group.
- * @param join_cb  Function called to approve / disapprove joining of a peer.
+ * @param join_request_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 a message fragment.
  * @param replay_msg_cb  Function that can be called to replay a message.
@@ -779,7 +815,7 @@ struct GNUNET_MULTICAST_Origin *
 GNUNET_MULTICAST_origin_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                const struct GNUNET_CRYPTO_EddsaPrivateKey *priv_key,
                                uint64_t max_fragment_id,
-                               GNUNET_MULTICAST_JoinCallback join_cb,
+                               GNUNET_MULTICAST_JoinRequestCallback join_request_cb,
                                GNUNET_MULTICAST_MembershipTestCallback member_test_cb,
                                GNUNET_MULTICAST_ReplayFragmentCallback replay_frag_cb,
                                GNUNET_MULTICAST_ReplayMessageCallback replay_msg_cb,
@@ -801,7 +837,7 @@ GNUNET_MULTICAST_origin_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
   grp->cfg = cfg;
 
   grp->cb_cls = cls;
-  grp->join_cb = join_cb;
+  grp->join_req_cb = join_request_cb;
   grp->member_test_cb = member_test_cb;
   grp->replay_frag_cb = replay_frag_cb;
   grp->replay_msg_cb = replay_msg_cb;
@@ -963,7 +999,8 @@ GNUNET_MULTICAST_origin_to_all_cancel (struct GNUNET_MULTICAST_OriginTransmitHan
  *        If empty, the @a join_request is sent directly to the @a origin.
  * @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 join_request_cb Function called to approve / disapprove joining of a peer.
+ * @param join_decision_cb Function called to inform about the join decision.
  * @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
  *        this peer already knows from this group. NULL if this
@@ -982,10 +1019,11 @@ GNUNET_MULTICAST_member_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               const struct GNUNET_CRYPTO_EddsaPublicKey *group_key,
                               const struct GNUNET_CRYPTO_EddsaPrivateKey *member_key,
                               const struct GNUNET_PeerIdentity *origin,
-                              uint32_t relay_count,
+                              uint16_t relay_count,
                               const struct GNUNET_PeerIdentity *relays,
                               const struct GNUNET_MessageHeader *join_msg,
-                              GNUNET_MULTICAST_JoinCallback join_cb,
+                              GNUNET_MULTICAST_JoinRequestCallback join_request_cb,
+                              GNUNET_MULTICAST_JoinDecisionCallback join_decision_cb,
                               GNUNET_MULTICAST_MembershipTestCallback member_test_cb,
                               GNUNET_MULTICAST_ReplayFragmentCallback replay_frag_cb,
                               GNUNET_MULTICAST_ReplayMessageCallback replay_msg_cb,
@@ -1014,18 +1052,14 @@ GNUNET_MULTICAST_member_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
   grp->cfg = cfg;
   grp->pub_key = *group_key;
 
-  grp->join_cb = join_cb;
+  mem->join_dcsn_cb = join_decision_cb;
+  grp->join_req_cb = join_request_cb;
   grp->member_test_cb = member_test_cb;
   grp->replay_frag_cb = replay_frag_cb;
   grp->message_cb = message_cb;
   grp->cb_cls = cls;
 
-  mem->origin = *origin;
-  mem->relay_count = relay_count;
-  mem->relays = *relays;
-  mem->priv_key = *member_key;
-
-  GNUNET_CRYPTO_eddsa_key_get_public (&mem->priv_key, &grp->pub_key);
+  GNUNET_CRYPTO_eddsa_key_get_public (member_key, &grp->pub_key);
   GNUNET_CRYPTO_hash (&grp->pub_key, sizeof (grp->pub_key), &grp->pub_key_hash);
 
   if (NULL == members)