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

21 files changed, 3942 insertions, 520 deletions

diff --git a/contrib/gnunet-logread b/contrib/gnunet-logread
index 773a5ff93..173ed2387 100755
--- a/contrib/gnunet-logread
+++ b/contrib/gnunet-logread
@@ -47,7 +47,7 @@ if (exists $opts{n})
     $ipc = $opts{i} || '/tmp/gnunet-logread-ipc.sock';
     $msg_level = exists $levels{$opts{L}} ? $levels{$opts{L}} : 0;
     $msg_regex = $opts{m};
-    print STDERR "RE: /$msg_regex/\n";
+    print STDERR "RE: /$msg_regex/\n" if defined $msg_regex;
     open IPC, '>', $ipc or die "$ipc: $!\n";
 }
 
diff --git a/src/include/gnunet_client_manager_lib.h b/src/include/gnunet_client_manager_lib.h
index 6ed2ddb17..07d9d2807 100644
--- a/src/include/gnunet_client_manager_lib.h
+++ b/src/include/gnunet_client_manager_lib.h
@@ -119,10 +119,14 @@ GNUNET_CLIENT_MANAGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
  *
  * @param mgr             Client manager connection.
  * @param transmit_queue  Transmit pending messages in queue before disconnecting.
+ * @param disconnect_cb   Function called after disconnected from the service.
+ * @param disconnect_cls  Closure for @a disconnect_cb.
  */
 void
 GNUNET_CLIENT_MANAGER_disconnect (struct GNUNET_CLIENT_MANAGER_Connection *mgr,
-                                  int transmit_queue);
+                                  int transmit_queue,
+                                  GNUNET_ContinuationCallback disconnect_cb,
+                                  void *disconnect_cls);
 
 
 /**
diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index d8444e100..2b501f91f 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -264,6 +264,15 @@ typedef int
                             const char *filename);
 
 
+/**
+ * Generic continuation callback.
+ *
+ * @param cls  Closure.
+ */
+typedef void
+(*GNUNET_ContinuationCallback) (void *cls);
+
+
 /* ****************************** logging ***************************** */
 
 /**
diff --git a/src/include/gnunet_multicast_service.h b/src/include/gnunet_multicast_service.h
index 41227b925..5b8ff1894 100644
--- a/src/include/gnunet_multicast_service.h
+++ b/src/include/gnunet_multicast_service.h
@@ -666,7 +666,9 @@ GNUNET_MULTICAST_origin_to_all_cancel (struct GNUNET_MULTICAST_OriginTransmitHan
  * @param origin Multicast group to stop.
  */
 void
-GNUNET_MULTICAST_origin_stop (struct GNUNET_MULTICAST_Origin *origin);
+GNUNET_MULTICAST_origin_stop (struct GNUNET_MULTICAST_Origin *origin,
+                              GNUNET_ContinuationCallback stop_cb,
+                              void *stop_cls);
 
 
 /**
@@ -795,7 +797,9 @@ GNUNET_MULTICAST_member_replay_cancel (struct GNUNET_MULTICAST_MemberReplayHandl
  * @param member Membership handle.
  */
 void
-GNUNET_MULTICAST_member_part (struct GNUNET_MULTICAST_Member *member);
+GNUNET_MULTICAST_member_part (struct GNUNET_MULTICAST_Member *member,
+                              GNUNET_ContinuationCallback part_cb,
+                              void *part_cls);
 
 
 /**
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index 3451cdbf4..cff78eea6 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -2158,32 +2158,34 @@ extern "C"
 /** C->S: request to add channel slave to the membership database */
 #define GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_SLAVE_RM 690
 
-
-/** M<->S<->C: PSYC message which contains one or more message parts. */
+/** S<--C: PSYC message which contains one or more message parts. */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE 691
 
+/** M<->S<->C: PSYC message which contains a header and one or more message parts. */
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER 692 // FIXME: start using this where appropriate
+
 /** Message part: method */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD 692
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD 693
 
 /** Message part: modifier */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER 693
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER 694
 
 /** Message part: modifier continuation */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT 694
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT 695
 
 /** Message part: data */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA 695
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA 696
 
 /** Message part: end of message */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END 696
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END 697
 
 /** Message part: message cancelled */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL 697
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL 698
 
 /** S->C: message acknowledgement */
-#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK 698
+#define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK 699
 
-/* 699-700 */
+/* 700 */
 
 /** C->S: client requests channel history from PSYCstore. */
 #define GNUNET_MESSAGE_TYPE_PSYC_STORY_REQUEST 701
diff --git a/src/include/gnunet_psyc_service.h b/src/include/gnunet_psyc_service.h
index 2ea282fa3..7097c46a8 100644
--- a/src/include/gnunet_psyc_service.h
+++ b/src/include/gnunet_psyc_service.h
@@ -190,6 +190,24 @@ enum GNUNET_PSYC_StateDeltaValues
 GNUNET_NETWORK_STRUCT_BEGIN
 
 /**
+ * A PSYC message.
+ *
+ * Used for single-fragment messages e.g. in a join request or response.
+ */
+struct GNUNET_PSYC_Message
+{
+  /**
+   * Message header with size and type information.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* Followed by concatenated PSYC message parts:
+   * messages with GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_* types
+   */
+};
+
+
+/**
  * Header of a PSYC message.
  *
  * Only present when receiving a message.
@@ -215,6 +233,12 @@ struct GNUNET_PSYC_MessageHeader
   uint64_t message_id GNUNET_PACKED;
 
   /**
+   * Byte offset of this @e fragment of the @e message.
+   * FIXME: use data_offset instead
+   */
+  uint64_t fragment_offset GNUNET_PACKED;
+
+  /**
    * Sending slave's public key.
    * Not set if the message is from the master.
    */
@@ -299,6 +323,9 @@ struct GNUNET_PSYC_CountersResultMessage
 };
 
 
+/**
+ * Join request sent to a PSYC master.
+ */
 struct GNUNET_PSYC_JoinRequestMessage
 {
   /**
@@ -314,6 +341,9 @@ struct GNUNET_PSYC_JoinRequestMessage
 };
 
 
+/**
+ * Join decision sent in reply to a join request.
+ */
 struct GNUNET_PSYC_JoinDecisionMessage
 {
   /**
@@ -379,23 +409,42 @@ struct GNUNET_PSYC_JoinHandle;
 
 
 /**
- * Method called from PSYC upon receiving part of a message.
+ * Method called from PSYC upon receiving a message.
  *
  * @param cls  Closure.
  * @param message_id  Sequence number of the message.
  * @param flags  OR'ed GNUNET_PSYC_MessageFlags
  * @param msg  Message part, one of the following types:
- * - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER
- * - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD
- * - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
- * - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT
- * - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
  */
 typedef void
 (*GNUNET_PSYC_MessageCallback) (void *cls,
                                 uint64_t message_id,
                                 uint32_t flags,
-                                const struct GNUNET_MessageHeader *msg);
+                                const struct GNUNET_PSYC_MessageHeader *msg);
+
+
+/**
+ * Method called from PSYC upon receiving part of a message.
+ *
+ * @param cls  Closure.
+ * @param message_id  Sequence number of the message.
+ * @param data_offset  Byte offset of data, only set if @a msg has a type
+ *                     #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
+ * @param flags  OR'ed GNUNET_PSYC_MessageFlags
+ * @param msg  Message part, one of the following types:
+ * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER
+ * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD
+ * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
+ * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT
+ * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
+ * or NULL if an error occurred while receiving a message.
+ */
+typedef void
+(*GNUNET_PSYC_MessagePartCallback) (void *cls,
+                                    uint64_t message_id,
+                                    uint64_t data_offset,
+                                    uint32_t flags,
+                                    const struct GNUNET_MessageHeader *msg);
 
 
 /**
@@ -408,10 +457,9 @@ typedef void
  */
 typedef void
 (*GNUNET_PSYC_JoinRequestCallback) (void *cls,
-                                    const struct
-                                    GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
-                                    const struct
-                                    GNUNET_PSYC_MessageHeader *join_msg,
+                                    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);
 
 
@@ -445,7 +493,7 @@ GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
                            int is_admitted,
                            uint32_t relay_count,
                            const struct GNUNET_PeerIdentity *relays,
-                           const struct GNUNET_PSYC_MessageHeader *join_resp);
+                           const struct GNUNET_PSYC_Message *join_resp);
 
 
 /**
@@ -501,6 +549,7 @@ GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                           GNUNET_PSYC_MasterStartCallback master_start_cb,
                           GNUNET_PSYC_JoinRequestCallback join_request_cb,
                           GNUNET_PSYC_MessageCallback message_cb,
+                          GNUNET_PSYC_MessagePartCallback message_part_cb,
                           void *cls);
 
 
@@ -645,10 +694,21 @@ GNUNET_PSYC_master_transmit_cancel (struct GNUNET_PSYC_MasterTransmitHandle *th)
 /**
  * Stop a PSYC master channel.
  *
- * @param master PSYC channel master to stop.
+ * @param master
+ *        PSYC channel master to stop.
+ * @param keep_active
+ *        Keep place active after last application disconnected.
+ * @param stop_cb
+ *        Function called after the master stopped
+ *        and disconnected from the psyc service.
+ * @param stop_cls
+ *        Closure for @a part_cb.
  */
 void
-GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *master);
+GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *master,
+                         int keep_active,
+                         GNUNET_ContinuationCallback stop_cb,
+                         void *stop_cls);
 
 
 /**
@@ -679,9 +739,9 @@ typedef void
  */
 typedef void
 (*GNUNET_PSYC_JoinDecisionCallback) (void *cls,
+                                     const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
                                      int is_admitted,
-                                     const struct
-                                     GNUNET_PSYC_MessageHeader *join_msg);
+                                     const struct GNUNET_PSYC_Message *join_msg);
 
 
 /**
@@ -726,10 +786,11 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
                         uint32_t relay_count,
                         const struct GNUNET_PeerIdentity *relays,
                         GNUNET_PSYC_MessageCallback message_cb,
+                        GNUNET_PSYC_MessagePartCallback message_part_cb,
                         GNUNET_PSYC_SlaveConnectCallback slave_connect_cb,
                         GNUNET_PSYC_JoinDecisionCallback join_decision_cb,
                         void *cls,
-                        const struct GNUNET_MessageHeader *join_msg);
+                        const struct GNUNET_PSYC_Message *join_msg);
 
 
 /**
@@ -738,10 +799,21 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * Will terminate the connection to the PSYC service.  Polite clients should
  * first explicitly send a part request (via GNUNET_PSYC_slave_transmit()).
  *
- * @param slave Slave handle.
+ * @param slave
+ *        Slave handle.
+ * @param keep_active
+ *        Keep place active after last application disconnected.
+ * @param part_cb
+ *        Function called after the slave parted the channel
+ *        and disconnected from the psyc service.
+ * @param part_cls
+ *        Closure for @a part_cb.
  */
 void
-GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slave);
+GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slave,
+                        int keep_active,
+                        GNUNET_ContinuationCallback part_cb,
+                        void *part_cls);
 
 
 /**
@@ -937,6 +1009,7 @@ GNUNET_PSYC_channel_story_tell (struct GNUNET_PSYC_Channel *channel,
                                 uint64_t start_message_id,
                                 uint64_t end_message_id,
                                 GNUNET_PSYC_MessageCallback message_cb,
+                                GNUNET_PSYC_MessagePartCallback message_part_cb,
                                 GNUNET_PSYC_FinishCallback finish_cb,
                                 void *cls);
 
diff --git a/src/include/gnunet_psyc_util_lib.h b/src/include/gnunet_psyc_util_lib.h
index f356b245b..b71f52910 100644
--- a/src/include/gnunet_psyc_util_lib.h
+++ b/src/include/gnunet_psyc_util_lib.h
@@ -55,12 +55,36 @@ extern "C"
  * @return Message header with size information,
  *         followed by the message parts.
  */
-struct GNUNET_MessageHeader *
+struct GNUNET_PSYC_Message *
 GNUNET_PSYC_message_create (const char *method_name,
                             const struct GNUNET_ENV_Environment *env,
                             const void *data,
                             size_t data_size);
 
+/**
+ * Parse PSYC message.
+ *
+ * @param msg
+ *        The PSYC message to parse.
+ * @param env
+ *        The environment for the message with a list of modifiers.
+ * @param[out] method_name
+ *        Pointer to the method name inside @a pmsg.
+ * @param[out] data
+ *        Pointer to data inside @a pmsg.
+ * @param[out] data_size
+ *        Size of @data is written here.
+ *
+ * @return #GNUNET_OK on success,
+ *         #GNUNET_SYSERR on parse error.
+ */
+int
+GNUNET_PSYC_message_parse (const struct GNUNET_PSYC_Message *msg,
+                           const char **method_name,
+                           struct GNUNET_ENV_Environment *env,
+                           const void **data,
+                           uint16_t *data_size);
+
 
 void
 GNUNET_PSYC_log_message (enum GNUNET_ErrorType kind,
@@ -150,7 +174,7 @@ struct GNUNET_PSYC_ReceiveHandle;
  */
 struct GNUNET_PSYC_ReceiveHandle *
 GNUNET_PSYC_receive_create (GNUNET_PSYC_MessageCallback message_cb,
-                            GNUNET_PSYC_MessageCallback hist_message_cb,
+                            GNUNET_PSYC_MessagePartCallback message_part_cb,
                             void *cb_cls);
 
 
diff --git a/src/include/gnunet_social_service.h b/src/include/gnunet_social_service.h
index f8b24c161..ca1578820 100644
--- a/src/include/gnunet_social_service.h
+++ b/src/include/gnunet_social_service.h
@@ -81,6 +81,8 @@ struct GNUNET_SOCIAL_Slicer;
  *
  * @param cls
  *        Closure.
+ * @param msg
+ *        Message part, as it arrived from the network.
  * @param message_id
  *        Message counter, monotonically increasing from 1.
  * @param nym
@@ -92,12 +94,53 @@ struct GNUNET_SOCIAL_Slicer;
  *        Original method name from PSYC.
  *        May be more specific than the registered method name due to
  *        try-and-slice matching.
- * @param env
- *        Environment with operations and variables for the message.
- *        Only set for the first call of this function for each @a message_id,
- *        NULL when notifying about further data fragments.
- *        It has to be freed using GNUNET_ENV_environment_destroy()
- *        when it is not needed anymore.
+ */
+typedef void
+(*GNUNET_SOCIAL_MethodCallback) (void *cls,
+                                 const struct GNUNET_PSYC_MessageMethod *msg,
+                                 uint64_t message_id,
+                                 uint32_t flags,
+                                 const struct GNUNET_SOCIAL_Nym *nym,
+                                 const char *method_name);
+
+
+/**
+ * Function called upon receiving a data fragment of a message.
+ *
+ * @param cls
+ *        Closure.
+ * @param message_id
+ *        Message ID this data fragment belongs to.
+ * @param msg
+ *        Message part, as it arrived from the network.
+ * @param oper
+ *        Operation to perform.
+ * @param name
+ *        Name of the modifier.
+ * @param value
+ *        Value of the modifier.
+ * @param value_size
+ *        Size of @value.
+ */
+typedef void
+(*GNUNET_SOCIAL_ModifierCallback) (void *cls,
+                                   const struct GNUNET_PSYC_MessageModifier *msg,
+                                   uint64_t message_id,
+                                   enum GNUNET_ENV_Operator oper,
+                                   const char *name,
+                                   const void *value,
+                                   uint16_t value_size);
+
+
+/**
+ * Function called upon receiving a data fragment of a message.
+ *
+ * @param cls
+ *        Closure.
+ * @param message_id
+ *        Message ID this data fragment belongs to.
+ * @param msg
+ *        Message part, as it arrived from the network.
  * @param data_offset
  *        Byte offset of @a data in the overall data of the method.
  * @param data_size
@@ -106,21 +149,37 @@ struct GNUNET_SOCIAL_Slicer;
  *        Data stream given to the method.
  * @param end
  *        End of message?
- *   #GNUNET_NO     if there are further fragments,
- *   #GNUNET_YES    if this is the last fragment,
- *   #GNUNET_SYSERR indicates the message was cancelled by the sender.
+ *        #GNUNET_NO     if there are further fragments,
+ *        #GNUNET_YES    if this is the last fragment,
+ *        #GNUNET_SYSERR indicates the message was cancelled by the sender.
  */
 typedef void
-(*GNUNET_SOCIAL_MethodCallback) (void *cls,
-                                 uint64_t message_id,
-                                 uint32_t flags,
-                                 const struct GNUNET_SOCIAL_Nym *nym,
-                                 const char *method_name,
-                                 struct GNUNET_ENV_Environment *env,
-                                 uint64_t data_offset,
-                                 size_t data_size,
-                                 const void *data,
-                                 int end);
+(*GNUNET_SOCIAL_DataCallback) (void *cls,
+                               const struct GNUNET_MessageHeader *msg,
+                               uint64_t message_id,
+                               uint64_t data_offset,
+                               const void *data,
+                               uint16_t data_size);
+
+
+/**
+ * End of message.
+ *
+ * @param cls
+ *        Closure.
+ * @param msg
+ *        Message part, as it arrived from the network.
+ * @param message_id
+ *        Message ID this data fragment belongs to.
+ * @param cancelled.
+ *        #GNUNET_YES if the message was cancelled,
+ *        #GNUNET_NO  if the message is complete.
+ */
+typedef void
+(*GNUNET_SOCIAL_EndOfMessageCallback) (void *cls,
+                                       const struct GNUNET_MessageHeader *msg,
+                                       uint64_t message_id,
+                                       uint8_t cancelled);
 
 
 /**
@@ -148,20 +207,27 @@ 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);
 
 
 /**
- * Remove a registered method from the try-and-slice instance.
+ * Remove a registered method handler from the try-and-slice instance.
  *
  * @param slicer The try-and-slice instance.
  * @param method_name Name of the method to remove.
  * @param method Method handler.
  */
-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);
+
 
 /**
  * Destroy a given try-and-slice instance.
@@ -257,7 +323,7 @@ typedef void
  */
 struct GNUNET_SOCIAL_Host *
 GNUNET_SOCIAL_host_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          struct GNUNET_IDENTITY_Ego *ego,
+                          const struct GNUNET_IDENTITY_Ego *ego,
                           const struct GNUNET_CRYPTO_EddsaPrivateKey *place_key,
                           enum GNUNET_PSYC_Policy policy,
                           struct GNUNET_SOCIAL_Slicer *slicer,
@@ -268,17 +334,32 @@ GNUNET_SOCIAL_host_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
- * Admit @a nym to the place.
- *
- * The @a nym reference will remain valid until either the @a host or @a nym
- * leaves the place.
+ * Decision whether to admit @a nym into the place or refuse entry.
  *
- * @param host  Host of the place.
- * @param nym  Handle for the entity that wants to enter.
+ * @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.
  */
-void
-GNUNET_SOCIAL_host_admit (struct GNUNET_SOCIAL_Host *host,
-                          struct GNUNET_SOCIAL_Nym *nym);
+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);
 
 
 /**
@@ -297,35 +378,17 @@ GNUNET_SOCIAL_host_eject (struct GNUNET_SOCIAL_Host *host,
 
 
 /**
- * Refuse @a nym entry into the place.
- *
- * @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.
- */
-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);
-
-
-/**
  * Get the public key of a @a nym.
  *
  * 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.
+ * @param nym
+ *        Pseudonym to map to a cryptographic identifier.
+ *
+ * @return Public key of nym;
  */
-void
-GNUNET_SOCIAL_nym_get_key (struct GNUNET_SOCIAL_Nym *nym,
-                           struct GNUNET_CRYPTO_EddsaPublicKey *nym_key);
+struct GNUNET_CRYPTO_EcdsaPublicKey *
+GNUNET_SOCIAL_nym_get_key (struct GNUNET_SOCIAL_Nym *nym);
 
 
 /**
@@ -418,9 +481,20 @@ GNUNET_SOCIAL_host_announce (struct GNUNET_SOCIAL_Host *host,
 
 
 /**
+ * Resume transmitting announcement.
+ *
+ * @param a
+ *        The announcement to resume.
+ */
+void
+GNUNET_SOCIAL_host_announce_resume (struct GNUNET_SOCIAL_Announcement *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);
@@ -431,7 +505,8 @@ GNUNET_SOCIAL_host_announce_cancel (struct GNUNET_SOCIAL_Announcement *a);
  *
  * The returned handle can be used to access the place API.
  *
- * @param host  Handle for the host.
+ * @param host
+ *        Handle for the host.
  *
  * @return Handle for the hosted place, valid as long as @a host is valid.
  */
@@ -444,11 +519,21 @@ GNUNET_SOCIAL_host_get_place (struct GNUNET_SOCIAL_Host *host);
  *
  * Invalidates host handle.
  *
- * @param host  Host leaving the place.
- * @param keep_active  Keep the place active after last host disconnected.
+ * @param host
+ *        Host leaving the place.
+ * @param keep_active
+ *        Keep the place active after last host disconnected.
+ * @param leave_cb
+ *        Function called after the host left the place
+ *        and disconnected from the social service.
+ * @param leave_cls
+ *        Closure for @a leave_cb.
  */
 void
-GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *host, int keep_active);
+GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *host,
+                          int keep_active,
+                          GNUNET_ContinuationCallback leave_cb,
+                          void *leave_cls);
 
 
 /**
@@ -493,13 +578,10 @@ typedef void
  * @param data
  *   Payload of the message.
  */
