ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
lib/network/tcp/server.c
Go to the documentation of this file.
1
5
6/* Storage capacities in elements; text buffers include the terminating NUL. */
7#define NETWORK_TCP_SERVER_PORT_BUFFER_SIZE 16
8#define NETWORK_TCP_SERVER_PORT_NAME_BUFFER_SIZE 32
9
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13#include <stdbool.h>
14#include <errno.h>
15
16#ifdef _WIN32
17#include <winsock2.h>
18#include <ws2tcpip.h>
19#else
20#include <netdb.h>
21#endif
22
24#include <ascii-chat/common.h>
25#include <ascii-chat/log/log.h>
26#include <libplatform/socket.h>
27#include <libplatform/thread.h>
28#include <ascii-chat/util/ip.h>
31
43static socket_t bind_and_listen(const char *address, int family, int port) {
44 struct addrinfo hints, *res = NULL;
45 memset(&hints, 0, sizeof(hints));
46 hints.ai_family = family;
47 hints.ai_socktype = SOCK_STREAM;
48 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
49
51 SAFE_SNPRINTF(port_str, sizeof(port_str), "%d", port);
52
53 // Use provided address or NULL for wildcard
54 const char *addr_str = (address && address[0] != '\0') ? address : NULL;
55
56 int gai_result = getaddrinfo(addr_str, port_str, &hints, &res);
57 if (gai_result != 0) {
58 log_error("getaddrinfo failed for %s:%d: %s", addr_str ? addr_str : "(wildcard)", port, gai_strerror(gai_result));
59 return INVALID_SOCKET_VALUE;
60 }
61
62 const char *socket_name = (family == AF_INET6) ? "server_ipv6" : "server_ipv4";
63 socket_t server_socket = socket_create(socket_name, res->ai_family, res->ai_socktype, res->ai_protocol);
64 if (server_socket == INVALID_SOCKET_VALUE) {
65 log_error("Failed to create socket for %s:%d", addr_str ? addr_str : "(wildcard)", port);
66 freeaddrinfo(res);
67 return INVALID_SOCKET_VALUE;
68 }
69
70 // Enable SO_REUSEADDR to allow quick restarts
71 int reuse = 1;
72 if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse, sizeof(reuse)) < 0) {
73 log_warn("Failed to set SO_REUSEADDR on %s:%d", addr_str ? addr_str : "(wildcard)", port);
74 }
75
76 // For IPv6, disable IPv4-mapped addresses (IPV6_V6ONLY=1) to support dual-stack
77 if (family == AF_INET6) {
78 int ipv6only = 1;
79 if (setsockopt(server_socket, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&ipv6only, sizeof(ipv6only)) < 0) {
80 log_warn("Failed to set IPV6_V6ONLY on [%s]:%d", addr_str ? addr_str : "::", port);
81 }
82 }
83
84 // Bind socket
85 if (bind(server_socket, res->ai_addr, (socklen_t)res->ai_addrlen) < 0) {
86 log_error("Failed to bind %s:%d", addr_str ? addr_str : "(wildcard)", port);
87 socket_close(server_socket);
88 freeaddrinfo(res);
89 return INVALID_SOCKET_VALUE;
90 }
91
92 freeaddrinfo(res);
93
94 // Listen with backlog of 128 connections
95 if (listen(server_socket, 128) < 0) {
96 log_error("Failed to listen on %s:%d", addr_str ? addr_str : "(wildcard)", port);
97 socket_close(server_socket);
98 return INVALID_SOCKET_VALUE;
99 }
100
101 log_info("Listening on %s%s%s:%d (%s)", family == AF_INET6 ? "[" : "", addr_str ? addr_str : (family == AF_INET ? "0.0.0.0" : "::"), family == AF_INET6 ? "]" : "", port,
102 family == AF_INET ? "IPv4" : "IPv6");
103
104 return server_socket;
105}
106
108 if (!server || !config) {
109 return SET_ERRNO(ERROR_INVALID_PARAM, "server or config is NULL");
110 }
111
112 // Initialize server state
113 memset(server, 0, sizeof(*server));
114 server->listen_socket = INVALID_SOCKET_VALUE;
115 server->listen_socket6 = INVALID_SOCKET_VALUE;
116 atomic_store_bool(&server->running, true);
117 server->config = *config; // Copy config
118
119 // Determine which IP versions to bind
120 bool should_bind_ipv4 = config->bind_ipv4;
121 bool should_bind_ipv6 = config->bind_ipv6;
122
123 // Bind IPv4 socket if requested
124 if (should_bind_ipv4) {
125 const char *ipv4_addr = (config->ipv4_address && config->ipv4_address[0] != '\0') ? config->ipv4_address : NULL;
126 server->listen_socket = bind_and_listen(ipv4_addr, AF_INET, config->port);
127
128 if (server->listen_socket == INVALID_SOCKET_VALUE) {
129 log_warn("Failed to bind IPv4 socket");
130 }
131 }
132
133 // Bind IPv6 socket if requested
134 if (should_bind_ipv6) {
135 const char *ipv6_addr = (config->ipv6_address && config->ipv6_address[0] != '\0') ? config->ipv6_address : NULL;
136 server->listen_socket6 = bind_and_listen(ipv6_addr, AF_INET6, config->port);
137
138 if (server->listen_socket6 == INVALID_SOCKET_VALUE) {
139 log_warn("Failed to bind IPv6 socket");
140 }
141 }
142
143 // Ensure at least one socket bound successfully
144 if (server->listen_socket == INVALID_SOCKET_VALUE && server->listen_socket6 == INVALID_SOCKET_VALUE) {
145 NAMED_UNREGISTER(&server->running);
146 return SET_ERRNO(ERROR_NETWORK_BIND, "Failed to bind any sockets (IPv4 and IPv6 both failed)");
147 }
148
149 /* Register server with named registry, identified by port */
151 snprintf(port_name, sizeof(port_name), "server:%d", server->config.port);
152 NAMED_REGISTER(server, port_name, "tcp_server", "0x%tx", NULL);
153
154 /* Register server's sync primitives with hierarchical naming */
155 NAMED_REGISTER_ATOMIC(&server->running, "is_running", (uintptr_t)(const void *)(server));
156
157 return ASCIICHAT_OK;
158}
159
160static void tcp_event_tick(void *arg) {
161 tcp_server_t *server = arg;
162 if (!atomic_load_bool(&server->running)) {
164 return;
165 }
166 if (server->config.tick_fn)
167 server->config.tick_fn(server->config.tick_user_data);
168}
169
170static asciichat_error_t tcp_server_run_events(tcp_server_t *server) {
172 if (result != ASCIICHAT_OK)
173 return result;
174 platform_event_listener_t *listener = NULL;
175 if (server->listen_socket != INVALID_SOCKET_VALUE)
176 result = platform_event_listen(server->event_loop, &server->listen_socket, server->config.event_handler, server->config.user_data, &listener);
177 if (result == ASCIICHAT_OK && server->listen_socket6 != INVALID_SOCKET_VALUE)
178 result = platform_event_listen(server->event_loop, &server->listen_socket6, server->config.event_handler, server->config.user_data, &listener);
179 if (result == ASCIICHAT_OK)
180 result = platform_event_loop_tick(server->event_loop, 50, tcp_event_tick, server);
181 if (result != ASCIICHAT_OK)
183 log_info("TCP event backend: %s", platform_event_backend());
186 server->event_loop = NULL;
187 return result != ASCIICHAT_OK ? result : cleanup;
188}
189
191 if (!server) {
192 return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
193 }
194
195 if (!server->config.event_handler)
196 return SET_ERRNO(ERROR_INVALID_PARAM, "TCP event handler is required");
197 return tcp_server_run_events(server);
198}
199
201 if (!server) {
202 return;
203 }
204
205 log_debug("Shutting down TCP server...");
206
207 // Signal server to stop
208 atomic_store_bool(&server->running, false);
209
210 // Close listen sockets
211 if (server->listen_socket != INVALID_SOCKET_VALUE) {
212 log_debug("Closing IPv4 listen socket");
214 server->listen_socket = INVALID_SOCKET_VALUE;
215 }
216
217 if (server->listen_socket6 != INVALID_SOCKET_VALUE) {
218 log_debug("Closing IPv6 listen socket");
220 server->listen_socket6 = INVALID_SOCKET_VALUE;
221 }
222
223 log_debug("TCP listener shutdown complete");
224 NAMED_UNREGISTER(&server->running);
225 NAMED_UNREGISTER(server);
226}
#define SET_ERRNO(code,...)
void atomic_store_bool(atomic_t *a, bool value)
Atomically store a boolean value.
bool atomic_load_bool(atomic_t *a)
Atomic pointer wrapper.
int socket_close(socket_t sock)
Named object registry for debugging — log identifiable resource names.
Dedicated worker for all pending errno stacks and handled history. Signal handlers may only request a...
asciichat_error_t platform_event_loop_destroy(platform_event_loop_t *loop)
Definition event.c:268
asciichat_error_t platform_event_listen(platform_event_loop_t *loop, socket_t *socket, platform_event_accept_fn accept, void *arg, platform_event_listener_t **out)
Definition event.c:448
void platform_event_loop_stop(platform_event_loop_t *loop)
Definition event.c:257
asciichat_error_t platform_event_loop_run(platform_event_loop_t *loop)
Definition event.c:234
asciichat_error_t platform_event_loop_create(platform_event_loop_t **out)
Definition event.c:205
asciichat_error_t platform_event_loop_tick(platform_event_loop_t *loop, uint64_t interval, platform_event_task_fn fn, void *arg)
Definition event.c:296
const char * platform_event_backend(void)
Definition event.c:279
struct platform_event_listener platform_event_listener_t
Definition event.h:17
#define SAFE_SNPRINTF(buffer, buffer_size,...)
#define NAMED_REGISTER_ATOMIC(a, name, parent_ptr)
Register an atomic_t with automatic format specifier.
#define NAMED_REGISTER(ptr, name, type, fmt, parent_ptr)
Register any pointer with base name, type, format spec, and location (auto-suffix).
#define NAMED_UNREGISTER(ptr)
Unregister a pointer.
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_NETWORK_BIND
Definition error_codes.h:77
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
int socket_t
⚙️ Common definitions, error codes, macros, and types shared throughout the application
struct tcp_server tcp_server_t
🌍 IP Address Parsing and Formatting Utilities
void tcp_server_destroy(tcp_server_t *server)
#define NETWORK_TCP_SERVER_PORT_BUFFER_SIZE
asciichat_error_t tcp_server_init(tcp_server_t *server, const tcp_server_config_t *config)
asciichat_error_t tcp_server_run(tcp_server_t *server)
#define NETWORK_TCP_SERVER_PORT_NAME_BUFFER_SIZE
📝 Logging API with multiple log levels and terminal output control
🔤 String Manipulation and Shell Escaping Utilities
bool bind_ipv6
Whether to bind IPv6 socket.
platform_event_accept_fn event_handler
Required asynchronous accept handler.
void * user_data
User data passed to each client handler.
bool bind_ipv4
Whether to bind IPv4 socket.
const char * ipv4_address
IPv4 bind address (NULL or empty = don't bind).
const char * ipv6_address
IPv6 bind address (NULL or empty = don't bind).
void(* tick_fn)(void *user_data)
Optional periodic callback on the tcp_server_run thread.
platform_event_loop_t * event_loop
Owned while the asynchronous server runs.
atomic_t running
Server running flag (set false to shutdown).
tcp_server_config_t config
Server configuration.
socket_t listen_socket
IPv4 listen socket.
socket_t listen_socket6
IPv6 listen socket.
⏱️ High-precision timing utilities using sokol_time.h and uthash