1 files changed, 296 insertions, 153 deletions

diff --git a/src/messenger/gnunet-service-messenger_handle.c b/src/messenger/gnunet-service-messenger_handle.c
index 38ad6fbb4..4d2318d62 100644
--- a/src/messenger/gnunet-service-messenger_handle.c
+++ b/src/messenger/gnunet-service-messenger_handle.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -28,18 +28,19 @@
 #include "gnunet-service-messenger.h"
 #include "gnunet-service-messenger_message_kind.h"
 
+#include "messenger_api_util.h"
+
 struct GNUNET_MESSENGER_SrvHandle*
 create_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
 {
+  GNUNET_assert((service) && (mq));
+
   struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct GNUNET_MESSENGER_SrvHandle);
 
   handle->service = service;
   handle->mq = mq;
 
   handle->name = NULL;
-
-  handle->operation = NULL;
-
   handle->ego = NULL;
 
   handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
@@ -58,11 +59,10 @@ iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *val
 void
 destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  if (handle->service->dir)
-   save_handle_configuration(handle);
+  GNUNET_assert(handle);
 
-  if (handle->operation)
-    GNUNET_IDENTITY_cancel (handle->operation);
+  if (handle->service->dir)
+    save_handle_configuration (handle);
 
   if (handle->name)
     GNUNET_free(handle->name);
@@ -74,8 +74,10 @@ destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 }
 
 void
-get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
+get_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
 {
+  GNUNET_assert((handle) && (dir));
+
   if (name)
     GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
                      DIR_SEPARATOR, name, DIR_SEPARATOR);
@@ -87,11 +89,15 @@ get_handle_data_subdir (struct GNUNET_MESSENGER_SrvHandle *handle, const char *n
 static int
 create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
-  struct GNUNET_ShortHashCode *random_id = generate_service_new_member_id (handle->service, key);
+  GNUNET_assert((handle) && (key));
+
+  struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
 
   if (!random_id)
     return GNUNET_NO;
 
+  generate_free_member_id (random_id, NULL);
+
   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, random_id,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
   {
@@ -99,8 +105,8 @@ create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const
     return GNUNET_NO;
   }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n",
-             GNUNET_sh2s(random_id), GNUNET_h2s(key));
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (random_id),
+             GNUNET_h2s (key));
 
   return GNUNET_YES;
 }
@@ -108,48 +114,61 @@ create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const
 const struct GNUNET_ShortHashCode*
 get_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 }
 
-void
+int
 change_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
                          const struct GNUNET_ShortHashCode *unique_id)
 {
-  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
-
-  if (member_id)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Changed a member id (%s) for room (%s) ",
-               GNUNET_sh2s(member_id), GNUNET_h2s(key));
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "into (%s).\n",
-               GNUNET_sh2s(unique_id));
-
-    GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
-
-    struct GNUNET_MESSENGER_MemberMessage *msg;
-    struct GNUNET_MQ_Envelope *env;
+  GNUNET_assert((handle) && (key) && (unique_id));
 
-    env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
-
-    GNUNET_memcpy(&(msg->key), key, sizeof(*key));
-    GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
+  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 
-    GNUNET_MQ_send (handle->mq, env);
-  }
-  else
+  if (!member_id)
   {
     member_id = GNUNET_new(struct GNUNET_ShortHashCode);
     GNUNET_memcpy(member_id, unique_id, sizeof(*member_id));
 
     if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, member_id,
                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    {
       GNUNET_free(member_id);
+      return GNUNET_SYSERR;
+    }
   }
+
+  if (0 == GNUNET_memcmp(unique_id, member_id))
+    goto send_message_to_client;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (member_id),
+             GNUNET_h2s (key));
+
+  GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
+
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n", GNUNET_sh2s (unique_id));
+
+  struct GNUNET_MESSENGER_MemberMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+send_message_to_client:
+
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+
+  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
+  GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
+
+  GNUNET_MQ_send (handle->mq, env);
+  return GNUNET_OK;
 }
 
 static void
 change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 {
+  GNUNET_assert(handle);
+
   if (handle->name)
     GNUNET_free(handle->name);
 
@@ -173,25 +192,67 @@ change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 }
 
 static void
-change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Ego *ego)
+change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
 {
+  GNUNET_assert(handle);
+
   handle->ego = ego;
 
-  ego = get_handle_ego(handle);
+  ego = get_handle_ego (handle);
+
+  const uint16_t length = GNUNET_IDENTITY_key_get_length(&(ego->pub));
 
   struct GNUNET_MESSENGER_KeyMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);
+  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);
 
-  GNUNET_memcpy(&(msg->pubkey), &(ego->pub), sizeof(ego->pub));
+  char *extra = ((char*) msg) + sizeof(*msg);
+
+  if (GNUNET_IDENTITY_write_key_to_buffer(&(ego->pub), extra, length) < 0)
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Could not write key to buffer.\n");
 
   GNUNET_MQ_send (handle->mq, env);
 }
 
