implemented CommonQueries

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

@@ -63,7 +63,7 @@ Result(void) ClientHandshake_tryConstruct(ClientHandshake* ptr, PacketHeader* he
 }
 
 void ServerHandshake_construct(ServerHandshake* ptr, PacketHeader* header,
-    u64 session_id)
+    i64 session_id)
 {
     _PacketHeader_construct(ServerHandshake);
     zeroStruct(ptr);
@@ -106,7 +106,7 @@ Result(void) LoginRequest_tryConstruct(LoginRequest *ptr, PacketHeader* header,
 }
 
 void LoginResponse_construct(LoginResponse* ptr, PacketHeader* header,
-    u64 user_id, u64 landing_channel_id)
+    i64 user_id, i64 landing_channel_id)
 {
     _PacketHeader_construct(LoginResponse);
     zeroStruct(ptr);
@@ -135,15 +135,73 @@ Result(void) RegisterRequest_tryConstruct(RegisterRequest *ptr, PacketHeader* he
 }
 
 void RegisterResponse_construct(RegisterResponse *ptr, PacketHeader* header,
-    u64 user_id)
+    i64 user_id)
 {
     _PacketHeader_construct(RegisterResponse);
     zeroStruct(ptr);
     ptr->user_id = user_id;
 }
 
+Result(u32) MessageBlock_writeMessage(
+    MessageMeta* msg, Array(u8) msg_content, 
+    MessageBlockMeta* block_meta, Array(u8)* block_free_part)
+{
+    Deferral(1);
+    try_assert(msg->data_size >= MESSAGE_SIZE_MIN && msg->data_size <= MESSAGE_SIZE_MAX);
+    try_assert(msg->data_size <= msg_content.len);
+
+    u32 offset_increment = sizeof(MessageMeta) + msg->data_size;
+    if(block_free_part->len < offset_increment){
+        Return RESULT_VALUE(u, 0);
+    }
+    
+    memcpy(block_free_part->data, msg, sizeof(MessageMeta));
+    block_free_part->data += sizeof(MessageMeta);
+    block_free_part->len -= sizeof(MessageMeta);
+
+    memcpy(block_free_part->data, msg_content.data, msg->data_size);
+    block_free_part->data += msg->data_size;
+    block_free_part->len -= msg->data_size;
+
+    if(block_meta->message_count == 0)
+        block_meta->first_message_id = msg->id;
+    block_meta->message_count++;
+    block_meta->data_size += offset_increment;
+    
+    Return RESULT_VALUE(u, offset_increment);
+}
+
+Result(u32) MessageBlock_readMessage(
+    Array(u8)* block_unread_part, 
+    MessageMeta* msg, Array(u8) msg_content)
+{
+    Deferral(1);
+    try_assert(block_unread_part->len >= sizeof(MessageMeta) + MESSAGE_SIZE_MIN);
+    try_assert(msg_content.len >= MESSAGE_SIZE_MIN && msg_content.len <= MESSAGE_SIZE_MAX);
+    
+    memcpy(msg, block_unread_part->data, sizeof(MessageMeta));
+    block_unread_part->data += sizeof(MessageMeta);
+    block_unread_part->len -= sizeof(MessageMeta);
+
+    if(msg->magic.n != MESSAGE_MAGIC.n){
+        Return RESULT_VALUE(u, 0);
+    }
+    try_assert(block_unread_part->len >= msg->data_size);
+    try_assert(msg->data_size >= MESSAGE_SIZE_MIN && msg->data_size <= MESSAGE_SIZE_MAX);
+    try_assert(msg->id > 0);
+    try_assert(msg->sender_id > 0);
+    try_assert(msg->timestamp.d.year > 2024);
+
+    memcpy(msg_content.data, block_unread_part->data, msg->data_size);
+    block_unread_part->data += msg->data_size;
+    block_unread_part->len -= msg->data_size;
+
+    u32 offset_increment = sizeof(MessageMeta) + msg->data_size;
+    Return RESULT_VALUE(u, offset_increment);
+}
+
 void SendMessageRequest_construct(SendMessageRequest *ptr, PacketHeader *header,
-    u64 channel_id, u16 data_size)
+    i64 channel_id, u16 data_size)
 {
     _PacketHeader_construct(SendMessageRequest);
     zeroStruct(ptr);
@@ -152,30 +210,28 @@ void SendMessageRequest_construct(SendMessageRequest *ptr, PacketHeader *header,
 }
 
 void SendMessageResponse_construct(SendMessageResponse *ptr, PacketHeader *header,
-    u64 message_id, DateTime receiving_time_utc)
+    i64 message_id, DateTime timestamp)
 {
     _PacketHeader_construct(SendMessageResponse);
     zeroStruct(ptr);
     ptr->message_id = message_id;
-    ptr->receiving_time_utc = receiving_time_utc;
+    ptr->timestamp = timestamp;
 }
 
 void GetMessageBlockRequest_construct(GetMessageBlockRequest *ptr, PacketHeader *header,
-    u64 channel_id, u64 first_message_id, u32 messages_count)
+    i64 channel_id, i64 first_message_id, u32 message_count)
 {
     _PacketHeader_construct(GetMessageBlockRequest);
     zeroStruct(ptr);
     ptr->channel_id = channel_id;
     ptr->first_message_id = first_message_id;
-    ptr->messages_count = messages_count;
+    ptr->message_count = message_count;
 }
 
 void GetMessageBlockResponse_construct(GetMessageBlockResponse *ptr, PacketHeader *header,
-    u64 first_message_id, u32 messages_count, u32 data_size)
+    MessageBlockMeta* block_meta)
 {
     _PacketHeader_construct(GetMessageBlockResponse);
     zeroStruct(ptr);
-    ptr->first_message_id = first_message_id;
-    ptr->messages_count = messages_count;
-    ptr->data_size = data_size;
+    memcpy(&ptr->block_meta, block_meta, sizeof(MessageBlockMeta));
 }