diff --git a/src/server/client.c b/src/server/client.c
index cc0e758..1f4261e 100644
--- a/src/server/client.c
+++ b/src/server/client.c
@@ -23,7 +23,7 @@ void client_init(client_t *client, int fd)
     memset(client, 0, sizeof *client);
     client->fd = fd;
     client->buffer[0] = '\0';
-    client->user = NULL;
+    uuid_clear(client->user);
     DEBUG_MSG("Client connected");
 }
 
diff --git a/src/server/cmds/cmd_info.c b/src/server/cmds/cmd_info.c
index 4c54c4b..297be28 100644
--- a/src/server/cmds/cmd_info.c
+++ b/src/server/cmds/cmd_info.c
@@ -16,64 +16,70 @@
 #include "ressources_infos.h"
 #include "server.h"
 
-static void info_team(client_t *client)
+static void info_team(server_t *server, client_t *client)
 {
     team_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
 
     dprintf(client->fd, "211");
     fsync(client->fd);
-    write(client->fd, team_to_info(client->team, &info), sizeof(info));
+    write(client->fd, team_to_info(team, &info), sizeof info);
 }
 
-static void info_channel(client_t *client)
+static void info_channel(server_t *server, client_t *client)
 {
     channel_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
 
     dprintf(client->fd, "212");
     fsync(client->fd);
-    write(client->fd, channel_to_info(client->channel, &info), sizeof(info));
+    write(client->fd, channel_to_info(channel, &info), sizeof info);
 }
 
-static void info_thread(client_t *client)
+static void info_thread(server_t *server, client_t *client)
 {
     thread_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
+    thread_t *thread = get_thread_by_uuid(channel, client->thread);
 
     dprintf(client->fd, "213");
     fsync(client->fd);
-    write(client->fd, thread_to_info(client->thread, &info), sizeof(info));
+    write(client->fd, thread_to_info(thread, &info), sizeof info);
 }
 
