social: implement enter/leave/messaging; psyc: improvements and fixes

- social: implement enter/leave, send/receive messages, slicer
- psyc, social: add struct GNUNET_PSYC_Message for single-fragment join messages
- psyc: add message callback in addition to message part callback
- client_manager, social, psyc, multicast: add disconnect callback

5 files changed, 3037 insertions, 217 deletions

diff --git a/src/social/Makefile.am b/src/social/Makefile.am
index 04184dbc6..02b1bf823 100644
--- a/src/social/Makefile.am
+++ b/src/social/Makefile.am
@@ -24,6 +24,11 @@ libgnunetsocial_la_SOURCES = \
 libgnunetsocial_la_LIBADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/env/libgnunetenv.la \
+  $(top_builddir)/src/psyc/libgnunetpsycutil.la \
+  $(top_builddir)/src/core/libgnunetcore.la \
+  $(top_builddir)/src/identity/libgnunetidentity.la \
+  $(top_builddir)/src/gns/libgnunetgns.la \
+  $(top_builddir)/src/namestore/libgnunetnamestore.la \
   $(GN_LIBINTL) $(XLIB)
 libgnunetsocial_la_LDFLAGS = \
   $(GN_LIB_LDFLAGS)  $(WINFLAGS) \
diff --git a/src/social/gnunet-service-social.c b/src/social/gnunet-service-social.c
index ab67bedd6..90d12200d 100644
--- a/src/social/gnunet-service-social.c
+++ b/src/social/gnunet-service-social.c
@@ -32,6 +32,7 @@
 #include "gnunet_protocols.h"
 #include "gnunet_statistics_service.h"
 #include "gnunet_psyc_service.h"
+#include "gnunet_psyc_util_lib.h"
 #include "gnunet_social_service.h"
 #include "social.h"
 
@@ -71,41 +72,56 @@ static struct GNUNET_CONTAINER_MultiHashMap *place_guests;
 
 
 /**
- * Message in the transmission queue.
+ * Message fragment transmission queue.
  */
-struct TransmitMessage
+struct FragmentTransmitQueue
 {
-  struct TransmitMessage *prev;
-  struct TransmitMessage *next;
+  struct FragmentTransmitQueue *prev;
+  struct FragmentTransmitQueue *next;
 
   struct GNUNET_SERVER_Client *client;
 
   /**
-   * ID assigned to the message.
+   * Pointer to the next message part inside the data after this struct.
    */
-  uint64_t id;
+  struct GNUNET_MessageHeader *next_part;
 
   /**
-   * Size of @a buf
+   * Size of message.
    */
   uint16_t size;
 
   /**
-   * @see enum MessageState
+   * @see enum GNUNET_PSYC_MessageState
    */
   uint8_t state;
 
-  /* Followed by message */
+  /* Followed by one or more message parts. */
 };
 
 
 /**
+ * Message transmission queue.
+ */
+struct MessageTransmitQueue
+{
+  struct MessageTransmitQueue *prev;
+  struct MessageTransmitQueue *next;
+
+  struct FragmentTransmitQueue *frags_head;
+  struct FragmentTransmitQueue *frags_tail;
+
+  struct GNUNET_SERVER_Client *client;
+};
+
+/**
  * List of connected clients.
  */
-struct ClientList
+struct ClientListItem
 {
-  struct ClientList *prev;
-  struct ClientList *next;
+  struct ClientListItem *prev;
+  struct ClientListItem *next;
+
   struct GNUNET_SERVER_Client *client;
 };
 
@@ -115,11 +131,11 @@ struct ClientList
  */
 struct Place
 {
-  struct ClientList *clients_head;
-  struct ClientList *clients_tail;
+  struct ClientListItem *clients_head;
+  struct ClientListItem *clients_tail;
 
-  struct TransmitMessage *tmit_head;
-  struct TransmitMessage *tmit_tail;
+  struct MessageTransmitQueue *tmit_msgs_head;
+  struct MessageTransmitQueue *tmit_msgs_tail;
 
   /**
    * Public key of the channel.
@@ -132,9 +148,27 @@ struct Place
   struct GNUNET_HashCode pub_key_hash;
 
   /**
+   * Last message ID received for the place.
+   * 0 if there is no such message.
+   */
+  uint64_t max_message_id;
+
+  /**
    * Is this a host (#GNUNET_YES), or guest (#GNUNET_NO)?
    */
   uint8_t is_host;
+
+  /**
+   * Is this place ready to receive messages from client?
+   * #GNUNET_YES or #GNUNET_NO
+   */
+  uint8_t is_ready;
+
+  /**
+   * Is the client disconnected?
+   * #GNUNET_YES or #GNUNET_NO
+   */
+  uint8_t is_disconnected;
 };
 
 
@@ -146,7 +180,7 @@ struct Host
   /**
    * Place struct common for Host and Guest
    */
-  struct Place pl;
+  struct Place plc;
 
   /**
    * Private key of the channel.
@@ -184,17 +218,17 @@ struct Guest
   /**
    * Place struct common for Host and Guest.
    */
-  struct Place pl;
+  struct Place plc;
 
   /**
    * Private key of the slave.
    */
-  struct GNUNET_CRYPTO_EddsaPrivateKey priv_key;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey priv_key;
 
   /**
    * Public key of the slave.
    */
-  struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
+  struct GNUNET_CRYPTO_EcdsaPublicKey pub_key;
 
   /**
    * Hash of @a pub_key.
@@ -230,11 +264,32 @@ struct Guest
    * Join request to be transmitted to the master on join.
    */
   struct GNUNET_MessageHeader *join_req;
+
+  /**
+   * Join decision received from PSYC.
+   */
+  struct GNUNET_PSYC_JoinDecisionMessage *join_dcsn;
+
+};
+
+
+struct Client
+{
+  /**
+   * Place where the client entered.
+   */
+  struct Place *plc;
+
+  /**
+   * Message queue for the message currently being transmitted
+   * by this client.
+   */
+  struct MessageTransmitQueue *tmit_msg;
 };
 
 
-static inline void
-transmit_message (struct Place *pl);
+static int
+psyc_transmit_message (struct Place *plc);
 
 
 /**
@@ -265,12 +320,12 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 cleanup_host (struct Host *hst)
 {
-  struct Place *pl = &hst->pl;
+  struct Place *plc = &hst->plc;
 
   if (NULL != hst->master)
-    GNUNET_PSYC_master_stop (hst->master);
+    GNUNET_PSYC_master_stop (hst->master, GNUNET_NO, NULL, NULL); // FIXME
   GNUNET_CONTAINER_multihashmap_destroy (hst->join_reqs);
-  GNUNET_CONTAINER_multihashmap_remove (hosts, &pl->pub_key_hash, pl);
+  GNUNET_CONTAINER_multihashmap_remove (hosts, &plc->pub_key_hash, plc);
 }
 
 
@@ -280,28 +335,28 @@ cleanup_host (struct Host *hst)
 static void
 cleanup_guest (struct Guest *gst)
 {
-  struct Place *pl = &gst->pl;
+  struct Place *plc = &gst->plc;
   struct GNUNET_CONTAINER_MultiHashMap *
-    pl_gst = GNUNET_CONTAINER_multihashmap_get (place_guests,
-                                                &pl->pub_key_hash);
-  GNUNET_assert (NULL != pl_gst);
-  GNUNET_CONTAINER_multihashmap_remove (pl_gst, &gst->pub_key_hash, gst);
+    plc_gst = GNUNET_CONTAINER_multihashmap_get (place_guests,
+                                                &plc->pub_key_hash);
+  GNUNET_assert (NULL != plc_gst);
+  GNUNET_CONTAINER_multihashmap_remove (plc_gst, &gst->pub_key_hash, gst);
 
-  if (0 == GNUNET_CONTAINER_multihashmap_size (pl_gst))
+  if (0 == GNUNET_CONTAINER_multihashmap_size (plc_gst))
   {
-    GNUNET_CONTAINER_multihashmap_remove (place_guests, &pl->pub_key_hash,
-                                          pl_gst);
-    GNUNET_CONTAINER_multihashmap_destroy (pl_gst);
+    GNUNET_CONTAINER_multihashmap_remove (place_guests, &plc->pub_key_hash,
+                                          plc_gst);
+    GNUNET_CONTAINER_multihashmap_destroy (plc_gst);
   }
-  GNUNET_CONTAINER_multihashmap_remove (guests, &pl->pub_key_hash, gst);
+  GNUNET_CONTAINER_multihashmap_remove (guests, &plc->pub_key_hash, gst);
 
   if (NULL != gst->join_req)
     GNUNET_free (gst->join_req);
   if (NULL != gst->relays)
     GNUNET_free (gst->relays);
   if (NULL != gst->slave)
-    GNUNET_PSYC_slave_part (gst->slave);
-  GNUNET_CONTAINER_multihashmap_remove (guests, &pl->pub_key_hash, pl);
+    GNUNET_PSYC_slave_part (gst->slave, GNUNET_NO, NULL, NULL); // FIXME
+  GNUNET_CONTAINER_multihashmap_remove (guests, &plc->pub_key_hash, plc);
 }
 
 
@@ -309,12 +364,23 @@ cleanup_guest (struct Guest *gst)
  * Clean up place data structures after a client disconnected.
  */
 static void
-cleanup_place (struct Place *pl)
+cleanup_place (struct Place *plc)
 {
-  (GNUNET_YES == pl->is_host)
-    ? cleanup_host ((struct Host *) pl)
-    : cleanup_guest ((struct Guest *) pl);
-  GNUNET_free (pl);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Cleaning up place %s\n",
+              plc, GNUNET_h2s (&plc->pub_key_hash));
+
+  (GNUNET_YES == plc->is_host)
+    ? cleanup_host ((struct Host *) plc)
+    : cleanup_guest ((struct Guest *) plc);
+  GNUNET_free (plc);
+}
+
+
+static void
+schedule_cleanup_place (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  cleanup_place (cls);
 }
 
 
@@ -331,76 +397,1073 @@ client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
   if (NULL == client)
     return;
 
-  struct Place *
-    pl = GNUNET_SERVER_client_get_user_context (client, struct Place);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%p Client (%s) disconnected from place %s\n",
-              pl, (GNUNET_YES == pl->is_host) ? "host" : "guest",
-              GNUNET_h2s (&pl->pub_key_hash));
-
-  if (NULL == pl)
+  struct Client *
+    ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
+  if (NULL == ctx)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%p User context is NULL in client_disconnect()\n", pl);
+                "%p User context is NULL in client_disconnect()\n", ctx);
     GNUNET_break (0);
     return;
   }
 
-  struct ClientList *cl = pl->clients_head;
-  while (NULL != cl)
+  struct Place *plc = ctx->plc;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Client (%s) disconnected from place %s\n",
+              plc, (GNUNET_YES == plc->is_host) ? "host" : "guest",
+              GNUNET_h2s (&plc->pub_key_hash));
+
+  struct ClientListItem *cli = plc->clients_head;
+  while (NULL != cli)
   {
-    if (cl->client == client)
+    if (cli->client == client)
     {
-      GNUNET_CONTAINER_DLL_remove (pl->clients_head, pl->clients_tail, cl);
-      GNUNET_free (cl);
+      GNUNET_CONTAINER_DLL_remove (plc->clients_head, plc->clients_tail, cli);
+      GNUNET_free (cli);
       break;
     }
-    cl = cl->next;
+    cli = cli->next;
   }
 
