socket: checkpoint on socket layer / win32 impl; plug into ipc driving

This commit is contained in:
Ryan Fleury committed 2026-09-29 21:08:34 -07:00
1 parent f781622a54
commit e270def19f
5 files changed
+187 -17

No files matched your search

+52 -2
View File
@@ -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();
+10
View File
@@ -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
+1
View File
@@ -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;}
+114 -14
View File
@@ -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
+10 -1
View File
@@ -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;