1 files changed, 168 insertions, 108 deletions

diff --git a/src/messenger/gnunet-service-messenger_handle.c b/src/messenger/gnunet-service-messenger_handle.c
index ddb437b7e..8d572013e 100644
--- a/src/messenger/gnunet-service-messenger_handle.c
+++ b/src/messenger/gnunet-service-messenger_handle.c
@@ -40,9 +40,10 @@ struct GNUNET_MESSENGER_SrvHandle*
 create_srv_handle (struct GNUNET_MESSENGER_Service *service,
                    struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_assert((service) && (mq));
+  GNUNET_assert ((service) && (mq));
 
-  struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct GNUNET_MESSENGER_SrvHandle);
+  struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new (struct
+                                                          GNUNET_MESSENGER_SrvHandle);
 
   handle->service = service;
   handle->mq = mq;
@@ -55,65 +56,72 @@ create_srv_handle (struct GNUNET_MESSENGER_Service *service,
   return handle;
 }
 
+
 int
 iterate_free_member_ids (void *cls,
                          const struct GNUNET_HashCode *key,
                          void *value)
 {
-  GNUNET_free(value);
+  GNUNET_free (value);
 
   return GNUNET_YES;
 }
 
+
 void
 destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  GNUNET_assert(handle);
+  GNUNET_assert (handle);
 
   if (handle->notify)
-    GNUNET_SCHEDULER_cancel(handle->notify);
+    GNUNET_SCHEDULER_cancel (handle->notify);
 
-  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids, iterate_free_member_ids, NULL);
-  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_free_member_ids, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+                                         iterate_free_member_ids, NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids,
+                                         iterate_free_member_ids, NULL);
 
   GNUNET_CONTAINER_multihashmap_destroy (handle->next_ids);
   GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);
 
-  GNUNET_free(handle);
+  GNUNET_free (handle);
 }
 
+
 void
 set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle,
                     const struct GNUNET_IDENTITY_PublicKey *key)
 {
-  GNUNET_assert(handle);
+  GNUNET_assert (handle);
 
-  if ((handle->key) && (!key))
+  if ((handle->key) && (! key))
   {
-    GNUNET_free(handle->key);
+    GNUNET_free (handle->key);
     handle->key = NULL;
   }
-  else if (!handle->key)
-    handle->key = GNUNET_new(struct GNUNET_IDENTITY_PublicKey);
+  else if (! handle->key)
+    handle->key = GNUNET_new (struct GNUNET_IDENTITY_PublicKey);
 
   if (key)
-    memcpy(handle->key, key, sizeof(struct GNUNET_IDENTITY_PublicKey));
+    memcpy (handle->key, key, sizeof(struct GNUNET_IDENTITY_PublicKey));
 }
 
+
 const struct GNUNET_IDENTITY_PublicKey*
 get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
 {
-  GNUNET_assert(handle);
+  GNUNET_assert (handle);
 
   return handle->key;
 }
 
+
 void
 get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle,
                             const char *name,
                             char **dir)
 {
-  GNUNET_assert((handle) && (dir));
+  GNUNET_assert ((handle) && (dir));
 
   if (name)
     GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
@@ -123,75 +131,88 @@ get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle,
                      DIR_SEPARATOR);
 }
 
+
 static int
 create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle,
                          const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (key));
+  GNUNET_assert ((handle) && (key));
 
-  struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
+  struct GNUNET_ShortHashCode *random_id = GNUNET_new (struct
+                                                       GNUNET_ShortHashCode);
 
-  if (!random_id)
+  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,
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
+                                                      random_id,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
   {
-    GNUNET_free(random_id);
+    GNUNET_free (random_id);
     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;
 }
 
+
 const struct GNUNET_ShortHashCode*
 get_srv_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle,
                           const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (key));
+  GNUNET_assert ((handle) && (key));
 
   return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 }
 
