implemented LoginRequest handler, changed ErrorMessage and ServerPublicInfoResponse

src/network/tcp-chat-protocol/v1.c

@@ -1,13 +1,55 @@
 #include "v1.h"
 
+str validateUsername_cstr(char username[USERNAME_SIZE_MAX+1], str* out_username_str){
+    // must end with 0
+    if(username[USERNAME_SIZE_MAX] != '\0'){
+        return STR("Username string doesn't end correctly");
+    }
+
+    str u = str_from_cstr(username);
+    str error_str = validateUsername_str(u);
+    if(error_str.data)
+        return error_str;
+
+    *out_username_str = u;
+    return str_null;
+}
+
+str validateUsername_str(str username){
+    if(username.size < USERNAME_SIZE_MIN){
+        return STR("Username length is too small");
+    }
+
+    for(u32 i = 0; i < username.size; i++){
+        char c = username.data[i];
+        if (char_isLatinLower(c) || 
+            char_isLatinUpper(c) ||
+            char_isDigit(c) ||
+            c == '.' || c == '_' || c == '-')
+            continue;
+        
+        return STR("Username contains restricted characters. "
+            "Allowed characters: latin, digits, ._-");
+    }
+
+    return str_null;
+}
+
 #define _PacketHeader_construct(T) \
     PacketHeader_construct(header, PROTOCOL_VERSION, PacketType_##T, sizeof(T))
 
+void ErrorMessage_construct(ErrorMessage* ptr, PacketHeader* header, u32 msg_size){
+    _PacketHeader_construct(ErrorMessage);
+    memset(ptr, 0, sizeof(*ptr));
+    ptr->msg_size = msg_size;
+}
+
 Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* header,
     Array(u8) session_key)
 {
     Deferral(1);
     _PacketHeader_construct(ClientHandshake);
+    memset(ptr, 0, sizeof(*ptr));
 
     try_assert(session_key.size == sizeof(ptr->session_key));
     memcpy(ptr->session_key, session_key.data, session_key.size);
@@ -19,6 +61,7 @@ void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
     u64 session_id)
 {
     _PacketHeader_construct(ServerHandshake);
+    memset(ptr, 0, sizeof(*ptr));
     ptr->session_id = session_id;
 }
 
@@ -26,14 +69,31 @@ void ServerPublicInfoRequest_construct(ServerPublicInfoRequest *ptr, PacketHeade
     ServerPublicInfo property)
 {
     _PacketHeader_construct(ServerPublicInfoRequest);
+    memset(ptr, 0, sizeof(*ptr));
     ptr->property = property;
 }
 
+void ServerPublicInfoResponse_construct(ServerPublicInfoResponse* ptr, PacketHeader* header,
+    u32 data_size)
+{
+    _PacketHeader_construct(ServerPublicInfoResponse);
+    memset(ptr, 0, sizeof(*ptr));
+    ptr->data_size = data_size;
+}
+
 Result(void) LoginRequest_tryConstruct(LoginRequest *ptr, PacketHeader* header,
-    Array(u8) token)
+    str username, Array(u8) token)
 {
     Deferral(1);
     _PacketHeader_construct(LoginRequest);
+    memset(ptr, 0, sizeof(*ptr));
+
+    str username_check_error = validateUsername_str(username);
+    if(username_check_error.data){
+        Return RESULT_ERROR(username_check_error.data, false);
+    }
+    memcpy(ptr->username, username.data, username.size);
+    ptr->username[username.size] = 0;
 
     try_assert(token.size == sizeof(ptr->token));
     memcpy(ptr->token, token.data, token.size);
@@ -45,6 +105,8 @@ void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
     u64 user_id, u64 landing_channel_id)
 {
     _PacketHeader_construct(LoginResponse);
+    memset(ptr, 0, sizeof(*ptr));
+
     ptr->user_id = user_id;
     ptr->landing_channel_id = landing_channel_id;
 }
@@ -54,8 +116,12 @@ Result(void) RegisterRequest_tryConstruct(RegisterRequest *ptr, PacketHeader* he
 {
     Deferral(1);
     _PacketHeader_construct(RegisterRequest);
+    memset(ptr, 0, sizeof(*ptr));
 
-    try_assert(username.size >= USERNAME_SIZE_MIN && username.size <= USERNAME_SIZE_MAX);
+    str username_check_error = validateUsername_str(username);
+    if(username_check_error.data){
+        Return RESULT_ERROR(username_check_error.data, false);
+    }
     memcpy(ptr->username, username.data, username.size);
     ptr->username[username.size] = 0;
 
@@ -69,5 +135,6 @@ void RegisterResponse_construct(RegisterResponse *ptr, PacketHeader* header,
     u64 user_id)
 {
     _PacketHeader_construct(RegisterResponse);
+    memset(ptr, 0, sizeof(*ptr));
     ptr->user_id = user_id;
 }