-  if (NULL == pl->clients_head)
+  if (NULL == plc->clients_head)
   { /* Last client disconnected. */
-    if (NULL != pl->tmit_head)
-    { /* Send pending messages to PSYC before cleanup. */
-      //FIXME: transmit_message (pl);
+    if (GNUNET_YES != plc->is_disconnected)
+    {
+      plc->is_disconnected = GNUNET_YES;
+      if (NULL != plc->tmit_msgs_head)
+      { /* Send pending messages to PSYC before cleanup. */
+        psyc_transmit_message (plc);
+      }
+      else
+      {
+        cleanup_place (plc);
+      }
     }
-    else
+  }
+}
+
+
+/**
+ * Send message to all clients connected to the channel.
+ */
+static void
+client_send_msg (const struct Place *plc,
+                 const struct GNUNET_MessageHeader *msg)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "%p Sending message to clients.\n", plc);
+
+  struct ClientListItem *cli = plc->clients_head;
+  while (NULL != cli)
+  {
+    GNUNET_SERVER_notification_context_add (nc, cli->client);
+    GNUNET_SERVER_notification_context_unicast (nc, cli->client, msg, GNUNET_NO);
+    cli = cli->next;
+  }
+}
+
+
+/**
+ * Called after a PSYC master is started.
+ */
+static void
+psyc_master_started (void *cls, uint64_t max_message_id)
+{
+  struct Host *hst = cls;
+  struct Place *plc = &hst->plc;
+  plc->max_message_id = max_message_id;
+  plc->is_ready = GNUNET_YES;
+
+  struct CountersResult res;
+  res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK);
+  res.header.size = htons (sizeof (res));
+  res.result_code = htonl (GNUNET_OK);
+  res.max_message_id = GNUNET_htonll (plc->max_message_id);
+
+  client_send_msg (plc, &res.header);
+}
+
+
+/**
+ * Called when a PSYC master receives a join request.
+ */
+static void
+psyc_recv_join_request (void *cls,
+                        const struct GNUNET_PSYC_JoinRequestMessage *req,
+                        const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
+                        const struct GNUNET_PSYC_Message *join_msg,
+                        struct GNUNET_PSYC_JoinHandle *jh)
+{
+  struct Host *hst = cls;
+  struct GNUNET_HashCode slave_key_hash;
+  GNUNET_CRYPTO_hash (slave_key, sizeof (*slave_key), &slave_key_hash);
+  GNUNET_CONTAINER_multihashmap_put (hst->join_reqs, &slave_key_hash, jh,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  client_send_msg (&hst->plc, &req->header);
+}
+
+
+/**
+ * Called after a PSYC slave is connected.
+ */
+static void
+psyc_slave_connected (void *cls, uint64_t max_message_id)
+{
+  struct Guest *gst = cls;
+  struct Place *plc = &gst->plc;
+  plc->max_message_id = max_message_id;
+  plc->is_ready = GNUNET_YES;
+
+  struct CountersResult res;
+  res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
+  res.header.size = htons (sizeof (res));
+  res.result_code = htonl (GNUNET_OK);
+  res.max_message_id = GNUNET_htonll (plc->max_message_id);
+
+  client_send_msg (plc, &res.header);
+}
+
+
+/**
+ * Called when a PSYC slave receives a join decision.
+ */
+static void
+psyc_recv_join_dcsn (void *cls,
+                     const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
+                     int is_admitted,
+                     const struct GNUNET_PSYC_Message *join_msg)
+{
+  struct Guest *gst = cls;
+  client_send_msg (&gst->plc, &dcsn->header);
+}
+
+
+/**
+ * Called when a PSYC master or slave receives a message.
+ */
+static void
+psyc_recv_message (void *cls,
+                   uint64_t message_id,
+                   uint32_t flags,
+                   const struct GNUNET_PSYC_MessageHeader *msg)
+{
+  struct Place *plc = cls;
+  client_send_msg (plc, &msg->header);
+
+  /* FIXME: further processing */
+}
+
+
+/**
+ * Initialize place data structure.
+ */
+static void
+place_init (struct Place *plc)
+{
+
+}
+
+
+/**
+ * Handle a connecting client entering a place as host.
+ */
+static void
+client_recv_host_enter (void *cls, struct GNUNET_SERVER_Client *client,
+                        const struct GNUNET_MessageHeader *msg)
+{
+  const struct HostEnterRequest *req
+    = (const struct HostEnterRequest *) msg;
+
+  struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
+  struct GNUNET_HashCode pub_key_hash;
+
+  GNUNET_CRYPTO_eddsa_key_get_public (&req->place_key, &pub_key);
+  GNUNET_CRYPTO_hash (&pub_key, sizeof (pub_key), &pub_key_hash);
+
+  struct Host *
+    hst = GNUNET_CONTAINER_multihashmap_get (hosts, &pub_key_hash);
+  struct Place *plc;
+
+  if (NULL == hst)
+  {
+    hst = GNUNET_new (struct Host);
+    hst->policy = ntohl (req->policy);
+    hst->priv_key = req->place_key;
+    hst->join_reqs = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
+
+    plc = &hst->plc;
+    plc->is_host = GNUNET_YES;
+    plc->pub_key = pub_key;
+    plc->pub_key_hash = pub_key_hash;
+    place_init (plc);
+
+    GNUNET_CONTAINER_multihashmap_put (hosts, &plc->pub_key_hash, plc,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    hst->master = GNUNET_PSYC_master_start (cfg, &hst->priv_key, hst->policy,
+                                            &psyc_master_started,
+                                            &psyc_recv_join_request,
+                                            &psyc_recv_message, NULL, hst);
+  }
+  else
+  {
+    plc = &hst->plc;
+
+    struct CountersResult res;
+    res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK);
+    res.header.size = htons (sizeof (res));
+    res.result_code = htonl (GNUNET_OK);
+    res.max_message_id = GNUNET_htonll (plc->max_message_id);
+
+    GNUNET_SERVER_notification_context_add (nc, client);
+    GNUNET_SERVER_notification_context_unicast (nc, client, &res.header,
+                                                GNUNET_NO);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "%p Client connected as host to place %s.\n",
+              hst, GNUNET_h2s (&plc->pub_key_hash));
+
+  struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
+  cli->client = client;
+  GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
+
+  struct Client *ctx = GNUNET_new (struct Client);
+  ctx->plc = plc;
+  GNUNET_SERVER_client_set_user_context (client, ctx);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Handle a connecting client entering a place as guest.
+ */
+static void
+client_recv_guest_enter (void *cls, struct GNUNET_SERVER_Client *client,
+                         const struct GNUNET_MessageHeader *msg)
+{
+  const struct GuestEnterRequest *req
+    = (const struct GuestEnterRequest *) msg;
+  uint16_t req_size = ntohs (req->header.size);
+
+  struct GNUNET_CRYPTO_EcdsaPublicKey gst_pub_key;
+  struct GNUNET_HashCode pub_key_hash, gst_pub_key_hash;
+
+  GNUNET_CRYPTO_ecdsa_key_get_public (&req->guest_key, &gst_pub_key);
+  GNUNET_CRYPTO_hash (&gst_pub_key, sizeof (gst_pub_key), &gst_pub_key_hash);
+  GNUNET_CRYPTO_hash (&req->place_key, sizeof (req->place_key), &pub_key_hash);
+
+  struct GNUNET_CONTAINER_MultiHashMap *
+    plc_gst = GNUNET_CONTAINER_multihashmap_get (place_guests, &pub_key_hash);
+  struct Guest *gst = NULL;
+  struct Place *plc;
+
+  if (NULL != plc_gst)
+  {
+    gst = GNUNET_CONTAINER_multihashmap_get (plc_gst, &gst_pub_key_hash);
+  }
+  if (NULL == gst || NULL == gst->slave)
+  {
+    gst = GNUNET_new (struct Guest);
+    gst->priv_key = req->guest_key;
+    gst->pub_key = gst_pub_key;
+    gst->pub_key_hash = gst_pub_key_hash;
+    gst->origin = req->origin;
+    gst->relay_count = ntohl (req->relay_count);
+
+    const struct GNUNET_PeerIdentity *
+      relays = (const struct GNUNET_PeerIdentity *) &req[1];
+    uint16_t relay_size = gst->relay_count * sizeof (*relays);
+    struct GNUNET_PSYC_Message *join_msg = NULL;
+    uint16_t join_msg_size = 0;
+
+    if (sizeof (*req) + relay_size + sizeof (struct GNUNET_MessageHeader)
+        <= req_size)
+    {
+      join_msg = (struct GNUNET_PSYC_Message *)
+        (((char *) &req[1]) + relay_size);
+      join_msg_size = ntohs (join_msg->header.size);
+    }
+    if (sizeof (*req) + relay_size + join_msg_size != req_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "%u + %u + %u != %u\n",
+                  sizeof (*req), relay_size, join_msg_size, req_size);
+      GNUNET_break (0);
+      GNUNET_SERVER_client_disconnect (client);
+      return;
+    }
+    if (0 < gst->relay_count)
+    {
+      gst->relays = GNUNET_malloc (relay_size);
+      memcpy (gst->relays, &req[1], relay_size);
+    }
+
+    plc = &gst->plc;
+    plc->is_host = GNUNET_NO;
+    plc->pub_key = req->place_key;
+    plc->pub_key_hash = pub_key_hash;
+    place_init (plc);
+
+    if (NULL == plc_gst)
+    {
+      plc_gst = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
+      GNUNET_CONTAINER_multihashmap_put (place_guests, &plc->pub_key_hash, plc_gst,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    }
+    GNUNET_CONTAINER_multihashmap_put (plc_gst, &gst->pub_key_hash, plc,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+    GNUNET_CONTAINER_multihashmap_put (guests, &plc->pub_key_hash, plc,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    gst->slave
+      = GNUNET_PSYC_slave_join (cfg, &plc->pub_key, &gst->priv_key,
+                                &gst->origin, gst->relay_count, gst->relays,
+                                &psyc_recv_message, NULL, &psyc_slave_connected,
+                                &psyc_recv_join_dcsn, gst, join_msg);
+  }
+  else
+  {
+    plc = &gst->plc;
+
+    struct CountersResult res;
+    res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
+    res.header.size = htons (sizeof (res));
+    res.result_code = htonl (GNUNET_OK);
+    res.max_message_id = GNUNET_htonll (plc->max_message_id);
+
+    GNUNET_SERVER_notification_context_add (nc, client);
+    GNUNET_SERVER_notification_context_unicast (nc, client, &res.header,
+                                                GNUNET_NO);
+    if (NULL != gst->join_dcsn)
     {
-      cleanup_place (pl);
+      GNUNET_SERVER_notification_context_add (nc, client);
+      GNUNET_SERVER_notification_context_unicast (nc, client,
+                                                  &gst->join_dcsn->header,
+                                                  GNUNET_NO);
     }
   }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Client connected as guest to place %s.\n",
+              gst, GNUNET_h2s (&plc->pub_key_hash));
+
+  struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
+  cli->client = client;
+  GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
+
+  struct Client *ctx = GNUNET_new (struct Client);
+  ctx->plc = plc;
+  GNUNET_SERVER_client_set_user_context (client, ctx);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
+struct JoinDecisionClosure
+{
+  int32_t is_admitted;
+  struct GNUNET_PSYC_Message *msg;
+};
+
+
+/**
+ * Iterator callback for responding to join requests.
+ */
+static int
+psyc_send_join_decision (void *cls, const struct GNUNET_HashCode *pub_key_hash,
+                         void *value)
+{
+  struct JoinDecisionClosure *jcls = cls;
+  struct GNUNET_PSYC_JoinHandle *jh = value;
+  // FIXME: add relays
+  GNUNET_PSYC_join_decision (jh, jcls->is_admitted, 0, NULL, jcls->msg);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Handle an entry decision from a host client.
+ */
 static void
-client_home_enter (void *cls, struct GNUNET_SERVER_Client *client,
-                   const struct GNUNET_MessageHeader *msg)
+client_recv_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
+                           const struct GNUNET_MessageHeader *msg)
 {
+  struct Client *
+    ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
+  GNUNET_assert (NULL != ctx);
+  struct Place *plc = ctx->plc;
+  GNUNET_assert (GNUNET_YES == plc->is_host);
+  struct Host *hst = (struct Host *) plc;
+
+  struct GNUNET_PSYC_JoinDecisionMessage *
+    dcsn = (struct GNUNET_PSYC_JoinDecisionMessage *) msg;
+  struct JoinDecisionClosure jcls;
+  jcls.is_admitted = ntohl (dcsn->is_admitted);
+  jcls.msg
+    = (sizeof (*dcsn) + sizeof (*jcls.msg) <= ntohs (msg->size))
+    ? (struct GNUNET_PSYC_Message *) &dcsn[1]
+    : NULL;
+
+  struct GNUNET_HashCode slave_key_hash;
+  GNUNET_CRYPTO_hash (&dcsn->slave_key, sizeof (dcsn->slave_key),
+                      &slave_key_hash);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Got join decision (%d) from client for place %s..\n",
+              hst, jcls.is_admitted, GNUNET_h2s (&plc->pub_key_hash));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p ..and slave %s.\n",
+              hst, GNUNET_h2s (&slave_key_hash));
+
+  GNUNET_CONTAINER_multihashmap_get_multiple (hst->join_reqs, &slave_key_hash,
+                                              &psyc_send_join_decision, &jcls);
+  GNUNET_CONTAINER_multihashmap_remove_all (hst->join_reqs, &slave_key_hash);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
+/**
+ * Send acknowledgement to a client.
+ *
+ * Sent after a message fragment has been passed on to multicast.
+ *
+ * @param plc The place struct for the client.
+ */
 static void
-client_place_enter (void *cls, struct GNUNET_SERVER_Client *client,
-                    const struct GNUNET_MessageHeader *msg)
+send_message_ack (struct Place *plc, struct GNUNET_SERVER_Client *client)
+{
+  struct GNUNET_MessageHeader res;
+  res.size = htons (sizeof (res));
+  res.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK);
+
+  GNUNET_SERVER_notification_context_add (nc, client);
+  GNUNET_SERVER_notification_context_unicast (nc, client, &res, GNUNET_NO);
+}
+
+
+/**
+ * Proceed to the next message part in the transmission queue.
+ *
+ * @param plc
+ *        Place where the transmission is going on.
+ * @param tmit_msg
+ *        Currently transmitted message.
+ * @param tmit_frag
+ *        Currently transmitted message fragment.
+ *
+ * @return @a tmit_frag, or NULL if reached the end of fragment.
+ */
+static struct FragmentTransmitQueue *
+psyc_transmit_queue_next_part (struct Place *plc,
+                               struct MessageTransmitQueue *tmit_msg,
+                               struct FragmentTransmitQueue *tmit_frag)
+{
+  uint16_t psize = ntohs (tmit_frag->next_part->size);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "%p psyc_transmit_queue_next_part: %x + %u - %x = %u < %u\n",
+              plc, tmit_frag->next_part, psize, &tmit_frag[1],
+              (char *) tmit_frag->next_part + psize - ((char *) &tmit_frag[1]),
+              tmit_frag->size);
+  if ((char *) tmit_frag->next_part + psize - ((char *) &tmit_frag[1])
+      < tmit_frag->size)
+  {
+    tmit_frag->next_part
+      = (struct GNUNET_MessageHeader *) ((char *) tmit_frag->next_part + psize);
+  }
+  else /* Reached end of current fragment. */
+  {
+    if (NULL != tmit_frag->client)
+      send_message_ack (plc, tmit_frag->client);
+    GNUNET_CONTAINER_DLL_remove (tmit_msg->frags_head, tmit_msg->frags_tail, tmit_frag);
+    GNUNET_free (tmit_frag);
+    tmit_frag = NULL;
+  }
+  return tmit_frag;
+}
+
+
+/**
+ * Proceed to next message in transmission queue.
+ *
+ * @param plc
+ *        Place where the transmission is going on.
+ * @param tmit_msg
+ *        Currently transmitted message.
+ *
+ * @return The next message in queue, or NULL if queue is empty.
+ */
+static struct MessageTransmitQueue *
+psyc_transmit_queue_next_msg (struct Place *plc,
+                              struct MessageTransmitQueue *tmit_msg)
+{
+  GNUNET_CONTAINER_DLL_remove (plc->tmit_msgs_head, plc->tmit_msgs_tail, tmit_msg);
+  GNUNET_free (tmit_msg);
+  return plc->tmit_msgs_head;
+}
+
+
+/**
+ * Callback for data transmission to PSYC.
+ */
+static int
+psyc_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
 {
+  struct Place *plc = cls;
+  struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
+  GNUNET_assert (NULL != tmit_msg);
+  struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
+  if (NULL == tmit_frag)
+  { /* Rest of the message have not arrived yet, pause transmission */
+    *data_size = 0;
+    return GNUNET_NO;
+  }
+  struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
+  if (NULL == pmsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_data: nothing to send.\n", plc);
+    *data_size = 0;
+    return GNUNET_NO;
+  }
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p psyc_transmit_notify_data()\n", plc);
+  GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, pmsg);
+
+  uint16_t ptype = ntohs (pmsg->type);
+  uint16_t pdata_size = ntohs (pmsg->size) - sizeof (*pmsg);
+  int ret;
+
+  switch (ptype)
+  {
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
+    if (*data_size < pdata_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_data: buffer size too small for data.\n", plc);
+      *data_size = 0;
+      return GNUNET_NO;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_data: sending %u bytes.\n",
+                plc, pdata_size);
+
+    *data_size = pdata_size;
+    memcpy (data, &pmsg[1], *data_size);
+    ret = GNUNET_NO;
+    break;
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
+    *data_size = 0;
+    ret = GNUNET_YES;
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%p psyc_transmit_notify_data: unexpected message part of type %u.\n",
+                plc, ptype);
+    ret = GNUNET_SYSERR;
+  }
+
+  if (GNUNET_SYSERR == ret)
+  {
+    *data_size = 0;
+    tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
+    plc->is_disconnected = GNUNET_YES;
+    GNUNET_SERVER_client_disconnect (tmit_frag->client);
+    GNUNET_SCHEDULER_add_now (&schedule_cleanup_place, plc);
+    return ret;
+  }
+  else
+  {
+    psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
+
+    if (NULL == tmit_msg->frags_head
+        && GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= ptype)
+    { /* Reached end of current message. */
+      tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
+    }
+  }
+
+  if (ret != GNUNET_NO)
+  {
+    if (NULL != tmit_msg)
+    {
+      psyc_transmit_message (plc);
+    }
+    else if (GNUNET_YES == plc->is_disconnected)
+    {
+      /* FIXME: handle partial message (when still in_transmit) */
+      cleanup_place (plc);
+    }
+  }
+  return ret;
 }
 
 