-typedef int
+typedef void
 (*GNUNET_SOCIAL_EntryDecisionCallback) (void *cls,
                                         int is_admitted,
-                                        const char *method_name,
-                                        struct GNUNET_ENV_Environment *env,
-                                        size_t data_size,
-                                        const void *data);
+                                        const struct GNUNET_PSYC_Message *entry_resp);
 
 
 /**
@@ -521,15 +603,12 @@ typedef int
  */
 struct GNUNET_SOCIAL_Guest *
 GNUNET_SOCIAL_guest_enter (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                           struct GNUNET_IDENTITY_Ego *ego,
-                           struct GNUNET_CRYPTO_EddsaPublicKey *place_key,
-                           struct GNUNET_PeerIdentity *origin,
+                           const struct GNUNET_IDENTITY_Ego *ego,
+                           const struct GNUNET_CRYPTO_EddsaPublicKey *place_key,
+                           const struct GNUNET_PeerIdentity *origin,
                            uint32_t relay_count,
-                           struct GNUNET_PeerIdentity *relays,
-                           const char *method_name,
-                           const struct GNUNET_ENV_Environment *env,
-                           const void *data,
-                           size_t data_size,
+                           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_decision_cb,
@@ -558,10 +637,7 @@ struct GNUNET_SOCIAL_Guest *
 GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                    struct GNUNET_IDENTITY_Ego *ego,
                                    char *gns_name,
-                                   const char *method_name,
-                                   const struct GNUNET_ENV_Environment *env,
-                                   const void *data,
-                                   size_t data_size,
+                                   const struct GNUNET_PSYC_Message *join_msg,
                                    struct GNUNET_SOCIAL_Slicer *slicer,
                                    GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
                                    GNUNET_SOCIAL_EntryDecisionCallback entry_decision_cb,
@@ -612,9 +688,20 @@ GNUNET_SOCIAL_guest_talk (struct GNUNET_SOCIAL_Guest *guest,
 
 
 /**
+ * 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);
+
+
+/**
  * 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);
@@ -625,11 +712,21 @@ GNUNET_SOCIAL_guest_talk_cancel (struct GNUNET_SOCIAL_TalkRequest *tr);
  *
  * Notifies the owner of the place about leaving, and destroys the place handle.
  *
- * @param place Place to leave permanently.
- * @param keep_active Keep place active after last application disconnected.
+ * @param place
+ *        Place to leave permanently.
+ * @param keep_active
+ *        Keep place active after last application disconnected.
+ * @param leave_cb
+ *        Function called after the guest left the place
+ *        and disconnected from the social service.
+ * @param leave_cls
+ *        Closure for @a leave_cb.
  */
 void
-GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Guest *guest, int keep_active);
+GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Guest *guest,
+                           int keep_active,
+                           GNUNET_ContinuationCallback leave_cb,
+                           void *leave_cls);
 
 
 /**
diff --git a/src/multicast/gnunet-service-multicast.c b/src/multicast/gnunet-service-multicast.c
index 1bb27f96e..1b8e5c8b6 100644
--- a/src/multicast/gnunet-service-multicast.c
+++ b/src/multicast/gnunet-service-multicast.c
@@ -423,6 +423,7 @@ client_origin_start (void *cls, struct GNUNET_SERVER_Client *client,
   {
     orig = GNUNET_new (struct Origin);
     orig->priv_key = msg->group_key;
+    orig->max_fragment_id = GNUNET_ntohll (msg->max_fragment_id);
     grp = &orig->grp;
     grp->is_origin = GNUNET_YES;
     grp->pub_key = pub_key;
@@ -482,6 +483,7 @@ client_member_join (void *cls, struct GNUNET_SERVER_Client *client,
     mem->priv_key = msg->member_key;
     mem->pub_key = mem_pub_key;
     mem->pub_key_hash = mem_pub_key_hash;
+    mem->max_fragment_id = 0; // FIXME
 
     grp = &mem->grp;
     grp->is_origin = GNUNET_NO;
@@ -663,7 +665,7 @@ client_multicast_message (void *cls, struct GNUNET_SERVER_Client *client,
   struct GNUNET_MULTICAST_MessageHeader *
     msg = (struct GNUNET_MULTICAST_MessageHeader *) m;
 
-  msg->fragment_id = GNUNET_htonll (orig->max_fragment_id++);
+  msg->fragment_id = GNUNET_htonll (++orig->max_fragment_id);
   msg->purpose.size = htonl (sizeof (*msg) + ntohs (m->size)
                              - sizeof (msg->header)
                              - sizeof (msg->hop_counter)
@@ -699,8 +701,7 @@ client_multicast_request (void *cls, struct GNUNET_SERVER_Client *client,
   struct GNUNET_MULTICAST_RequestHeader *
     req = (struct GNUNET_MULTICAST_RequestHeader *) m;
 
-  req->fragment_id = GNUNET_ntohll (mem->max_fragment_id++);
-
+  req->fragment_id = GNUNET_ntohll (++mem->max_fragment_id);
   req->purpose.size = htonl (sizeof (*req) + ntohs (m->size)
                              - sizeof (req->header)
                              - sizeof (req->member_key)
diff --git a/src/multicast/multicast_api.c b/src/multicast/multicast_api.c
index d2a0412bb..fb2630081 100644
--- a/src/multicast/multicast_api.c
+++ b/src/multicast/multicast_api.c
@@ -88,6 +88,16 @@ struct GNUNET_MULTICAST_Group
   void *cb_cls;
 
   /**
+   * Function called after disconnected from the service.
+   */
+  GNUNET_ContinuationCallback disconnect_cb;
+
+  /**
+   * Closure for @a disconnect_cb.
+   */
+  void *disconnect_cls;
+
+  /**
    * Are we currently transmitting a message?
    */
   uint8_t in_transmit;
@@ -96,6 +106,12 @@ struct GNUNET_MULTICAST_Group
    * Is this the origin or a member?
    */
   uint8_t is_origin;
+
+  /**
+   * Is this channel in the process of disconnecting from the service?
+   * #GNUNET_YES or #GNUNET_NO
+   */
+  uint8_t is_disconnecting;
 };
 
 
@@ -320,8 +336,9 @@ member_recv_join_decision (void *cls,
     mem->join_dcsn_cb (grp->cb_cls, is_admitted, &hdcsn->peer,
                        relay_count, relays, join_resp);
 
-  if (GNUNET_YES != is_admitted)
-    GNUNET_MULTICAST_member_part (mem);
+  // FIXME:
+  //if (GNUNET_YES != is_admitted)
+  //  GNUNET_MULTICAST_member_part (mem);
 }
 
 
@@ -371,6 +388,33 @@ static struct GNUNET_CLIENT_MANAGER_MessageHandler member_handlers[] =
 };
 
 
+static void
+group_cleanup (struct GNUNET_MULTICAST_Group *grp)
+{
+  GNUNET_free (grp->connect_msg);
+  if (NULL != grp->disconnect_cb)
+    grp->disconnect_cb (grp->disconnect_cls);
+}
+
+
+static void
+origin_cleanup (void *cls)
+{
+  struct GNUNET_MULTICAST_Origin *orig = cls;
+  group_cleanup (&orig->grp);
+  GNUNET_free (orig);
+}
+
+
+static void
+member_cleanup (void *cls)
+{
+  struct GNUNET_MULTICAST_Member *mem = cls;
+  group_cleanup (&mem->grp);
+  GNUNET_free (mem);
+}
+
+
 /**
  * Function to call with the decision made for a join request.
  *
@@ -565,10 +609,18 @@ GNUNET_MULTICAST_origin_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param origin Multicast group to stop.
  */
 void
-GNUNET_MULTICAST_origin_stop (struct GNUNET_MULTICAST_Origin *orig)
+GNUNET_MULTICAST_origin_stop (struct GNUNET_MULTICAST_Origin *orig,
+                              GNUNET_ContinuationCallback stop_cb,
+                              void *stop_cls)
 {
-  GNUNET_CLIENT_MANAGER_disconnect (orig->grp.client, GNUNET_YES);
-  GNUNET_free (orig);
+  struct GNUNET_MULTICAST_Group *grp = &orig->grp;
+
+  grp->is_disconnecting = GNUNET_YES;
+  grp->disconnect_cb = stop_cb;
+  grp->disconnect_cls = stop_cls;
+
+  GNUNET_CLIENT_MANAGER_disconnect (orig->grp.client, GNUNET_YES,
+                                    &origin_cleanup, orig);
 }
 
 
@@ -774,10 +826,18 @@ GNUNET_MULTICAST_member_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param member Membership handle.
  */
 void
-GNUNET_MULTICAST_member_part (struct GNUNET_MULTICAST_Member *mem)
+GNUNET_MULTICAST_member_part (struct GNUNET_MULTICAST_Member *mem,
+                              GNUNET_ContinuationCallback part_cb,
+                              void *part_cls)
 {
-  GNUNET_CLIENT_MANAGER_disconnect (mem->grp.client, GNUNET_YES);
-  GNUNET_free (mem);
+  struct GNUNET_MULTICAST_Group *grp = &mem->grp;
+
+  grp->is_disconnecting = GNUNET_YES;
+  grp->disconnect_cb = part_cb;
+  grp->disconnect_cls = part_cls;
+
+  GNUNET_CLIENT_MANAGER_disconnect (mem->grp.client, GNUNET_YES,
+                                    &member_cleanup, mem);
 }
 
 
diff --git a/src/psyc/gnunet-service-psyc.c b/src/psyc/gnunet-service-psyc.c
index 866275a79..8fc080baf 100644
--- a/src/psyc/gnunet-service-psyc.c
+++ b/src/psyc/gnunet-service-psyc.c
@@ -168,7 +168,7 @@ struct FragmentQueue
    * Is the message queued for delivery to the client?
    * i.e. added to the recv_msgs queue
    */
-  uint8_t queued;
+  uint8_t is_queued;
 };
 
 
@@ -382,7 +382,7 @@ struct Slave
   /**
    * Join request to be transmitted to the master on join.
    */
