added new packet types

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

@@ -9,6 +9,25 @@ Result(void) PacketHeader_validateMagic(PacketHeader* ptr){
     return RESULT_VOID;
 }
 
+Result(void) PacketHeader_validateType(PacketHeader* ptr, u16 expected_type){
+    if(ptr->type != expected_type){
+        return RESULT_ERROR_FMT(
+            "expected message of type %u, but received of type %u",
+            expected_type, ptr->type);
+    }
+    return RESULT_VOID;
+}
+
+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_size, ptr->content_size);
+    }
+    return RESULT_VOID;
+}
+
 void PacketHeader_construct(PacketHeader* ptr, u8 protocol_version, u16 type, u64 content_size){
     ptr->magic.n = PacketHeader_MAGIC.n;
     ptr->protocol_version = protocol_version;

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

@@ -14,7 +14,9 @@ typedef struct PacketHeader {
     u16 type;
     u32 _reserved4;
     u64 content_size;
-} __attribute__((aligned(64))) PacketHeader;
+} ATTRIBUTE_ALIGNED(64) PacketHeader;
 
 void PacketHeader_construct(PacketHeader* ptr, u8 protocol_version, u16 type, u64 content_size);
 Result(void) PacketHeader_validateMagic(PacketHeader* ptr);
+Result(void) PacketHeader_validateType(PacketHeader* ptr, u16 expected_type);
+Result(void) PacketHeader_validateContentSize(PacketHeader* ptr, u64 expected_size);

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

@@ -1,9 +1,73 @@
 #include "v1.h"
 
-void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key){
-    memcpy(ptr->session_key, session_key.data, sizeof(ptr->session_key));
+#define _PacketHeader_construct(T) \
+    PacketHeader_construct(header, PROTOCOL_VERSION, PacketType_##T, sizeof(T))
+
+Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* header,
+    Array(u8) session_key)
+{
+    Deferral(1);
+    _PacketHeader_construct(ClientHandshake);
+
+    try_assert(session_key.size == sizeof(ptr->session_key));
+    memcpy(ptr->session_key, session_key.data, session_key.size);
+
+    Return RESULT_VOID;
 }
 
-void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id){
+void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
+    u64 session_id)
+{
+    _PacketHeader_construct(ServerHandshake);
     ptr->session_id = session_id;
 }
+
+void ServerPublicInfoRequest_construct(ServerPublicInfoRequest *ptr, PacketHeader* header,
+    ServerPublicInfo property)
+{
+    _PacketHeader_construct(ServerPublicInfoRequest);
+    ptr->property = property;
+}
+
+Result(void) LoginRequest_tryConstruct(LoginRequest *ptr, PacketHeader* header,
+    Array(u8) token)
+{
+    Deferral(1);
+    _PacketHeader_construct(LoginRequest);
+
+    try_assert(token.size == sizeof(ptr->token));
+    memcpy(ptr->token, token.data, token.size);
+
+    Return RESULT_VOID;
+}
+
+void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
+    u64 user_id, u64 landing_channel_id)
+{
+    _PacketHeader_construct(LoginResponse);
+    ptr->user_id = user_id;
+    ptr->landing_channel_id = landing_channel_id;
+}
+
+Result(void) RegisterRequest_tryConstruct(RegisterRequest *ptr, PacketHeader* header,
+    str username, Array(u8) token)
+{
+    Deferral(1);
+    _PacketHeader_construct(RegisterRequest);
+
+    try_assert(username.size >= USERNAME_SIZE_MIN && username.size <= USERNAME_SIZE_MAX);
+    ptr->username_size = username.size;
+    memcpy(ptr->username, username.data, username.size);
+
+    try_assert(token.size == sizeof(ptr->token));
+    memcpy(ptr->token, token.data, token.size);
+
+    Return RESULT_VOID;
+}
+
+void RegisterResponse_construct(RegisterResponse *ptr, PacketHeader* header,
+    u64 user_id)
+{
+    _PacketHeader_construct(RegisterResponse);
+    ptr->user_id = user_id;
+}

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

