Update

diff --git a/client-cli/client-cli b/client-cli/client-cli
index 4a7a161a94f53ad56dc49905380b2e3a9ca49b61..04e65373e4402a8c144bef47b694fbca635160fd 100755 (executable)
Binary files a/client-cli/client-cli and b/client-cli/client-cli differ

diff --git a/client-cli/command.odin b/client-cli/command.odin
index 9382e8de12b64ae2fd0b8c9c9de885736186c050..9a6482b17f9c60627ff66974b5519d154b4f8ac1 100644 (file)
--- a/client-cli/command.odin
+++ b/client-cli/command.odin
@@ -108,13 +108,15 @@ handle_command :: proc(app: ^App, command: string) -> Maybe(Handle_Command_Error
                 room_id = room_get_id(&room),
             }
 
-            err := request_host(app.host.?, request, &app.profile.private_key)
+            request_id, err := request_host(app, request, &app.profile.private_key)
 
             if err != nil {
                 app_set_info_bar(app, "Could not subscribe to room.")
                 return .Command_Failed
             }
 
+            response := wait_host_response(app, request_id)
+
             app_add_room(app, room)
             app_set_info_bar(app, "Room added.")
 
@@ -142,16 +144,14 @@ handle_command :: proc(app: ^App, command: string) -> Maybe(Handle_Command_Error
                 room_id = room_get_id(&room),
             }
 
-            err := request_host(app.host.?, request, &app.profile.private_key)
+            request_id, err := request_host(app, request, &app.profile.private_key)
 
             if err != nil {
                 app_set_info_bar(app, "Could not subscribe to room.")
                 return .Command_Failed
             }
 
-            buffer: [1_000]u8
-            bytes_read, _ := net.recv_tcp(app.host.?, buffer[:])
-            response := transmute(string)buffer[:bytes_read]
+            response := wait_host_response(app, request_id)
 
             log.infof("Response %v", response)
 
@@ -196,16 +196,14 @@ handle_command :: proc(app: ^App, command: string) -> Maybe(Handle_Command_Error
                 room_id = room_get_id(room),
             }
 
-            err := request_host(app.host.?, request, &app.profile.private_key)
+            request_id, err := request_host(app, request, &app.profile.private_key)
 
             if err != nil {
                 app_set_info_bar(app, "Could not subscribe to room.")
                 return .Command_Failed
             }
 
-            buffer: [1_000]u8
-            bytes_read, _ := net.recv_tcp(app.host.?, buffer[:])
-            response := transmute(string)buffer[:bytes_read]
+            response := wait_host_response(app, request_id)
 
             log.infof("Response %v", response)
 

diff --git a/client-cli/host.odin b/client-cli/host.odin
index 5a745fdf04c35e42c23ae6d869fd6139de1aeca0..0d3c4d4bd64f2719ddc50be2a49150bc6267cbfb 100644 (file)
--- a/client-cli/host.odin
+++ b/client-cli/host.odin
@@ -4,18 +4,24 @@ import "core:bytes"
 import "core:crypto/ed25519"
 import "core:encoding/endian"
 import "core:io"
+import "core:math/rand"
 import "core:net"
 import "core:slice"
+import "core:sync"
 import "core:time"
 
 import "../common"
 