-  struct GNUNET_MessageHeader *join_req;
+  struct GNUNET_PSYC_Message *join_msg;
 
   /**
    * Join decision received from multicast.
@@ -435,7 +435,7 @@ cleanup_master (struct Master *mst)
   struct Channel *chn = &mst->chn;
 
   if (NULL != mst->origin)
-    GNUNET_MULTICAST_origin_stop (mst->origin);
+    GNUNET_MULTICAST_origin_stop (mst->origin, NULL, NULL); // FIXME
   GNUNET_CONTAINER_multihashmap_destroy (mst->join_reqs);
   GNUNET_CONTAINER_multihashmap_remove (masters, &chn->pub_key_hash, chn);
 }
@@ -462,12 +462,21 @@ cleanup_slave (struct Slave *slv)
   }
   GNUNET_CONTAINER_multihashmap_remove (slaves, &chn->pub_key_hash, slv);
 
-  if (NULL != slv->join_req)
-    GNUNET_free (slv->join_req);
+  if (NULL != slv->join_msg)
+  {
+    GNUNET_free (slv->join_msg);
+    slv->join_msg = NULL;
+  }
   if (NULL != slv->relays)
+  {
     GNUNET_free (slv->relays);
+    slv->relays = NULL;
+  }
   if (NULL != slv->member)
-    GNUNET_MULTICAST_member_part (slv->member);
+  {
+    GNUNET_MULTICAST_member_part (slv->member, NULL, NULL); // FIXME
+    slv->member = NULL;
+  }
   GNUNET_CONTAINER_multihashmap_remove (slaves, &chn->pub_key_hash, chn);
 }
 
@@ -482,7 +491,10 @@ cleanup_channel (struct Channel *chn)
   GNUNET_CONTAINER_multihashmap_remove_all (recv_cache, &chn->pub_key_hash);
 
   if (NULL != chn->store_op)
+  {
     GNUNET_PSYCSTORE_operation_cancel (chn->store_op);
+    chn->store_op = NULL;
+  }
 
   (GNUNET_YES == chn->is_master)
     ? cleanup_master ((struct Master *) chn)
@@ -574,7 +586,7 @@ struct JoinMemTestClosure
   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
   struct Channel *chn;
   struct GNUNET_MULTICAST_JoinHandle *jh;
-  struct MasterJoinRequest *master_join_req;
+  struct GNUNET_PSYC_JoinRequestMessage *join_msg;
 };
 
 
@@ -594,14 +606,14 @@ join_mem_test_cb (void *cls, int64_t result, const char *err_msg)
                         &slave_key_hash);
     GNUNET_CONTAINER_multihashmap_put (mst->join_reqs, &slave_key_hash, jcls->jh,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-    client_send_msg (jcls->chn, &jcls->master_join_req->header);
+    client_send_msg (jcls->chn, &jcls->join_msg->header);
   }
   else
   {
     // FIXME: add relays
     GNUNET_MULTICAST_join_decision (jcls->jh, result, 0, NULL, NULL);
   }
-  GNUNET_free (jcls->master_join_req);
+  GNUNET_free (jcls->join_msg);
   GNUNET_free (jcls);
 }
 
@@ -633,7 +645,8 @@ mcast_recv_join_request (void *cls,
     }
   }
 
-  struct MasterJoinRequest *req = GNUNET_malloc (sizeof (*req) + join_msg_size);
+  struct GNUNET_PSYC_JoinRequestMessage *
+    req = GNUNET_malloc (sizeof (*req) + join_msg_size);
   req->header.size = htons (sizeof (*req) + join_msg_size);
   req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST);
   req->slave_key = *slave_key;
@@ -644,7 +657,7 @@ mcast_recv_join_request (void *cls,
   jcls->slave_key = *slave_key;
   jcls->chn = chn;
   jcls->jh = jh;
-  jcls->master_join_req = req;
+  jcls->join_msg = req;
 
   GNUNET_PSYCSTORE_membership_test (store, &chn->pub_key, slave_key,
                                     chn->max_message_id, 0,
@@ -780,6 +793,7 @@ client_send_mcast_msg (struct Channel *chn,
   pmsg->header.size = htons (psize);
   pmsg->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE);
   pmsg->message_id = mmsg->message_id;
+  pmsg->fragment_offset = mmsg->fragment_offset;
 
   memcpy (&pmsg[1], &mmsg[1], size - sizeof (*mmsg));
   client_send_msg (chn, &pmsg->header);
@@ -810,6 +824,7 @@ client_send_mcast_req (struct Master *mst,
   pmsg->header.size = htons (psize);
   pmsg->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE);
   pmsg->message_id = req->request_id;
+  pmsg->fragment_offset = req->fragment_offset;
   pmsg->flags = htonl (GNUNET_PSYC_MESSAGE_REQUEST);
 
   memcpy (&pmsg[1], &req[1], size - sizeof (*req));
@@ -870,11 +885,12 @@ fragment_queue_insert (struct Channel *chn,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "%p Adding message fragment to cache. "
-                "message_id: %" PRIu64 ", fragment_id: %" PRIu64 ", "
-                "header_size: %" PRIu64 " + %u).\n",
+                "message_id: %" PRIu64 ", fragment_id: %" PRIu64 "\n",
                 chn, GNUNET_ntohll (mmsg->message_id),
-                GNUNET_ntohll (mmsg->fragment_id),
-                fragq->header_size, size);
+                GNUNET_ntohll (mmsg->fragment_id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%p header_size: %" PRIu64 " + %u\n",
+                chn, fragq->header_size, size);
     cache_entry = GNUNET_new (struct RecvCacheEntry);
     cache_entry->ref_count = 1;
     cache_entry->mmsg = GNUNET_malloc (size);
@@ -955,11 +971,11 @@ fragment_queue_insert (struct Channel *chn,
   case MSG_FRAG_STATE_DATA:
   case MSG_FRAG_STATE_END:
   case MSG_FRAG_STATE_CANCEL:
-    if (GNUNET_NO == fragq->queued)
+    if (GNUNET_NO == fragq->is_queued)
     {
       GNUNET_CONTAINER_heap_insert (chn->recv_msgs, NULL,
                                     GNUNET_ntohll (mmsg->message_id));
-      fragq->queued = GNUNET_YES;
+      fragq->is_queued = GNUNET_YES;
     }
   }
 
@@ -1034,7 +1050,7 @@ fragment_queue_run (struct Channel *chn, uint64_t msg_id,
   if (MSG_FRAG_STATE_END <= fragq->state)
   {
     struct GNUNET_HashCode msg_id_hash;
-    hash_key_from_nll (&msg_id_hash, msg_id);
+    hash_key_from_hll (&msg_id_hash, msg_id);
 
     GNUNET_CONTAINER_multihashmap_remove (chn->recv_frags, &msg_id_hash, fragq);
     GNUNET_CONTAINER_heap_destroy (fragq->fragments);
@@ -1042,7 +1058,7 @@ fragment_queue_run (struct Channel *chn, uint64_t msg_id,
   }
   else
   {
-    fragq->queued = GNUNET_NO;
+    fragq->is_queued = GNUNET_NO;
   }
 }
 
@@ -1331,13 +1347,18 @@ store_recv_slave_counters (void *cls, int result, uint64_t max_fragment_id,
       = GNUNET_MULTICAST_member_join (cfg, &chn->pub_key, &slv->priv_key,
                                       &slv->origin,
                                       slv->relay_count, slv->relays,
-                                      slv->join_req,
+                                      &slv->join_msg->header,
                                       &mcast_recv_join_request,
                                       &mcast_recv_join_decision,
                                       &mcast_recv_membership_test,
                                       &mcast_recv_replay_fragment,
                                       &mcast_recv_replay_message,
                                       &mcast_recv_message, chn);
+    if (NULL != slv->join_msg)
+    {
+      GNUNET_free (slv->join_msg);
+      slv->join_msg = NULL;
+    }
   }
   else
   {
@@ -1435,6 +1456,7 @@ client_recv_slave_join (void *cls, struct GNUNET_SERVER_Client *client,
 {
   const struct SlaveJoinRequest *req
     = (const struct SlaveJoinRequest *) msg;
+  uint16_t req_size = ntohs (req->header.size);
 
   struct GNUNET_CRYPTO_EcdsaPublicKey slv_pub_key;
   struct GNUNET_HashCode pub_key_hash, slv_pub_key_hash;
@@ -1460,15 +1482,32 @@ client_recv_slave_join (void *cls, struct GNUNET_SERVER_Client *client,
     slv->pub_key_hash = slv_pub_key_hash;
     slv->origin = req->origin;
     slv->relay_count = ntohl (req->relay_count);
+
+    const struct GNUNET_PeerIdentity *
+      relays = (const struct GNUNET_PeerIdentity *) &req[1];
+    uint16_t relay_size = slv->relay_count * sizeof (*relays);
+    uint16_t join_msg_size = 0;
+
+    if (sizeof (*req) + relay_size + sizeof (struct GNUNET_MessageHeader)
+        <= req_size)
+    {
+      join_msg_size = ntohs (slv->join_msg->header.size);
+      slv->join_msg = GNUNET_malloc (join_msg_size);
+      memcpy (slv->join_msg, ((char *) &req[1]) + relay_size, join_msg_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 < slv->relay_count)
     {
-      const struct GNUNET_PeerIdentity *relays
-        = (const struct GNUNET_PeerIdentity *) &req[1];
-      slv->relays
-        = GNUNET_malloc (slv->relay_count * sizeof (struct GNUNET_PeerIdentity));
-      uint32_t i;
-      for (i = 0; i < slv->relay_count; i++)
-        memcpy (&slv->relays[i], &relays[i], sizeof (*relays));
+      slv->relays = GNUNET_malloc (relay_size);
+      memcpy (slv->relays, &req[1], relay_size);
     }
 
     chn = &slv->chn;
@@ -1510,14 +1549,18 @@ client_recv_slave_join (void *cls, struct GNUNET_SERVER_Client *client,
         = GNUNET_MULTICAST_member_join (cfg, &chn->pub_key, &slv->priv_key,
                                         &slv->origin,
                                         slv->relay_count, slv->relays,
-                                        slv->join_req,
+                                        &slv->join_msg->header,
                                         &mcast_recv_join_request,
                                         &mcast_recv_join_decision,
                                         &mcast_recv_membership_test,
                                         &mcast_recv_replay_fragment,
                                         &mcast_recv_replay_message,
                                         &mcast_recv_message, chn);
-
+      if (NULL != slv->join_msg)
+      {
+        GNUNET_free (slv->join_msg);
+        slv->join_msg = NULL;
+      }
     }
     else if (NULL != slv->join_dcsn)
     {
@@ -1549,13 +1592,14 @@ struct JoinDecisionClosure
 
 
 /**
- * Iterator callback for responding to join requests of a slave.
+ * Iterator callback for sending join decisions to multicast.
  */
 static int
 mcast_send_join_decision (void *cls, const struct GNUNET_HashCode *pub_key_hash,
-                          void *jh)
+                          void *value)
 {
   struct JoinDecisionClosure *jcls = cls;
+  struct GNUNET_MULTICAST_JoinHandle *jh = value;
   // FIXME: add relays
   GNUNET_MULTICAST_join_decision (jh, jcls->is_admitted, 0, NULL, jcls->msg);
   return GNUNET_YES;
@@ -1579,8 +1623,7 @@ client_recv_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
   struct JoinDecisionClosure jcls;
   jcls.is_admitted = ntohl (dcsn->is_admitted);
   jcls.msg
-    = (sizeof (*dcsn) + sizeof (struct GNUNET_PSYC_MessageHeader)
-       <= ntohs (msg->size))
+    = (sizeof (*dcsn) + sizeof (*jcls.msg) <= ntohs (msg->size))
     ? (struct GNUNET_MessageHeader *) &dcsn[1]
     : NULL;
 
@@ -1901,6 +1944,9 @@ client_recv_psyc_message (void *cls, struct GNUNET_SERVER_Client *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",
+              chn, first_ptype, last_ptype);
 
   queue_message (chn, client, size - sizeof (*msg), &msg[1],
                  first_ptype, last_ptype);
diff --git a/src/psyc/psyc.h b/src/psyc/psyc.h
index 995fb1fa4..82800a334 100644
--- a/src/psyc/psyc.h
+++ b/src/psyc/psyc.h
@@ -229,22 +229,6 @@ struct OperationResult
    */
 };
 