+
 int
 change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
                              const struct GNUNET_HashCode *key,
                              const struct GNUNET_ShortHashCode *unique_id)
 {
-  GNUNET_assert((handle) && (key) && (unique_id));
+  GNUNET_assert ((handle) && (key) && (unique_id));
 
-  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
+  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (
+    handle->member_ids, key);
 
-  if (!member_id)
+  if (! member_id)
   {
-    member_id = GNUNET_new(struct GNUNET_ShortHashCode);
-    GNUNET_memcpy(member_id, unique_id, sizeof(*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,
+    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
+                                                        member_id,
                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
     {
-      GNUNET_free(member_id);
+      GNUNET_free (member_id);
       return GNUNET_SYSERR;
     }
   }
 
-  if (0 == GNUNET_memcmp(unique_id, member_id))
+  if (0 == GNUNET_memcmp (unique_id, member_id))
     return GNUNET_OK;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (member_id),
-             GNUNET_h2s (key));
+  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_memcpy (member_id, unique_id, sizeof(*unique_id));
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n", GNUNET_sh2s (unique_id));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n",
+              GNUNET_sh2s (unique_id));
   return GNUNET_OK;
 }
 
+
 struct RoomInitializationClosure
 {
   struct GNUNET_MESSENGER_SrvHandle *handle;
@@ -206,160 +227,185 @@ find_member_session_in_room (void *cls,
 {
   struct RoomInitializationClosure *init = cls;
 
-  if (!public_key)
+  if (! public_key)
     return GNUNET_YES;
 
-  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key(init->handle);
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (
+    init->handle);
 
-  if (0 != GNUNET_memcmp(pubkey, public_key))
+  if (0 != GNUNET_memcmp (pubkey, public_key))
     return GNUNET_YES;
 
-  const struct GNUNET_ShortHashCode *id = get_member_session_id(session);
+  const struct GNUNET_ShortHashCode *id = get_member_session_id (session);
 
-  if (!id)
+  if (! id)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialitation: Missing member id!");
     return GNUNET_NO;
   }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Initialitation: Matching member found (%s)!\n",
-              GNUNET_sh2s(id));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Initialitation: Matching member found (%s)!\n",
+              GNUNET_sh2s (id));
 
-  change_srv_handle_member_id(init->handle, init->key, id);
+  change_srv_handle_member_id (init->handle, init->key, id);
   return GNUNET_NO;
 }
 
+
 static void
-initialize_srv_handle_via_matching_member (struct GNUNET_MESSENGER_SrvHandle *handle,
+initialize_srv_handle_via_matching_member (struct
+                                           GNUNET_MESSENGER_SrvHandle *handle,
                                            const struct GNUNET_HashCode *key)
 {
-  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room(handle->service, key);
-  if (!room)
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+                                                            key);
+  if (! room)
     return;
 
-  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store(room);
-  if (!store)
+  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store (room);
+  if (! store)
     return;
 
-  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key(handle);
-  if ((!pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key())))
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (handle);
+  if ((! pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key ())))
     return;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialize member id of handle via matching member in room!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initialize member id of handle via matching member in room!\n");
 
   struct RoomInitializationClosure init;
   init.handle = handle;
   init.key = key;
   init.pubkey = pubkey;
 
-  iterate_store_members(store, find_member_session_in_room, &init);
+  iterate_store_members (store, find_member_session_in_room, &init);
 }
 
+
 int
 open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
                       const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (key));
+  GNUNET_assert ((handle) && (key));
 
   initialize_srv_handle_via_matching_member (handle, key);
 
-  if ((!get_srv_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
+  if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
+                                                     create_handle_member_id (
+                                                       handle, key)))
     return GNUNET_NO;
 
   return open_service_room (handle->service, handle, key);
 }
 
+
 int
 entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
                        const struct GNUNET_PeerIdentity *door,
                        const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (door) && (key));
+  GNUNET_assert ((handle) && (door) && (key));
 
   initialize_srv_handle_via_matching_member (handle, key);
 
-  if ((!get_srv_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
+  if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
+                                                     create_handle_member_id (
+                                                       handle, key)))
     return GNUNET_NO;
 
   return entry_service_room (handle->service, handle, door, key);
 }
 