-request_host :: proc(host: net.TCP_Socket, inner: common.Client_Request_Inner, private_key: ^ed25519.Private_Key) -> (id: u32, err: Error) {
-    client_request: Client_Request
-    ed25519.public_key_set_priv(&client_request.public_key, private_key)
-    client_request.inner = inner
-    client_request.timestamp = time.time_to_unix_nano(time.now())
-    client_request.signature = client_request_signature(client_request, private_key)
+request_host :: proc(
+    app: ^App,
+    inner: common.Client_Request_Inner,
+    private_key: ^ed25519.Private_Key
+) -> (id: u32, err: common.Error) {
+    request: common.Client_Request
+    ed25519.public_key_set_priv(&request.public_key, private_key)
+    request.inner = inner
+    request.timestamp = time.time_to_unix_nano(time.now())
+    request.signature = common.client_request_signature(request, private_key)
 
     bytes_buf: [10_000]u8
     bytes_buffer: bytes.Buffer
@@ -31,7 +37,7 @@ request_host :: proc(host: net.TCP_Socket, inner: common.Client_Request_Inner, p
     _, _ = io.write(request_stream, id_bytes[:])
 
     // Request.
-    _ = client_request_to_bytes(request_stream, request)
+    _ = common.client_request_to_bytes(request_stream, request)
 
     // Length.
     buffer_length := bytes.buffer_length(&bytes_buffer)
@@ -43,11 +49,50 @@ request_host :: proc(host: net.TCP_Socket, inner: common.Client_Request_Inner, p
 
     request_bytes := bytes.buffer_to_bytes(&bytes_buffer)
 
-    _ = net.send_tcp(server, request_bytes) or_return
+    _ = net.send_tcp(app.host.?, request_bytes) or_return
 
     return id, nil
 }
 
-receive_host :: proc(host: net.TCP_Socket) -> Message {
-       
+receive_host :: proc(app: ^App) -> (message: common.Server_Message, err: common.Error) {
+    buffer: [1_000]u8
+    packet := common.receive_packet(app.host.?) or_return
+    packet_buffer: bytes.Buffer
+    packet_buffer.buf = slice.into_dynamic(bytes_buf[:])
+    packet_stream := bytes.buffer_to_stream(&bytes_buffer)
+
+    // Message type.
+    message_type, _ := io.read_byte(packet_stream)
+
+    // Message ID.
+    id_bytes: [size_of(u32)]u8
+    _, _ = io.read(packet_stream, id_bytes[:])
+
+    id, _ := endian.get_u32(.Little, id_bytes[:])
+
+    switch message_type {
+    // Request.
+    case 0:
+
+    // Response.
+    case 1:
+
+    case:
+        return nil, common.Receive_Message_Error.Invalid_Type
+    }
+}
+
+wait_host_response :: proc(app: ^App, id: u32) -> common.Server_Response {
+    for {
+        time.sleep(1_000_000)
+
+        sync.mutex_lock(&app.mutex)
+        defer sync.mutex_unlock(&app.mutex)
+
+        for response in app.responses {
+            if response.id == id {
+                return response
+            }
+        }
+    }
 }

diff --git a/client-cli/main.odin b/client-cli/main.odin
index 839e2fd12fa516ae6a69b8cbd7abf8cb2895d200..9a7cb141f383a47bc7683048858aa4cea51adf6d 100644 (file)
--- a/client-cli/main.odin
+++ b/client-cli/main.odin
@@ -62,7 +62,7 @@ App :: struct {
     seed_phrase_checksum: u8,
 
     host: Maybe(net.TCP_Socket),
-    waiting_respones: [dynamic]common.Server_Response,
+    waiting_responses: [dynamic]common.Server_Response,
 
     selected_room: int,
 }
@@ -735,5 +735,17 @@ main :: proc() {
             time.sleep(1_000_000)
             free_all(context.temp_allocator)
         }
+
+        server_message := receive_host(&app)
+
+        #partial switch message in server_message {
+        case common.Server_Response:
+            response := message
+
+            sync.mutex_lock(&app.mutex)
+            defer sync.mutex_unlock(&app.mutex)
+
+            append(&app.waiting_responses, response)
+        }
     }
 }

diff --git a/client-cli/state.odin b/client-cli/state.odin
index a351d1232e03a329821434ab2466dad2323103a4..733182db55aa09ac1ce32d98b8a080bf3b33cb72 100644 (file)
--- a/client-cli/state.odin
+++ b/client-cli/state.odin
@@ -552,7 +552,7 @@ state_room :: proc(app: ^App) {
             encrypted_message = encrypted_message,
         }
 
-        err := common.request_server(app.host.?, request, &app.profile.private_key)
+        _, err := request_host(app, request, &app.profile.private_key)
 
         if err != nil {
             app_set_info_bar(app, "Failed to send message.")

diff --git a/common/request.odin b/common/request.odin
index 844fef1f6d180d9b2150a7993b233e2db6f74a1d..9bfcfb7dcdb0c34adc75794d306fdbaf08f30d4d 100644 (file)
--- a/common/request.odin
+++ b/common/request.odin
@@ -16,6 +16,7 @@ ROOM_KEY_SIZE :: 32
 MESSAGE_SIZE :: 1_000 * 4
 
 Receive_Packet_Error :: enum {
+    Packet_Empty,
     Packet_Too_Large,
 }
 
@@ -23,6 +24,10 @@ Receive_Request_Error :: enum {
     Invalid_Request,
 }
 
+Receive_Message_Error :: enum {
+    Invalid_Type,
+}
+
 Client_Request_From_Bytes_Error :: enum {
     Invalid_Inner_Kind,
     Invalid_Public_Key,
@@ -264,4 +269,42 @@ client_request_verify :: proc(request: Client_Request, expiration: Maybe(i64)) -
     return nil
 }
 
-Server_Request :: union {}
+Server_Request :: struct {}
+
+Server_Response_Inner :: union {
+    string,
+}
+
+Server_Response :: struct {
+    id: u32,
+    inner: Server_Response_Inner,
+}
+
+Server_Message :: union {
+    Server_Request,
+    Server_Response,
+}
+
+receive_packet :: proc(socket: net.Socket, buffer: []u8) -> (packet: []u8, err: Error) {
+    length_bytes: [size_of(u32)]u8
+    _ = net.recv_tcp(client, length_bytes[:]) or_return
+
+    length, _ := endian.get_u32(length_bytes[:], .Little)
+
+    if length == 0 {
+        return {}, common.Receive_Packet_Error.Packet_Empty
+    }
+
+    if int(length) > len(buffer) {
+        // Empty the socket buffer.
+        for _ in 0..<length {
+            _ = net.recv_tcp(client, buffer) or_return
+        }
+
+        return 0, {}, common.Receive_Packet_Error.Packet_Too_Large
+    }
+
+    _ = net.recv_tcp(client, buffer[:length]) or_return
+
+    return buffer[:length], nil
+}

diff --git a/server/client.odin b/server/client.odin
index d3c52e3d86fbcf54028d5a315f22cfa42c1623d0..188af73d25590a907a52be10dbae0a84a3effefe 100644 (file)
--- a/server/client.odin
+++ b/server/client.odin
@@ -9,32 +9,13 @@ import "core:slice"
 import "../common"
 
 receive_request :: proc(client: net.TCP_Socket) -> (id: u32, request: common.Client_Request, err: common.Error) {
-    length_bytes: [size_of(u32)]u8
-    _ = net.recv_tcp(client, length_bytes[:]) or_return
-
-    length, _ := endian.get_u32(length_bytes[:], .Little)
-
-    if length == 0 {
-        return 0, {}, nil
-    }
-
     buffer: [10_000]u8
+    packet := common.receive_packet(client, buffer[:]) or_return
 
-    if int(length) > len(buffer) {
-        // Empty the socket buffer.
-        for _ in 0..<length {
-            _ = net.recv_tcp(client, buffer[:]) or_return
-        }
-
-        return 0, {}, common.Receive_Packet_Error.Packet_Too_Large
-    }
-
-    _ = net.recv_tcp(client, buffer[:length]) or_return
-
-    id_bytes := buffer[:size_of(u32)]
+    id_bytes := packet[:size_of(u32)]
     id, _ = endian.get_u32(id_bytes[:], .Little)
 
-    request_bytes := buffer[size_of(u32):]
+    request_bytes := packet[size_of(u32):]
 
     request, err = common.client_request_from_bytes(request_bytes)
 
@@ -52,7 +33,7 @@ send_response :: proc(client: net.TCP_Socket, id: u32, content: string) -> commo
     response_stream := bytes.buffer_to_stream(&bytes_buffer)
 
     // Message type.
-    _ = io.write_byte(response_stream, 0)
+    _ = io.write_byte(response_stream, 1)
 
     // Reponse ID.
     id_bytes: [size_of(u32)]u8

diff --git a/server/server b/server/server
index 92462e07ccaf694719f765a4231976261c24fb9a..49703157c9f53f9144948010e576710332e16b75 100755 (executable)
Binary files a/server/server and b/server/server differ