-
-struct MasterJoinRequest
-{
-  /**
-   * Type: GNUNET_MESSAGE_TYPE_PSYC_MASTER_JOIN_REQUEST
-   */
-  struct GNUNET_MessageHeader header;
-  /**
-   * Public key of the joining slave.
-   */
-  struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
-
-  /* Followed by struct GNUNET_MessageHeader join_request */
-};
-
-
 GNUNET_NETWORK_STRUCT_END
 
 #endif
diff --git a/src/psyc/psyc_api.c b/src/psyc/psyc_api.c
index 88b007a0f..a43b1ef5f 100644
--- a/src/psyc/psyc_api.c
+++ b/src/psyc/psyc_api.c
@@ -74,6 +74,16 @@ struct GNUNET_PSYC_Channel
   struct GNUNET_MessageHeader *connect_msg;
 
   /**
+   * Function called after disconnected from the service.
+   */
+  GNUNET_ContinuationCallback disconnect_cb;
+
+  /**
+   * Closure for @a disconnect_cb.
+   */
+  void *disconnect_cls;
+
+  /**
    * Are we polling for incoming messages right now?
    */
   uint8_t in_receive;
@@ -82,6 +92,12 @@ struct GNUNET_PSYC_Channel
    * Is this a master or slave channel?
    */
   uint8_t is_master;
+
+  /**
+   * Is this channel in the process of disconnecting from the service?
+   * #GNUNET_YES or #GNUNET_NO
+   */
+  uint8_t is_disconnecting;
 };
 
 
@@ -232,19 +248,26 @@ master_recv_join_request (void *cls,
   struct GNUNET_PSYC_Master *
     mst = GNUNET_CLIENT_MANAGER_get_user_context_ (client,
                                                    sizeof (struct GNUNET_PSYC_Channel));
-
-  const struct MasterJoinRequest *req = (const struct MasterJoinRequest *) msg;
-
-  struct GNUNET_PSYC_MessageHeader *pmsg = NULL;
-  if (ntohs (req->header.size) <= sizeof (*req) + sizeof (*pmsg))
-    pmsg = (struct GNUNET_PSYC_MessageHeader *) &req[1];
+  if (NULL == mst->join_req_cb)
+    return;
+
+  const struct GNUNET_PSYC_JoinRequestMessage *
+    req = (const struct GNUNET_PSYC_JoinRequestMessage *) msg;
+  const struct GNUNET_PSYC_Message *join_msg = NULL;
+  if (sizeof (*req) + sizeof (*join_msg) <= ntohs (req->header.size))
+  {
+    join_msg = (struct GNUNET_PSYC_Message *) &req[1];
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Received join_msg of type %u and size %u.\n",
+         ntohs (join_msg->header.type), ntohs (join_msg->header.size));
+  }
 
   struct GNUNET_PSYC_JoinHandle *jh = GNUNET_malloc (sizeof (*jh));
   jh->mst = mst;
   jh->slave_key = req->slave_key;
 
   if (NULL != mst->join_req_cb)
-    mst->join_req_cb (mst->cb_cls, &req->slave_key, pmsg, jh);
+    mst->join_req_cb (mst->cb_cls, req, &req->slave_key, join_msg, jh);
 }
 
 
@@ -273,13 +296,12 @@ slave_recv_join_decision (void *cls,
   const struct GNUNET_PSYC_JoinDecisionMessage *
     dcsn = (const struct GNUNET_PSYC_JoinDecisionMessage *) msg;
 
-  struct GNUNET_PSYC_MessageHeader *pmsg = NULL;
+  struct GNUNET_PSYC_Message *pmsg = NULL;
   if (ntohs (dcsn->header.size) <= sizeof (*dcsn) + sizeof (*pmsg))
-    pmsg = (struct GNUNET_PSYC_MessageHeader *) &dcsn[1];
+    pmsg = (struct GNUNET_PSYC_Message *) &dcsn[1];
 
-  struct GNUNET_PSYC_JoinHandle *jh = GNUNET_malloc (sizeof (*jh));
   if (NULL != slv->join_dcsn_cb)
-    slv->join_dcsn_cb (slv->cb_cls, ntohl (dcsn->is_admitted), pmsg);
+    slv->join_dcsn_cb (slv->cb_cls, dcsn, ntohl (dcsn->is_admitted), pmsg);
 }
 
 
@@ -299,7 +321,7 @@ static struct GNUNET_CLIENT_MANAGER_MessageHandler master_handlers[] =
 
   { &master_recv_join_request, NULL,
     GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
-    sizeof (struct MasterJoinRequest), GNUNET_YES },
+    sizeof (struct GNUNET_PSYC_JoinRequestMessage), GNUNET_YES },
 
   { &channel_recv_disconnect, NULL, 0, 0, GNUNET_NO },
 
@@ -331,6 +353,35 @@ static struct GNUNET_CLIENT_MANAGER_MessageHandler slave_handlers[] =
 };
 
 
+static void
+channel_cleanup (struct GNUNET_PSYC_Channel *chn)
+{
+  GNUNET_PSYC_transmit_destroy (chn->tmit);
+  GNUNET_PSYC_receive_destroy (chn->recv);
+  GNUNET_free (chn->connect_msg);
+  if (NULL != chn->disconnect_cb)
+    chn->disconnect_cb (chn->disconnect_cls);
+}
+
+
+static void
+master_cleanup (void *cls)
+{
+  struct GNUNET_PSYC_Master *mst = cls;
+  channel_cleanup (&mst->chn);
+  GNUNET_free (mst);
+}
+
+
+static void
+slave_cleanup (void *cls)
+{
+  struct GNUNET_PSYC_Slave *slv = cls;
+  channel_cleanup (&slv->chn);
+  GNUNET_free (slv);
+}
+
+
 /**
  * Start a PSYC master channel.
  *
@@ -367,6 +418,7 @@ GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                           GNUNET_PSYC_MasterStartCallback start_cb,
                           GNUNET_PSYC_JoinRequestCallback join_request_cb,
                           GNUNET_PSYC_MessageCallback message_cb,
+                          GNUNET_PSYC_MessagePartCallback message_part_cb,
                           void *cls)
 {
   struct GNUNET_PSYC_Master *mst = GNUNET_malloc (sizeof (*mst));
@@ -390,7 +442,7 @@ GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_CLIENT_MANAGER_set_user_context_ (chn->client, mst, sizeof (*chn));
 
   chn->tmit = GNUNET_PSYC_transmit_create (chn->client);
-  chn->recv = GNUNET_PSYC_receive_create (message_cb, message_cb, cls);
+  chn->recv = GNUNET_PSYC_receive_create (message_cb, message_part_cb, cls);
 
   channel_send_connect_msg (chn);
   return mst;
@@ -404,10 +456,21 @@ GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param keep_active  FIXME
  */
 void
-GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *mst)
+GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *mst,
+                         int keep_active,
+                         GNUNET_ContinuationCallback stop_cb,
+                         void *stop_cls)
 {
-  GNUNET_CLIENT_MANAGER_disconnect (mst->chn.client, GNUNET_YES);
-  GNUNET_free (mst);
+  struct GNUNET_PSYC_Channel *chn = &mst->chn;
+
+  /* FIXME: send msg to service */
+
+  chn->is_disconnecting = GNUNET_YES;
+  chn->disconnect_cb = stop_cb;
+  chn->disconnect_cls = stop_cls;
+
+  GNUNET_CLIENT_MANAGER_disconnect (mst->chn.client, GNUNET_YES,
+                                    &master_cleanup, mst);
 }
 
 
@@ -439,7 +502,7 @@ GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
                            int is_admitted,
                            uint32_t relay_count,
                            const struct GNUNET_PeerIdentity *relays,
-                           const struct GNUNET_PSYC_MessageHeader *join_resp)
+                           const struct GNUNET_PSYC_Message *join_resp)
 {
   struct GNUNET_PSYC_Channel *chn = &jh->mst->chn;
   struct GNUNET_PSYC_JoinDecisionMessage *dcsn;
@@ -461,6 +524,7 @@ GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
     memcpy (&dcsn[1], join_resp, join_resp_size);
 
   GNUNET_CLIENT_MANAGER_transmit (chn->client, &dcsn->header);
+  GNUNET_free (jh);
   return GNUNET_OK;
 }
 
@@ -576,15 +640,19 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
                         uint32_t relay_count,
                         const struct GNUNET_PeerIdentity *relays,
                         GNUNET_PSYC_MessageCallback message_cb,
+                        GNUNET_PSYC_MessagePartCallback message_part_cb,
                         GNUNET_PSYC_SlaveConnectCallback connect_cb,
                         GNUNET_PSYC_JoinDecisionCallback join_decision_cb,
                         void *cls,
-                        const struct GNUNET_MessageHeader *join_msg)
+                        const struct GNUNET_PSYC_Message *join_msg)
 {
   struct GNUNET_PSYC_Slave *slv = GNUNET_malloc (sizeof (*slv));
   struct GNUNET_PSYC_Channel *chn = &slv->chn;
+
+  uint16_t relay_size = relay_count * sizeof (*relays);
+  uint16_t join_msg_size = ntohs (join_msg->header.size);
   struct SlaveJoinRequest *req
-    = GNUNET_malloc (sizeof (*req) + relay_count * sizeof (*relays));
+    = GNUNET_malloc (sizeof (*req) + relay_size + join_msg_size);
   req->header.size = htons (sizeof (*req)
                             + relay_count * sizeof (*relays));
   req->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN);
@@ -592,7 +660,12 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
   req->slave_key = *slave_key;
   req->origin = *origin;
   req->relay_count = htonl (relay_count);
-  memcpy (&req[1], relays, relay_count * sizeof (*relays));
+
+  if (0 < relay_size)
+    memcpy (&req[1], relays, relay_size);
+
+  if (0 < join_msg_size)
+    memcpy ((char *) &req[1] + relay_size, join_msg, join_msg_size);
 
   chn->connect_msg = (struct GNUNET_MessageHeader *) req;
   chn->cfg = cfg;
@@ -605,7 +678,7 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
   chn->client = GNUNET_CLIENT_MANAGER_connect (cfg, "psyc", slave_handlers);
   GNUNET_CLIENT_MANAGER_set_user_context_ (chn->client, slv, sizeof (*chn));
 
-  chn->recv = GNUNET_PSYC_receive_create (message_cb, message_cb, cls);
+  chn->recv = GNUNET_PSYC_receive_create (message_cb, message_part_cb, cls);
   chn->tmit = GNUNET_PSYC_transmit_create (chn->client);
 
   channel_send_connect_msg (chn);