-struct GNUNET_MESSENGER_Ego*
-get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle)
+struct GNUNET_MESSENGER_MessageHandle
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle;
+  struct GNUNET_MESSENGER_Message *message;
+};
+
+static int
+iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
+
+  send_handle_message (msg_handle->handle, key, msg_handle->message);
+
+  return GNUNET_YES;
+}
+
+void
+set_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
+{
+  GNUNET_assert((handle) && (ego));
+
+  struct GNUNET_MESSENGER_MessageHandle msg_handle;
+
+  msg_handle.handle = handle;
+  msg_handle.message = create_message_key (&(ego->priv));
+
+  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
+
+  destroy_message (msg_handle.message);
+
+  change_handle_ego (handle, ego);
+}
+
+const struct GNUNET_MESSENGER_Ego*
+get_handle_ego (const struct GNUNET_MESSENGER_SrvHandle *handle)
 {
+  GNUNET_assert(handle);
+
   static struct GNUNET_MESSENGER_Ego anonymous;
   static int read_keys = 0;
 
@@ -200,99 +261,86 @@ get_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle)
 
   if (!read_keys)
   {
-    struct GNUNET_IDENTITY_Ego* ego = GNUNET_IDENTITY_ego_get_anonymous ();
-    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key(ego), sizeof(anonymous.priv));
-    GNUNET_IDENTITY_ego_get_public_key(ego, &(anonymous.pub));
+    struct GNUNET_IDENTITY_Ego *ego = GNUNET_IDENTITY_ego_get_anonymous ();
+    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key (ego), sizeof(anonymous.priv));
+    GNUNET_IDENTITY_ego_get_public_key (ego, &(anonymous.pub));
     read_keys = 1;
   }
 
   return &anonymous;
 }
 
-void
-setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+static void
+callback_setup_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting up handle...\n");
+
   change_handle_name (handle, name);
-  change_handle_ego (handle, handle->name? lookup_service_ego(handle->service, handle->name) : NULL);
+  change_handle_ego (handle, ego);
 
   if (handle->service->dir)
-   load_handle_configuration(handle);
+    load_handle_configuration (handle);
 }
 
-struct GNUNET_MESSENGER_MessageHandle
-{
-  struct GNUNET_MESSENGER_SrvHandle *handle;
-  struct GNUNET_MESSENGER_Message *message;
-};
-
-static int
-iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
+void
+setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
 {
-  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
+  GNUNET_assert(handle);
 
-  send_handle_message (msg_handle->handle, key, msg_handle->message);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return GNUNET_YES;
+  lookup_store_ego (store, name, callback_setup_handle_name, handle);
 }
 
 static void
-callback_ego_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *emsg)
+callback_update_handle (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
   struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  handle->operation = NULL;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating handle...\n");
 
-  if (emsg)
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", emsg);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  if (key)
-  {
-    struct GNUNET_MESSENGER_MessageHandle msg_handle;
-
-    msg_handle.handle = handle;
-    msg_handle.message = create_message_key (key);
-
-    GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);
-
-    destroy_message (msg_handle.message);
-
-    update_service_ego(handle->service, handle->name, key);
-
-    change_handle_ego (handle, lookup_service_ego(handle->service, handle->name));
-  }
+  if (!ego)
+    create_store_ego(store, handle->name, handle);
+  else
+    change_handle_ego (handle, ego);
 }
 
-int
+void
 update_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
   GNUNET_assert(handle);
 
   if (!handle->name)
-    return GNUNET_SYSERR;
-
-  struct GNUNET_MESSENGER_Ego *ego = lookup_service_ego(handle->service, handle->name);
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating handle failed: Name is required!\n");
+    return;
+  }
 
-  if (!ego)
-    handle->operation = GNUNET_IDENTITY_create (handle->service->identity, handle->name, NULL,
-                                                GNUNET_IDENTITY_TYPE_ECDSA, callback_ego_create, handle);
-  else
-    change_handle_ego (handle, ego);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return GNUNET_OK;
+  lookup_store_ego (store, handle->name, callback_update_handle, handle);
 }
 
-int
-set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+static void
+callback_set_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
 {
-  GNUNET_assert(handle);
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  if ((name) && (lookup_service_ego(handle->service, name)))
-    return GNUNET_NO;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Renaming handle...\n");
+
+  if (ego)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is occupied! (%s)\n", name);
+    return;
+  }
 
-  struct GNUNET_IDENTITY_Operation *operation = handle->operation;
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  if (handle->name)
-    handle->operation = GNUNET_IDENTITY_rename (handle->service->identity, handle->name, name, NULL, NULL);
+  int rename_ego_in_store = handle->ego? GNUNET_YES : GNUNET_NO;
 
   char *old_dir;
   get_handle_data_subdir (handle, handle->name, &old_dir);
