implemented LoginRequest handler, changed ErrorMessage and ServerPublicInfoResponse

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

@@ -21,14 +21,15 @@ Result(void) PacketHeader_validateType(PacketHeader* ptr, u16 expected_type){
 Result(void) PacketHeader_validateContentSize(PacketHeader* ptr, u64 expected_size){
     if(ptr->content_size != expected_size){
         return RESULT_ERROR_FMT(
-            "expected message with content_size " IFWIN("%llu", "%lu")
-            ", but received with content_size " IFWIN("%llu", "%lu"),
+            "expected message with content_size "FMT_u64
+            ", but received with content_size "FMT_u64,
             expected_size, ptr->content_size);
     }
     return RESULT_VOID;
 }
 
 void PacketHeader_construct(PacketHeader* ptr, u8 protocol_version, u16 type, u64 content_size){
+    memset(ptr, 0, sizeof(*ptr));
     ptr->magic.n = PacketHeader_MAGIC.n;
     ptr->protocol_version = protocol_version;
     ptr->type = type;

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;
 }

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

@@ -8,6 +8,18 @@
 
 #define ALIGN_PACKET_STRUCT ATTRIBUTE_ALIGNED(8)
 
+/*
+Valid username:
+- must end with '\0'
+- USERNAME_SIZE_MIN <= size <= USERNAME_SIZE_MAX
+- allowed characters: latin, digits, ._-
+*/
+/// validates username char[] and constructs str from it
+/// @return str_null on success, stack-allocated error message on fail
+str validateUsername_cstr(char username[USERNAME_SIZE_MAX+1], str* out_username_str) ATTRIBUTE_WARN_UNUSED_RESULT;
+
+str validateUsername_str(str username) ATTRIBUTE_WARN_UNUSED_RESULT;
+
 
 typedef enum PacketType {
     PacketType_Invalid,
@@ -23,9 +35,15 @@ typedef enum PacketType {
 } ATTRIBUTE_PACKED PacketType;
 
 
-// typedef struct ErrorMessage {
-//     /* stream of size header.content_size */
-// } ErrorMessage;
+#define ERROR_MESSAGE_MAX_SIZE 8192
+
+typedef struct ErrorMessage {
+    u32 msg_size; // <= ERROR_MESSAGE_MAX_SIZE
+    /* stream of size msg_size */
+} ErrorMessage;
+
+void ErrorMessage_construct(ErrorMessage* ptr, PacketHeader* header,
+    u32 msg_size);
 
 
 typedef struct ClientHandshake {
@@ -57,17 +75,22 @@ void ServerPublicInfoRequest_construct(ServerPublicInfoRequest* ptr, PacketHeade
     ServerPublicInfo property);
 
 
-// typedef struct ServerPublicInfoResponse {
-//     /* stream of size header.content_size */
-// } ServerPublicInfoResponse;
+typedef struct ServerPublicInfoResponse {
+    u32 data_size;
+    /* stream of size data_size */
+} ServerPublicInfoResponse;
+
+void ServerPublicInfoResponse_construct(ServerPublicInfoResponse* ptr, PacketHeader* header,
+    u32 data_size);
 
 
 typedef struct LoginRequest {
+    char username[USERNAME_SIZE_MAX + 1]; // null-terminated
     u8 token[PASSWORD_HASH_SIZE];
 } ALIGN_PACKET_STRUCT LoginRequest;
 
 Result(void) LoginRequest_tryConstruct(LoginRequest* ptr, PacketHeader* header,
-    Array(u8) token);
+    str username, Array(u8) token);
 
 
 typedef struct LoginResponse {