+/**
+ * Callback for modifier transmission to PSYC.
+ */
+static int
+psyc_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
+                          uint8_t *oper, uint32_t *full_value_size)
+{
+  struct Place *plc = cls;
+  struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
+  GNUNET_assert (NULL != tmit_msg);
+  struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
+  if (NULL == tmit_frag)
+  { /* Rest of the message have not arrived yet, pause transmission */
+    *data_size = 0;
+    return GNUNET_NO;
+  }
+  struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
+  if (NULL == pmsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_mod: nothing to send.\n", plc);
+    *data_size = 0;
+    return GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p psyc_transmit_notify_mod()\n", plc);
+  GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, pmsg);
+
+  uint16_t ptype = ntohs (pmsg->type);
+  int ret;
+
+  switch (ptype)
+  {
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
+  {
+    if (NULL == oper)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "%p psyc_transmit_notify_mod: oper is NULL.\n", plc);
+      ret = GNUNET_SYSERR;
+      break;
+    }
+    struct GNUNET_PSYC_MessageModifier *
+      pmod = (struct GNUNET_PSYC_MessageModifier *) tmit_frag->next_part;
+    uint16_t mod_size = ntohs (pmod->header.size) - sizeof (*pmod);
+
+    if (*data_size < mod_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_mod: buffer size too small for data.\n", plc);
+      *data_size = 0;
+      return GNUNET_NO;
+    }
+
+    *full_value_size = ntohl (pmod->value_size);
+    *oper = pmod->oper;
+    *data_size = mod_size;
+    memcpy (data, &pmod[1], mod_size);
+    ret = GNUNET_NO;
+#if REMOVE // FIXME
+    ret = (mod_size - strnlen ((char *) &pmod[1], mod_size) - 1
+           == *full_value_size)
+      ? GNUNET_YES
+      : GNUNET_NO;
+#endif
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
+  {
+    if (NULL != oper)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "%p psyc_transmit_notify_mod: oper is not NULL.\n", plc);
+      ret = GNUNET_SYSERR;
+      break;
+    }
+    uint16_t mod_size = ntohs (pmsg->size) - sizeof (*pmsg);
+    if (*data_size < mod_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_mod: buffer size too small for data.\n", plc);
+      *data_size = 0;
+      return GNUNET_NO;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p psyc_transmit_notify_mod: sending %u bytes.\n", plc, mod_size);
+
+    *data_size = mod_size;
+    memcpy (data, &pmsg[1], *data_size);
+    ret = GNUNET_NO;
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
+    *data_size = 0;
+    ret = GNUNET_YES;
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%p psyc_transmit_notify_mod: unexpected message part of type %u.\n",
+                plc, ptype);
+    ret = GNUNET_SYSERR;
+  }
+
+  if (GNUNET_SYSERR == ret)
+  {
+    *data_size = 0;
+    ret = GNUNET_SYSERR;
+    tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
+    plc->is_disconnected = GNUNET_YES;
+    GNUNET_SERVER_client_disconnect (tmit_frag->client);
+    GNUNET_SCHEDULER_add_now (&schedule_cleanup_place, plc);
+  }
+  else
+  {
+    psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
+
+    if (NULL == tmit_msg->frags_head
+        && GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= ptype)
+    { /* Reached end of current message. */
+      tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
+    }
+  }
+  return ret;
+}
+
+/**
+ * Callback for data transmission from a host to PSYC.
+ */
+static int
+host_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
+{
+  int ret = psyc_transmit_notify_data (cls, data_size, data);
+
+  if (GNUNET_NO != ret)
+  {
+    struct Host *hst = cls;
+    hst->tmit_handle = NULL;
+  }
+  return ret;
+}
+
+
+/**
+ * Callback for the transmit functions of multicast.
+ */
+static int
+guest_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
+{
+  int ret = psyc_transmit_notify_data (cls, data_size, data);
+
+  if (GNUNET_NO != ret)
+  {
+    struct Guest *gst = cls;
+    gst->tmit_handle = NULL;
+  }
+  return ret;
+}
+
+
+/**
+ * Callback for modifier transmission from a host to PSYC.
+ */
+static int
+host_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
+                          uint8_t *oper, uint32_t *full_value_size)
+{
+  int ret = psyc_transmit_notify_mod (cls, data_size, data,
+                                      oper, full_value_size);
+  if (GNUNET_SYSERR == ret)
+  {
+    struct Host *hst = cls;
+    hst->tmit_handle = NULL;
+  }
+  return ret;
+}
+
+
+/**
+ * Callback for modifier transmission from a guest to PSYC.
+ */
+static int
+guest_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
+                           uint8_t *oper, uint32_t *full_value_size)
+{
+  int ret = psyc_transmit_notify_mod (cls, data_size, data,
+                                      oper, full_value_size);
+  if (GNUNET_SYSERR == ret)
+  {
+    struct Guest *gst = cls;
+    gst->tmit_handle = NULL;
+  }
+  return ret;
+}
+
+
+/**
+ * Get method part of next message from transmission queue.
+ *
+ * @param tmit_msg
+ *        Next item in message transmission queue.
+ * @param[out] pmeth
+ *        The message method is returned here.
+ *
+ * @return #GNUNET_OK on success
+ *         #GNUNET_NO if there are no more messages in queue.
+ *         #GNUNET_SYSERR if the next message is malformed.
+ */
+static int
+psyc_transmit_queue_next_method (struct Place *plc,
+                                 struct GNUNET_PSYC_MessageMethod **pmeth)
+{
+  struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
+  if (NULL == tmit_msg)
+    return GNUNET_NO;
+
+  struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
+  if (NULL == tmit_frag)
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
+
+  struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
+  if (NULL == pmsg
+      || GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD != ntohs (pmsg->type))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%p psyc_transmit_queue_next_method: unexpected message part of type %u.\n",
+                plc, ntohs (pmsg->type));
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+
+  uint16_t psize = ntohs (pmsg->size);
+  *pmeth = (struct GNUNET_PSYC_MessageMethod *) pmsg;
+
+  if (psize < sizeof (**pmeth) + 1 || '\0' != *((char *) *pmeth + psize - 1))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%p psyc_transmit_queue_next_method: invalid method name.\n",
+                plc, ntohs (pmsg->type));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%u <= %u || NUL != %u\n",
+                sizeof (**pmeth), psize, *((char *) *pmeth + psize - 1));
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transmit the next message in queue from the host to the PSYC channel.
+ */
+static int
+psyc_master_transmit_message (struct Host *hst)
+{
+
+  if (NULL == hst->tmit_handle)
+  {
+    struct GNUNET_PSYC_MessageMethod *pmeth = NULL;
+    int ret = psyc_transmit_queue_next_method (&hst->plc, &pmeth);
+    if (GNUNET_OK != ret)
+      return ret;
+
+    hst->tmit_handle
+      = GNUNET_PSYC_master_transmit (hst->master, (const char *) &pmeth[1],
+                                     &host_transmit_notify_mod,
+                                     &host_transmit_notify_data, hst,
+                                     pmeth->flags);
+  }
+  else
+  {
+    GNUNET_PSYC_master_transmit_resume (hst->tmit_handle);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transmit the next message in queue from a guest to the PSYC channel.
+ */
+static int
+psyc_slave_transmit_message (struct Guest *gst)
+{
+  if (NULL == gst->tmit_handle)
+  {
+    struct GNUNET_PSYC_MessageMethod *pmeth = NULL;
+    int ret = psyc_transmit_queue_next_method (&gst->plc, &pmeth);
+    if (GNUNET_OK != ret)
+      return ret;
+
+    gst->tmit_handle
+      = GNUNET_PSYC_slave_transmit (gst->slave, (const char *) &pmeth[1],
+                                    &guest_transmit_notify_mod,
+                                    &guest_transmit_notify_data, gst,
+                                    pmeth->flags);
+  }
+  else
+  {
+    GNUNET_PSYC_slave_transmit_resume (gst->tmit_handle);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transmit a message to PSYC.
+ */
+static int
+psyc_transmit_message (struct Place *plc)
+{
+  return
+    (plc->is_host)
+    ? psyc_master_transmit_message ((struct Host *) plc)
+    : psyc_slave_transmit_message ((struct Guest *) plc);
+}
+
+
+/**
+ * Queue message parts for sending to PSYC.
+ *
+ * @param plc          Place to send to.
+ * @param client       Client the message originates from.
+ * @param data_size    Size of @a data.
+ * @param data         Concatenated message parts.
+ * @param first_ptype  First message part type in @a data.
+ * @param last_ptype   Last message part type in @a data.
+ */
+static struct MessageTransmitQueue *
+psyc_transmit_queue_message (struct Place *plc,
+                             struct GNUNET_SERVER_Client *client,
+                             size_t data_size,
+                             const void *data,
+                             uint16_t first_ptype, uint16_t last_ptype,
+                             struct MessageTransmitQueue *tmit_msg)
+{
+  if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == first_ptype)
+  {
+    tmit_msg = GNUNET_malloc (sizeof (*tmit_msg));
+    GNUNET_CONTAINER_DLL_insert_tail (plc->tmit_msgs_head, plc->tmit_msgs_tail, tmit_msg);
+  }
+  else if (NULL == tmit_msg)
+  {
+    return NULL;
+  }
+
+  struct FragmentTransmitQueue *
+    tmit_frag = GNUNET_malloc (sizeof (*tmit_frag) + data_size);
+  memcpy (&tmit_frag[1], data, data_size);
+  tmit_frag->next_part = (struct GNUNET_MessageHeader *) &tmit_frag[1];
+  tmit_frag->client = client;
+  tmit_frag->size = data_size;
+
+  GNUNET_CONTAINER_DLL_insert_tail (tmit_msg->frags_head, tmit_msg->frags_tail, tmit_frag);
+  tmit_msg->client = client;
+  return tmit_msg;
+}
+
+
+/**
+ * Cancel transmission of current message to PSYC.
+ *
+ * @param plc     Place to send to.
+ * @param client  Client the message originates from.
+ */
 static void
-client_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
-                      const struct GNUNET_MessageHeader *msg)
+psyc_transmit_cancel (struct Place *plc, struct GNUNET_SERVER_Client *client)
 {
+  uint16_t type = GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL;
+
+  struct GNUNET_MessageHeader msg;
+  msg.size = htons (sizeof (msg));
+  msg.type = htons (type);
 
+  psyc_transmit_queue_message (plc, client, sizeof (msg), &msg, type, type, NULL);
+  psyc_transmit_message (plc);
+
+  /* FIXME: cleanup */
 }
 
 
+/**
+ * Handle an incoming message from a client, to be transmitted to the place.
+ */
 static void
-client_psyc_message (void *cls, struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *msg)
+client_recv_psyc_message (void *cls, struct GNUNET_SERVER_Client *client,
+                          const struct GNUNET_MessageHeader *msg)
 {
+  struct Client *
+    ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
+  GNUNET_assert (NULL != ctx);
+  struct Place *plc = ctx->plc;
+  int ret = GNUNET_SYSERR;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Received message from client.\n", plc);
+  GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, msg);
+
+  if (GNUNET_YES != plc->is_ready)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "%p Place is not ready yet, disconnecting client.\n", plc);
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+
+  uint16_t size = ntohs (msg->size);
+  uint16_t psize = size - sizeof (*msg);
+  if (psize < sizeof (struct GNUNET_MessageHeader)
+      || GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD < psize)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "%p Received message with invalid payload size (%u) from client.\n",
+                plc, psize);
+    GNUNET_break (0);
+    psyc_transmit_cancel (plc, client);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+
+  uint16_t first_ptype = 0, last_ptype = 0;
+  if (GNUNET_SYSERR
+      == GNUNET_PSYC_receive_check_parts (psize, (const char *) &msg[1],
+                                          &first_ptype, &last_ptype))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "%p Received invalid message part from client.\n", plc);
+    GNUNET_break (0);
+    psyc_transmit_cancel (plc, client);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%p Received message with first part type %u and last part type %u.\n",
+              plc, first_ptype, last_ptype);
+
+  ctx->tmit_msg
+    = psyc_transmit_queue_message (plc, client, psize, &msg[1],
+                                   first_ptype, last_ptype, ctx->tmit_msg);
+  if (NULL != ctx->tmit_msg)
+  {
+    if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= last_ptype)
+      ctx->tmit_msg = NULL;
+    ret = psyc_transmit_message (plc);
+  }
+
+  if (GNUNET_OK != ret)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "%p Received invalid message part from client.\n", plc);
+    GNUNET_break (0);
+    psyc_transmit_cancel (plc, client);
+    ret = GNUNET_SYSERR;
+  }
+  GNUNET_SERVER_receive_done (client, ret);
 }
 
 
@@ -416,16 +1479,16 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    { &client_home_enter, NULL,
-      GNUNET_MESSAGE_TYPE_SOCIAL_HOME_ENTER, 0 },
+    { &client_recv_host_enter, NULL,
+      GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER, 0 },
 
-    { &client_place_enter, NULL,
-      GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_ENTER, 0 },
+    { &client_recv_guest_enter, NULL,
+      GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER, 0 },
 
-    { &client_join_decision, NULL,
-      GNUNET_MESSAGE_TYPE_SOCIAL_JOIN_DECISION, 0 },
+    { &client_recv_join_decision, NULL,
+      GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, 0 },
 
-    { &client_psyc_message, NULL,
+    { &client_recv_psyc_message, NULL,
       GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, 0 }
   };
 
diff --git a/src/social/social.h b/src/social/social.h
index 7f854eed8..00edaefd1 100644
--- a/src/social/social.h
+++ b/src/social/social.h
@@ -19,7 +19,7 @@
  */
 
 /**
- * @file psyc/psyc.h
+ * @file social/social.h
  * @brief Common type definitions for the Social service and API.
  * @author Gabor X Toth
  */
@@ -30,16 +30,99 @@
 #include "platform.h"
 #include "gnunet_social_service.h"
 
+enum MessageState
+{
+  MSG_STATE_START    = 0,
+  MSG_STATE_HEADER   = 1,
+  MSG_STATE_METHOD   = 2,
+  MSG_STATE_MODIFIER = 3,
+  MSG_STATE_MOD_CONT = 4,
+  MSG_STATE_DATA     = 5,
+  MSG_STATE_END      = 6,
+  MSG_STATE_CANCEL   = 7,
+  MSG_STATE_ERROR    = 8,
+};
+
 
 GNUNET_NETWORK_STRUCT_BEGIN
 
 /**** library -> service ****/
 
 
+struct HostEnterRequest
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER
+   */
+  struct GNUNET_MessageHeader header;
+
+  uint32_t policy GNUNET_PACKED;
+
+  struct GNUNET_CRYPTO_EcdsaPrivateKey host_key;
+
+  struct GNUNET_CRYPTO_EddsaPrivateKey place_key;
+};
+
+
+struct GuestEnterRequest
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ADDR
+   */
+  struct GNUNET_MessageHeader header;
+
+  uint32_t relay_count GNUNET_PACKED;
+
+  struct GNUNET_CRYPTO_EcdsaPrivateKey guest_key;
+
+  struct GNUNET_CRYPTO_EddsaPublicKey place_key;
+
+  struct GNUNET_PeerIdentity origin;
+
+  /* Followed by struct GNUNET_PeerIdentity relays[relay_count] */
+
+  /* Followed by struct GNUNET_MessageHeader join_msg */
+};
+
 
 /**** service -> library ****/
 
 
+struct CountersResult
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_PSYC_RESULT_COUNTERS
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Status code for the operation.
+   */
+  int32_t result_code GNUNET_PACKED;
+
+  /**
+   * Last message ID sent to the channel.
+   */
+  uint64_t max_message_id;
+};
+
+
+#if REMOVE
+struct NymEnterRequest
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SOCIAL_NYM_ENTER
+   */
+  struct GNUNET_MessageHeader header;
+  /**
+   * Public key of the joining slave.
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey nym_key;
+
+  /* Followed by struct GNUNET_MessageHeader join_request */
+};
+#endif
+
 
 GNUNET_NETWORK_STRUCT_END
 