@@ -1,32 +1,105 @@
 #pragma once
 #include "tlibc/errors.h"
+#include "tlibc/string/str.h"
 #include "network/tcp-chat-protocol/constant.h"
+#include "cryptography/cryptography.h"
 
 #define PROTOCOL_VERSION 1 /* 1.0.0 */
 #define NETWORK_BUFFER_SIZE 65536
 
+#define ALIGN_PACKET_STRUCT ATTRIBUTE_ALIGNED(8)
+
+
 typedef enum PacketType {
     PacketType_Invalid,
     PacketType_ErrorMessage,
     PacketType_ClientHandshake,
     PacketType_ServerHandshake,
-} __attribute__((__packed__)) PacketType;
+    PacketType_ServerPublicInfoRequest,
+    PacketType_ServerPublicInfoResponse,
+    PacketType_LoginRequest,
+    PacketType_LoginResponse,
+    PacketType_RegisterRequest,
+    PacketType_RegisterResponse,
+} ATTRIBUTE_PACKED PacketType;
 
 
-typedef struct ErrorMessage {
-    /* content stream of size `header.content_size` */
-} ErrorMessage;
+// typedef struct ErrorMessage {
+//     /* stream of size header.content_size */
+// } ErrorMessage;
 
 
 typedef struct ClientHandshake {
     u8 session_key[AES_SESSION_KEY_SIZE];
-} ClientHandshake;
+} ALIGN_PACKET_STRUCT ClientHandshake;
 
-void ClientHandshake_construct(ClientHandshake* ptr, Array(u8) session_key);
+Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* header,
+    Array(u8) session_key);
 
 
 typedef struct ServerHandshake {
     u64 session_id;
-} ServerHandshake;
+} ALIGN_PACKET_STRUCT ServerHandshake;
+
+void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
+    u64 session_id);
+
+
+typedef enum ServerPublicInfo {
+    ServerPublicInfo_Name,
+    ServerPublicInfo_Description,
+} ATTRIBUTE_PACKED ServerPublicInfo;
+
+typedef struct ServerPublicInfoRequest {
+    u32 property;
+} ALIGN_PACKET_STRUCT ServerPublicInfoRequest;
+
+void ServerPublicInfoRequest_construct(ServerPublicInfoRequest* ptr, PacketHeader* header,
+    ServerPublicInfo property);
+
+
+// typedef struct ServerPublicInfoResponse {
+//     /* stream of size header.content_size */
+// } ServerPublicInfoResponse;
+
+
+typedef struct LoginRequest {
+    u8 token[PASSWORD_HASH_SIZE];
+} ALIGN_PACKET_STRUCT LoginRequest;
+
+Result(void) LoginRequest_tryConstruct(LoginRequest* ptr, PacketHeader* header,
+    Array(u8) token);
+
+
+typedef struct LoginResponse {
+    u64 user_id;
+    u64 landing_channel_id;
+} ALIGN_PACKET_STRUCT LoginResponse;
+
+void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
+    u64 user_id, u64 landing_channel_id);
+
+
+#define USERNAME_SIZE_MIN 4
+#define USERNAME_SIZE_MAX 64
+#define PASSWORD_SIZE_MIN 8
+#define PASSWORD_SIZE_MAX 32
+
+typedef struct RegisterRequest {
+    u32 username_size;
+    char username[USERNAME_SIZE_MAX];
+    u8 token[PASSWORD_HASH_SIZE];
+} ALIGN_PACKET_STRUCT RegisterRequest;
+
+Result(void) RegisterRequest_tryConstruct(RegisterRequest* ptr, PacketHeader* header,
+    str username, Array(u8) token);
+
+
+typedef struct RegisterResponse {
+    u64 user_id;
+} ALIGN_PACKET_STRUCT RegisterResponse;
+
+void RegisterResponse_construct(RegisterResponse* ptr, PacketHeader* header,
+    u64 user_id);
+
 
-void ServerHandshake_construct(ServerHandshake* ptr, u64 session_id);