226 lines
8.0 KiB
C
226 lines
8.0 KiB
C
#include <c_TcpSelectReactor.h>
|
|
#include <c_Macros.h>
|
|
|
|
/* ================================================================================================================== */
|
|
/* Concrete Implementation: Refactored Cross-Platform select() Driver Subclass Context */
|
|
|
|
typedef struct {
|
|
c_TcpReactor_t base;
|
|
c_socket_t* sockets; /* Array tracking all registered socket handles (Listener + Clients) */
|
|
c_size_t count; /* Current count of monitored sockets */
|
|
c_size_t capacity; /* Upper bounds allocation capacity limit */
|
|
c_Allocator_t allocator; /* Deep copy of the user-provided allocator */
|
|
} c_SelectReactorImpl_t;
|
|
|
|
static c_err_t Select_Add(c_TcpReactor_t* self, c_socket_t sock, uint32_t events) {
|
|
c_SelectReactorImpl_t* impl = (c_SelectReactorImpl_t*)self;
|
|
(void)events;
|
|
|
|
/* Enforce hard ceiling compliance checks against maximum threshold allowances for select */
|
|
if (impl->count >= FD_SETSIZE) {
|
|
return C_ERR_OUTOFBOUND;
|
|
}
|
|
|
|
if (impl->count >= impl->capacity) {
|
|
c_size_t old_cap = impl->capacity;
|
|
c_size_t new_cap = old_cap == 0 ? 16 : C_MIN(old_cap * 2, FD_SETSIZE);
|
|
|
|
c_socket_t* new_sockets = (c_socket_t*)c_Allocator_Realloc(
|
|
&impl->allocator, impl->sockets, old_cap * sizeof(c_socket_t), new_cap * sizeof(c_socket_t)
|
|
);
|
|
if (!new_sockets) return C_ERR_NOMEM;
|
|
|
|
impl->sockets = new_sockets;
|
|
impl->capacity = new_cap;
|
|
}
|
|
|
|
/* Prevent duplicate entries inside the tracking index */
|
|
for (c_size_t i = 0; i < impl->count; ++i) {
|
|
if (impl->sockets[i] == sock) return C_SUCCESS;
|
|
}
|
|
|
|
impl->sockets[impl->count++] = sock;
|
|
return C_SUCCESS;
|
|
}
|
|
|
|
static c_err_t Select_Remove(c_TcpReactor_t* self, c_socket_t sock) {
|
|
c_SelectReactorImpl_t* impl = (c_SelectReactorImpl_t*)self;
|
|
for (c_size_t i = 0; i < impl->count; ++i) {
|
|
if (impl->sockets[i] == sock) {
|
|
impl->sockets[i] = impl->sockets[impl->count - 1]; /* O(1) tail-swap optimization */
|
|
impl->count--;
|
|
return C_SUCCESS;
|
|
}
|
|
}
|
|
return C_ERR_NOTFOUND;
|
|
}
|
|
|
|
static c_err_t Select_Poll(c_TcpReactor_t* self, long timeout_ms, c_TcpServer_t* server, void* args) {
|
|
c_SelectReactorImpl_t* impl = (c_SelectReactorImpl_t*)self;
|
|
if (impl->count == 0 || !server->is_running) return C_SUCCESS;
|
|
|
|
fd_set read_set;
|
|
fd_set err_set;
|
|
FD_ZERO(&read_set);
|
|
FD_ZERO(&err_set);
|
|
|
|
c_socket_t max_fd = 0;
|
|
for (c_size_t i = 0; i < impl->count; ++i) {
|
|
FD_SET(impl->sockets[i], &read_set);
|
|
FD_SET(impl->sockets[i], &err_set);
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
|
if (impl->sockets[i] > max_fd) {
|
|
max_fd = impl->sockets[i];
|
|
}
|
|
#endif
|
|
}
|
|
|
|
struct timeval tv;
|
|
struct timeval* tv_ptr = NULL;
|
|
if (timeout_ms >= 0) {
|
|
tv.tv_sec = timeout_ms / 1000;
|
|
tv.tv_usec = (timeout_ms % 1000) * 1000;
|
|
tv_ptr = &tv;
|
|
}
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
int ret = select(0, &read_set, NULL, &err_set, tv_ptr);
|
|
#else
|
|
int ret = select((int)(max_fd + 1), &read_set, NULL, &err_set, tv_ptr);
|
|
#endif
|
|
|
|
if (ret < 0) {
|
|
if (server->fnOnError) {
|
|
server->fnOnError(server, server->listen_sock, C_TCPSERVER_ERR_ON_POLL, args);
|
|
}
|
|
return C_SUCCESS;
|
|
}
|
|
if (ret == 0) return C_SUCCESS; /* Timeout pass, exit early */
|
|
|
|
/*
|
|
* Safe Backward Traversal Pass:
|
|
* Scanning the tracked sockets pool backward ensures that deleting an element via
|
|
* tail-swapping doesn't corrupt unvisited index boundaries during the current pass.
|
|
*/
|
|
for (c_size_t i = impl->count; i > 0; --i) {
|
|
c_size_t idx = i - 1;
|
|
c_socket_t active_sock = impl->sockets[idx];
|
|
|
|
c_bool_t has_read = FD_ISSET(active_sock, &read_set);
|
|
c_bool_t has_error = FD_ISSET(active_sock, &err_set);
|
|
|
|
if (!has_read && !has_error) continue;
|
|
|
|
/* Channel A: Master server listener handles events */
|
|
if (active_sock == server->listen_sock) {
|
|
if (has_read) {
|
|
c_SockAddr_t peer_addr;
|
|
c_socket_t client = c_SocketUtil_Accept(server->listen_sock, &peer_addr);
|
|
|
|
if (c_Socket_IsValid(client)) {
|
|
bool keep = true;
|
|
if (server->fnOnConnect) {
|
|
keep = server->fnOnConnect(server, client, &peer_addr, args);
|
|
}
|
|
|
|
if (keep) {
|
|
Select_Add(self, client, 1); /* Add client onto select watchlist */
|
|
} else {
|
|
c_Socket_Close(client);
|
|
}
|
|
} else if (server->fnOnError) {
|
|
server->fnOnError(server, server->listen_sock, C_TCPSERVER_ERR_ON_ACCEPT, args);
|
|
}
|
|
}
|
|
if (has_error) {
|
|
if (server->fnOnError) {
|
|
server->fnOnError(server, server->listen_sock, C_TCPSERVER_ERR_ON_POLLERR, args);
|
|
}
|
|
}
|
|
ret--;
|
|
}
|
|
/* Channel B: Connected active client descriptor processing */
|
|
else {
|
|
c_bool_t keep_alive = C_TRUE;
|
|
|
|
/* Intercept operational error signals first */
|
|
if (has_error) {
|
|
if (server->fnOnError) {
|
|
server->fnOnError(server, active_sock, C_TCPSERVER_ERR_ON_POLLERR, args);
|
|
}
|
|
keep_alive = C_FALSE;
|
|
}
|
|
|
|
if (keep_alive && has_read) {
|
|
/* Intercept silent socket termination conditions using zero-byte peeks */
|
|
char peek_buf;
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
int peek_res = recv(active_sock, &peek_buf, 1, MSG_PEEK);
|
|
#else
|
|
ssize_t peek_res = recv(active_sock, &peek_buf, 1, MSG_PEEK);
|
|
#endif
|
|
|
|
if (peek_res == 0 || peek_res == C_SOCKET_ERROR) {
|
|
keep_alive = C_FALSE; /* Connection broken or closed by remote peer node */
|
|
} else if (server->fnOnRequest) {
|
|
/* Fire your exact matching signature callback layout */
|
|
keep_alive = server->fnOnRequest(server, active_sock, args);
|
|
}
|
|
}
|
|
|
|
/* Clean up active client descriptor arrays if data pipeline drops or errors out */
|
|
if (!keep_alive) {
|
|
Select_Remove(self, active_sock);
|
|
|
|
/* Fire your formal on_disconnect registration interface hook */
|
|
if (server->fnOnDisconnect) {
|
|
server->fnOnDisconnect(server, active_sock, args);
|
|
}
|
|
c_Socket_Close(active_sock);
|
|
}
|
|
ret--;
|
|
}
|
|
|
|
if (ret == 0) break; /* Event counters satisfied, return early */
|
|
}
|
|
|
|
return C_SUCCESS;
|
|
}
|
|
|
|
static void Select_Destroy(c_TcpReactor_t* self) {
|
|
c_SelectReactorImpl_t* impl = (c_SelectReactorImpl_t*)self;
|
|
c_Allocator_t alloc = impl->allocator;
|
|
|
|
/* Safely dismantle any hanging active client sockets remaining in the array pool */
|
|
for (c_size_t i = 0; i < impl->count; ++i) {
|
|
c_socket_t sock = impl->sockets[i];
|
|
c_Socket_Close(sock);
|
|
}
|
|
|
|
if (impl->sockets) c_Allocator_Free(&alloc, impl->sockets);
|
|
c_Allocator_Free(&alloc, impl);
|
|
}
|
|
|
|
static const c_TcpReactorVtbl_t g_SelectReactorVtbl = { Select_Add, Select_Remove, Select_Poll, Select_Destroy };
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
c_err_t c_TcpSelectReactor_Create(c_TcpReactor_t** out_reactor, c_Allocator_t* allocator) {
|
|
if (!out_reactor) return C_ERR_PARAM;
|
|
c_Allocator_t alloc = allocator ? *allocator : c_DefaultAllocator;
|
|
|
|
c_SelectReactorImpl_t* impl = (c_SelectReactorImpl_t*)c_Allocator_Calloc(&alloc, 1, sizeof(c_SelectReactorImpl_t));
|
|
if (!impl) return C_ERR_NOMEM;
|
|
|
|
impl->base.vtbl = &g_SelectReactorVtbl;
|
|
impl->sockets = NULL;
|
|
impl->count = 0;
|
|
impl->capacity = 0;
|
|
impl->allocator = alloc;
|
|
|
|
*out_reactor = &impl->base;
|
|
return C_SUCCESS;
|
|
}
|
|
|