diff --git a/src/social/social_api.c b/src/social/social_api.c
index ee13c7d61..d19f83e89 100644
--- a/src/social/social_api.c
+++ b/src/social/social_api.c
@@ -1,4 +1,4 @@
-/*
+ /*
  * This file is part of GNUnet
  * (C) 2013 Christian Grothoff (and other contributing authors)
  *
@@ -25,30 +25,93 @@
  */
 
 #include <inttypes.h>
+#include <string.h>
 
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_env_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+#include "gnunet_gns_service.h"
 #include "gnunet_psyc_service.h"
+#include "gnunet_psyc_util_lib.h"
 #include "gnunet_social_service.h"
 #include "social.h"
 
+#define LOG(kind,...) GNUNET_log_from (kind, "social-api",__VA_ARGS__)
 
-/**
- * Handle for a pseudonym of another user in the network.
- */
-struct GNUNET_SOCIAL_Nym
-{
-
-};
 
+static struct GNUNET_CORE_Handle *core;
+static struct GNUNET_GNS_Handle *gns;
+static struct GNUNET_NAMESTORE_Handle *namestore;
+static struct GNUNET_PeerIdentity this_peer;
 
 /**
  * Handle for a place where social interactions happen.
  */
 struct GNUNET_SOCIAL_Place
 {
-
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Client connection to the service.
+   */
+  struct GNUNET_CLIENT_MANAGER_Connection *client;
+
+  /**
+   * Transmission handle;
+   */
+  struct GNUNET_PSYC_TransmitHandle *tmit;
+
+  /**
+   * Receipt handle;
+   */
+  struct GNUNET_PSYC_ReceiveHandle *recv;
+
+  /**
+   * Message to send on reconnect.
+   */
+  struct GNUNET_MessageHeader *connect_msg;
+
+  /**
+   * Slicer for processing incoming methods.
+   */
+  struct GNUNET_SOCIAL_Slicer *slicer;
+
+  /**
+   * Function called after disconnected from the service.
+   */
+  GNUNET_ContinuationCallback disconnect_cb;
+
+  /**
+   * Closure for @a disconnect_cb.
+   */
+  void *disconnect_cls;
+
+  /**
+   * Public key of the place.
+   */
+  struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
+
+  /**
+   * Private key of the ego.
+   */
+  struct GNUNET_CRYPTO_EcdsaPrivateKey ego_key;
+
+  /**
+   * Does this place belong to a host (#GNUNET_YES) or guest (#GNUNET_NO)?
+   */
+  uint8_t is_host;
+
+  /**
+   * Is this place in the process of disconnecting from the service?
+   * #GNUNET_YES or #GNUNET_NO
+   */
+  uint8_t is_disconnecting;
 };
 
 
@@ -57,7 +120,20 @@ struct GNUNET_SOCIAL_Place
  */
 struct GNUNET_SOCIAL_Host
 {
+  struct GNUNET_SOCIAL_Place plc;
 
+  struct GNUNET_CRYPTO_EddsaPrivateKey place_key;
+
+  GNUNET_SOCIAL_HostEnterCallback enter_cb;
+
+  GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb;
+
+  GNUNET_SOCIAL_FarewellCallback farewell_cb;
+
+  /**
+   * Closure for callbacks.
+   */
+  void *cb_cls;
 };
 
 
@@ -66,16 +142,91 @@ struct GNUNET_SOCIAL_Host
  */
 struct GNUNET_SOCIAL_Guest
 {
+  struct GNUNET_SOCIAL_Place plc;
 
+  GNUNET_SOCIAL_GuestEnterCallback enter_cb;
+
+  GNUNET_SOCIAL_EntryDecisionCallback entry_dcsn_cb;
+
+  /**
+   * Closure for callbacks.
+   */
+  void *cb_cls;
 };
 
 
 /**
- * Handle to an implementation of try-and-slice.
+ * Handle for a pseudonym of another user in the network.
+ */
+struct GNUNET_SOCIAL_Nym
+{
+  struct GNUNET_CRYPTO_EcdsaPublicKey pub_key;
+  struct GNUNET_HashCode pub_key_hash;
+};
+
+
+/**
+ * Hash map of all nyms.
+ * pub_key_hash -> struct GNUNET_SOCIAL_Nym *
+ */
+struct GNUNET_CONTAINER_MultiHashMap *nyms;
+
+
+/**
+ * Handle for a try-and-slice instance.
  */
 struct GNUNET_SOCIAL_Slicer
 {
+  /**
+   * Message handlers: method_name -> SlicerCallbacks
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *handlers;
+
+
+  /**
+   * Currently being processed message part.
+   */
+  const struct GNUNET_MessageHeader *msg;
+
+  /**
+   * ID of currently being received message.
+   */
+  uint64_t message_id;
+
+  /**
+   * Method name of currently being received message.
+   */
+  char *method_name;
+
+  /**
+   * Public key of the nym the current message originates from.
+   */
+  struct GNUNET_CRYPTO_EcdsaPublicKey nym_key;
+
+  /**
+   * Size of @a method_name (including terminating \0).
+   */
+  uint16_t method_name_size;
+};
+
 
+/**
+ * Callbacks for a slicer method handler.
+ */
+struct SlicerCallbacks
+{
+  GNUNET_SOCIAL_MethodCallback method_cb;
+  GNUNET_SOCIAL_ModifierCallback modifier_cb;
+  GNUNET_SOCIAL_DataCallback data_cb;
+  GNUNET_SOCIAL_EndOfMessageCallback eom_cb;
+  void *cls;
+};
+
+
+struct SlicerRemoveClosure
+{
+  struct GNUNET_SOCIAL_Slicer *slicer;
+  struct SlicerCallbacks rm_cbs;
 };
 
 
@@ -118,6 +269,181 @@ struct GNUNET_SOCIAL_HistoryLesson
 };
 
 