+
 int
 close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle,
                        const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (key));
+  GNUNET_assert ((handle) && (key));
 
-  GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key, iterate_free_member_ids, NULL);
+  GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key,
+                                              iterate_free_member_ids, NULL);
   GNUNET_CONTAINER_multihashmap_remove_all (handle->next_ids, key);
 
-  if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (handle->next_ids)))
+  if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
+                             handle->next_ids)))
   {
-    GNUNET_SCHEDULER_cancel(handle->notify);
+    GNUNET_SCHEDULER_cancel (handle->notify);
     handle->notify = NULL;
   }
 
-  if (!get_srv_handle_member_id (handle, key))
+  if (! get_srv_handle_member_id (handle, key))
     return GNUNET_NO;
 
   return close_service_room (handle->service, handle, key);
 }
 
+
 int
 send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
                          const struct GNUNET_HashCode *key,
                          const struct GNUNET_MESSENGER_Message *message)
 {
-  GNUNET_assert((handle) && (key) && (message));
+  GNUNET_assert ((handle) && (key) && (message));
 
-  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle, key);
+  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+                                                                    key);
 
-  if (!id)
+  if (! id)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "It is required to be a member of a room to send messages!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "It is required to be a member of a room to send messages!\n");
     return GNUNET_NO;
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
               GNUNET_sh2s (id));
 
-  if (0 != GNUNET_memcmp(id, &(message->header.sender_id)))
+  if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Member id does not match with handle!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Member id does not match with handle!\n");
     return GNUNET_NO;
   }
 
-  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service, key);
+  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service,
+                                                            key);
 
-  if (!room)
+  if (! room)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n", GNUNET_h2s (key));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
+                GNUNET_h2s (key));
     return GNUNET_NO;
   }
 
-  struct GNUNET_MESSENGER_Message *msg = copy_message(message);
+  struct GNUNET_MESSENGER_Message *msg = copy_message (message);
   return send_srv_room_message (room, handle, msg);
 }
 
+
 static const struct GNUNET_HashCode*
-get_next_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
+get_next_member_session_context (const struct
+                                 GNUNET_MESSENGER_MemberSession *session)
 {
   if (session->next)
     return get_next_member_session_context (session->next);
   else
-    return get_member_session_context(session);
+    return get_member_session_context (session);
 }
 
+
 static const struct GNUNET_MESSENGER_MemberSession*
 get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle,
                            struct GNUNET_MESSENGER_SrvRoom *room,
                            const struct GNUNET_HashCode *key)
 {
-  GNUNET_assert((handle) && (room) && (key) && (handle->service));
+  GNUNET_assert ((handle) && (room) && (key) && (handle->service));
 
-  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id(handle, key);
+  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle,
+                                                                    key);
 
-  if (!id)
+  if (! id)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Handle is missing a member id for its member session! (%s)\n",
@@ -367,12 +413,12 @@ get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle,
     return NULL;
   }
 
-  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store(room);
-  struct GNUNET_MESSENGER_Member *member = get_store_member(store, id);
+  struct GNUNET_MESSENGER_MemberStore *store = get_srv_room_member_store (room);
+  struct GNUNET_MESSENGER_Member *member = get_store_member (store, id);
 
-  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key(handle);
+  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_srv_handle_key (handle);
 
-  if (!pubkey)
+  if (! pubkey)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Handle is missing a public key for its member session! (%s)\n",
@@ -380,9 +426,10 @@ get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle,
     return NULL;
   }
 
-  return get_member_session(member, pubkey);
+  return get_member_session (member, pubkey);
 }
 
+
 void
 notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
                            struct GNUNET_MESSENGER_SrvRoom *room,
@@ -390,13 +437,14 @@ notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
                            const struct GNUNET_MESSENGER_Message *message,
                            const struct GNUNET_HashCode *hash)
 {
-  GNUNET_assert((handle) && (room) && (session) && (message) && (hash));
+  GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
 
-  const struct GNUNET_HashCode *key = get_srv_room_key(room);
+  const struct GNUNET_HashCode *key = get_srv_room_key (room);
 
-  if ((!handle->mq) || (!get_srv_handle_member_id (handle, key)))
+  if ((! handle->mq) || (! get_srv_handle_member_id (handle, key)))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Notifying client about message requires membership!\n");
     return;
   }
 