@@ -323,29 +371,42 @@ set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
     destroy_message (msg_handle.message);
 
     change_handle_name (handle, name);
-
-    if (operation)
-      GNUNET_IDENTITY_cancel (operation);
   }
   else
+    rename_ego_in_store = GNUNET_NO;
+
+  GNUNET_free(old_dir);
+  GNUNET_free(new_dir);
+
+  if (GNUNET_YES == rename_ego_in_store)
+    rename_store_ego(store, handle->name, name);
+}
+
+void
+set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
+{
+  GNUNET_assert(handle);
+
+  if (!name)
   {
-    if (handle->operation)
-    {
-      GNUNET_IDENTITY_cancel (handle->operation);
+    if (handle->ego)
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is required!\n");
+    else
+      change_handle_name (handle, name);
 
-      handle->operation = operation;
-    }
+    return;
   }
 
-  GNUNET_free(old_dir);
-  GNUNET_free(new_dir);
+  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
-  return (result == 0 ? GNUNET_OK : GNUNET_NO);
+  lookup_store_ego (store, name, callback_set_handle_name, handle);
 }
 
 int
 open_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
     return GNUNET_NO;
 
@@ -356,6 +417,8 @@ int
 entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door,
                    const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (door) && (key));
+
   if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
     return GNUNET_NO;
 
@@ -365,6 +428,8 @@ entry_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
 int
 close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 {
+  GNUNET_assert((handle) && (key));
+
   if (!get_handle_member_id (handle, key))
     return GNUNET_NO;
 
@@ -373,8 +438,10 @@ close_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNE
 
 int
 send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
-                     struct GNUNET_MESSENGER_Message *message)
+                     const struct GNUNET_MESSENGER_Message *message)
 {
+  GNUNET_assert((handle) && (key) && (message));
+
   const struct GNUNET_ShortHashCode *id = get_handle_member_id (handle, key);
 
   if (!id)
@@ -391,45 +458,120 @@ send_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNU
     return GNUNET_NO;
   }
 
-  struct GNUNET_HashCode hash;
+  struct GNUNET_MESSENGER_Message *msg = copy_message(message);
 
-  GNUNET_memcpy(&(message->header.sender_id), id, sizeof(*id));
+  GNUNET_memcpy(&(msg->header.sender_id), id, sizeof(*id));
 
-  send_room_message (room, handle, message, &hash);
-  return GNUNET_YES;
+  return send_room_message (room, handle, msg);
+}
+
+static const struct GNUNET_HashCode*
+get_next_member_session_contect(const struct GNUNET_MESSENGER_MemberSession *session)
+{
+  if (session->next)
+    return get_next_member_session_contect (session->next);
+  else
+    return get_member_session_context(session);
+}
+
+void
+notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key,
+                       const struct GNUNET_MESSENGER_MemberSession *session,
+                       const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
+{
+  GNUNET_assert((handle) && (key) && (session) && (message) && (hash));
+
+  if ((!handle->mq) || (!get_handle_member_id (handle, key)))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
+    return;
+  }
+
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->contact);
+
+  struct GNUNET_HashCode sender;
+  GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
+
+  const struct GNUNET_HashCode *context = get_next_member_session_contect (session);
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying client about message: %s\n", GNUNET_h2s (hash));
+
+  struct GNUNET_MESSENGER_Message *private_message = NULL;
+
+  if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
+  {
+    private_message = copy_message(message);
+
+    if (GNUNET_YES != decrypt_message(private_message, &(get_handle_ego(handle)->priv)))
+    {
+      destroy_message(private_message);
+      private_message = NULL;
+    }
+    else
+      message = private_message;
+  }
+
+  struct GNUNET_MESSENGER_RecvMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
+  uint16_t length = get_message_size (message, GNUNET_YES);
+
+  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
+
+  GNUNET_memcpy(&(msg->key), key, sizeof(msg->key));
+  GNUNET_memcpy(&(msg->sender), &sender, sizeof(msg->sender));
+  GNUNET_memcpy(&(msg->context), context, sizeof(msg->context));
+  GNUNET_memcpy(&(msg->hash), hash, sizeof(msg->hash));
+
+  msg->flags = (uint32_t) (
+      private_message? GNUNET_MESSENGER_FLAG_PRIVATE : GNUNET_MESSENGER_FLAG_NONE
+  );
+
+  char *buffer = ((char*) msg) + sizeof(*msg);
+  encode_message (message, length, buffer, GNUNET_YES);
+
+  if (private_message)
+    destroy_message(private_message);
+
+  GNUNET_MQ_send (handle->mq, env);
 }
 