+static struct GNUNET_SOCIAL_Nym *
+nym_get_or_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *pub_key)
+{
+  struct GNUNET_SOCIAL_Nym *nym = NULL;
+  struct GNUNET_HashCode pub_key_hash;
+
+  if (NULL == pub_key)
+    return NULL;
+
+  GNUNET_CRYPTO_hash (pub_key, sizeof (*pub_key), &pub_key_hash);
+
+  if (NULL == nyms)
+    nyms = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
+  else
+    nym = GNUNET_CONTAINER_multihashmap_get (nyms, &pub_key_hash);
+
+  if (NULL == nym)
+  {
+    nym = GNUNET_new (struct GNUNET_SOCIAL_Nym);
+    nym->pub_key = *pub_key;
+    nym->pub_key_hash = pub_key_hash;
+    GNUNET_CONTAINER_multihashmap_put (nyms, &nym->pub_key_hash, nym,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+  return nym;
+}
+
+
+static void
+nym_destroy (struct GNUNET_SOCIAL_Nym *nym)
+{
+  GNUNET_CONTAINER_multihashmap_remove (nyms, &nym->pub_key_hash, nym);
+  GNUNET_free (nym);
+}
+
+
+/**
+ * Call a handler for an incoming message part.
+ *
+ * @param cls
+ * @param key
+ * @param value
+ *
+ * @return
+ */
+int
+slicer_handler_notify (void *cls, const struct GNUNET_HashCode *key,
+                       void *value)
+{
+  struct GNUNET_SOCIAL_Slicer *slicer = cls;
+  const struct GNUNET_MessageHeader *msg = slicer->msg;
+  struct SlicerCallbacks *cbs = value;
+  uint16_t ptype = ntohs (msg->type);
+
+  switch (ptype)
+  {
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD:
+  {
+    if (NULL == cbs->method_cb)
+      break;
+    struct GNUNET_PSYC_MessageMethod *
+      meth = (struct GNUNET_PSYC_MessageMethod *) msg;
+    cbs->method_cb (cbs->cls, meth, slicer->message_id,
+                    ntohl (meth->flags),
+                    nym_get_or_create (&slicer->nym_key),
+                    slicer->method_name);
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
+  {
+    if (NULL == cbs->modifier_cb)
+      break;
+    struct GNUNET_PSYC_MessageModifier *
+      mod = (struct GNUNET_PSYC_MessageModifier *) msg;
+    cbs->modifier_cb (cbs->cls, mod, slicer->message_id,
+                      mod->oper, (const char *) &mod[1],
+                      (const void *) &mod[1] + ntohs (mod->name_size),
+                      ntohs (mod->value_size));
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
+  {
+    if (NULL == cbs->modifier_cb)
+      break;
+    /* FIXME: concatenate until done */
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
+  {
+    if (NULL == cbs->data_cb)
+      break;
+    uint64_t data_offset = 0; // FIXME
+    cbs->data_cb (cbs->cls, msg, slicer->message_id,
+                  data_offset, &msg[1], ntohs (msg->size) - sizeof (*msg));
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
+    if (NULL == cbs->eom_cb)
+      break;
+    cbs->eom_cb (cbs->cls, msg, slicer->message_id, GNUNET_NO);
+    break;
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
+    if (NULL == cbs->eom_cb)
+      break;
+    cbs->eom_cb (cbs->cls, msg, slicer->message_id, GNUNET_YES);
+    break;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Process an incoming message part and call matching handlers.
+ *
+ * @param cls
+ *        Closure.
+ * @param message_id
+ *        ID of the message.
+ * @param flags
+ *        Flags for the message.
+ *        @see enum GNUNET_PSYC_MessageFlags
+ * @param msg
+ *        The message part. as it arrived from the network.
+ */
+static void
+slicer_message (void *cls, uint64_t message_id, uint64_t fragment_offset,
+                uint32_t flags, const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Slicer *slicer = cls;
+  uint16_t ptype = ntohs (msg->type);
+  if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == ptype)
+  {
+    struct GNUNET_PSYC_MessageMethod *
+      meth = (struct GNUNET_PSYC_MessageMethod *) msg;
+    slicer->method_name_size = ntohs (meth->header.size) - sizeof (*meth);
+    slicer->method_name = GNUNET_malloc (slicer->method_name_size);
+    memcpy (slicer->method_name, &meth[1], slicer->method_name_size);
+    slicer->message_id = message_id;
+  }
+  else
+  {
+    GNUNET_assert (message_id == slicer->message_id);
+  }
+
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "Slicer received message of type %u and size %u, "
+       "with ID %" PRIu64 " and method %s\n",
+       ptype, ntohs (msg->size), message_id, slicer->method_name);
+
+  slicer->msg = msg;
+  char *name = GNUNET_malloc (slicer->method_name_size);
+  memcpy (name, slicer->method_name, slicer->method_name_size);
+  do
+  {
+    struct GNUNET_HashCode key;
+    uint16_t name_len = strlen (name);
+    GNUNET_CRYPTO_hash (name, name_len, &key);
+    GNUNET_CONTAINER_multihashmap_get_multiple (slicer->handlers, &key,
+                                                &slicer_handler_notify, slicer);
+    char *p = strrchr (name, '_');
+    if (NULL == p)
+      break;
+    *p = '\0';
+  } while (1);
+  GNUNET_free (name);
+  slicer->msg = NULL;
+
+  if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= ptype)
+    GNUNET_free (slicer->method_name);
+}
 
 
 /**
@@ -128,7 +454,9 @@ struct GNUNET_SOCIAL_HistoryLesson
 struct GNUNET_SOCIAL_Slicer *
 GNUNET_SOCIAL_slicer_create (void)
 {
-  return NULL;
+  struct GNUNET_SOCIAL_Slicer *slicer = GNUNET_malloc (sizeof (*slicer));
+  slicer->handlers = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
+  return slicer;
 }
 
 
@@ -148,36 +476,338 @@ void
 GNUNET_SOCIAL_slicer_add (struct GNUNET_SOCIAL_Slicer *slicer,
                           const char *method_name,
                           GNUNET_SOCIAL_MethodCallback method_cb,
+                          GNUNET_SOCIAL_ModifierCallback modifier_cb,
+                          GNUNET_SOCIAL_DataCallback data_cb,
+                          GNUNET_SOCIAL_EndOfMessageCallback eom_cb,
                           void *cls)
 {
+  struct GNUNET_HashCode key;
+  GNUNET_CRYPTO_hash (method_name, strlen (method_name), &key);
+
+  struct SlicerCallbacks *cbs = GNUNET_malloc (sizeof (*cbs));
+  cbs->method_cb = method_cb;
+  cbs->modifier_cb = modifier_cb;
+  cbs->data_cb = data_cb;
+  cbs->eom_cb = eom_cb;
+  cbs->cls = cls;
+
+  GNUNET_CONTAINER_multihashmap_put (slicer->handlers, &key, cbs,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+}
 
+
+int
+slicer_remove_handler (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct SlicerRemoveClosure *rm_cls = cls;
+  struct GNUNET_SOCIAL_Slicer *slicer = rm_cls->slicer;
+  struct SlicerCallbacks *rm_cbs = &rm_cls->rm_cbs;
+  struct SlicerCallbacks *cbs = value;
+
+  if (cbs->method_cb == rm_cbs->method_cb
+      && cbs->modifier_cb == rm_cbs->modifier_cb
+      && cbs->data_cb == rm_cbs->data_cb
+      && cbs->eom_cb == rm_cbs->eom_cb)
+  {
+    GNUNET_CONTAINER_multihashmap_remove (slicer->handlers, key, cbs);
+    GNUNET_free (cbs);
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
 }
 
 
 /**
  * Remove a registered method from the try-and-slice instance.
  *
+ * Removes the first matching handler registered with @a method and the given callbacks.
+ *
  * @param slicer The try-and-slice instance.
  * @param method_name Name of the method to remove.
  * @param method Method handler.
+ *
+ * @return #GNUNET_OK if a method handler was removed,
+ *         #GNUNET_NO if no handler matched the given method name and callbacks.
  */
-void
+int
 GNUNET_SOCIAL_slicer_remove (struct GNUNET_SOCIAL_Slicer *slicer,
                              const char *method_name,
-                             GNUNET_SOCIAL_MethodCallback method_cb)
+                             GNUNET_SOCIAL_MethodCallback method_cb,
+                             GNUNET_SOCIAL_ModifierCallback modifier_cb,
+                             GNUNET_SOCIAL_DataCallback data_cb,
+                             GNUNET_SOCIAL_EndOfMessageCallback eom_cb)
 {
+  struct GNUNET_HashCode key;
+  GNUNET_CRYPTO_hash (method_name, strlen (method_name), &key);
+
+  struct SlicerRemoveClosure rm_cls;
+  rm_cls.slicer = slicer;
+  struct SlicerCallbacks *rm_cbs = &rm_cls.rm_cbs;
+  rm_cbs->method_cb = method_cb;
+  rm_cbs->modifier_cb = modifier_cb;
+  rm_cbs->data_cb = data_cb;
+  rm_cbs->eom_cb = eom_cb;
+
+  return
+    (GNUNET_SYSERR
+     == GNUNET_CONTAINER_multihashmap_get_multiple (slicer->handlers, &key,
+                                                    &slicer_remove_handler,
+                                                    &rm_cls))
+    ? GNUNET_NO
+    : GNUNET_OK;
+}
+
 
+int
+slicer_free_handler (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct SlicerCallbacks *cbs = value;
+  GNUNET_free (cbs);
+  return GNUNET_YES;
 }
 
+
 /**
  * Destroy a given try-and-slice instance.
  *
- * @param slicer slicer to destroy
+ * @param slicer
+ *        Slicer to destroy
  */
 void
 GNUNET_SOCIAL_slicer_destroy (struct GNUNET_SOCIAL_Slicer *slicer)
 {
+  GNUNET_CONTAINER_multihashmap_iterate (slicer->handlers, &slicer_free_handler,
+                                         NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (slicer->handlers);
+  GNUNET_free (slicer);
+}
+
+
+static void
+place_send_connect_msg (struct GNUNET_SOCIAL_Place *plc)
+{
+  uint16_t cmsg_size = ntohs (plc->connect_msg->size);
+  struct GNUNET_MessageHeader * cmsg = GNUNET_malloc (cmsg_size);
+  memcpy (cmsg, plc->connect_msg, cmsg_size);
+  GNUNET_CLIENT_MANAGER_transmit_now (plc->client, cmsg);
+}
+
+
+static void
+place_recv_message_ack (void *cls,
+                        struct GNUNET_CLIENT_MANAGER_Connection *client,
+                        const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Place *
+    plc = GNUNET_CLIENT_MANAGER_get_user_context_ (client, sizeof (*plc));
+  GNUNET_PSYC_transmit_got_ack (plc->tmit);
+}
+
+
+static void
+place_recv_message (void *cls,
+                    struct GNUNET_CLIENT_MANAGER_Connection *client,
+                    const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Place *
+    plc = GNUNET_CLIENT_MANAGER_get_user_context_ (client, sizeof (*plc));
+  GNUNET_PSYC_receive_message (plc->recv,
+                               (const struct GNUNET_PSYC_MessageHeader *) msg);
+}
+
+
+static void
+place_recv_disconnect (void *cls,
+                       struct GNUNET_CLIENT_MANAGER_Connection *client,
+                       const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Place *
+    plc = GNUNET_CLIENT_MANAGER_get_user_context_ (client, sizeof (*plc));
+
+  GNUNET_CLIENT_MANAGER_reconnect (client);
+  place_send_connect_msg (plc);
+}
+
+
+static void
+host_recv_enter_ack (void *cls,
+                     struct GNUNET_CLIENT_MANAGER_Connection *client,
+                     const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Host *
+    hst = GNUNET_CLIENT_MANAGER_get_user_context_ (client,
+                                                   sizeof (struct GNUNET_SOCIAL_Place));
+
+  struct GNUNET_PSYC_CountersResultMessage *
+    cres = (struct GNUNET_PSYC_CountersResultMessage *) msg;
+  if (NULL != hst->enter_cb)
+    hst->enter_cb (hst->cb_cls, GNUNET_ntohll (cres->max_message_id));
+}
+
+
+static void
+host_recv_enter_request (void *cls,
+                         struct GNUNET_CLIENT_MANAGER_Connection *client,
+                         const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Host *
+    hst = GNUNET_CLIENT_MANAGER_get_user_context_ (client,
+                                                   sizeof (struct GNUNET_SOCIAL_Place));
+  if (NULL == hst->answer_door_cb)
+     return;
+
+  const char *method_name = NULL;
+  struct GNUNET_ENV_Environment *env = NULL;
+  const void *data = NULL;
+  uint16_t data_size = 0;
+
+  const struct GNUNET_PSYC_JoinRequestMessage *
+    req = (const struct GNUNET_PSYC_JoinRequestMessage *) msg;
+  const struct GNUNET_PSYC_Message *entry_msg = NULL;
+  if (sizeof (*req) + sizeof (*entry_msg) <= ntohs (req->header.size))
+  {
+    entry_msg = (struct GNUNET_PSYC_Message *) &req[1];
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Received entry_msg of type %u and size %u.\n",
+         ntohs (entry_msg->header.type), ntohs (entry_msg->header.size));
+
+    env = GNUNET_ENV_environment_create ();
+    if (GNUNET_OK != GNUNET_PSYC_message_parse (entry_msg, &method_name, env,
+                                                &data, &data_size))
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Ignoring invalid entry request from nym %s.\n",
+           GNUNET_CRYPTO_ecdsa_public_key_to_string (&req->slave_key));
+      GNUNET_break_op (0);
+      GNUNET_ENV_environment_destroy (env);
+      return;
+    }
+  }
+
+  struct GNUNET_SOCIAL_Nym *nym = nym_get_or_create (&req->slave_key);
+  hst->answer_door_cb (hst->cb_cls, nym, method_name, env,
+                       data_size, data);
+
+  if (NULL != env)
+    GNUNET_ENV_environment_destroy (env);
+}
+
+
+static void
+guest_recv_enter_ack (void *cls,
+                     struct GNUNET_CLIENT_MANAGER_Connection *client,
+                     const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Guest *
+    gst = GNUNET_CLIENT_MANAGER_get_user_context_ (client,
+                                                   sizeof (struct GNUNET_SOCIAL_Place));
+
+  struct GNUNET_PSYC_CountersResultMessage *
+    cres = (struct GNUNET_PSYC_CountersResultMessage *) msg;
+  if (NULL != gst->enter_cb)
+    gst->enter_cb (gst->cb_cls, ntohl (cres->result_code),
+                   GNUNET_ntohll (cres->max_message_id));
+}
+
+
+static void
+guest_recv_join_decision (void *cls,
+                          struct GNUNET_CLIENT_MANAGER_Connection *client,
+                          const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_SOCIAL_Guest *
+    gst = GNUNET_CLIENT_MANAGER_get_user_context_ (client,
+                                                   sizeof (struct GNUNET_SOCIAL_Place));
+  const struct GNUNET_PSYC_JoinDecisionMessage *
+    dcsn = (const struct GNUNET_PSYC_JoinDecisionMessage *) msg;
+
+  struct GNUNET_PSYC_Message *pmsg = NULL;
+  if (ntohs (dcsn->header.size) <= sizeof (*dcsn) + sizeof (*pmsg))
+    pmsg = (struct GNUNET_PSYC_Message *) &dcsn[1];
+
+  if (NULL != gst->entry_dcsn_cb)
+    gst->entry_dcsn_cb (gst->cb_cls, ntohl (dcsn->is_admitted), pmsg);
+}
+
+
+static struct GNUNET_CLIENT_MANAGER_MessageHandler host_handlers[] =
+{
+  { &host_recv_enter_ack, NULL,
+    GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK,
+    sizeof (struct CountersResult), GNUNET_NO },
+
+  { &host_recv_enter_request, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
+    sizeof (struct GNUNET_PSYC_JoinRequestMessage), GNUNET_YES },
+
+  { &place_recv_message, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
+    sizeof (struct GNUNET_PSYC_MessageHeader), GNUNET_YES },
+
+  { &place_recv_message_ack, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK,
+    sizeof (struct GNUNET_MessageHeader), GNUNET_NO },
+
+  { &place_recv_disconnect, NULL, 0, 0, GNUNET_NO },
+
+  { NULL, NULL, 0, 0, GNUNET_NO }
+};
+
+
+static struct GNUNET_CLIENT_MANAGER_MessageHandler guest_handlers[] =
+{
+  { &guest_recv_enter_ack, NULL,
+    GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK,
+    sizeof (struct CountersResult), GNUNET_NO },
+
+  { &host_recv_enter_request, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
+    sizeof (struct GNUNET_PSYC_JoinRequestMessage), GNUNET_YES },
+
+  { &place_recv_message, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
+    sizeof (struct GNUNET_PSYC_MessageHeader), GNUNET_YES },
+
+  { &place_recv_message_ack, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK,
+    sizeof (struct GNUNET_MessageHeader), GNUNET_NO },
+
+  { &guest_recv_join_decision, NULL,
+    GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION,
+    sizeof (struct GNUNET_PSYC_JoinDecisionMessage), GNUNET_YES },
+
+  { &place_recv_disconnect, NULL, 0, 0, GNUNET_NO },
+
+  { NULL, NULL, 0, 0, GNUNET_NO }
+};
+
+
+static void
+place_cleanup (struct GNUNET_SOCIAL_Place *plc)
+{
+  GNUNET_PSYC_transmit_destroy (plc->tmit);
+  GNUNET_PSYC_receive_destroy (plc->recv);
+  GNUNET_free (plc->connect_msg);
+  if (NULL != plc->disconnect_cb)
+    plc->disconnect_cb (plc->disconnect_cls);
+}
+
+
+static void
+host_cleanup (void *cls)
+{
+  struct GNUNET_SOCIAL_Host *hst = cls;
+  place_cleanup (&hst->plc);
+  GNUNET_free (hst);
+}
+
 
+static void
+guest_cleanup (void *cls)
+{
+  struct GNUNET_SOCIAL_Guest *gst = cls;
+  place_cleanup (&gst->plc);
+  GNUNET_free (gst);
 }
 
 
@@ -187,46 +817,179 @@ GNUNET_SOCIAL_slicer_destroy (struct GNUNET_SOCIAL_Slicer *slicer)
  * A place is created upon first entering, and it is active until permanently
  * left using GNUNET_SOCIAL_host_leave().
  *
- * @param cfg  Configuration to contact the social service.
- * @param place_keyfile  File with the private-public key pair of the place,
- *        created if the file does not exist; pass NULL for ephemeral places.
- * @param policy  Policy specifying entry and history restrictions of the place.
- * @param ego  Identity of the host.
- * @param slicer  Slicer to handle incoming messages.
- * @param listener_cb  Function to handle new nyms that want to enter.
- * @param farewell_cb  Function to handle departing nyms.
- * @param cls  Closure for @a listener_cb and @a farewell_cb.
+ * @param cfg
+ *        Configuration to contact the social service.
+ * @param ego
+ *        Identity of the host.
+ * @param place_key
+ *        Private-public key pair of the place.
+ *        NULL for ephemeral places.
+ * @param policy
+ *        Policy specifying entry and history restrictions for the place.
+ * @param slicer
+ *        Slicer to handle incoming messages.
+ * @param answer_door_cb
+ *        Function to handle new nyms that want to enter.
+ * @param farewell_cb
+ *        Function to handle departing nyms.
+ * @param cls
+ *        Closure for the callbacks.
  *
  * @return Handle for the host.
  */
 struct GNUNET_SOCIAL_Host *
 GNUNET_SOCIAL_host_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          const char *place_keyfile,
+                          const struct GNUNET_IDENTITY_Ego *ego,
+                          const struct GNUNET_CRYPTO_EddsaPrivateKey *place_key,
                           enum GNUNET_PSYC_Policy policy,
-                          struct GNUNET_IDENTITY_Ego *ego,
                           struct GNUNET_SOCIAL_Slicer *slicer,
-                          GNUNET_SOCIAL_AnswerDoorCallback listener_cb,
+                          GNUNET_SOCIAL_HostEnterCallback enter_cb,
+                          GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb,
                           GNUNET_SOCIAL_FarewellCallback farewell_cb,
                           void *cls)
 {
-  return NULL;
+  struct GNUNET_SOCIAL_Host *hst = GNUNET_malloc (sizeof (*hst));
+  struct GNUNET_SOCIAL_Place *plc = &hst->plc;
+  struct HostEnterRequest *req = GNUNET_malloc (sizeof (*req));
+
+  if (NULL != place_key)
+  {
+    hst->place_key = *place_key;
+  }
+  else
+  {
+    struct GNUNET_CRYPTO_EddsaPrivateKey *
+      ephemeral_key = GNUNET_CRYPTO_eddsa_key_create ();
+    hst->place_key = *ephemeral_key;
+    GNUNET_CRYPTO_eddsa_key_get_public (&hst->place_key, &plc->pub_key);
+    GNUNET_CRYPTO_eddsa_key_clear (ephemeral_key);
+    GNUNET_free (ephemeral_key);
+  }
+  plc->ego_key = *GNUNET_IDENTITY_ego_get_private_key (ego);
+
+  req->header.size = htons (sizeof (*req));
+  req->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
+  req->policy = policy;
+  req->place_key = hst->place_key;
+  req->host_key = plc->ego_key;
+
+  plc->connect_msg = (struct GNUNET_MessageHeader *) req;
+  plc->cfg = cfg;
+  plc->is_host = GNUNET_YES;
+  plc->slicer = slicer;
+
+  hst->plc.ego_key = *GNUNET_IDENTITY_ego_get_private_key (ego);
+  hst->enter_cb = enter_cb;
+  hst->answer_door_cb = answer_door_cb;
+  hst->cb_cls = cls;
+
+  plc->client = GNUNET_CLIENT_MANAGER_connect (cfg, "social", host_handlers);
+  GNUNET_CLIENT_MANAGER_set_user_context_ (plc->client, hst, sizeof (*plc));
+
+  plc->tmit = GNUNET_PSYC_transmit_create (plc->client);
+  plc->recv = GNUNET_PSYC_receive_create (NULL, &slicer_message, plc->slicer);
+
+  place_send_connect_msg (plc);
+  return hst;
 }
 
 
 /**
- * Admit @a nym to the place.
+ * Enter a place as host.
  *
- * The @a nym reference will remain valid until either the @a host or @a nym
- * leaves the place.
+ * A place is created upon first entering, and it is active until permanently
+ * left using GNUNET_SOCIAL_host_leave().
  *
- * @param host  Host of the place.
- * @param nym  Handle for the entity that wants to enter.
+ * @param cfg
+ *        Configuration to contact the social service.
+ * @param ego
+ *        Identity of the host.
+ * @param gns_name
+ *        GNS name in the zone of the @a ego that contains the
+ *        public key of the place in a PLACE record.
+ * @param policy
+ *        Policy specifying entry and history restrictions for the place.
+ * @param slicer
+ *        Slicer to handle incoming messages.
+ * @param answer_door_cb
+ *        Function to handle new nyms that want to enter.
+ * @param farewell_cb
+ *        Function to handle departing nyms.
+ * @param cls
+ *        Closure for the callbacks.
+ *
+ * @return Handle for the host.
  */
-void
-GNUNET_SOCIAL_host_admit (struct GNUNET_SOCIAL_Host *host,
-                          struct GNUNET_SOCIAL_Nym *nym)
+struct GNUNET_SOCIAL_Host *
+GNUNET_SOCIAL_host_enter_by_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                  struct GNUNET_IDENTITY_Ego *ego,
+                                  const char *gns_name,
+                                  enum GNUNET_PSYC_Policy policy,
+                                  struct GNUNET_SOCIAL_Slicer *slicer,
+                                  GNUNET_SOCIAL_HostEnterCallback enter_cb,
+                                  GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb,
+                                  GNUNET_SOCIAL_FarewellCallback farewell_cb,
+                                  void *cls)
 {
+  struct GNUNET_CRYPTO_EddsaPrivateKey place_key = {};
 
+  /* FIXME:
+   * 1. get public key by looking up PLACE entry under gns_name
+   *    in the zone of the ego.
+   * 2. get private key from $GNUNET_DATA_HOME/social/places/PUB_KEY_HASH
+   */
+
+  return GNUNET_SOCIAL_host_enter (cfg, ego, &place_key, policy, slicer,
+                                   enter_cb, answer_door_cb, farewell_cb, cls);
+}
+
+
+/**
+ * Decision whether to admit @a nym into the place or refuse entry.
+ *
+ * @param hst
+ *        Host of the place.
+ * @param nym
+ *        Handle for the entity that wanted to enter.
+ * @param is_admitted
+ *        #GNUNET_YES    if @a nym is admitted,
+ *        #GNUNET_NO     if @a nym is refused entry,
+ *        #GNUNET_SYSERR if we cannot answer the request.
+ * @param method_name
+ *        Method name for the rejection message.
+ * @param env
+ *        Environment containing variables for the message, or NULL.
+ * @param data
+ *        Data for the rejection message to send back.
+ * @param data_size
+ *        Number of bytes in @a data for method.
+ * @return #GNUNET_OK on success,
+ *         #GNUNET_SYSERR if the message is too large.
+ */
+int
+GNUNET_SOCIAL_host_entry_decision (struct GNUNET_SOCIAL_Host *hst,
+                                   struct GNUNET_SOCIAL_Nym *nym,
+                                   int is_admitted,
+                                   const struct GNUNET_PSYC_Message *entry_resp)
+{
+  struct GNUNET_PSYC_JoinDecisionMessage *dcsn;
+  uint16_t entry_resp_size
+    = (NULL != entry_resp) ? ntohs (entry_resp->header.size) : 0;
+
+  if (GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD < sizeof (*dcsn) + entry_resp_size)
+    return GNUNET_SYSERR;
+
+  dcsn = GNUNET_malloc (sizeof (*dcsn) + entry_resp_size);
+  dcsn->header.size = htons (sizeof (*dcsn) + entry_resp_size);
+  dcsn->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION);
+  dcsn->is_admitted = htonl (is_admitted);
+  dcsn->slave_key = nym->pub_key;
+
+  if (0 < entry_resp_size)
+    memcpy (&dcsn[1], entry_resp, entry_resp_size);
+
+  GNUNET_CLIENT_MANAGER_transmit (hst->plc.client, &dcsn->header);
+  return GNUNET_OK;
 }
 
 