-static void info_user(client_t *client)
+static void info_user(server_t *server, client_t *client)
 {
     user_info_t info = {0};
+    user_t *user = get_user_by_uuid(server, client->user);
+    team_t *team = get_team_by_uuid(server, client->team);
 
     printf("send user info\n");
     dprintf(client->fd, "215");
     fsync(client->fd);
-    write(
-        client->fd, user_to_info(client->user, &info, client->team),
-        sizeof(info));
+    write(client->fd, user_to_info(user, &info, team), sizeof info);
 }
 
 void cmd_info(server_t *server, client_t *client)
 {
     if (!server || !client || !is_logged_in(client) || !check_context(client))
         return;
-    if (!client->team) {
-        info_user(client);
+    if (uuid_is_null(client->team)) {
+        info_user(server, client);
         return;
     }
-    if (!user_in_team(client->user->uuid, client->team)) {
+    if (!user_in_team(client->user, get_team_by_uuid(server, client->team))) {
         dprintf(client->fd, "520");
         return;
     }
-    if (!client->channel) {
-        info_team(client);
+    if (uuid_is_null(client->channel)) {
+        info_team(server, client);
         return;
     }
-    if (!client->thread) {
-        info_channel(client);
+    if (uuid_is_null(client->thread)) {
+        info_channel(server, client);
         return;
     }
-    info_thread(client);
+    info_thread(server, client);
 }
diff --git a/src/server/cmds/cmd_list.c b/src/server/cmds/cmd_list.c
index 1b0e88c..1edb511 100644
--- a/src/server/cmds/cmd_list.c
+++ b/src/server/cmds/cmd_list.c
@@ -22,76 +22,73 @@ static void list_teams(server_t *server, client_t *client)
 
     dprintf(client->fd, "221");
     fsync(client->fd);
-    write(client->fd, &server->teams.size, sizeof(server->teams.size));
-    for (size_t i = 0; i < server->teams.size; i++) {
-        write(
-            client->fd, team_to_info(&server->teams.arr[i], &info),
-            sizeof(team_info_t));
-    }
+    WRITE(client->fd, server->teams.size);
+    for (size_t i = 0; i < server->teams.size; i++)
+        WRITE(client->fd, *team_to_info(&server->teams.arr[i], &info));
 }
 
-static void list_channels(client_t *client, team_t *team)
+static void list_channels(server_t *server, client_t *client)
 {
+    team_t *team = get_team_by_uuid(server, client->team);
     channel_info_t info = {0};
 
+    if (team == NULL)
+        return;
     dprintf(client->fd, "222");
     fsync(client->fd);
-    write(client->fd, &team->channels.size, sizeof(team->channels.size));
-    for (size_t i = 0; i < team->channels.size; i++) {
-        write(
-            client->fd, channel_to_info(&team->channels.arr[i], &info),
-            sizeof(info));
-    }
+    WRITE(client->fd, team->channels.size);
+    for (size_t i = 0; i < team->channels.size; i++)
+        WRITE(client->fd, *channel_to_info(&team->channels.arr[i], &info));
 }
 
-static void list_threads(client_t *client, channel_t *channel)
+static void list_threads(server_t *server, client_t *client)
 {
     thread_info_t info = {0};
+    channel_t *channel = get_channel_by_uuid(
+        get_team_by_uuid(server, client->team), client->channel);
 
     dprintf(client->fd, "223");
     fsync(client->fd);
-    write(client->fd, &channel->threads.size, sizeof(channel->threads.size));
-    for (size_t i = 0; i < channel->threads.size; i++) {
-        write(
-            client->fd, thread_to_info(&channel->threads.arr[i], &info),
-            sizeof(info));
-    }
+    WRITE(client->fd, channel->threads.size);
+    for (size_t i = 0; i < channel->threads.size; i++)
+        WRITE(client->fd, *thread_to_info(&channel->threads.arr[i], &info));
 }
 
-static void list_replies(client_t *client, thread_t *thread, team_t *team)
+static void list_replies(server_t *server, client_t *client)
 {
     reply_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
+    thread_t *thread = get_thread_by_uuid(channel, client->thread);
 
     dprintf(client->fd, "224");
     fsync(client->fd);
-    write(client->fd, &thread->comments.size, sizeof(thread->comments.size));
-    for (size_t i = 0; i < thread->comments.size; i++) {
-        write(
+    WRITE(client->fd, thread->comments.size);
+    for (size_t i = 0; i < thread->comments.size; i++)
+        WRITE(
             client->fd,
-            comment_to_info(&thread->comments.arr[i], &info, thread, team),
-            sizeof(info));
-    }
+            *comment_to_info(&thread->comments.arr[i], &info, thread, team));
 }
 
 void cmd_list(server_t *server, client_t *client)
 {
     if (!server || !client || !is_logged_in(client) || !check_context(client))
         return;
-    if (!client->team) {
+    if (uuid_is_null(client->team)) {
         list_teams(server, client);
         return;
     }
-    if (!user_in_team(client->user->uuid, client->team)) {
+    if (!user_in_team(client->user, get_team_by_uuid(server, client->team))) {
         dprintf(client->fd, "520");
         return;
     }
-    if (!client->channel) {
-        list_channels(client, client->team);
+    if (uuid_is_null(client->channel)) {
+        list_channels(server, client);
         return;
     }
-    if (!client->thread) {
-        list_threads(client, client->channel);
+    if (uuid_is_null(client->thread)) {
+        list_threads(server, client);
         return;
     }
-    list_replies(client, client->thread, client->team);
+    list_replies(server, client);
 }
diff --git a/src/server/cmds/cmd_login.c b/src/server/cmds/cmd_login.c
index dfa5899..b4e9844 100644
--- a/src/server/cmds/cmd_login.c
+++ b/src/server/cmds/cmd_login.c
@@ -38,9 +38,9 @@ static void assign_user(client_t *client, user_t *user)
 {
     char uuid_str[UUID_STR_LEN] = {0};
 
-    client->user = user;
+    uuid_copy(client->user, user->uuid);
     uuid_unparse(user->uuid, uuid_str);
-    DEBUG("User %s <%s> logged", client->user->name, uuid_str);
+    DEBUG("User %s <%s> logged", user->name, uuid_str);
     server_event_user_logged_in(uuid_str);
 }
 
@@ -64,10 +64,9 @@ void cmd_login(server_t *server, client_t *client)
         return;
     }
     user = get_user_by_name(server, name);
-    if (!user)
+    if (user == NULL)
         user = create_user(server, name);
     assign_user(client, user);
-    client->user->status += 1;
-    broadcast(
-        server, "311", user_to_info(client->user, &info, NULL), sizeof info);
+    user->status += 1;
+    broadcast(server, "311", user_to_info(user, &info, NULL), sizeof info);
 }
diff --git a/src/server/cmds/cmd_logout.c b/src/server/cmds/cmd_logout.c
index ee0c0e5..23951c4 100644
--- a/src/server/cmds/cmd_logout.c
+++ b/src/server/cmds/cmd_logout.c
@@ -18,17 +18,18 @@ void cmd_logout(server_t *server, client_t *client)
 {
     char uuid_str[UUID_STR_LEN] = {0};
     user_info_t info = {0};
+    user_t *user = NULL;
 
-    if (client->user == NULL)
+    if (uuid_is_null(client->user))
         return;
-    client->user->status = client->user->status - 1;
-    printf("-->%d\n", client->user->status);
-    client->user->status -= 1;
-    if (client->user->status < 0)
-        client->user->status = 0;
-    uuid_unparse(client->user->uuid, uuid_str);
+    user = get_user_by_uuid(server, client->user);
+    if (user == NULL)
+        return;
+    user->status -= 1;
+    if (user->status < 0)
+        user->status = 0;
+    uuid_unparse(user->uuid, uuid_str);
     server_event_user_logged_out(uuid_str);
-    broadcast(
-        server, "312", user_to_info(client->user, &info, NULL), sizeof info);
-    client->user = NULL;
+    broadcast(server, "312", user_to_info(user, &info, NULL), sizeof info);
+    uuid_clear(client->user);
 }
diff --git a/src/server/cmds/cmd_subscribe.c b/src/server/cmds/cmd_subscribe.c
index 0f78336..f0266cf 100644
--- a/src/server/cmds/cmd_subscribe.c
+++ b/src/server/cmds/cmd_subscribe.c
@@ -29,17 +29,18 @@ static team_t *get_team(server_t *server, client_t *client, char *uuid_str)
     return NULL;
 }
 
-static void send_message(client_t *client, team_t *team)
+static void send_message(server_t *server, client_t *client, team_t *team)
 {
     user_info_t info = {0};
     char team_uuid[UUID_STR_LEN] = {0};
     char user_uuid[UUID_STR_LEN] = {0};
+    user_t *user = get_user_by_uuid(server, client->user);
 
-    uuid_unparse(client->user->uuid, user_uuid);
+    uuid_unparse(client->user, user_uuid);
     uuid_unparse(team->uuid, team_uuid);
     server_event_user_subscribed(team_uuid, user_uuid);
     write(client->fd, "215", 3);
-    write(client->fd, user_to_info(client->user, &info, team), sizeof info);
+    WRITE(client->fd, *user_to_info(user, &info, team));
 }
 
 void cmd_subscribe(server_t *server, client_t *client)
@@ -57,8 +58,8 @@ void cmd_subscribe(server_t *server, client_t *client)
     team = get_team(server, client, arg);
     if (!team)
         return;
-    if (user_in_team(client->user->uuid, team))
+    if (user_in_team(client->user, team))
         return;
-    append_to_array(&team->users, sizeof(uuid_t), client->user->uuid);
-    send_message(client, team);
+    append_to_array(&team->users, sizeof(uuid_t), client->user);
+    send_message(server, client, team);
 }
diff --git a/src/server/cmds/cmd_subscribed.c b/src/server/cmds/cmd_subscribed.c
index a2e9d5b..ae3a063 100644
--- a/src/server/cmds/cmd_subscribed.c
+++ b/src/server/cmds/cmd_subscribed.c
@@ -44,7 +44,7 @@ static size_t count_teams(server_t *server, client_t *client)
     size_t nb = 0;
 
     for (size_t i = 0; i < server->teams.size; i++) {
-        if (user_in_team(client->user->uuid, &server->teams.arr[i]))
+        if (user_in_team(client->user, &server->teams.arr[i]))
             nb += 1;
     }
     return nb;
@@ -57,14 +57,10 @@ static void list_subscribed_team(server_t *server, client_t *client)
 
     dprintf(client->fd, "221");
     fsync(client->fd);
-    write(client->fd, &nb, sizeof(nb));
-    for (size_t i = 0; i < server->teams.size; i++) {
-        if (!user_in_team(client->user->uuid, &server->teams.arr[i]))
-            continue;
-        write(
-            client->fd, team_to_info(&server->teams.arr[i], &info),
-            sizeof(team_info_t));
-    }
+    WRITE(client->fd, nb);
+    for (size_t i = 0; i < server->teams.size; i++)
+        if (user_in_team(client->user, &server->teams.arr[i]))
+            WRITE(client->fd, *team_to_info(&server->teams.arr[i], &info));
 }
 
 static void list_subscribed_users(
@@ -74,14 +70,11 @@ static void list_subscribed_users(
 
     dprintf(client->fd, "225");
     fsync(client->fd);
-    write(client->fd, &team->users.size, sizeof(team->users.size));
-    for (size_t i = 0; i < server->users.size; i++) {
-        if (!user_in_team(server->users.arr[i].uuid, team))
-            continue;
-        write(
-            client->fd, user_to_info(&server->users.arr[i], &info, team),
-            sizeof(user_info_t));
-    }
+    WRITE(client->fd, team->users.size);
+    for (size_t i = 0; i < server->users.size; i++)
+        if (user_in_team(server->users.arr[i].uuid, team))
+            WRITE(
+                client->fd, *user_to_info(&server->users.arr[i], &info, team));
 }
 
 void cmd_subscribed(server_t *server, client_t *client)
diff --git a/src/server/cmds/cmd_unsubscribe.c b/src/server/cmds/cmd_unsubscribe.c
index cb4a06c..f67449d 100644
--- a/src/server/cmds/cmd_unsubscribe.c
+++ b/src/server/cmds/cmd_unsubscribe.c
@@ -30,23 +30,26 @@ static team_t *get_team(server_t *server, client_t *client, char *uuid_str)
     return NULL;
 }
 
-static void send_message(client_t *client, team_t *team)
+static void send_message(server_t *server, client_t *client, team_t *team)
 {
     user_info_t info = {0};
     char team_uuid[UUID_STR_LEN] = {0};
     char user_uuid[UUID_STR_LEN] = {0};
+    user_t *user = get_user_by_uuid(server, client->user);
 
-    uuid_unparse(client->user->uuid, user_uuid);
+    if (user == NULL)
+        return;
+    uuid_unparse(client->user, user_uuid);
     uuid_unparse(team->uuid, team_uuid);
     server_event_user_unsubscribed(team_uuid, user_uuid);
     write(client->fd, "215", 3);
-    write(client->fd, user_to_info(client->user, &info, team), sizeof info);
+    write(client->fd, user_to_info(user, &info, team), sizeof info);
 }
 
 static void remove_user(client_t *client, team_t *team)
 {
     for (size_t i = 0; i < team->users.size; i++) {
-        if (uuid_compare(client->user->uuid, team->users.arr[i]) == 0) {
+        if (uuid_compare(client->user, team->users.arr[i]) == 0) {
             uuid_copy(
                 team->users.arr[i], team->users.arr[team->users.size - 1]);
             team->users.size -= 1;
@@ -68,10 +71,8 @@ void cmd_unsubscribe(server_t *server, client_t *client)
         return;
     }
     team = get_team(server, client, arg);
-    if (!team)
-        return;
-    if (!user_in_team(client->user->uuid, team))
+    if (team == NULL || !user_in_team(client->user, team))
         return;
     remove_user(client, team);
-    send_message(client, team);
+    send_message(server, client, team);
 }
diff --git a/src/server/cmds/cmd_use.c b/src/server/cmds/cmd_use.c
index a8dbe42..e722d17 100644
--- a/src/server/cmds/cmd_use.c
+++ b/src/server/cmds/cmd_use.c
@@ -14,77 +14,43 @@
 #include "debug.h"
 #include "server.h"
 
-static void set_team(server_t *server, client_t *client, char **ptr)
+static void parse_uuid(char **ptr, uuid_t *target)
 {
     size_t end = 0;
     uuid_t uuid = {0};
 
+    uuid_clear(*target);
     *ptr = get_quoted_arg(*ptr, 0, &end);
     if (*ptr == NULL)
         return;
     uuid_parse(*ptr, uuid);
     *ptr += end + 1;
-    memcpy(client->uuid.team, uuid, sizeof uuid);
-    if (uuid_is_null(client->uuid.team))
-        client->uuid.team[0] = 1;
-    client->team = get_team_by_uuid(server, uuid);
-}
-
-static void set_channel(UNUSED server_t *server, client_t *client, char **ptr)
-{
-    size_t end = 0;
-    uuid_t uuid = {0};
-
-    *ptr = get_quoted_arg(*ptr, 0, &end);
-    if (*ptr == NULL)
-        return;
-    uuid_parse(*ptr, uuid);
-    *ptr += end + 1;
-    memcpy(client->uuid.channel, uuid, sizeof uuid);
-    if (client->team != NULL)
-        client->channel = get_channel_by_uuid(client->team, uuid);
-}
-
-static void set_thread(UNUSED server_t *server, client_t *client, char **ptr)
-{
-    size_t end = 0;
-    uuid_t uuid = {0};
-
-    *ptr = get_quoted_arg(*ptr, 0, &end);
-    if (*ptr == NULL)
-        return;
-    uuid_parse(*ptr, uuid);
-    *ptr += end + 1;
-    memcpy(client->uuid.thread, uuid, sizeof uuid);
-    if (client->channel != NULL)
-        client->thread = get_thread_by_uuid(client->channel, uuid);
+    uuid_copy(*target, uuid);
+    if (uuid_is_null(*target))
+        uuid_copy(*target, INVALID_UUID);
 }
 
 DEBUG_USED static void debug_cmd_use(client_t *client)
 {
     char uuid[UUID_STR_LEN] = {0};
 
-    uuid_unparse(client->uuid.team, uuid);
+    uuid_unparse(client->team, uuid);
     DEBUG("Team: (%s) %p", uuid, (void *)client->team);
-    uuid_unparse(client->uuid.channel, uuid);
+    uuid_unparse(client->channel, uuid);
     DEBUG("Channel: (%s) %p", uuid, (void *)client->channel);
-    uuid_unparse(client->uuid.thread, uuid);
+    uuid_unparse(client->thread, uuid);
     DEBUG("Thread: (%s) %p", uuid, (void *)client->thread);
 }
 
-void cmd_use(server_t *server, client_t *client)
+void cmd_use(UNUSED server_t *server, client_t *client)
 {
     char *ptr = NULL;
 
     if (!is_logged_in(client))
         return;
     ptr = client->buffer;
-    memset(&client->uuid, 0, sizeof client->uuid);
-    client->team = NULL;
-    client->channel = NULL;
-    client->thread = NULL;
-    set_team(server, client, &ptr);
-    set_channel(server, client, &ptr);
-    set_thread(server, client, &ptr);
+    parse_uuid(&ptr, &client->team);
+    parse_uuid(&ptr, &client->channel);
+    parse_uuid(&ptr, &client->thread);
     DEBUG_DO(debug_cmd_use(client));
 }
diff --git a/src/server/cmds/cmds_utils.c b/src/server/cmds/cmds_utils.c
index 98212d0..b5b2cd6 100644
--- a/src/server/cmds/cmds_utils.c
+++ b/src/server/cmds/cmds_utils.c
@@ -37,9 +37,13 @@ char *get_quoted_arg(char *buff, size_t start, size_t *end)
 
 void broadcast(server_t *server, char *code, void *msg, size_t size)
 {
+    if (server == NULL || code == NULL || msg == NULL)
+        return;
+    DEBUG_MSG("Broadcasting message");
     for (size_t i = 0; i < server->clients.size; i++) {
         if (server->clients.arr[i].fd == -1)
             continue;
+        DEBUG("Broadcasting to fd %d", server->clients.arr[i].fd);
         write(server->clients.arr[i].fd, code, strlen(code));
         write(server->clients.arr[i].fd, msg, size);
     }
@@ -47,6 +51,8 @@ void broadcast(server_t *server, char *code, void *msg, size_t size)
 
 bool user_in_team(uuid_t uuid, team_t *team)
 {
+    if (team == NULL)
+        return false;
     for (size_t i = 0; i < team->users.size; i++) {
         if (uuid_compare(team->users.arr[i], uuid) == 0)
             return true;
@@ -56,7 +62,9 @@ bool user_in_team(uuid_t uuid, team_t *team)
 
 bool is_logged_in(client_t *client)
 {
-    if (!client->user) {
+    if (client == NULL)
+        return false;
+    if (uuid_is_null(client->user)) {
         dprintf(client->fd, "520\n");
         return false;
     }
@@ -75,21 +83,28 @@ static bool send_unknow_error(client_t *client, char type, uuid_t uuid)
     return false;
 }
 
+static bool uuid_is_invalid(uuid_t uuid)
+{
+    return uuid_compare(uuid, INVALID_UUID) == 0;
+}
+
 bool check_context(client_t *client)
 {
-    if (!client->team) {
-        if (!uuid_is_null(client->uuid.team))
-            return send_unknow_error(client, '1', client->uuid.team);
+    if (client == NULL)
+        return false;
+    if (uuid_is_null(client->team)) {
+        if (uuid_is_invalid(client->team))
+            return send_unknow_error(client, '1', client->team);
         return true;
     }
-    if (!client->channel) {
-        if (!uuid_is_null(client->uuid.channel))
-            return send_unknow_error(client, '2', client->uuid.channel);
+    if (uuid_is_null(client->channel)) {
+        if (uuid_is_invalid(client->channel))
+            return send_unknow_error(client, '2', client->channel);
         return true;
     }
-    if (!client->thread) {
-        if (!uuid_is_null(client->uuid.thread))
-            return send_unknow_error(client, '3', client->uuid.thread);
+    if (uuid_is_null(client->thread)) {
+        if (uuid_is_invalid(client->thread))
+            return send_unknow_error(client, '3', client->thread);
         return true;
     }
     return true;
diff --git a/src/server/cmds/cmds_utils.h b/src/server/cmds/cmds_utils.h
index a28df16..cb5a442 100644
--- a/src/server/cmds/cmds_utils.h
+++ b/src/server/cmds/cmds_utils.h
@@ -8,9 +8,14 @@
 #pragma once
 
 #include <uuid/uuid.h>
+
 #include "ressources_infos.h"
 #include "server.h"
 
+#define WRITE(fd, v) write(fd, &(v), sizeof(v))
+
+static const uuid_t INVALID_UUID = {1};
+
 bool user_in_team(uuid_t uuid, team_t *team);
 void broadcast(server_t *server, char *code, void *msg, size_t size);
 char *get_quoted_arg(char *buff, size_t start, size_t *end);
diff --git a/src/server/cmds/create/cmd_create.c b/src/server/cmds/create/cmd_create.c
index 069a3a4..0a87870 100644
--- a/src/server/cmds/create/cmd_create.c
+++ b/src/server/cmds/create/cmd_create.c
@@ -22,20 +22,24 @@ static void send_to_users(server_t *server, team_t *team, reply_info_t *info)
 {
     for (size_t i = 0; i < server->clients.size; i++) {
         if (server->clients.arr[i].fd == -1 ||
-            !user_in_team(server->clients.arr[i].user->uuid, team))
+            !user_in_team(server->clients.arr[i].user, team))
             continue;
         write(server->clients.arr[i].fd, "344", 3);
         write(server->clients.arr[i].fd, info, sizeof(*info));
     }
 }
 
-static void message_user(client_t *client, comment_t *comm)
+static void message_user(server_t *server, client_t *client, comment_t *comm)
 {
     char thread_uuid[UUID_STR_LEN] = {0};
     char user_uuid[UUID_STR_LEN] = {0};
+    user_t *user = get_user_by_uuid(server, client->user);
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
+    thread_t *thread = get_thread_by_uuid(channel, client->thread);
 
-    uuid_unparse(client->thread->thread_uuid, thread_uuid);
-    uuid_unparse(client->user->uuid, user_uuid);
+    uuid_unparse(thread->thread_uuid, thread_uuid);
+    uuid_unparse(user->uuid, user_uuid);
     server_event_reply_created(thread_uuid, user_uuid, comm->message);
 }
 
@@ -44,17 +48,20 @@ static void create_new_reply(
 {
     comment_t comment = {0};
     reply_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
+    thread_t *thread = get_thread_by_uuid(channel, client->thread);
 
-    if (!body)
+    if (body == NULL)
         return;
-    uuid_copy(comment.author_uuid, client->user->uuid);
+    uuid_copy(comment.author_uuid, client->user);
     strcpy(comment.message, body);
-    append_to_array(&client->thread->comments, sizeof(comment_t), &comment);
+    append_to_array(&thread->comments, sizeof comment, &comment);
     write(client->fd, "214", 3);
-    comment_to_info(&comment, &info, client->thread, client->team);
-    write(client->fd, &info, sizeof(info));
-    message_user(client, &comment);
-    send_to_users(server, client->team, &info);
+    comment_to_info(&comment, &info, thread, team);
+    write(client->fd, &info, sizeof info);
+    message_user(server, client, &comment);
+    send_to_users(server, team, &info);
 }
 
 static void create_reply(UNUSED server_t *server, UNUSED client_t *client)
@@ -74,21 +81,18 @@ void cmd_create(server_t *server, client_t *client)
 {
     if (!server || !client || !is_logged_in(client) || !check_context(client))
         return;
-    if (!client->team) {
+    if (uuid_is_null(client->team)) {
         create_teams(server, client);
         return;
     }
-    if (!user_in_team(client->user->uuid, client->team)) {
+    if (!user_in_team(client->user, get_team_by_uuid(server, client->team))) {
         dprintf(client->fd, "520");
         return;
     }
-    if (!client->channel) {
+    if (uuid_is_null(client->channel))
         create_channel(server, client);
-        return;
-    }
-    if (!client->thread) {
+    else if (uuid_is_null(client->thread))
         create_thread(server, client);
-        return;
-    }
-    create_reply(server, client);
+    else
+        create_reply(server, client);
 }
diff --git a/src/server/cmds/create/create_channel.c b/src/server/cmds/create/create_channel.c
index 63e8ce2..d2cdc5d 100644
--- a/src/server/cmds/create/create_channel.c
+++ b/src/server/cmds/create/create_channel.c
@@ -21,7 +21,7 @@ static void send_to_users(server_t *server, team_t *team, channel_info_t *info)
 {
     for (size_t i = 0; i < server->clients.size; i++) {
         if (server->clients.arr[i].fd == -1 ||
-            !user_in_team(server->clients.arr[i].user->uuid, team))
+            !user_in_team(server->clients.arr[i].user, team))
             continue;
         write(server->clients.arr[i].fd, "342", 3);
         write(server->clients.arr[i].fd, info, sizeof(*info));
@@ -36,6 +36,7 @@ static void create_new_channel(
     char chan_uuid[UUID_STR_LEN] = {0};
     char team_uuid[UUID_STR_LEN] = {0};
     channel_info_t info = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
 
     if (!name || !description)
         return;
@@ -43,12 +44,12 @@ static void create_new_channel(
     strcpy(new_chan.description, description);
     uuid_generate(new_chan.uuid);
     uuid_unparse(new_chan.uuid, chan_uuid);
-    uuid_unparse(client->team->uuid, team_uuid);
-    append_to_array(&client->team->channels, sizeof(channel_t), &new_chan);
+    uuid_unparse(client->team, team_uuid);
+    append_to_array(&team->channels, sizeof new_chan, &new_chan);
     server_event_channel_created(team_uuid, chan_uuid, new_chan.name);
     write(client->fd, "212", 3);
     write(client->fd, channel_to_info(&new_chan, &info), sizeof(info));
-    send_to_users(server, client->team, &info);
+    send_to_users(server, team, &info);
 }
 
 static bool channel_already_exist(team_t *team, client_t *client, char *name)
@@ -67,10 +68,11 @@ void create_channel(server_t *server, client_t *client)
     char *name = NULL;
     char *description = NULL;
     size_t arg_pos = 0;
+    team_t *team = get_team_by_uuid(server, client->team);
 
     name = get_quoted_arg(client->buffer, 0, &arg_pos);
     arg_pos += 1;
-    if (name && channel_already_exist(client->team, client, name))
+    if (name && channel_already_exist(team, client, name))
         return;
     if (name) {
         description = get_quoted_arg(client->buffer, arg_pos, &arg_pos);
diff --git a/src/server/cmds/create/create_team.c b/src/server/cmds/create/create_team.c
index 413f49f..af1228e 100644
--- a/src/server/cmds/create/create_team.c
+++ b/src/server/cmds/create/create_team.c
@@ -32,7 +32,7 @@ static void create_new_team(
     strcpy(new_team.description, description);
     uuid_generate(new_team.uuid);
     uuid_unparse(new_team.uuid, team_uuid_str);
-    uuid_unparse(client->user->uuid, client_uuid_str);
+    uuid_unparse(client->user, client_uuid_str);
     append_to_array(&server->teams, sizeof(team_t), &new_team);
     server_event_team_created(team_uuid_str, new_team.name, client_uuid_str);
     team_to_info(&new_team, &info);
diff --git a/src/server/cmds/create/create_thread.c b/src/server/cmds/create/create_thread.c
index b11d085..774e5ba 100644
--- a/src/server/cmds/create/create_thread.c
+++ b/src/server/cmds/create/create_thread.c
@@ -18,11 +18,14 @@
 #include "ressources_infos.h"
 #include "server.h"
 
-static void send_to_users(server_t *server, team_t *team, thread_info_t *info)
+static void send_to_users(
+    server_t *server, uuid_t team_uuid, thread_info_t *info)
 {
+    team_t *team = get_team_by_uuid(server, team_uuid);
+
     for (size_t i = 0; i < server->clients.size; i++) {
         if (server->clients.arr[i].fd == -1 ||
-            !user_in_team(server->clients.arr[i].user->uuid, team))
+            !user_in_team(server->clients.arr[i].user, team))
             continue;
         write(server->clients.arr[i].fd, "343", 3);
         write(server->clients.arr[i].fd, info, sizeof(*info));
@@ -37,8 +40,8 @@ static void send_messages(server_t *server, client_t *client, thread_t *thread)
     char user_uuid[UUID_STR_LEN] = {0};
 
     uuid_unparse(thread->thread_uuid, thread_uuid);
-    uuid_unparse(client->channel->uuid, channel_uuid);
-    uuid_unparse(client->user->uuid, user_uuid);
+    uuid_unparse(client->channel, channel_uuid);
+    uuid_unparse(client->user, user_uuid);
     server_event_thread_created(
         channel_uuid, thread_uuid, user_uuid, thread->title, thread->body);
     write(client->fd, "213", 3);
@@ -51,6 +54,8 @@ static void create_new_thread(
     const char description[])
 {
     thread_t thread = {0};
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
 
     if (!name || !description)
         return;
@@ -58,14 +63,17 @@ static void create_new_thread(
     strcpy(thread.title, name);
     strcpy(thread.body, description);
     uuid_generate(thread.thread_uuid);
-    uuid_copy(thread.author_uuid, client->user->uuid);
-    append_to_array(&client->channel->threads, sizeof(thread_t), &thread);
+    uuid_copy(thread.author_uuid, client->user);
+    append_to_array(&channel->threads, sizeof(thread_t), &thread);
     send_messages(server, client, &thread);
 }
 
 static bool thread_already_exist(
-    channel_t *channel, client_t *client, char *name)
+    server_t *server, client_t *client, char *name)
 {
+    team_t *team = get_team_by_uuid(server, client->team);
+    channel_t *channel = get_channel_by_uuid(team, client->channel);
+
     for (size_t i = 0; name && i < channel->threads.size; i++) {
         if (strcmp(name, channel->threads.arr[i].title) == 0) {
             dprintf(client->fd, "530\n");
@@ -83,7 +91,7 @@ void create_thread(server_t *server, client_t *client)
 
     name = get_quoted_arg(client->buffer, 0, &arg_pos);
     arg_pos += 1;
-    if (name && thread_already_exist(client->channel, client, name))
+    if (name && thread_already_exist(server, client, name))
         return;
     if (name) {
         description = get_quoted_arg(client->buffer, arg_pos, &arg_pos);
diff --git a/src/server/cmds/struct_to_info.c b/src/server/cmds/struct_to_info.c
index e7c1992..d690d67 100644
--- a/src/server/cmds/struct_to_info.c
+++ b/src/server/cmds/struct_to_info.c
@@ -22,7 +22,7 @@ user_info_t *user_to_info(user_t *user, user_info_t *info, team_t *team)
         info->status = 1;
     strcpy(info->name, user->name);
     uuid_copy(info->user_uuid, user->uuid);
-    if (team)
+    if (team != NULL)
         uuid_copy(info->team_uuid, team->uuid);
     return info;
 }
@@ -65,7 +65,7 @@ thread_info_t *thread_to_info(thread_t *thread, thread_info_t *info)
 reply_info_t *comment_to_info(
     comment_t *reply, reply_info_t *info, thread_t *thread, team_t *team)
 {
-    if (reply == NULL || info == NULL)
+    if (reply == NULL || info == NULL || thread == NULL || team == NULL)
         return NULL;
     memset(info, 0, sizeof *info);
     strcpy(info->body, reply->message);
diff --git a/src/server/getters.c b/src/server/getters.c
index 0f66557..1118d48 100644
--- a/src/server/getters.c
+++ b/src/server/getters.c
@@ -14,8 +14,10 @@ user_t *get_user_by_uuid(server_t *server, uuid_t uuid)
 {
     user_t *user = NULL;
 
-    for (size_t i = 0; i < server->clients.size; i++) {
-        user = server->clients.arr[i].user;
+    if (server == NULL)
+        return NULL;
+    for (size_t i = 0; i < server->users.size; i++) {
+        user = &server->users.arr[i];
         if (user != NULL && uuid_compare(user->uuid, uuid) == 0)
             return user;
     }
@@ -26,6 +28,8 @@ team_t *get_team_by_uuid(server_t *server, uuid_t uuid)
 {
     team_t *team = NULL;
 
+    if (server == NULL)
+        return NULL;
     for (size_t i = 0; i < server->teams.size; i++) {
         team = &server->teams.arr[i];
         if (uuid_compare(team->uuid, uuid) == 0)
@@ -38,6 +42,8 @@ channel_t *get_channel_by_uuid(team_t *team, uuid_t uuid)
 {
     channel_t *channel = NULL;
 
+    if (team == NULL)
+        return NULL;
     for (size_t i = 0; i < team->channels.size; i++) {
         channel = &team->channels.arr[i];
         if (uuid_compare(channel->uuid, uuid) == 0)
@@ -50,6 +56,8 @@ thread_t *get_thread_by_uuid(channel_t *channel, uuid_t uuid)
 {
     thread_t *thread = NULL;
 
+    if (channel == NULL)
+        return NULL;
     for (size_t i = 0; i < channel->threads.size; i++) {
         thread = &channel->threads.arr[i];
         if (uuid_compare(thread->thread_uuid, uuid) == 0)
diff --git a/src/server/server.h b/src/server/server.h
index 33025ce..8fc02a3 100644
--- a/src/server/server.h
+++ b/src/server/server.h
@@ -82,16 +82,11 @@ typedef struct {
     int fd;
     struct sockaddr_in addr;
     socklen_t len;
-    user_t *user;
+    uuid_t user;
     char buffer[BUFSIZ];
-    team_t *team;
-    channel_t *channel;
-    thread_t *thread;
-    struct {
-        uuid_t team;
-        uuid_t channel;
-        uuid_t thread;
-    } uuid;
+    uuid_t team;
+    uuid_t channel;
+    uuid_t thread;
 } client_t;
 
 typedef struct {