@@ -406,37 +454,40 @@ notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
   if (GNUNET_YES == is_peer_message (message))
   {
     const struct GNUNET_PeerIdentity *identity = session->peer;
-    GNUNET_CRYPTO_hash(identity, sizeof(*identity), &sender);
+    GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
 
     context = &sender;
   }
   else
   {
-    const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->member->contact);
-    GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
+    const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key (
+      session->member->contact);
+    GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
 
     context = get_next_member_session_context (session->member);
   }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Notifying client about message: %s\n", GNUNET_h2s (hash));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Notifying client about message: %s\n",
+              GNUNET_h2s (hash));
 
   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);
+  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));
+  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) GNUNET_MESSENGER_FLAG_NONE;
 
   if (GNUNET_YES == is_peer_message (message))
     msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
-  else if (get_handle_member_session(handle, room, key) == session->member)
+  else if (get_handle_member_session (handle, room, key) == session->member)
     msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
 
   char *buffer = ((char*) msg) + sizeof(*msg);
@@ -445,6 +496,7 @@ notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle,
   GNUNET_MQ_send (handle->mq, env);
 }
 
+
 static int
 iterate_next_member_ids (void *cls,
                          const struct GNUNET_HashCode *key,
@@ -456,10 +508,10 @@ iterate_next_member_ids (void *cls,
   struct GNUNET_MESSENGER_MemberMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
 
-  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
-  GNUNET_memcpy(&(msg->id), &(next->id), sizeof(next->id));
+  GNUNET_memcpy (&(msg->key), key, sizeof(*key));
+  GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
   msg->reset = (uint32_t) next->reset;
 
   GNUNET_MQ_send (handle->mq, env);
@@ -468,26 +520,30 @@ iterate_next_member_ids (void *cls,
   return GNUNET_YES;
 }
 
+
 static void
 task_notify_srv_handle_member_id (void *cls)
 {
   struct GNUNET_MESSENGER_SrvHandle *handle = cls;
   handle->notify = NULL;
 
-  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids, iterate_next_member_ids, handle);
+  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
+                                         iterate_next_member_ids, handle);
   GNUNET_CONTAINER_multihashmap_clear (handle->next_ids);
 }
 
+
 void
 notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
                              struct GNUNET_MESSENGER_SrvRoom *room,
                              const struct GNUNET_ShortHashCode *member_id,
                              enum GNUNET_GenericReturnValue reset)
 {
-  GNUNET_assert((handle) && (room) && (member_id));
+  GNUNET_assert ((handle) && (room) && (member_id));
 
-  struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct GNUNET_MESSENGER_NextMemberId);
-  if (!next)
+  struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
+                                                           GNUNET_MESSENGER_NextMemberId);
+  if (! next)
   {
     return;
   }
@@ -495,10 +551,13 @@ notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
   GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
   next->reset = reset;
 
-  const struct GNUNET_HashCode *key = get_srv_room_key(room);
+  const struct GNUNET_HashCode *key = get_srv_room_key (room);
 
-  struct GNUNET_MESSENGER_NextMemberId *prev = GNUNET_CONTAINER_multihashmap_get(handle->next_ids, key);
-  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put(handle->next_ids, key, next, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
+  struct GNUNET_MESSENGER_NextMemberId *prev =
+    GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
+  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put (handle->next_ids, key,
+                                                       next,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
   {
     return;
   }
@@ -506,6 +565,7 @@ notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle,
   if (prev)
     GNUNET_free (prev);
 
-  if (!handle->notify)
-    handle->notify = GNUNET_SCHEDULER_add_now (task_notify_srv_handle_member_id, handle);
+  if (! handle->notify)
+    handle->notify = GNUNET_SCHEDULER_add_now (task_notify_srv_handle_member_id,
+                                               handle);
 }