@@ -249,63 +1012,60 @@ GNUNET_SOCIAL_host_eject (struct GNUNET_SOCIAL_Host *host,
 
 
 /**
- * Refuse @a nym entry into the place.
+ * Get the public key of a @a nym.
  *
- * @param host  Host of the place.
- * @param nym Handle for the entity that wanted to enter.
- * @param method_name Method name for the rejection message.
- * @param env Environment containing variables for the message, or NULL.
- * @param data Data for the rejection message to send back.
- * @param data_size Number of bytes in @a data for method.
+ * Suitable, for example, to be used with GNUNET_NAMESTORE_zone_to_name().
+ *
+ * @param nym Pseudonym to map to a cryptographic identifier.
+ * @param[out] nym_key Set to the public key of the nym.
  */
-void
-GNUNET_SOCIAL_host_refuse_entry (struct GNUNET_SOCIAL_Host *host,
-                                 struct GNUNET_SOCIAL_Nym *nym,
-                                 const char *method_name,
-                                 const struct GNUNET_ENV_Environment *env,
-                                 const void *data,
-                                 size_t data_size)
+struct GNUNET_CRYPTO_EcdsaPublicKey *
+GNUNET_SOCIAL_nym_get_key (struct GNUNET_SOCIAL_Nym *nym)
 {
-
+  return &nym->pub_key;
 }
 
 
 /**
- * Get the public key of a @a nym.
+ * Obtain the private-public key pair of the hosted place.
  *
- * Suitable, for example, to be used with GNUNET_NAMESTORE_zone_to_name().
+ * The public part is suitable for storing in GNS within a PLACE record,
+ * along with peer IDs to join at.
  *
- * @param nym Pseudonym to map to a cryptographic identifier.
- * @param[out] nym_key Set to the public key of the nym.
+ * @param host
+ *        Host of the place.
+ *
+ * @return Private-public key pair of the hosted place.
  */
-void
-GNUNET_SOCIAL_nym_get_key (struct GNUNET_SOCIAL_Nym *nym,
-                           struct GNUNET_CRYPTO_EddsaPublicKey *nym_key)
+const struct GNUNET_CRYPTO_EddsaPrivateKey *
+GNUNET_SOCIAL_host_get_place_key (struct GNUNET_SOCIAL_Host *hst)
+{
+  return &hst->place_key;
+}
+
+
+static void
+namestore_result_host_advertise (void *cls, int32_t success, const char *emsg)
 {
 
 }
 
 
 /**
- * Obtain the private-public key pair of the host.
- *
- * @param host  Host to get the key of.
- * @param[out] host_key  Set to the private-public key pair of the host.  The
- *                 public part is suitable for storing in GNS within a "PLACE"
- *                 record, along with peer IDs to join at.
+ * Connected to core service.
  */
-void
-GNUNET_SOCIAL_host_get_key (struct GNUNET_SOCIAL_Host *host,
-                            struct GNUNET_CRYPTO_EddsaPrivateKey *host_key)
+static void
+core_connected_cb  (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 {
-
+  this_peer = *my_identity;
+  // FIXME
 }
 
 
 /**
  * Advertise the place in the GNS zone of the @e ego of the @a host.
  *
- * @param host  Host of the place.
+ * @param hst  Host of the place.
  * @param name The name for the PLACE record to put in the zone.
  * @param peer_count Number of elements in the @a peers array.
  * @param peers List of peers in the PLACE record that can be used to send join
@@ -314,14 +1074,37 @@ GNUNET_SOCIAL_host_get_key (struct GNUNET_SOCIAL_Host *host,
  * @param password Password used to encrypt the record.
  */
 void
-GNUNET_SOCIAL_host_advertise (struct GNUNET_SOCIAL_Host *host,
+GNUNET_SOCIAL_host_advertise (struct GNUNET_SOCIAL_Host *hst,
                               const char *name,
                               size_t peer_count,
                               const struct GNUNET_PeerIdentity *peers,
                               struct GNUNET_TIME_Relative expiration_time,
                               const char *password)
 {
-
+  struct GNUNET_SOCIAL_Place *plc = &hst->plc;
+  if (NULL == namestore)
+    namestore = GNUNET_NAMESTORE_connect (plc->cfg);
+  if (NULL == core)
+    core = GNUNET_CORE_connect (plc->cfg, NULL, core_connected_cb, NULL, NULL,
+                                NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
+
+  struct GNUNET_GNSRECORD_Data rd = { 0 };
+  rd.record_type = GNUNET_GNSRECORD_TYPE_PLACE;
+  rd.flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+  rd.expiration_time
+    = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_WEEKS, 1).rel_value_us;
+
+  struct GNUNET_GNSRECORD_PlaceData *rec = GNUNET_malloc (sizeof (*rec));
+  rec->place_key = plc->pub_key;
+  rec->origin = this_peer;
+  rec->relay_count = htons (0); // FIXME
+
+  rd.data_size = sizeof (*rec);
+  rd.data = rec;
+
+  GNUNET_NAMESTORE_records_store (namestore, &hst->plc.ego_key,
+                                  name, 1, &rd, namestore_result_host_advertise,
+                                  hst);
 }
 
 
@@ -342,26 +1125,43 @@ GNUNET_SOCIAL_host_advertise (struct GNUNET_SOCIAL_Host *host,
  * @return NULL on error (announcement already in progress?).
  */
 struct GNUNET_SOCIAL_Announcement *
-GNUNET_SOCIAL_host_announce (struct GNUNET_SOCIAL_Host *host,
+GNUNET_SOCIAL_host_announce (struct GNUNET_SOCIAL_Host *hst,
                              const char *method_name,
                              const struct GNUNET_ENV_Environment *env,
-                             GNUNET_CONNECTION_TransmitReadyNotify notify,
-                             void *notify_cls,
+                             GNUNET_PSYC_TransmitNotifyData notify_data,
+                             void *notify_data_cls,
                              enum GNUNET_SOCIAL_AnnounceFlags flags)
 {
-  return NULL;
+  if (GNUNET_OK ==
+      GNUNET_PSYC_transmit_message (hst->plc.tmit, method_name, env,
+                                    NULL, notify_data, notify_data_cls, flags));
+  return (struct GNUNET_SOCIAL_Announcement *) hst->plc.tmit;
+}
+
+
+/**
+ * Resume transmitting announcement.
+ *
+ * @param a
+ *        The announcement to resume.
+ */
+void
+GNUNET_SOCIAL_host_announce_resume (struct GNUNET_SOCIAL_Announcement *a)
+{
+  GNUNET_PSYC_transmit_resume ((struct GNUNET_PSYC_TransmitHandle *) a);
 }
 
 
 /**
  * Cancel announcement.
  *
- * @param a The announcement to cancel.
+ * @param a
+ *        The announcement to cancel.
  */
 void
 GNUNET_SOCIAL_host_announce_cancel (struct GNUNET_SOCIAL_Announcement *a)
 {
-
+  GNUNET_PSYC_transmit_cancel ((struct GNUNET_PSYC_TransmitHandle *) a);
 }
 
 
@@ -375,9 +1175,9 @@ GNUNET_SOCIAL_host_announce_cancel (struct GNUNET_SOCIAL_Announcement *a)
  * @return Handle for the hosted place, valid as long as @a host is valid.
  */
 struct GNUNET_SOCIAL_Place *
-GNUNET_SOCIAL_host_get_place (struct GNUNET_SOCIAL_Host *host)
+GNUNET_SOCIAL_host_get_place (struct GNUNET_SOCIAL_Host *hst)
 {
-  return NULL;
+  return &hst->plc;
 }
 
 
@@ -390,22 +1190,65 @@ GNUNET_SOCIAL_host_get_place (struct GNUNET_SOCIAL_Host *host)
  * @param keep_active  Keep the place active after last host disconnected.
  */
 void
-GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *host, int keep_active)
+GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *hst,
+                          int keep_active,
+                          GNUNET_ContinuationCallback leave_cb,
+                          void *leave_cls)
 {
+  struct GNUNET_SOCIAL_Place *plc = &hst->plc;
+
+ /* FIXME: send msg to service */
+
+  plc->is_disconnecting = GNUNET_YES;
+  plc->disconnect_cb = leave_cb;
+  plc->disconnect_cls = leave_cls;
 
+  GNUNET_CLIENT_MANAGER_disconnect (plc->client, GNUNET_YES,
+                                    &host_cleanup, hst);
 }
 
 
+static struct GuestEnterRequest *
+guest_enter_request_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *guest_key,
+                            const struct GNUNET_CRYPTO_EddsaPublicKey *place_key,
+                            const struct GNUNET_PeerIdentity *origin,
+                            size_t relay_count,
+                            const struct GNUNET_PeerIdentity *relays,
+                            const struct GNUNET_PSYC_Message *join_msg)
+{
+  uint16_t join_msg_size = ntohs (join_msg->header.size);
+  uint16_t relay_size = relay_count * sizeof (*relays);
+
+  struct GuestEnterRequest *
+    req = GNUNET_malloc (sizeof (*req) + relay_size + join_msg_size);
+
+  req->header.size = htons (sizeof (*req) + relay_size + join_msg_size);
+  req->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER);
+  req->place_key = *place_key;
+  req->guest_key = *guest_key;
+  req->origin = *origin;
+  req->relay_count = relay_count;
+
+  uint16_t p = sizeof (*req);
+  if (0 < relay_size)
+  {
+    memcpy ((char *) req + p, relays, relay_size);
+    p += relay_size;
+  }
+
+  memcpy ((char *) req + p, join_msg, join_msg_size);
+  return req;
+}
+
 /**
  * Request entry to a place as a guest.
  *
- * @param cfg  Configuration to contact the social service.
+ * @param cfg Configuration to contact the social service.
  * @param ego  Identity of the guest.
- * @param address GNS name of the place to enter.  Either in the form of
- *        'room.friend.gnu', or 'NYMPUBKEY.zkey'.  This latter case refers to
- *        the 'PLACE' record of the empty label ("+") in the GNS zone with the
- *        nym's public key 'NYMPUBKEY', and can be used to request entry to a
- *        pseudonym's place directly.
+ * @param crypto_address Public key of the place to enter.
+ * @param origin Peer identity of the origin of the underlying multicast group.
+ * @param relay_count Number of elements in the @a relays array.
+ * @param relays Relays for the underlying multicast group.
  * @param method_name Method name for the message.
  * @param env Environment containing variables for the message, or NULL.
  * @param data Payload for the message to give to the enter callback.
@@ -416,26 +1259,132 @@ GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *host, int keep_active)
  */
 struct GNUNET_SOCIAL_Guest *
 GNUNET_SOCIAL_guest_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                           struct GNUNET_IDENTITY_Ego *ego,
-                           char *address,
-                           const char *method_name,
-                           const struct GNUNET_ENV_Environment *env,
-                           const void *data,
-                           size_t data_size,
-                           struct GNUNET_SOCIAL_Slicer *slicer)
+                           const struct GNUNET_IDENTITY_Ego *ego,
+                           const struct GNUNET_CRYPTO_EddsaPublicKey *place_key,
+                           const struct GNUNET_PeerIdentity *origin,
+                           uint32_t relay_count,
+                           const struct GNUNET_PeerIdentity *relays,
+                           const struct GNUNET_PSYC_Message *entry_msg,
+                           struct GNUNET_SOCIAL_Slicer *slicer,
+                           GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
+                           GNUNET_SOCIAL_EntryDecisionCallback entry_dcsn_cb,
+                           void *cls)
 {
-  return NULL;
+  struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
+  struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+
+  struct GuestEnterRequest *
+    req = guest_enter_request_create (&plc->ego_key, place_key, origin,
+                                      relay_count, relays, entry_msg);
+  plc->connect_msg = &req->header;
+  plc->ego_key = *GNUNET_IDENTITY_ego_get_private_key (ego);
+  plc->pub_key = *place_key;
+  plc->cfg = cfg;
+  plc->is_host = GNUNET_YES;
+  plc->slicer = slicer;
+
+  gst->enter_cb = local_enter_cb;
+  gst->entry_dcsn_cb = entry_dcsn_cb;
+  gst->cb_cls = cls;
+
+  plc->client = GNUNET_CLIENT_MANAGER_connect (cfg, "social", guest_handlers);
+  GNUNET_CLIENT_MANAGER_set_user_context_ (plc->client, gst, sizeof (*plc));
+
+  plc->tmit = GNUNET_PSYC_transmit_create (plc->client);
+  plc->recv = GNUNET_PSYC_receive_create (NULL, &slicer_message, plc->slicer);
+
+  place_send_connect_msg (plc);
+  return gst;
+}
+
+
+/**
+ * Result of a GNS name lookup for entering a place.
+ *
+ * @see GNUNET_SOCIAL_guest_enter_by_name
+ */
+static void
+gns_result_guest_enter (void *cls, uint32_t rd_count,
+                        const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct GNUNET_SOCIAL_Guest *gst = cls;
+  struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+
+  const struct GNUNET_GNSRECORD_PlaceData *
+    rec = (const struct GNUNET_GNSRECORD_PlaceData *) rd->data;
+
+  if (0 == rd_count)
+  {
+    if (NULL != gst->enter_cb)
+      gst->enter_cb (gst->cb_cls, GNUNET_SYSERR, 0);
+    return;
+  }
+
+
+  if (rd->data_size < sizeof (*rec))
+  {
+    GNUNET_break_op (0);
+    if (NULL != gst->enter_cb)
+      gst->enter_cb (gst->cb_cls, GNUNET_SYSERR, 0);
+    return;
+  }
+
+  struct GuestEnterRequest *
+    req = (struct GuestEnterRequest *) plc->connect_msg;
+  uint16_t req_size = ntohs (req->header.size);
+
+  struct GNUNET_PeerIdentity *relays = NULL;
+  uint16_t relay_count = ntohs (rec->relay_count);
+
+  if (0 < relay_count)
+  {
+    uint16_t relay_size = relay_count * sizeof (struct GNUNET_PeerIdentity);
+    struct GuestEnterRequest *
+      req2 = GNUNET_malloc (req_size + relay_size);
+
+    req2->header.size = htons (req_size + relay_size);
+    req2->header.type = req->header.type;
+    req2->guest_key = req->guest_key;
+
+    uint16_t p = sizeof (*req);
+    if (0 < relay_size)
+    {
+      memcpy ((char *) req2 + p, relays, relay_size);
+      p += relay_size;
+    }
+
+    memcpy ((char *) req + p, &req[1], req_size - sizeof (*req));
+
+    plc->connect_msg = &req2->header;
+    GNUNET_free (req);
+    req = req2;
+  }
+
+  req->place_key = rec->place_key;
+  req->origin = rec->origin;
+  req->relay_count = rec->relay_count;
+  memcpy (&req[1], &rec[1],
+          ntohl (rec->relay_count) * sizeof (struct GNUNET_PeerIdentity));
+
+  plc->connect_msg = &req->header;
+  plc->pub_key = req->place_key;
+
+  plc->tmit = GNUNET_PSYC_transmit_create (plc->client);
+  plc->recv = GNUNET_PSYC_receive_create (NULL, &slicer_message, plc);
+
+  place_send_connect_msg (plc);
 }
 
 /**
  * Request entry to a place as a guest.
  *
- * @param cfg Configuration to contact the social service.
+ * @param cfg  Configuration to contact the social service.
  * @param ego  Identity of the guest.
- * @param crypto_address Public key of the place to enter.
- * @param origin Peer identity of the origin of the underlying multicast group.
- * @param relay_count Number of elements in the @a relays array.
- * @param relays Relays for the underlying multicast group.
+ * @param address GNS name of the place to enter.  Either in the form of
+ *        'room.friend.gnu', or 'NYMPUBKEY.zkey'.  This latter case refers to
+ *        the 'PLACE' record of the empty label ("+") in the GNS zone with the
+ *        nym's public key 'NYMPUBKEY', and can be used to request entry to a
+ *        pseudonym's place directly.
  * @param method_name Method name for the message.
  * @param env Environment containing variables for the message, or NULL.
  * @param data Payload for the message to give to the enter callback.
@@ -445,41 +1394,75 @@ GNUNET_SOCIAL_guest_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return NULL on errors, otherwise handle for the guest.
  */
 struct GNUNET_SOCIAL_Guest *