@@ -622,10 +695,21 @@ GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param slave Slave handle.
  */
 void
-GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slv)
+GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slv,
+                        int keep_active,
+                        GNUNET_ContinuationCallback part_cb,
+                        void *part_cls)
 {
-  GNUNET_CLIENT_MANAGER_disconnect (slv->chn.client, GNUNET_YES);
-  GNUNET_free (slv);
+  struct GNUNET_PSYC_Channel *chn = &slv->chn;
+
+  /* FIXME: send msg to service */
+
+  chn->is_disconnecting = GNUNET_YES;
+  chn->disconnect_cb = part_cb;
+  chn->disconnect_cls = part_cls;
+
+  GNUNET_CLIENT_MANAGER_disconnect (slv->chn.client, GNUNET_YES,
+                                    &slave_cleanup, slv);
 }
 
 
@@ -796,6 +880,7 @@ GNUNET_PSYC_channel_story_tell (struct GNUNET_PSYC_Channel *channel,
                                 uint64_t start_message_id,
                                 uint64_t end_message_id,
                                 GNUNET_PSYC_MessageCallback message_cb,
+                                GNUNET_PSYC_MessagePartCallback message_part_cb,
                                 GNUNET_PSYC_FinishCallback finish_cb,
                                 void *cls)
 {
diff --git a/src/psyc/psyc_util_lib.c b/src/psyc/psyc_util_lib.c
index 8ab0bdad2..6177976de 100644
--- a/src/psyc/psyc_util_lib.c
+++ b/src/psyc/psyc_util_lib.c
@@ -76,7 +76,11 @@ struct GNUNET_PSYC_TransmitHandle
    *
    */
   const char *mod_value;
-  size_t mod_value_size;
+
+  /**
+   * Number of bytes remaining to be transmitted from the current modifier value.
+   */
+  uint32_t mod_value_remaining;
 
   /**
    * State of the current message being received from client.
@@ -104,14 +108,14 @@ struct GNUNET_PSYC_TransmitHandle
 struct GNUNET_PSYC_ReceiveHandle
 {
   /**
-   * Message part callback.
+   * Message callback.
    */
   GNUNET_PSYC_MessageCallback message_cb;
 
   /**
-   * Message part callback for historic message.
+   * Message part callback.
    */
-  GNUNET_PSYC_MessageCallback hist_message_cb;
+  GNUNET_PSYC_MessagePartCallback message_part_cb;
 
   /**
    * Closure for the callbacks.
@@ -149,6 +153,7 @@ struct GNUNET_PSYC_ReceiveHandle
   uint32_t mod_value_size;
 };
 
+
 /**** Messages ****/
 
 
@@ -167,7 +172,7 @@ struct GNUNET_PSYC_ReceiveHandle
  * @return Message header with size information,
  *         followed by the message parts.
  */
-struct GNUNET_MessageHeader *
+struct GNUNET_PSYC_Message *
 GNUNET_PSYC_message_create (const char *method_name,
                             const struct GNUNET_ENV_Environment *env,
                             const void *data,
@@ -188,7 +193,7 @@ GNUNET_PSYC_message_create (const char *method_name,
     }
   }
 
-  struct GNUNET_MessageHeader *msg;
+  struct GNUNET_PSYC_Message *msg;
   uint16_t method_name_size = strlen (method_name) + 1;
   if (method_name_size == 1)
     return NULL;
@@ -199,12 +204,13 @@ GNUNET_PSYC_message_create (const char *method_name,
     + ((0 < data_size) ? sizeof (*pmsg) + data_size : 0)/* data */
     + sizeof (*pmsg);                                   /* end of message */
   msg = GNUNET_malloc (msg_size);
-  msg->size = htons (msg_size);
-  msg->type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE);
+  msg->header.size = htons (msg_size);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE); /* FIXME */
 
   pmeth = (struct GNUNET_PSYC_MessageMethod *) &msg[1];
+  pmeth->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD);
   pmeth->header.size = htons (sizeof (*pmeth) + method_name_size);
-  memcpy (pmeth, method_name, method_name_size);
+  memcpy (&pmeth[1], method_name, method_name_size);
 
   uint16_t p = sizeof (*msg) + sizeof (*pmeth) + method_name_size;
   if (NULL != env)
@@ -215,7 +221,7 @@ GNUNET_PSYC_message_create (const char *method_name,
       uint16_t mod_name_size = strlen (mod->name) + 1;
       pmod = (struct GNUNET_PSYC_MessageModifier *) ((char *) msg + p);
       pmod->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER);
-      pmod->header.size = sizeof (*pmod) + mod_name_size + 1 + mod->value_size;
+      pmod->header.size = sizeof (*pmod) + mod_name_size + mod->value_size;
       p += pmod->header.size;
       pmod->header.size = htons (pmod->header.size);
 
@@ -241,6 +247,7 @@ GNUNET_PSYC_message_create (const char *method_name,
   pmsg->size = htons (sizeof (*pmsg));
   pmsg->type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END);
 
+  GNUNET_assert (p + sizeof (*pmsg) == msg_size);
   return msg;
 }
 
@@ -276,8 +283,8 @@ GNUNET_PSYC_log_message (enum GNUNET_ErrorType kind,
     uint16_t name_size = ntohs (mod->name_size);
     char oper = ' ' < mod->oper ? mod->oper : ' ';
     GNUNET_log (kind, "\t%c%.*s\t%.*s\n", oper, name_size, &mod[1],
-                size - sizeof (*mod) - name_size - 1,
-                ((char *) &mod[1]) + name_size + 1);
+                size - sizeof (*mod) - name_size,
+                ((char *) &mod[1]) + name_size);
     break;
   }
   case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
@@ -331,7 +338,7 @@ transmit_queue_insert (struct GNUNET_PSYC_TransmitHandle *tmit,
   uint16_t size = (NULL != msg) ? ntohs (msg->size) : 0;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Queueing message of type %u and size %u (end: %u)).\n",
+       "Queueing message part of type %u and size %u (end: %u)).\n",
        ntohs (msg->type), size, end);
 
   if (NULL != tmit->msg)
@@ -396,6 +403,9 @@ transmit_data (struct GNUNET_PSYC_TransmitHandle *tmit)
   msg->type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA);
 
   int notify_ret = tmit->notify_data (tmit->notify_data_cls, &data_size, &msg[1]);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "transmit_data (ret: %d, size: %u): %.*s\n",
+       notify_ret, data_size, data_size, &msg[1]);
   switch (notify_ret)
   {
   case GNUNET_NO:
@@ -463,9 +473,15 @@ transmit_mod (struct GNUNET_PSYC_TransmitHandle *tmit)
     msg->size = sizeof (struct GNUNET_PSYC_MessageModifier);
     notify_ret = tmit->notify_mod (tmit->notify_mod_cls, &data_size, &mod[1],
                                    &mod->oper, &mod->value_size);
-    mod->name_size = strnlen ((char *) &mod[1], data_size);
+
+    mod->name_size = strnlen ((char *) &mod[1], data_size) + 1;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "transmit_mod (ret: %d, size: %u + %u): %.*s\n",
+         notify_ret, mod->name_size, mod->value_size, data_size, &mod[1]);
     if (mod->name_size < data_size)
     {
+      tmit->mod_value_remaining
+        = mod->value_size - (data_size - mod->name_size);
       mod->value_size = htonl (mod->value_size);
       mod->name_size = htons (mod->name_size);
     }
@@ -483,6 +499,10 @@ transmit_mod (struct GNUNET_PSYC_TransmitHandle *tmit)
     msg->size = sizeof (struct GNUNET_MessageHeader);
     notify_ret = tmit->notify_mod (tmit->notify_mod_cls,
                                    &data_size, &msg[1], NULL, NULL);
+    tmit->mod_value_remaining -= data_size;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "transmit_mod (ret: %d, size: %u): %.*s\n",
+         notify_ret, data_size, data_size, &msg[1]);
     break;
   }
   default:
@@ -497,26 +517,19 @@ transmit_mod (struct GNUNET_PSYC_TransmitHandle *tmit)
       tmit->paused = GNUNET_YES;
       return;
     }
-    tmit->state = GNUNET_PSYC_MESSAGE_STATE_MOD_CONT;
+    tmit->state
+      = (0 == tmit->mod_value_remaining)
+      ? GNUNET_PSYC_MESSAGE_STATE_MODIFIER
+      : GNUNET_PSYC_MESSAGE_STATE_MOD_CONT;
     break;
 
-  case GNUNET_YES:
-    if (0 == data_size)
-    {
-      /* End of modifiers. */
-      tmit->state = GNUNET_PSYC_MESSAGE_STATE_DATA;
-      if (0 == tmit->acks_pending)
-        transmit_data (tmit);
-
-      return;
-    }
-    tmit->state = GNUNET_PSYC_MESSAGE_STATE_MODIFIER;
+  case GNUNET_YES: /* End of modifiers. */
+    GNUNET_assert (0 == tmit->mod_value_remaining);
     break;
 
   default:
     LOG (GNUNET_ERROR_TYPE_ERROR,
-         "TransmitNotifyModifier callback returned error "
-         "when requesting a modifier.\n");
+         "TransmitNotifyModifier callback returned with error.\n");
 
     tmit->state = GNUNET_PSYC_MESSAGE_STATE_CANCEL;
     msg->type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL);
@@ -533,7 +546,16 @@ transmit_mod (struct GNUNET_PSYC_TransmitHandle *tmit)
     transmit_queue_insert (tmit, msg, GNUNET_NO);
   }
 
-  transmit_mod (tmit);
+  if (GNUNET_YES == notify_ret)
+  {
+    tmit->state = GNUNET_PSYC_MESSAGE_STATE_DATA;
+    if (0 == tmit->acks_pending)
+      transmit_data (tmit);
+  }
+  else
+  {
+    transmit_mod (tmit);
+  }
 }
 
 
