room_id = room_get_id(room),
}
- request_id, err := request_host(app, 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
- }
+ // if err != nil {
+ // app_set_info_bar(app, "Could not subscribe to room.")
+ // return .Command_Failed
+ // }
- response := wait_host_response(app, request_id)
+ // response := wait_host_response(app, request_id)
- log.infof("Response %v", response)
+ // log.infof("Response %v", response)
app_remove_room(app, app.selected_room)
app_set_info_bar(app, "Room removed.")
receive_host :: proc(app: ^App) -> (id: u32, message: common.Server_Message, err: common.Error) {
buffer: [1_000]u8
- packet := common.receive_packet(app.host.?) or_return
+ packet := common.receive_packet(app.host.?, buffer[:]) or_return
packet_buffer: bytes.Buffer
- packet_buffer.buf = slice.into_dynamic(bytes_buf[:])
- packet_stream := bytes.buffer_to_stream(&bytes_buffer)
+ packet_buffer.buf = slice.into_dynamic(packet)
+ packet_stream := bytes.buffer_to_stream(&packet_buffer)
return common.server_message_from_bytes(app.host.?, packet_stream)
}
sync.mutex_lock(&app.mutex)
defer sync.mutex_unlock(&app.mutex)
- for response in app.responses {
- if response.id == id {
+ for res_id, response in app.waiting_responses {
+ if res_id == id {
+ delete_key(&app.waiting_responses, res_id)
return response
}
}
seed_phrase_checksum: u8,
host: Maybe(net.TCP_Socket),
- waiting_responses: [dynamic]common.Server_Response,
+ waiting_responses: map[u32]common.Server_Response,
selected_room: int,
}
info_bar = info_bar,
input_window = input_window,
- waiting_responses = make([dynamic]common.Server_Response),
+ waiting_responses = make(map[u32]common.Server_Response),
}
app_update_info_bar(&app)
sync.mutex_lock(&app.mutex)
defer sync.mutex_unlock(&app.mutex)
+ for _, response in app.waiting_responses {
+ common.server_response_deinit(response)
+ }
+
delete(app.waiting_responses)
if host, ok := app.host.?; ok {
free_all(context.temp_allocator)
}
- server_message := receive_host(&app)
-
- #partial switch message in server_message {
- case common.Server_Response:
- response := message
+ state: State
+ {
sync.mutex_lock(&app.mutex)
defer sync.mutex_unlock(&app.mutex)
- append(&app.waiting_responses, response)
+ state = app.state
}
+
+ // #partial switch state {
+ // case .Room_List, .Room:
+ // message_id, server_message, err := receive_host(&app)
+
+ // if err != nil {
+ // log.errorf("Failed to receive server message with error %v", err)
+ // continue
+ // }
+
+ // #partial switch message in server_message {
+ // case common.Server_Response:
+ // response := message
+
+ // sync.mutex_lock(&app.mutex)
+ // defer sync.mutex_unlock(&app.mutex)
+
+ // app.waiting_responses[message_id] = response
+ // }
+ // }
}
}
import "core:math/rand"
import "core:mem"
import "core:slice"
+import "core:strings"
import "core:time"
ROOM_KEY_SIZE :: 32
Error :: union {
Receive_Packet_Error,
Receive_Request_Error,
+ Receive_Message_Error,
Client_Request_From_Bytes_Error,
string,
}
+server_response_deinit :: proc(response: Server_Response) {
+ switch r in response {
+ case string:
+ delete(r)
+ }
+}
+
server_response_from_bytes :: proc(stream: io.Stream) -> (response: Server_Response, err: Error) {
-
+ buffer: [1_000]u8
+ _, _ = io.read(stream, buffer[:])
+
+ response, _ = strings.clone_from_bytes(buffer[:])
+
+ return response, nil
}
Server_Message :: union {
id_bytes: [size_of(u32)]u8
_, _ = io.read(stream, id_bytes[:])
- id, _ := endian.get_u32(.Little, id_bytes[:])
+ id, _ = endian.get_u32(id_bytes[:], .Little)
switch message_type {
// Request.
// Response.
case 1:
-
+ message, err = server_response_from_bytes(stream)
case:
- return nil, common.Receive_Message_Error.Invalid_Type
+ return 0, nil, Receive_Message_Error.Invalid_Type
}
+
+ return id, message, err
}
receive_packet :: proc(socket: net.TCP_Socket, buffer: []u8) -> (packet: []u8, err: Error) {
length_bytes: [size_of(u32)]u8
- _ = net.recv_tcp(client, length_bytes[:]) or_return
+ bytes_read := net.recv_tcp(socket, length_bytes[:]) or_return
+
+ if bytes_read == 0 {
+ return {}, Receive_Packet_Error.Packet_Empty
+ }
length, _ := endian.get_u32(length_bytes[:], .Little)
if length == 0 {
- return {}, common.Receive_Packet_Error.Packet_Empty
+ return {}, 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
+ _ = net.recv_tcp(socket, buffer) or_return
}
- return 0, {}, common.Receive_Packet_Error.Packet_Too_Large
+ return {}, Receive_Packet_Error.Packet_Too_Large
}
- _ = net.recv_tcp(client, buffer[:length]) or_return
+ _ = net.recv_tcp(socket, buffer[:length]) or_return
return buffer[:length], nil
}
request_bytes := packet[size_of(u32):]
request_buffer: bytes.Buffer
- request_buffer.buf = slice.into_dynamic(bytes_buf[:])
- request_stream := bytes.buffer_to_stream(&bytes_buffer)
+ request_buffer.buf = slice.into_dynamic(request_bytes[:])
+ request_stream := bytes.buffer_to_stream(&request_buffer)
- request, err = common.client_request_from_bytes(request_stream)
+ request, err = common.client_request_from_bytes(request_stream)
return id, request, err
}
request_id, request, err1 := receive_request(client_socket)
if err1 != nil {
+ #partial switch err in err1 {
+ case common.Receive_Packet_Error:
+ #partial switch err {
+ case .Packet_Empty:
+ return
+ }
+
+ case net.Network_Error:
+ #partial switch err.(net.TCP_Recv_Error) {
+ case .Connection_Closed:
+ return
+ }
+ }
+
+ log.infof("Request error %v", err1)
+
response_string := "Invalid request"
response = transmute([]u8)response_string
projects / mesange.git / commitdiff