-GNUNET_SOCIAL_guest_enter2 (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                            struct GNUNET_IDENTITY_Ego *ego,
-                            struct GNUNET_CRYPTO_EddsaPublicKey *crypto_address,
-                            struct GNUNET_PeerIdentity *origin,
-                            size_t relay_count,
-                            struct GNUNET_PeerIdentity *relays,
-                            const char *method_name,
-                            const struct GNUNET_ENV_Environment *env,
-                            const void *data,
-                            size_t data_size,
-                            struct GNUNET_SOCIAL_Slicer *slicer)
+GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                   struct GNUNET_IDENTITY_Ego *ego,
+                                   char *gns_name,
+                                   const struct GNUNET_PSYC_Message *join_msg,
+                                   struct GNUNET_SOCIAL_Slicer *slicer,
+                                   GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
+                                   GNUNET_SOCIAL_EntryDecisionCallback entry_decision_cb,
+                                   void *cls)
 {
-  return NULL;
+  struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
+  struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+
+  gst->enter_cb = local_enter_cb;
+  gst->cb_cls = cls;
+
+  plc->ego_key = *GNUNET_IDENTITY_ego_get_private_key (ego);
+  plc->cfg = cfg;
+  plc->is_host = GNUNET_NO;
+  plc->slicer = slicer;
+
+  struct GuestEnterRequest *
+    req = guest_enter_request_create (&plc->ego_key, NULL, NULL, 0, NULL,
+                                      join_msg);
+  plc->connect_msg = &req->header;
+
+  /* FIXME: get the public key of the origin and relays
+   *        by looking up the PLACE record of gns_name.
+   */
+  if (NULL == gns)
+    gns = GNUNET_GNS_connect (cfg);
+
+  plc->client = GNUNET_CLIENT_MANAGER_connect (cfg, "social", guest_handlers);
+  GNUNET_CLIENT_MANAGER_set_user_context_ (plc->client, gst, sizeof (*plc));
+
+  struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
+  GNUNET_IDENTITY_ego_get_public_key (ego, &ego_pub_key);
+  GNUNET_GNS_lookup (gns, gns_name, &ego_pub_key,
+                     GNUNET_GNSRECORD_TYPE_PLACE, GNUNET_GNS_LO_DEFAULT,
+                     NULL, gns_result_guest_enter, gst);
+
+  return gst;
 }
 
 
 /**
  * Talk to the host of the place.
  *
- * @param place Place where we want to talk to the host.
- * @param method_name Method to invoke on the host.
- * @param env Environment containing variables for the message, or NULL.
- * @param notify Function to use to get the payload for the method.
- * @param notify_cls Closure for @a notify.
- * @param flags Flags for the message being sent.
+ * @param place
+ *        Place where we want to talk to the host.
+ * @param method_name
+ *        Method to invoke on the host.
+ * @param env
+ *        Environment containing variables for the message, or NULL.
+ * @param notify_data
+ *        Function to use to get the payload for the method.
+ * @param notify_data_cls
+ *        Closure for @a notify_data.
+ * @param flags
+ *        Flags for the message being sent.
  *
  * @return NULL if we are already trying to talk to the host,
  *         otherwise handle to cancel the request.
  */
 struct GNUNET_SOCIAL_TalkRequest *
-GNUNET_SOCIAL_guest_talk (struct GNUNET_SOCIAL_Place *place,
+GNUNET_SOCIAL_guest_talk (struct GNUNET_SOCIAL_Guest *guest,
                           const char *method_name,
                           const struct GNUNET_ENV_Environment *env,
-                          GNUNET_CONNECTION_TransmitReadyNotify notify,
-                          void *notify_cls,
+                          GNUNET_PSYC_TransmitNotifyData notify_data,
+                          void *notify_data_cls,
                           enum GNUNET_SOCIAL_TalkFlags flags)
 {
   return NULL;
@@ -487,14 +1470,28 @@ GNUNET_SOCIAL_guest_talk (struct GNUNET_SOCIAL_Place *place,
 
 
 /**
+ * Resume talking to the host of the place.
+ *
+ * @param tr
+ *        Talk request to resume.
+ */
+void
+GNUNET_SOCIAL_guest_talk_resume (struct GNUNET_SOCIAL_TalkRequest *tr)
+{
+  GNUNET_PSYC_transmit_resume ((struct GNUNET_PSYC_TransmitHandle *) tr);
+}
+
+
+/**
  * Cancel talking to the host of the place.
  *
- * @param tr Talk request to cancel.
+ * @param tr
+ *        Talk request to cancel.
  */
 void
 GNUNET_SOCIAL_guest_talk_cancel (struct GNUNET_SOCIAL_TalkRequest *tr)
 {
-
+  GNUNET_PSYC_transmit_cancel ((struct GNUNET_PSYC_TransmitHandle *) tr);
 }
 
 
@@ -507,9 +1504,21 @@ GNUNET_SOCIAL_guest_talk_cancel (struct GNUNET_SOCIAL_TalkRequest *tr)
  * @param keep_active Keep place active after last application disconnected.
  */
 void
-GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Place *place, int keep_active)
+GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Guest *gst,
+                           int keep_active,
+                           GNUNET_ContinuationCallback leave_cb,
+                           void *leave_cls)
 {
+  struct GNUNET_SOCIAL_Place *plc = &gst->plc;
+
+  /* FIXME: send msg to service */
+
+  plc->is_disconnecting = GNUNET_YES;
+  plc->disconnect_cb = leave_cb;
+  plc->disconnect_cls = leave_cls;
 
+  GNUNET_CLIENT_MANAGER_disconnect (plc->client, GNUNET_YES,
+                                    &guest_cleanup, gst);
 }
 
 
@@ -523,9 +1532,9 @@ GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Place *place, int keep_active)
  * @return Handle for the place, valid as long as @a guest is valid.
  */
 struct GNUNET_SOCIAL_Place *
-GNUNET_SOCIAL_guest_get_place (struct GNUNET_SOCIAL_Host *guest)
+GNUNET_SOCIAL_guest_get_place (struct GNUNET_SOCIAL_Guest *gst)
 {
-  return NULL;
+  return &gst->plc;
 }
 
 
@@ -671,6 +1680,4 @@ GNUNET_SOCIAL_place_look_at (struct GNUNET_SOCIAL_Place *place,
 }
 
 
-
-
 /* end of social_api.c */
diff --git a/src/social/test_social.c b/src/social/test_social.c
index 053e347d1..340c4482a 100644
--- a/src/social/test_social.c
+++ b/src/social/test_social.c
@@ -17,7 +17,6 @@
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
-
 /**
  * @file social/test_social.c
  * @brief Tests for the Social API.
@@ -32,32 +31,132 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_testing_lib.h"
 #include "gnunet_env_lib.h"
+#include "gnunet_psyc_util_lib.h"
 #include "gnunet_social_service.h"
+#include "gnunet_core_service.h"
+#include "gnunet_identity_service.h"
 
 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 #define DEBUG_SERVICE 0
+#define DATA2ARG(data) data, sizeof (data)
 
 /**
  * Return value from 'main'.
  */
-static int res;
-
-static const struct GNUNET_CONFIGURATION_Handle *cfg;
+int res;
 
 /**
  * Handle for task for timeout termination.
  */
-static GNUNET_SCHEDULER_TaskIdentifier end_badly_task;
+GNUNET_SCHEDULER_TaskIdentifier end_badly_task;
+
+const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+struct GNUNET_CORE_Handle *core;
+struct GNUNET_PeerIdentity this_peer;
+
+struct GNUNET_IDENTITY_Handle *id;
+
+const struct GNUNET_IDENTITY_Ego *host_ego;
+const struct GNUNET_IDENTITY_Ego *guest_ego;
+
+const char *host_name = "Host One";
+const char *guest_name = "Guest One";
+
+struct GNUNET_CRYPTO_EddsaPrivateKey *place_key;
+struct GNUNET_CRYPTO_EcdsaPrivateKey *guest_key;
+
+struct GNUNET_CRYPTO_EddsaPublicKey place_pub_key;
+struct GNUNET_CRYPTO_EcdsaPublicKey guest_pub_key;
+
+struct GNUNET_SOCIAL_Slicer *host_slicer;
+struct GNUNET_SOCIAL_Slicer *guest_slicer;
+
+struct GNUNET_SOCIAL_Host *hst;
+struct GNUNET_SOCIAL_Guest *gst;
+
+struct GuestEnterMessage
+{
+  struct GNUNET_PSYC_Message *msg;
+  const char *method_name;
+  struct GNUNET_ENV_Environment *env;
+  void *data;
+  uint16_t data_size;
+} guest_enter_msg;
+
+struct TransmitClosure
+{
+  struct GNUNET_SOCIAL_Announcement *host_ann;
+  struct GNUNET_SOCIAL_TalkRequest *guest_talk;
+  struct GNUNET_ENV_Environment *env;
+  char *data[16];
+  uint8_t data_delay[16];
+  uint8_t data_count;
+  uint8_t paused;
+  uint8_t n;
+} tmit;
+
+uint8_t join_req_count;
+struct GNUNET_PSYC_Message *join_resp;
+
+enum
+{
+  TEST_NONE = 0,
+  TEST_HOST_ANSWER_DOOR_REFUSE      = 1,
+  TEST_GUEST_RECV_ENTRY_DCSN_REFUSE = 2,
+  TEST_HOST_ANSWER_DOOR_ADMIT       = 3,
+  TEST_GUEST_RECV_ENTRY_DCSN_ADMIT  = 4,
+  TEST_HOST_ANNOUNCE     = 5,
+  TEST_HOST_ANNOUNCE_END = 6,
+  TEST_GUEST_TALK        = 7,
+  TEST_GUEST_TALK_END    = 8,
+  TEST_GUEST_LEAVE       = 9,
+  TEST_HOST_LEAVE       = 10,
+} test;
+
+
+void
+guest_enter ();
+
+
+void
+guest_talk ();
+
+
+void
+host_announce2 ();
 
 
 /**
  * Clean up all resources used.
  */