@@ -547,9 +569,10 @@ transmit_notify_env (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
   size_t value_size = 0;
   const char *value = NULL;
 
-  if (NULL != oper && NULL != tmit->mod)
+  if (NULL != oper)
   { /* New modifier */
-    tmit->mod = tmit->mod->next;
+    if (NULL != tmit->mod)
+      tmit->mod = tmit->mod->next;
     if (NULL == tmit->mod)
     { /* No more modifiers, continue with data */
       *data_size = 0;
@@ -559,30 +582,29 @@ transmit_notify_env (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
     GNUNET_assert (tmit->mod->value_size < UINT32_MAX);
     *full_value_size = tmit->mod->value_size;
     *oper = tmit->mod->oper;
-    name_size = strlen (tmit->mod->name);
+    name_size = strlen (tmit->mod->name) + 1;
 
-    if (name_size + 1 + tmit->mod->value_size <= *data_size)
+    if (name_size + tmit->mod->value_size <= *data_size)
     {
-      *data_size = name_size + 1 + tmit->mod->value_size;
+      *data_size = name_size + tmit->mod->value_size;
     }
     else
     {
-      tmit->mod_value_size = tmit->mod->value_size;
-      value_size = *data_size - name_size - 1;
-      tmit->mod_value_size -= value_size;
+      value_size = *data_size - name_size;
       tmit->mod_value = tmit->mod->value + value_size;
     }
 
     memcpy (data, tmit->mod->name, name_size);
-    ((char *)data)[name_size] = '\0';
-    memcpy ((char *)data + name_size + 1, tmit->mod->value, value_size);
+    memcpy ((char *)data + name_size, tmit->mod->value, value_size);
+    return GNUNET_NO;
   }
-  else if (NULL != tmit->mod_value && 0 < tmit->mod_value_size)
+  else
   { /* Modifier continuation */
+    GNUNET_assert (NULL != tmit->mod_value && 0 < tmit->mod_value_remaining);
     value = tmit->mod_value;
-    if (tmit->mod_value_size <= *data_size)
+    if (tmit->mod_value_remaining <= *data_size)
     {
-      value_size = tmit->mod_value_size;
+      value_size = tmit->mod_value_remaining;
       tmit->mod_value = NULL;
     }
     else
@@ -590,7 +612,6 @@ transmit_notify_env (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
       value_size = *data_size;
       tmit->mod_value += value_size;
     }
-    tmit->mod_value_size -= value_size;
 
     if (*data_size < value_size)
     {
@@ -603,9 +624,8 @@ transmit_notify_env (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
 
     *data_size = value_size;
     memcpy (data, value, value_size);
+    return (tmit->mod_value = NULL) ? GNUNET_YES : GNUNET_NO;
   }
-
-  return 0 == tmit->mod_value_size ? GNUNET_YES : GNUNET_NO;
 }
 
 
@@ -663,10 +683,16 @@ GNUNET_PSYC_transmit_message (struct GNUNET_PSYC_TransmitHandle *tmit,
   {
     tmit->notify_mod = &transmit_notify_env;
     tmit->notify_mod_cls = tmit;
-    tmit->mod
-      = (NULL != env)
-      ? GNUNET_ENV_environment_head (env)
-      : NULL;
+    if (NULL != env)
+    {
+      struct GNUNET_ENV_Modifier mod = {};
+      mod.next = GNUNET_ENV_environment_head (env);
+      tmit->mod = &mod;
+    }
+    else
+    {
+      tmit->mod = NULL;
+    }
   }
 
   transmit_mod (tmit);
@@ -762,12 +788,12 @@ GNUNET_PSYC_transmit_got_ack (struct GNUNET_PSYC_TransmitHandle *tmit)
  */
 struct GNUNET_PSYC_ReceiveHandle *
 GNUNET_PSYC_receive_create (GNUNET_PSYC_MessageCallback message_cb,
-                            GNUNET_PSYC_MessageCallback hist_message_cb,
+                            GNUNET_PSYC_MessagePartCallback message_part_cb,
                             void *cb_cls)
 {
   struct GNUNET_PSYC_ReceiveHandle *recv = GNUNET_malloc (sizeof (*recv));
   recv->message_cb = message_cb;
-  recv->hist_message_cb = hist_message_cb;
+  recv->message_part_cb = message_part_cb;
   recv->cb_cls = cb_cls;
   return recv;
 }
@@ -800,13 +826,11 @@ GNUNET_PSYC_receive_reset (struct GNUNET_PSYC_ReceiveHandle *recv)
 static void
 recv_error (struct GNUNET_PSYC_ReceiveHandle *recv)
 {
-  GNUNET_PSYC_MessageCallback message_cb
-    = recv->flags & GNUNET_PSYC_MESSAGE_HISTORIC
-    ? recv->hist_message_cb
-    : recv->message_cb;
+  if (NULL != recv->message_part_cb)
+    recv->message_part_cb (recv->cb_cls, recv->message_id, 0, recv->flags, NULL);
 
-  if (NULL != message_cb)
-    message_cb (recv->cb_cls, recv->message_id, recv->flags, NULL);
+  if (NULL != recv->message_cb)
+    recv->message_cb (recv->cb_cls, recv->message_id, recv->flags, NULL);
 
   GNUNET_PSYC_receive_reset (recv);
 }
@@ -827,6 +851,7 @@ GNUNET_PSYC_receive_message (struct GNUNET_PSYC_ReceiveHandle *recv,
 {
   uint16_t size = ntohs (msg->header.size);
   uint32_t flags = ntohl (msg->flags);
+  uint64_t message_id;
 
   GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG,
                            (struct GNUNET_MessageHeader *) msg);
@@ -858,6 +883,7 @@ GNUNET_PSYC_receive_message (struct GNUNET_PSYC_ReceiveHandle *recv,
     recv_error (recv);
     return GNUNET_SYSERR;
   }
+  message_id = recv->message_id;
 
   uint16_t pos = 0, psize = 0, ptype, size_eq, size_min;
 
@@ -964,10 +990,10 @@ GNUNET_PSYC_receive_message (struct GNUNET_PSYC_ReceiveHandle *recv,
 
       uint16_t name_size = ntohs (mod->name_size);
       recv->mod_value_size_expected = ntohl (mod->value_size);
-      recv->mod_value_size = psize - sizeof (*mod) - name_size - 1;
+      recv->mod_value_size = psize - sizeof (*mod) - name_size;
 
-      if (psize < sizeof (*mod) + name_size + 1
-          || '\0' != *((char *) &mod[1] + name_size)
+      if (psize < sizeof (*mod) + name_size
+          || '\0' != *((char *) &mod[1] + name_size - 1)
           || recv->mod_value_size_expected < recv->mod_value_size)
       {
         LOG (GNUNET_ERROR_TYPE_WARNING, "Dropping malformed modifier.\n");
@@ -1018,13 +1044,9 @@ GNUNET_PSYC_receive_message (struct GNUNET_PSYC_ReceiveHandle *recv,
     }
     }
 
-    GNUNET_PSYC_MessageCallback message_cb
-      = recv->flags & GNUNET_PSYC_MESSAGE_HISTORIC
-      ? recv->hist_message_cb
-      : recv->message_cb;
-
-    if (NULL != message_cb)
-      message_cb (recv->cb_cls, recv->message_id, recv->flags, pmsg);
+    if (NULL != recv->message_part_cb)
+      recv->message_part_cb (recv->cb_cls, recv->message_id, 0, // FIXME: data_offset
+                             recv->flags, pmsg);
 
     switch (ptype)
     {
@@ -1034,6 +1056,9 @@ GNUNET_PSYC_receive_message (struct GNUNET_PSYC_ReceiveHandle *recv,
       break;
     }
   }
+
+  if (NULL != recv->message_cb)
+    recv->message_cb (recv->cb_cls, message_id, flags, msg);
   return GNUNET_OK;
 }
 
@@ -1063,6 +1088,7 @@ GNUNET_PSYC_receive_check_parts (uint16_t data_size, const char *data,
   for (pos = 0; pos < data_size; pos += psize, parts++)
   {
     pmsg = (const struct GNUNET_MessageHeader *) (data + pos);
+    GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, pmsg);
     psize = ntohs (pmsg->size);
     ptype = ntohs (pmsg->type);
     if (0 == parts && NULL != first_ptype)
@@ -1084,3 +1110,111 @@ GNUNET_PSYC_receive_check_parts (uint16_t data_size, const char *data,
   }
   return parts;
 }
+
+
+struct ParseMessageClosure
+{
+  struct GNUNET_ENV_Environment *env;
+  const char **method_name;
+  const void **data;
+  uint16_t *data_size;
+  enum GNUNET_PSYC_MessageState msg_state;
+};
+
+
+static void
+parse_message_part_cb (void *cls, uint64_t message_id, uint64_t data_offset,
+                       uint32_t flags, const struct GNUNET_MessageHeader *msg)
+{
+  struct ParseMessageClosure *pmc = cls;
+  if (NULL == msg)
+  {
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_ERROR;
+    return;
+  }
+
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD:
+  {
+    struct GNUNET_PSYC_MessageMethod *
+      pmeth = (struct GNUNET_PSYC_MessageMethod *) msg;
+    *pmc->method_name = (const char *) &pmeth[1];
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_METHOD;
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
+  {
+    struct GNUNET_PSYC_MessageModifier *
+      pmod = (struct GNUNET_PSYC_MessageModifier *) msg;
+
+    const char *name = (const char *) &pmod[1];
+    const void *value = name + pmod->name_size;
+    GNUNET_ENV_environment_add (pmc->env, pmod->oper, name, value,
+                                pmod->value_size);
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_MODIFIER;
+    break;
+  }
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
+    *pmc->data = &msg[1];
+    *pmc->data_size = ntohs (msg->size) - sizeof (*msg);
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_DATA;
+    break;
+
+  case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_END;
+    break;
+
+  default:
+    pmc->msg_state = GNUNET_PSYC_MESSAGE_STATE_ERROR;
+  }
+}
+
+
+/**
+ * Parse PSYC message.
+ *
+ * @param msg
+ *        The PSYC message to parse.
+ * @param[out] method_name
+ *        Pointer to the method name inside @a pmsg.
+ * @param env
+ *        The environment for the message with a list of modifiers.
+ * @param[out] data
+ *        Pointer to data inside @a pmsg.
+ * @param[out] data_size
+ *        Size of @data is written here.
+ *
+ * @return #GNUNET_OK on success,
+ *         #GNUNET_SYSERR on parse error.
+ */
+int
+GNUNET_PSYC_message_parse (const struct GNUNET_PSYC_Message *msg,
+                           const char **method_name,
+                           struct GNUNET_ENV_Environment *env,
+                           const void **data,
+                           uint16_t *data_size)
+{
+  struct ParseMessageClosure cls;
+  cls.env = env;
+  cls.method_name = method_name;
+  cls.data = data;
+  cls.data_size = data_size;
+
+  uint16_t msg_size = ntohs (msg->header.size);
+  struct GNUNET_PSYC_MessageHeader *
+    pmsg = GNUNET_malloc (sizeof (*pmsg) + msg_size - sizeof (*msg));
+  memcpy (&pmsg[1], &msg[1], msg_size - sizeof (*msg));
+
+  struct GNUNET_PSYC_ReceiveHandle *
+    recv = GNUNET_PSYC_receive_create (NULL, &parse_message_part_cb, &cls);
+  GNUNET_PSYC_receive_message (recv, pmsg);
+  GNUNET_PSYC_receive_destroy (recv);
+  GNUNET_free (pmsg);
+
+  return (GNUNET_PSYC_MESSAGE_STATE_END == cls.msg_state)
+    ? GNUNET_OK
+    : GNUNET_SYSERR;
+}
diff --git a/src/psyc/test_psyc.c b/src/psyc/test_psyc.c
index 0077bc9b7..495e3be47 100644
--- a/src/psyc/test_psyc.c
+++ b/src/psyc/test_psyc.c
@@ -62,8 +62,6 @@ static struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key;
 static struct GNUNET_CRYPTO_EddsaPublicKey channel_pub_key;
 static struct GNUNET_CRYPTO_EcdsaPublicKey slave_pub_key;
 
-struct GNUNET_PSYC_MasterTransmitHandle *mth;
-
 struct TransmitClosure
 {
   struct GNUNET_PSYC_MasterTransmitHandle *mst_tmit;
@@ -95,6 +93,28 @@ static void
 master_transmit ();
 
 
+void master_stopped (void *cls)
+{
+  if (NULL != tmit)
+  {
+    GNUNET_ENV_environment_destroy (tmit->env);
+    GNUNET_free (tmit);
+    tmit = NULL;
+  }
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+void slave_parted (void *cls)
+{
+  if (NULL != mst)
+  {
+    GNUNET_PSYC_master_stop (mst, GNUNET_NO, &master_stopped, NULL);
+    mst = NULL;
+  }
+  else
+    master_stopped (NULL);
+}
+
 /**
  * Clean up all resources used.
  */
@@ -103,21 +123,11 @@ cleanup ()
 {
   if (NULL != slv)
   {
-    GNUNET_PSYC_slave_part (slv);
+    GNUNET_PSYC_slave_part (slv, GNUNET_NO, &slave_parted, NULL);
     slv = NULL;
   }
-  if (NULL != mst)
-  {
-    GNUNET_PSYC_master_stop (mst);
-    mst = NULL;
-  }
-  if (NULL != tmit)
-  {
-    GNUNET_ENV_environment_destroy (tmit->env);
-    GNUNET_free (tmit);
-    tmit = NULL;
-  }
-  GNUNET_SCHEDULER_shutdown ();
+  else
+    slave_parted (NULL);
 }
 
 
@@ -171,7 +181,20 @@ end ()
 
 static void
 master_message_cb (void *cls, uint64_t message_id, uint32_t flags,
-                   const struct GNUNET_MessageHeader *msg)
+                   const struct GNUNET_PSYC_MessageHeader *msg)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Master got PSYC message fragment of size %u "
+              "belonging to message ID %llu with flags %x\n",
+              ntohs (msg->header.size), message_id, flags);
+  // FIXME
+}
+
+
+static void
+master_message_part_cb (void *cls, uint64_t message_id,
+                        uint64_t data_offset, uint32_t flags,
+                        const struct GNUNET_MessageHeader *msg)
 {
   if (NULL == msg)
   {
@@ -215,7 +238,20 @@ master_message_cb (void *cls, uint64_t message_id, uint32_t flags,
 
 static void
 slave_message_cb (void *cls, uint64_t message_id, uint32_t flags,
-                  const struct GNUNET_MessageHeader *msg)
+                  const struct GNUNET_PSYC_MessageHeader *msg)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Slave got PSYC message fragment of size %u "
+              "belonging to message ID %llu with flags %x\n",
+              ntohs (msg->header.size), message_id, flags);
+  // FIXME
+}
+
+
+static void
+slave_message_part_cb (void *cls, uint64_t message_id,
+                       uint64_t data_offset, uint32_t flags,
+                       const struct GNUNET_MessageHeader *msg)
 {
   if (NULL == msg)
   {
@@ -371,7 +407,7 @@ tmit_notify_mod (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
     memcpy (data, value, value_size);
   }
 
-  return 0 == tmit->mod_value_size ? GNUNET_YES : GNUNET_NO;
+  return GNUNET_NO;
 }
 
 
@@ -380,8 +416,10 @@ slave_join ();
 
 
 static void
-join_decision_cb (void *cls, int is_admitted,
-                  const struct GNUNET_PSYC_MessageHeader *join_msg)
+join_decision_cb (void *cls,
+                  const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
+                  int is_admitted,
+                  const struct GNUNET_PSYC_Message *join_msg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
               "Slave got join decision: %d\n", is_admitted);
@@ -415,8 +453,10 @@ join_decision_cb (void *cls, int is_admitted,
 
 
 static void
-join_request_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
-                 const struct GNUNET_PSYC_MessageHeader *msg,
+join_request_cb (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 GNUNET_HashCode slave_key_hash;
@@ -450,11 +490,11 @@ slave_join ()
                               "_foo", "bar baz", 7);
   GNUNET_ENV_environment_add (env, GNUNET_ENV_OP_ASSIGN,
                               "_foo_bar", "foo bar baz", 11);
-  struct GNUNET_MessageHeader *
+  struct GNUNET_PSYC_Message *
     join_msg = GNUNET_PSYC_message_create ("_request_join", env, "some data", 9);
 
-  slv = GNUNET_PSYC_slave_join (cfg, &channel_pub_key, slave_key, &origin,
-                                0, NULL, &slave_message_cb,
+  slv = GNUNET_PSYC_slave_join (cfg, &channel_pub_key, slave_key, &origin, 0, NULL,
+                                &slave_message_cb, &slave_message_part_cb,
                                 &slave_connect_cb, &join_decision_cb, NULL,
                                 join_msg);
   GNUNET_ENV_environment_destroy (env);
@@ -551,7 +591,8 @@ run (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Starting master.\n");
   mst = GNUNET_PSYC_master_start (cfg, channel_key, GNUNET_PSYC_CHANNEL_PRIVATE,
                                   &master_start_cb, &join_request_cb,
-                                  &master_message_cb, NULL);
+                                  &master_message_cb, &master_message_part_cb,
+                                  NULL);
 }
 
 
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);
 }
 
 
diff --git a/src/util/client_manager.c b/src/util/client_manager.c
index c415ce845..6ab2c7c6d 100644
--- a/src/util/client_manager.c
+++ b/src/util/client_manager.c
@@ -30,7 +30,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "util",__VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-client-mgr", __VA_ARGS__)
 
 
 /**
@@ -94,6 +94,16 @@ struct GNUNET_CLIENT_MANAGER_Connection
   const struct GNUNET_CLIENT_MANAGER_MessageHandler *handlers;
 
   /**
+   * Disconnect callback.
+   */
+  void (*disconnect_cb)(void *);
+
+  /**
+   * Disconnect closure.
+   */
+  void *disconnect_cls;
+
+  /**
    * User context value.
    * @see GNUNET_CLIENT_MANAGER_set_user_context()
    * @see GNUNET_CLIENT_MANAGER_get_user_context()
@@ -125,7 +135,7 @@ struct GNUNET_CLIENT_MANAGER_Connection
    * #GNUNET_YES if GNUNET_CLIENT_MANAGER_disconnect() was called
    * and we're transmitting the last messages from the queue.
    */
-  uint8_t disconnecting;
+  uint8_t is_disconnecting;
 };
 
 
@@ -185,6 +195,15 @@ static void
 transmit_next (struct GNUNET_CLIENT_MANAGER_Connection *mgr);
 
 
+static void
+schedule_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CLIENT_MANAGER_Connection *mgr = cls;
+  GNUNET_CLIENT_MANAGER_disconnect (mgr, GNUNET_NO,
+                                    mgr->disconnect_cb, mgr->disconnect_cls);
+}
+
+
 /**
  * Transmit next message to service.
  *
@@ -221,7 +240,14 @@ send_next_message (void *cls, size_t buf_size, void *buf)
   GNUNET_free (mqi);
 
   if (NULL != mgr->tmit_head)
+  {
     transmit_next (mgr);
+  }
+  else if (GNUNET_YES == mgr->is_disconnecting)
+  {
+    GNUNET_SCHEDULER_add_now (&schedule_disconnect, mgr);
+    return size;
+  }
 
   if (GNUNET_NO == mgr->in_receive)
   {
@@ -247,8 +273,9 @@ transmit_next (struct GNUNET_CLIENT_MANAGER_Connection *mgr)
 
   if (NULL == mgr->tmit_head)
   {
-    if (GNUNET_YES == mgr->disconnecting)
-      GNUNET_CLIENT_MANAGER_disconnect (mgr, GNUNET_NO);
+    if (GNUNET_YES == mgr->is_disconnecting)
+      GNUNET_CLIENT_MANAGER_disconnect (mgr, GNUNET_NO,
+                                        mgr->disconnect_cb, mgr->disconnect_cls);
     return;
   }
 
@@ -269,7 +296,7 @@ transmit_next (struct GNUNET_CLIENT_MANAGER_Connection *mgr)
  * @param tc Scheduler context.
  */
 static void
-reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CLIENT_MANAGER_Connection *mgr = cls;
   mgr->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
@@ -305,7 +332,7 @@ GNUNET_CLIENT_MANAGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   mgr->service_name = service_name;
   mgr->handlers = handlers;
   mgr->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  mgr->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, mgr);
+  mgr->reconnect_task = GNUNET_SCHEDULER_add_now (&schedule_reconnect, mgr);
   return mgr;
 }
 
@@ -315,17 +342,25 @@ GNUNET_CLIENT_MANAGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
  *
  * @param mgr             Client manager connection.
  * @param transmit_queue  Transmit pending messages in queue before disconnecting.
+ * @param disconnect_cb   Function called after disconnected from the service.
+ * @param disconnect_cls  Closure for @a disconnect_cb.
  */
 void
 GNUNET_CLIENT_MANAGER_disconnect (struct GNUNET_CLIENT_MANAGER_Connection *mgr,
-                                  int transmit_queue)
+                                  int transmit_queue,
+                                  GNUNET_ContinuationCallback disconnect_cb,
+                                  void *disconnect_cls)
 {
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting (%d)\n", transmit_queue);
+  mgr->disconnect_cb = disconnect_cb;
+  mgr->disconnect_cls = disconnect_cls;
   if (NULL != mgr->tmit_head)
   {
     if (GNUNET_YES == transmit_queue)
     {
-      mgr->disconnecting = GNUNET_YES;
+      mgr->is_disconnecting = GNUNET_YES;
       transmit_next (mgr);
+      return;
     }
     else
     {
@@ -350,7 +385,10 @@ GNUNET_CLIENT_MANAGER_disconnect (struct GNUNET_CLIENT_MANAGER_Connection *mgr,
     GNUNET_CLIENT_disconnect (mgr->client);
     mgr->client = NULL;
   }
+  if (NULL != mgr->disconnect_cb)
+    mgr->disconnect_cb (mgr->disconnect_cls);
   GNUNET_free (mgr);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnected.\n");
 }
 
 
@@ -380,7 +418,7 @@ GNUNET_CLIENT_MANAGER_reconnect (struct GNUNET_CLIENT_MANAGER_Connection *mgr)
        "Scheduling task to reconnect to service in %s.\n",
        GNUNET_STRINGS_relative_time_to_string (mgr->reconnect_delay, GNUNET_YES));
   mgr->reconnect_task =
-      GNUNET_SCHEDULER_add_delayed (mgr->reconnect_delay, &reconnect, mgr);
+    GNUNET_SCHEDULER_add_delayed (mgr->reconnect_delay, &schedule_reconnect, mgr);
   mgr->reconnect_delay = GNUNET_TIME_STD_BACKOFF (mgr->reconnect_delay);
 }