-static int callback_scan_for_rooms(void* cls, const char *filename) {
-  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
+static int
+callback_scan_for_rooms (void *cls, const char *filename)
+{
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
-  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
 
-  if ((GNUNET_YES == GNUNET_DISK_file_test(filename)) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_parse(cfg, filename)))
+  if ((GNUNET_YES == GNUNET_DISK_file_test (filename)) && (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, filename)))
   {
     struct GNUNET_HashCode key;
     struct GNUNET_ShortHashCode member_id;
 
-    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "key", &key, sizeof(key))) &&
-        (GNUNET_OK == GNUNET_CONFIGURATION_get_data(cfg, "room", "member_id", &member_id, sizeof(member_id))))
-      change_handle_member_id(handle, &key, &member_id);
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "key", &key, sizeof(key))) &&
+        (GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "member_id", &member_id, sizeof(member_id))))
+      change_handle_member_id (handle, &key, &member_id);
   }
 
-  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_CONFIGURATION_destroy (cfg);
   return GNUNET_OK;
 }
 
-void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle) {
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+void
+load_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
+{
+  GNUNET_assert(handle);
 
-  if (GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_YES))
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
+
+  if (GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_YES))
   {
-    char* scan_dir;
-    GNUNET_asprintf(&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+    char *scan_dir;
+    GNUNET_asprintf (&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
 
-    if (GNUNET_OK == GNUNET_DISK_directory_test(scan_dir, GNUNET_YES))
-      GNUNET_DISK_directory_scan(scan_dir, callback_scan_for_rooms, handle);
+    if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
+      GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_rooms, handle);
 
     GNUNET_free(scan_dir);
   }
@@ -438,63 +580,64 @@ void load_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle) {
 }
 
 static int
-iterate_save_rooms(void* cls, const struct GNUNET_HashCode* key, void* value)
+iterate_save_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
-  struct GNUNET_MESSENGER_SrvHandle* handle = cls;
-  struct GNUNET_ShortHashCode* member_id = value;
+  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
+  struct GNUNET_ShortHashCode *member_id = value;
 
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
 
-  char* filename;
-  GNUNET_asprintf(&filename, "%s%s%c%s.cfg",
-                  id_dir, "rooms", DIR_SEPARATOR,
-                  GNUNET_h2s(key));
+  char *filename;
+  GNUNET_asprintf (&filename, "%s%s%c%s.cfg", id_dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (key));
 
   GNUNET_free(id_dir);
 
-  struct GNUNET_CONFIGURATION_Handle* cfg = GNUNET_CONFIGURATION_create();
+  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
 
-  char* key_data = GNUNET_STRINGS_data_to_string_alloc(key, sizeof(*key));
+  char *key_data = GNUNET_STRINGS_data_to_string_alloc (key, sizeof(*key));
 
   if (key_data)
   {
-    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "key", key_data);
+    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "key", key_data);
 
     GNUNET_free(key_data);
   }
 
-  char* member_id_data = GNUNET_STRINGS_data_to_string_alloc(member_id, sizeof(*member_id));
+  char *member_id_data = GNUNET_STRINGS_data_to_string_alloc (member_id, sizeof(*member_id));
 
   if (member_id_data)
   {
-    GNUNET_CONFIGURATION_set_value_string(cfg, "room", "member_id", member_id_data);
+    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "member_id", member_id_data);
 
     GNUNET_free(member_id_data);
   }
 
-  GNUNET_CONFIGURATION_write(cfg, filename);
-  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_CONFIGURATION_write (cfg, filename);
+  GNUNET_CONFIGURATION_destroy (cfg);
 
   GNUNET_free(filename);
 
   return GNUNET_YES;
 }
 
-void save_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
+void
+save_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  char* id_dir;
-  get_handle_data_subdir(handle, handle->name, &id_dir);
+  GNUNET_assert(handle);
+
+  char *id_dir;
+  get_handle_data_subdir (handle, handle->name, &id_dir);
 
-  if ((GNUNET_YES == GNUNET_DISK_directory_test(id_dir, GNUNET_NO)) ||
-      (GNUNET_OK == GNUNET_DISK_directory_create(id_dir)))
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_NO)) || (GNUNET_OK
+      == GNUNET_DISK_directory_create (id_dir)))
   {
-    char* save_dir;
-    GNUNET_asprintf(&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
+    char *save_dir;
+    GNUNET_asprintf (&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
 
-    if ((GNUNET_YES == GNUNET_DISK_directory_test(save_dir, GNUNET_NO)) ||
-        (GNUNET_OK == GNUNET_DISK_directory_create(save_dir)))
-      GNUNET_CONTAINER_multihashmap_iterate(handle->member_ids, iterate_save_rooms, handle);
+    if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
+        (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
+      GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_save_rooms, handle);
 
     GNUNET_free(save_dir);
   }