-static void
+void
 cleanup ()
 {
+  if (NULL != core)
+  {
+    GNUNET_CORE_disconnect (core);
+    core = NULL;
+  }
 
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+
+  if (NULL != gst)
+  {
+    GNUNET_SOCIAL_guest_leave (gst, GNUNET_NO, NULL, NULL);
+    gst = NULL;
+  }
+  if (NULL != hst)
+  {
+    GNUNET_SOCIAL_host_leave (hst, GNUNET_NO, NULL, NULL);
+    hst = NULL;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -67,7 +166,7 @@ cleanup ()
  * @param cls NULL
  * @param tc scheduler context
  */
-static void
+void
 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   res = 1;
@@ -82,7 +181,7 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param cls NULL
  * @param tc scheduler context
  */
-static void
+void
 end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   res = 0;
@@ -94,7 +193,7 @@ end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Finish the test case (successfully).
  */
-static void
+void
 end ()
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending tests.\n");
@@ -109,6 +208,564 @@ end ()
 }
 
 
+static void
+transmit_resume (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmission resumed.\n");
+  struct TransmitClosure *tmit = cls;
+  if (NULL != tmit->host_ann)
+    GNUNET_SOCIAL_host_announce_resume (tmit->host_ann);
+  else
+    GNUNET_SOCIAL_guest_talk_resume (tmit->guest_talk);
+}
+
+
+int
+notify_data (void *cls, uint16_t *data_size, void *data)
+{
+  struct TransmitClosure *tmit = cls;
+  if (NULL != tmit->env)
+  {
+    GNUNET_ENV_environment_destroy (tmit->env);
+    tmit->env = NULL;
+  }
+  if (0 == tmit->data_count)
+  {
+    *data_size = 0;
+    return GNUNET_YES;
+  }
+
+  uint16_t size = strlen (tmit->data[tmit->n]) + 1;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transmit notify data: %u bytes available, "
+              "processing fragment %u/%u (size %u).\n",
+              *data_size, tmit->n + 1, tmit->data_count, size);
+  if (*data_size < size)
+  {
+    *data_size = 0;
+    GNUNET_assert (0);
+    return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_YES != tmit->paused && 0 < tmit->data_delay[tmit->n])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmission paused.\n");
+    tmit->paused = GNUNET_YES;
+    GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     tmit->data_delay[tmit->n]),
+      &transmit_resume, tmit);
+    *data_size = 0;
+    return GNUNET_NO;
+  }
+  tmit->paused = GNUNET_NO;
+
+  *data_size = size;
+  memcpy (data, tmit->data[tmit->n], size);
+
+  return ++tmit->n < tmit->data_count ? GNUNET_NO : GNUNET_YES;
+}
+
+
+void host_left ()
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "The host has left the place.\n");
+  GNUNET_SOCIAL_slicer_destroy (host_slicer);
+  host_slicer = NULL;
+  hst = NULL;
+
+  end ();
+}
+
+
+void
+schedule_host_leave (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  test = TEST_HOST_LEAVE;
+  GNUNET_SOCIAL_host_leave (hst, GNUNET_NO, &host_left, NULL);
+}
+
+
+void
+host_farewell (void *cls,
+               struct GNUNET_SOCIAL_Nym *nym,
+               struct GNUNET_ENV_Environment *env,
+               size_t variable_count,
+               struct GNUNET_ENV_Modifier *variables)
+{
+  struct GNUNET_CRYPTO_EcdsaPublicKey *
+    nym_key = GNUNET_SOCIAL_nym_get_key (nym);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Nym %s has left the place.\n",
+              GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key));
+  GNUNET_assert (0 == memcmp (&guest_pub_key, nym_key, sizeof (*nym_key)));
+
+  GNUNET_SCHEDULER_add_now (&schedule_host_leave, NULL);
+}
+
+
+void
+guest_left (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "The guest has left the place.\n");
+  GNUNET_SOCIAL_slicer_destroy (guest_slicer);
+  guest_slicer = NULL;
+  gst = NULL;
+
+  GNUNET_SCHEDULER_add_now (&schedule_host_leave, NULL);
+}
+
+
+void
+schedule_guest_leave (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  test = TEST_GUEST_LEAVE;
+  /* FIXME test keep_active */
+  GNUNET_SOCIAL_guest_leave (gst, GNUNET_NO, &guest_left, NULL);
+}
+
+
+
+void
+guest_recv_method (void *cls,
+                  const struct GNUNET_PSYC_MessageMethod *meth,
+                  uint64_t message_id,
+                  uint32_t flags,
+                  const struct GNUNET_SOCIAL_Nym *nym,
+                  const char *method_name)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Guest received method for message ID %" PRIu64 ":\n"
+              "%s\n",
+              test, message_id, method_name);
+  /* FIXME: check message */
+}
+
+
+void
+guest_recv_modifier (void *cls,
+                    const struct GNUNET_PSYC_MessageModifier *mod,
+                    uint64_t message_id,
+                    enum GNUNET_ENV_Operator oper,
+                    const char *name,
+                    const void *value,
+                    uint16_t value_size)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Guest received modifier for message ID %" PRIu64 ":\n"
+              "%c%s: %.*s\n",
+              test, message_id, oper, name, value_size, value);
+}
+
+
+void
+guest_recv_data (void *cls,
+                const struct GNUNET_MessageHeader *msg,
+                uint64_t message_id,
+                uint64_t data_offset,
+                const void *data,
+                uint16_t data_size)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Guest received data for message ID %" PRIu64 ":\n"
+              "%.*s\n",
+              test, message_id, data_size, data);
+}
+
+
+void
+guest_recv_eom (void *cls,
+               const struct GNUNET_MessageHeader *msg,
+               uint64_t message_id,
+               uint8_t cancelled)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Guest received end of message ID %" PRIu64
+              ", cancelled: %u\n",
+              test, message_id, cancelled);
+
+  switch (test)
+  {
+  case TEST_HOST_ANNOUNCE:
+    test = TEST_HOST_ANNOUNCE_END;
+    break;
+
+  case TEST_HOST_ANNOUNCE_END:
+    guest_talk ();
+    break;
+
+  case TEST_GUEST_TALK:
+    test = TEST_GUEST_TALK_END;
+    break;
+
+  case TEST_GUEST_TALK_END:
+    GNUNET_SCHEDULER_add_now (&schedule_guest_leave, NULL);
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+void
+host_recv_method (void *cls,
+                  const struct GNUNET_PSYC_MessageMethod *meth,
+                  uint64_t message_id,
+                  uint32_t flags,
+                  const struct GNUNET_SOCIAL_Nym *nym,
+                  const char *method_name)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Host received method for message ID %" PRIu64 ":\n"
+              "%s\n",
+              test, message_id, method_name);
+  /* FIXME: check message */
+}
+
+
+void
+host_recv_modifier (void *cls,
+                    const struct GNUNET_PSYC_MessageModifier *mod,
+                    uint64_t message_id,
+                    enum GNUNET_ENV_Operator oper,
+                    const char *name,
+                    const void *value,
+                    uint16_t value_size)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Host received modifier for message ID %" PRIu64 ":\n"
+              "%c%s: %.*s\n",
+              test, message_id, oper, name, value_size, value);
+}
+
+
+void
+host_recv_data (void *cls,
+                const struct GNUNET_MessageHeader *msg,
+                uint64_t message_id,
+                uint64_t data_offset,
+                const void *data,
+                uint16_t data_size)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Host received data for message ID %" PRIu64 ":\n"
+              "%.*s\n",
+              test, message_id, data_size, data);
+}
+
+
+void
+host_recv_eom (void *cls,
+               const struct GNUNET_MessageHeader *msg,
+               uint64_t message_id,
+               uint8_t cancelled)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test #%u: Host received end of message ID %" PRIu64
+              ", cancelled: %u\n",
+              test, message_id, cancelled);
+
+  switch (test)
+  {
+  case TEST_HOST_ANNOUNCE:
+    test = TEST_HOST_ANNOUNCE_END;
+    //host_announce2 ();
+    break;
+
+  case TEST_HOST_ANNOUNCE_END:
+    guest_talk ();
+    break;
+
+  case TEST_GUEST_TALK:
+    test = TEST_GUEST_TALK_END;
+    break;
+
+  case TEST_GUEST_TALK_END:
+    GNUNET_SCHEDULER_add_now (&schedule_guest_leave, NULL);
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+void
+guest_talk ()
+{
+  test = TEST_GUEST_TALK;
+
+  tmit = (struct TransmitClosure) {};
+  tmit.env = GNUNET_ENV_environment_create ();
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_bar_foo", DATA2ARG ("one two three"));
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_bar_baz", DATA2ARG ("four five"));
+  tmit.data[0] = "zzz xxx yyy";
+  tmit.data[1] = "zyx wvu tsr qpo";
+  tmit.data[2] = "testing ten nine eight";
+  tmit.data_count = 3;
+
+  tmit.host_ann
+    = GNUNET_SOCIAL_host_announce (hst, "_message_guest", tmit.env,
+                                   &notify_data, &tmit,
+                                   GNUNET_SOCIAL_TALK_NONE);
+}
+
+void
+host_announce ()
+{
+  test = TEST_HOST_ANNOUNCE;
+
+  tmit = (struct TransmitClosure) {};
+  tmit.env = GNUNET_ENV_environment_create ();
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo", DATA2ARG ("bar baz"));
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo_bar", DATA2ARG ("foo bar"));
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo_bar_baz", DATA2ARG ("foo bar baz"));
+  tmit.data[0] = "aaa bbb ccc";
+  tmit.data[1] = "abc def ghi jkl";
+  tmit.data[2] = "testing one two three";
+  tmit.data[3] = "four five";
+  tmit.data_count = 4;
+
+  tmit.host_ann
+    = GNUNET_SOCIAL_host_announce (hst, "_message_host", tmit.env,
+                                   &notify_data, &tmit,
+                                   GNUNET_SOCIAL_ANNOUNCE_NONE);
+}
+
+void
+host_announce2 ()
+{
+  test = TEST_HOST_ANNOUNCE;
+
+  tmit = (struct TransmitClosure) {};
+  tmit.env = GNUNET_ENV_environment_create ();
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo2", DATA2ARG ("BAR BAZ"));
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo2_bar", DATA2ARG ("FOO BAR"));
+  GNUNET_ENV_environment_add (tmit.env, GNUNET_ENV_OP_ASSIGN,
+                              "_foo2_bar", DATA2ARG ("FOO BAR BAZ"));
+  tmit.data[0] = "AAA BBB CCC";
+  tmit.data[1] = "ABC DEF GHI JKL";
+  tmit.data[2] = "TESTING ONE TWO THREE";
+  tmit.data_count = 3;
+
+  tmit.host_ann
+    = GNUNET_SOCIAL_host_announce (hst, "_message_host_two", tmit.env,
+                                   &notify_data, &tmit,
+                                   GNUNET_SOCIAL_ANNOUNCE_NONE);
+}
+
+
+void
+guest_recv_entry_decision (void *cls,
+                           int is_admitted,
+                           const struct GNUNET_PSYC_Message *entry_resp)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Guest received entry decision (try %u): %d.\n",
+              join_req_count, is_admitted);
+
+  if (NULL != entry_resp)
+  {
+    struct GNUNET_ENV_Environment *env = GNUNET_ENV_environment_create ();
+    const char *method_name = NULL;
+    const void *data = NULL;
+    uint16_t data_size = 0;
+    GNUNET_PSYC_message_parse (entry_resp, &method_name, env, &data, &data_size);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%s\n%.*s\n",
+                method_name, data_size, data);
+    /* FIXME: check response message */
+  }
+
+  switch (test)
+  {
+  case TEST_GUEST_RECV_ENTRY_DCSN_REFUSE:
+    GNUNET_assert (GNUNET_NO == is_admitted);
+    guest_enter ();
+    break;
+
+  case TEST_GUEST_RECV_ENTRY_DCSN_ADMIT:
+    GNUNET_assert (GNUNET_YES == is_admitted);
+    host_announce ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+void
+host_answer_door (void *cls,
+                  struct GNUNET_SOCIAL_Nym *nym,
+                  const char *method_name,
+                  struct GNUNET_ENV_Environment *env,
+                  size_t data_size,
+                  const void *data)
+{
+  join_req_count++;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Host received entry request from guest (try %u).\n",
+                join_req_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%s\n%.*s\n",
+              method_name, data_size, data);
+
+  switch (test)
+  {
+  case TEST_HOST_ANSWER_DOOR_REFUSE:
+    test = TEST_GUEST_RECV_ENTRY_DCSN_REFUSE;
+    join_resp = GNUNET_PSYC_message_create ("_refuse_nym", env,
+                                            DATA2ARG ("Go away!"));
+    GNUNET_SOCIAL_host_entry_decision (hst, nym, GNUNET_NO, join_resp);
+    break;
+
+  case TEST_HOST_ANSWER_DOOR_ADMIT:
+    test = TEST_GUEST_RECV_ENTRY_DCSN_ADMIT;
+    join_resp = GNUNET_PSYC_message_create ("_admit_nym", env,
+                                            DATA2ARG ("Welcome, nym!"));
+    GNUNET_SOCIAL_host_entry_decision (hst, nym, GNUNET_YES, join_resp);
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+void
+guest_recv_local_enter (void *cls, int result, uint64_t max_message_id)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Guest entered to local place.\n");
+
+}
+
+
+void
+guest_enter ()
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Entering to place as guest.\n");
+
+  struct GuestEnterMessage *emsg = &guest_enter_msg;
+
+  emsg->method_name = "_request_enter";
+  emsg->env = GNUNET_ENV_environment_create ();
+  GNUNET_ENV_environment_add (emsg->env, GNUNET_ENV_OP_ASSIGN,
+                              "_abc", "abc def", 7);
+  GNUNET_ENV_environment_add (emsg->env, GNUNET_ENV_OP_ASSIGN,
+                              "_abc_def", "abc def ghi", 11);
+  emsg->data = "let me in";
+  emsg->data_size = strlen (emsg->data) + 1;
+  emsg->msg = GNUNET_PSYC_message_create (emsg->method_name, emsg->env,
+                                          emsg->data, emsg->data_size);
+
+  gst = GNUNET_SOCIAL_guest_enter (cfg, guest_ego, &place_pub_key,
+                                   &this_peer, 0, NULL, emsg->msg,
+                                   guest_slicer, &guest_recv_local_enter,
+                                   &guest_recv_entry_decision, NULL);
+}
+
+
+void id_guest_ego_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
+{
+  GNUNET_assert (NULL != ego);
+  guest_ego = ego;
+
+  guest_slicer = GNUNET_SOCIAL_slicer_create ();
+  GNUNET_SOCIAL_slicer_add (guest_slicer, "",
+                            &guest_recv_method, &guest_recv_modifier,
+                            &guest_recv_data, &guest_recv_eom, NULL);
+  test = TEST_HOST_ANSWER_DOOR_ADMIT;
+  //host_announce ();
+  guest_enter ();
+}
+
+
+void id_guest_created (void *cls, const char *emsg)
+{
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not create guest identity: %s\n", emsg);
+#if 0 == DEBUG_SERVICE
+    GNUNET_assert (0);
+#endif
+  }
+
+ GNUNET_IDENTITY_ego_lookup (cfg, guest_name, &id_guest_ego_cb, NULL);
+}
+
+
+void host_entered (void *cls, uint64_t max_message_id)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Host entered to place.\n");
+
+  GNUNET_IDENTITY_create (id, guest_name, &id_guest_created, NULL);
+}
+
+
+void id_host_ego_cb (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
+{
+  GNUNET_assert (NULL != ego);
+  host_ego = ego;
+
+  host_slicer = GNUNET_SOCIAL_slicer_create ();
+  GNUNET_SOCIAL_slicer_add (host_slicer, "",
+                            &host_recv_method, &host_recv_modifier,
+                            &host_recv_data, &host_recv_eom, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Entering to place as host.\n");
+  hst = GNUNET_SOCIAL_host_enter (cfg, host_ego, place_key,
+                                  GNUNET_PSYC_CHANNEL_PRIVATE, host_slicer,
+                                  &host_entered, &host_answer_door,
+                                  &host_farewell, NULL);
+}
+
+
+void id_host_created (void *cls, const char *emsg)
+{
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not create host identity: %s\n", emsg);
+#if 0 == DEBUG_SERVICE
+    GNUNET_assert (0);
+#endif
+  }
+
+  GNUNET_IDENTITY_ego_lookup (cfg, host_name, &id_host_ego_cb, NULL);
+}
+
+
+void identity_ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego,
+                      void **ctx, const char *name)
+{
+
+}
+
+
+void
+core_connected (void *cls, const struct GNUNET_PeerIdentity *my_identity)
+{
+  this_peer = *my_identity;
+
+  id = GNUNET_IDENTITY_connect (cfg, &identity_ego_cb, NULL);
+  GNUNET_IDENTITY_create (id, host_name, &id_host_created, NULL);
+}
+
+
 /**
  * Main function of the test, run from scheduler.
  *
@@ -116,7 +773,7 @@ end ()
  * @param cfg configuration we use (also to connect to Social service)
  * @param peer handle to access more of the peer (not used)
  */
-static void
+void
 #if DEBUG_SERVICE
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *c)
@@ -129,9 +786,14 @@ run (void *cls,
   cfg = c;
   end_badly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 
-  /* FIXME: add tests */
+  place_key = GNUNET_CRYPTO_eddsa_key_create ();
+  guest_key = GNUNET_CRYPTO_ecdsa_key_create ();
 
-  end ();
+  GNUNET_CRYPTO_eddsa_key_get_public (place_key, &place_pub_key);
+  GNUNET_CRYPTO_ecdsa_key_get_public (guest_key, &guest_pub_key);
+
+  core = GNUNET_CORE_connect (cfg, NULL, &core_connected, NULL, NULL,
+                              NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
 }