From e270def19f714b07b5ac3f066857e18be3936125 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Tue, 29 Sep 2026 21:08:34 -0700 Subject: [PATCH] socket: checkpoint on socket layer / win32 impl; plug into ipc driving --- src/raddbg/raddbg_main.c | 54 +++++++++++++- src/socket/socket.h | 10 +++ src/socket/socket_stub.c | 1 + src/win32/socket/win32_socket.c | 128 ++++++++++++++++++++++++++++---- src/win32/socket/win32_socket.h | 11 ++- 5 files changed, 187 insertions(+), 17 deletions(-) diff --git a/src/raddbg/raddbg_main.c b/src/raddbg/raddbg_main.c index 2225d739..6076cc69 100644 --- a/src/raddbg/raddbg_main.c +++ b/src/raddbg/raddbg_main.c @@ -413,7 +413,7 @@ #include "mdesk/mdesk.h" #include "window_manager/window_manager_inc.h" #include "shell/shell_inc.h" -// #include "socket/socket_inc.h" +#include "socket/socket_inc.h" #include "http/http_inc.h" #include "symbol_server/symbol_server_inc.h" #include "config/config_inc.h" @@ -475,7 +475,7 @@ #include "mdesk/mdesk.c" #include "window_manager/window_manager_inc.c" #include "shell/shell_inc.c" -// #include "socket/socket_inc.c" +#include "socket/socket_inc.c" #include "http/http_inc.c" #include "symbol_server/symbol_server_inc.c" #include "config/config_inc.c" @@ -728,6 +728,7 @@ entry_point(CmdLine *cmd_line) fnt_init(); rd_init(cmd_line); d_set_wakeup_hook(wakeup_hook_ctrl); + sock_set_wakeup_hook(wakeup_hook_ctrl); } //- rjf: set up shared resources for ipc to this instance; launch IPC signaler thread @@ -832,6 +833,55 @@ entry_point(CmdLine *cmd_line) scratch_end(scratch); } + //- rjf: receive socket data, run as IPC messages + { + Temp scratch = scratch_begin(0, 0); + SOCK_Protocol protocol = SOCK_Protocol_TCP; + SOCK_Endpoint endpoint = {0}; + String8 msg = {0}; + if(sock_recv(scratch.arena, &protocol, &endpoint, &msg, 0)) + { + String8List cmd_parts_of_msg = str8_split(scratch.arena, msg, (U8 *)";", 1, 0); + RD_WindowState *dst_ws = rd_state->first_window_state; + for(RD_WindowState *ws = dst_ws; ws != &rd_nil_window_state; ws = ws->order_next) + { + if(wm_window_is_focused(ws->os)) + { + dst_ws = ws; + break; + } + } + if(dst_ws != &rd_nil_window_state) + { + dst_ws->window_temporarily_focused_ipc = 1; + RD_RegsScope() + { + if(dst_ws->cfg_id != rd_regs()->window) + { + Temp scratch = scratch_begin(0, 0); + CFG_PanelTree panel_tree = cfg_panel_tree_from_cfg(scratch.arena, cfg_node_from_id(dst_ws->cfg_id)); + rd_regs()->window = dst_ws->cfg_id; + rd_regs()->panel = panel_tree.focused->cfg->id; + rd_regs()->tab = panel_tree.focused->selected_tab->id; + rd_regs()->view = panel_tree.focused->selected_tab->id; + scratch_end(scratch); + } + for EachNode(n, String8Node, cmd_parts_of_msg.first) + { + String8 cmd_string = str8_skip_chop_whitespace(n->string); + if(cmd_string.size != 0) + { + rd_cmd(RD_CmdKind_RunExternalDriverTextCommand, .string = cmd_string); + } + } + rd_request_frame(); + ipc_command_frame = 1; + } + } + } + scratch_end(scratch); + } + //- rjf: update quit = update(); diff --git a/src/socket/socket.h b/src/socket/socket.h index 0656cfb6..99bd72be 100644 --- a/src/socket/socket.h +++ b/src/socket/socket.h @@ -4,6 +4,9 @@ #ifndef SOCKET_H #define SOCKET_H +//////////////////////////////// +//~ rjf: Socket Types + #if !defined(SOCKET_PORT) # define SOCKET_PORT 7423 #endif @@ -40,6 +43,12 @@ struct SOCK_Endpoint }; }; +//////////////////////////////// +//~ rjf: Wakeup Hook Function Types + +#define SOCK_WAKEUP_FUNCTION_DEF(name) void name(void) +typedef SOCK_WAKEUP_FUNCTION_DEF(SOCK_WakeupFunctionType); + //////////////////////////////// //~ rjf: Helpers @@ -54,6 +63,7 @@ internal SOCK_Endpoint sock_endpoint_from_string(String8 address_and_port); #endif internal void sock_init(void); internal void sock_async_tick(void); +internal void sock_set_wakeup_hook(SOCK_WakeupFunctionType *hook); //////////////////////////////// //~ rjf: @per_os_impl Sends diff --git a/src/socket/socket_stub.c b/src/socket/socket_stub.c index 2b1fd97d..d5da5e91 100644 --- a/src/socket/socket_stub.c +++ b/src/socket/socket_stub.c @@ -3,5 +3,6 @@ internal void sock_init(void){} internal void sock_async_tick(void){} +internal void sock_set_wakeup_hook(SOCK_WakeupFunctionType *hook){} internal B32 sock_send(SOCK_Protocol protocol, SOCK_Endpoint endpoint, String8 data, U64 endt_us){return 0;} internal B32 sock_recv(Arena *arena, SOCK_Protocol *protocol_out, SOCK_Endpoint *endpoint_out, String8 *data_out, U64 endt_us){return 0;} diff --git a/src/win32/socket/win32_socket.c b/src/win32/socket/win32_socket.c index 1a33f80b..b0ab9c8a 100644 --- a/src/win32/socket/win32_socket.c +++ b/src/win32/socket/win32_socket.c @@ -11,16 +11,26 @@ w32_sock_listener_thread_entry_point(void *p) SOCK_Protocol protocol = (SOCK_Protocol)p; for(;;) { - //- rjf: + //- rjf: get next completion from IOCP + DWORD byte_count = 0; + U64 completion_key = 0; + OVERLAPPED *overlapped_ptr = 0; + B32 success = GetQueuedCompletionStatus(w32_sock_state->iocp, &byte_count, &completion_key, &overlapped_ptr, INFINITE); - //- rjf: accept new connection on the TCP listener - struct sockaddr_storage addr = {0}; - int addr_size = sizeof(addr); - SOCKET new_socket = accept(w32_sock_state->tcp_listen_socket, (struct sockaddr *)&addr, &addr_size); - - //- rjf: got new TCP connection socket -> store connection - if(new_socket != INVALID_SOCKET) + //- rjf: call wakeup hook + if(w32_sock_state->wakeup_hook) { + w32_sock_state->wakeup_hook(); + } + + //- rjf: overlapped_ptr == accept overlapped? -> new connection + if(overlapped_ptr == &w32_sock_state->tcp_accept_overlapped) + { + // rjf: unpack new socket + SOCKET new_socket = w32_sock_state->tcp_accept_socket; + struct sockaddr_storage addr = {0}; + MemoryCopy(&addr, w32_sock_state->tcp_accept_buffer + sizeof(struct sockaddr_storage) + 16, sizeof(addr)); + // rjf: unpack socket's endpoint info SOCK_Endpoint endpoint = {0}; { @@ -49,6 +59,9 @@ w32_sock_listener_thread_entry_point(void *p) Stripe *stripe = stripe_from_slot_idx(&w32_sock_state->connection_stripes, slot_idx); // rjf: store new connection + WSABUF buf = {0}; + DWORD *recv_size = 0; + OVERLAPPED *recv_overlapped = 0; RWMutexScope(stripe->rw_mutex, 1) { W32_SOCK_Connection *con = (W32_SOCK_Connection *)stripe->free; @@ -64,6 +77,62 @@ w32_sock_listener_thread_entry_point(void *p) con->protocol = SOCK_Protocol_TCP; con->socket = new_socket; DLLPushBack(slot->first, slot->last, con); + buf.len = sizeof(con->recv_buffer); + buf.buf = con->recv_buffer; + recv_size = &con->recv_size; + recv_overlapped = &con->recv_overlapped; + } + + // rjf: kick off receive + DWORD flags = MSG_PUSH_IMMEDIATE; + WSARecv(new_socket, &buf, 1, recv_size, &flags, recv_overlapped, 0); + + // rjf: create new accept socket, associate with iocp, zero overlapped, kick off next accept + w32_sock_state->tcp_accept_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + CreateIoCompletionPort((HANDLE)w32_sock_state->tcp_accept_socket, w32_sock_state->iocp, 0, 0); + MemoryZeroStruct(&w32_sock_state->tcp_accept_overlapped); + w32_sock_state->lpfnAcceptEx(w32_sock_state->tcp_listen_socket, w32_sock_state->tcp_accept_socket, w32_sock_state->tcp_accept_buffer, 0, sizeof(struct sockaddr_storage) + 16, sizeof(struct sockaddr_storage) + 16, &w32_sock_state->tcp_accept_size_out, &w32_sock_state->tcp_accept_overlapped); + } + + //- rjf: overlapped ptr anywhere else -> completion of async recv + else + { + // rjf: unpack associated connection + W32_SOCK_Connection *con = CastFromMember(W32_SOCK_Connection, recv_overlapped, overlapped_ptr); + SOCK_Endpoint endpoint = con->endpoint; + U64 hash = u64_hash_from_str8(str8_struct(&endpoint)); + U64 slot_idx = hash%w32_sock_state->connection_slots_count; + W32_SOCK_ConnectionSlot *slot = &w32_sock_state->connection_slots[slot_idx]; + Stripe *stripe = stripe_from_slot_idx(&w32_sock_state->connection_stripes, slot_idx); + + // rjf: success? -> push result to user. kick off next recv + if(success) + { + RingGuard g = guarded_ring_open(w32_sock_state->s2u_ring); + U64 header[5] = + { + (U64)SOCK_Protocol_TCP, + (U64)endpoint.port, + endpoint.address_u64[0], + endpoint.address_u64[1], + (U64)byte_count, + }; + guarded_ring_write_or_wait(&g, sizeof(header), header, max_U64); + guarded_ring_write_or_wait(&g, byte_count, con->recv_buffer, max_U64); + MemoryZeroStruct(&con->recv_overlapped); + WSABUF buf = {sizeof(con->recv_buffer), con->recv_buffer}; + DWORD flags = MSG_PUSH_IMMEDIATE; + WSARecv(con->socket, &buf, 1, &con->recv_size, &flags, &con->recv_overlapped, 0); + guarded_ring_close(&g); + } + + // rjf: no success? -> connection closed. + else RWMutexScope(stripe->rw_mutex, 1) + { + closesocket(con->socket); + DLLRemove(slot->first, slot->last, con); + con->next = stripe->free; + stripe->free = con; } } } @@ -84,13 +153,14 @@ sock_init(void) w32_sock_state->u2s_ring = guarded_ring_alloc(arena, KB(256)); w32_sock_state->s2u_ring = guarded_ring_alloc(arena, KB(256)); - //- rjf: create listener sockets - w32_sock_state->tcp_listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - w32_sock_state->udp_listen_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + //- rjf: set up IOCP + w32_sock_state->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0); + + //- rjf: create listener(s) + w32_sock_state->tcp_listen_socket = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, 0, WSA_FLAG_OVERLAPPED); { DWORD ipv6only = 0; setsockopt(w32_sock_state->tcp_listen_socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only)); - setsockopt(w32_sock_state->udp_listen_socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only)); } //- rjf: bind listener sockets @@ -100,7 +170,6 @@ sock_init(void) server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = htons(SOCKET_PORT); bind(w32_sock_state->tcp_listen_socket, (SOCKADDR *)&server_addr, sizeof(server_addr)); - bind(w32_sock_state->udp_listen_socket, (SOCKADDR *)&server_addr, sizeof(server_addr)); } //- rjf: start listening for TCP connections @@ -108,13 +177,38 @@ sock_init(void) listen(w32_sock_state->tcp_listen_socket, SOMAXCONN); } + //- rjf: associate listener sockets with IOCP + { + CreateIoCompletionPort((HANDLE)w32_sock_state->tcp_listen_socket, w32_sock_state->iocp, 0, 0); + } + + //- rjf: load AcceptEx function + DWORD dwBytes = 0; + GUID AcceptEx_guid = WSAID_ACCEPTEX; + WSAIoctl(w32_sock_state->tcp_listen_socket, SIO_GET_EXTENSION_FUNCTION_POINTER, &AcceptEx_guid, sizeof(AcceptEx_guid), &w32_sock_state->lpfnAcceptEx, sizeof(w32_sock_state->lpfnAcceptEx), &dwBytes, 0, 0); + + //- rjf: create accepting socket + { + w32_sock_state->tcp_accept_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + } + + //- rjf: associate accepting socket with IOCP + { + CreateIoCompletionPort((HANDLE)w32_sock_state->tcp_accept_socket, w32_sock_state->iocp, 0, 0); + } + + //- rjf: kick off accept + { + w32_sock_state->lpfnAcceptEx(w32_sock_state->tcp_listen_socket, w32_sock_state->tcp_accept_socket, w32_sock_state->tcp_accept_buffer, 0, sizeof(struct sockaddr_storage) + 16, sizeof(struct sockaddr_storage) + 16, &w32_sock_state->tcp_accept_size_out, &w32_sock_state->tcp_accept_overlapped); + } + //- rjf: set up connection cache w32_sock_state->connection_slots_count = 8; w32_sock_state->connection_slots = push_array(arena, W32_SOCK_ConnectionSlot, w32_sock_state->connection_slots_count); w32_sock_state->connection_stripes = stripe_array_alloc(arena); //- rjf: launch one-off listener threads to block & accept connections - w32_sock_state->tcp_listener_thread = thread_launch(w32_sock_listener_thread_entry_point, (void *)SOCK_Protocol_TCP); + w32_sock_state->tcp_listener_thread = thread_launch(w32_sock_listener_thread_entry_point, 0); } internal void @@ -208,6 +302,12 @@ sock_async_tick(void) scratch_end(scratch); } +internal void +sock_set_wakeup_hook(SOCK_WakeupFunctionType *hook) +{ + w32_sock_state->wakeup_hook = hook; +} + //////////////////////////////// //~ rjf: @per_os_impl Sends diff --git a/src/win32/socket/win32_socket.h b/src/win32/socket/win32_socket.h index 38f46df8..4d0be4c8 100644 --- a/src/win32/socket/win32_socket.h +++ b/src/win32/socket/win32_socket.h @@ -15,6 +15,9 @@ struct W32_SOCK_Connection SOCK_Endpoint endpoint; SOCK_Protocol protocol; SOCKET socket; + U8 recv_buffer[4096]; + DWORD recv_size; + OVERLAPPED recv_overlapped; }; typedef struct W32_SOCK_ConnectionSlot W32_SOCK_ConnectionSlot; @@ -30,12 +33,18 @@ struct W32_SOCK_State Arena *arena; GuardedRing *u2s_ring; GuardedRing *s2u_ring; + HANDLE iocp; SOCKET tcp_listen_socket; - SOCKET udp_listen_socket; + SOCKET tcp_accept_socket; + OVERLAPPED tcp_accept_overlapped; + U8 tcp_accept_buffer[4096]; + DWORD tcp_accept_size_out; Thread tcp_listener_thread; U64 connection_slots_count; StripeArray connection_stripes; W32_SOCK_ConnectionSlot *connection_slots; + LPFN_ACCEPTEX lpfnAcceptEx; + SOCK_WakeupFunctionType *wakeup_hook; }; global W32_SOCK_State *w32_sock_state = 0;