ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
parallel_connect.c
Go to the documentation of this file.
1
2/* Storage capacities in elements; text buffers include the terminating NUL. */
3#define NETWORK_PARALLEL_CONNECT_PORT_BUFFER_SIZE 16
4
10
11#include <ascii-chat/otel.h>
13#include <ascii-chat/log/log.h>
14#include <libplatform/compiler.h>
15#include <libplatform/system.h>
16#include <libplatform/terminal.h>
18#include <string.h>
19
20#ifdef _WIN32
21#include <winsock2.h>
22#include <ws2tcpip.h>
23#else
24#include <netdb.h>
25#include <sys/socket.h>
26#include <sys/types.h>
27#include <sys/select.h>
28#include <fcntl.h>
29#endif
30
35typedef struct {
37 struct sockaddr_storage addr;
38 socklen_t addr_len;
39 int family;
40 const char *family_name;
42 volatile bool connected;
43 volatile bool done;
45 volatile bool *winner_found;
46 mutex_t *lock;
47 cond_t *signal;
51
52static void *attempt_connection_thread(void *arg) {
54 if (!attempt)
55 return NULL;
56
57 log_debug("PCONN: [%s] Starting connection attempt", attempt->family_name);
58
59 attempt->socket = socket(attempt->family, SOCK_STREAM, 0);
60 if (attempt->socket == INVALID_SOCKET_VALUE) {
61 log_debug("PCONN: [%s] Failed to create socket", attempt->family_name);
62 goto done;
63 }
64
65 // Check if winner already found
66 mutex_lock(attempt->lock);
67 if (*attempt->winner_found) {
68 log_debug("PCONN: [%s] Winner already found, aborting", attempt->family_name);
69 mutex_unlock(attempt->lock);
70 socket_close(attempt->socket);
71 attempt->socket = INVALID_SOCKET_VALUE;
72 goto done;
73 }
74 mutex_unlock(attempt->lock);
75
76 // Set socket to non-blocking
77 if (socket_set_nonblocking(attempt->socket, true) != ASCIICHAT_OK) {
78 log_debug("PCONN: [%s] Failed to set non-blocking mode", attempt->family_name);
79 socket_close(attempt->socket);
80 attempt->socket = INVALID_SOCKET_VALUE;
81 goto done;
82 }
83
84 // Attempt non-blocking connect
85 log_debug("PCONN: [%s] Attempting connect with %dms timeout", attempt->family_name, attempt->timeout_ms);
86 int connect_result = connect(attempt->socket, (struct sockaddr *)&attempt->addr, attempt->addr_len);
87
88 int connect_error = socket_get_last_error();
89 bool is_in_progress = socket_is_in_progress_error(connect_error) || socket_is_would_block_error(connect_error);
90
91 if (connect_result == 0) {
92 // Immediate success (rare)
93 log_debug("PCONN: [%s] Connected immediately", attempt->family_name);
94 attempt->connected = true;
95 } else if (is_in_progress) {
96 // Wait with select() using short timeouts so we can check for winner, exit callback, and exit early
97 uint32_t elapsed_ms = 0;
98 uint32_t check_interval_ms = 100; // Check every 100ms if winner found or exit requested
99
100 while (elapsed_ms < attempt->timeout_ms) {
101 // Check if caller requested shutdown/exit (e.g., SIGTERM signal handler set flag)
102 if (attempt->should_exit_callback && attempt->should_exit_callback(attempt->callback_data)) {
103 log_debug("PCONN: [%s] Exit requested via callback, aborting connection", attempt->family_name);
104 break;
105 }
106
107 // Check if winner was already found (allow loser to exit early)
108 mutex_lock(attempt->lock);
109 bool should_exit = *attempt->winner_found;
110 mutex_unlock(attempt->lock);
111
112 if (should_exit) {
113 log_debug("PCONN: [%s] Winner already found, exiting early", attempt->family_name);
114 break;
115 }
116
117 fd_set writefds;
118 FD_ZERO(&writefds);
119 FD_SET(attempt->socket, &writefds);
120
121 struct timeval tv;
122 tv.tv_sec = check_interval_ms / 1000;
123 tv.tv_usec = (check_interval_ms % 1000) * 1000;
124
125 int select_result = select((int)attempt->socket + 1, NULL, &writefds, NULL, &tv);
126
127 if (select_result > 0) {
128 // Check if connection actually succeeded
129 int so_error = 0;
130 socklen_t len = sizeof(so_error);
131 getsockopt(attempt->socket, SOL_SOCKET, SO_ERROR, (char *)&so_error, &len);
132
133 if (so_error == 0) {
134 log_debug("PCONN: [%s] Connection succeeded", attempt->family_name);
135 attempt->connected = true;
136 } else {
137 log_debug("PCONN: [%s] Connection failed: %d", attempt->family_name, so_error);
138 }
139 break;
140 } else if (select_result < 0) {
141 log_debug("PCONN: [%s] Select error", attempt->family_name);
142 break;
143 }
144
145 elapsed_ms += check_interval_ms;
146 }
147
148 if (elapsed_ms >= attempt->timeout_ms && !attempt->connected) {
149 log_debug("PCONN: [%s] Connection timeout after %dms", attempt->family_name, attempt->timeout_ms);
150 }
151 } else {
152 log_debug("PCONN: [%s] Connect failed immediately: %d", attempt->family_name, connect_error);
153 }
154
155 // Signal winner if this succeeded
156 if (attempt->connected) {
157 mutex_lock(attempt->lock);
158 if (!*attempt->winner_found) {
159 log_info("PCONN: [%s] Won the race! Setting as winner", attempt->family_name);
160 *attempt->winner_socket = attempt->socket;
161 *attempt->winner_found = true;
162 attempt->socket = INVALID_SOCKET_VALUE; // Don't close it - caller owns it
163 cond_signal(attempt->signal);
164 } else {
165 log_debug("PCONN: [%s] Connected but another won already, closing", attempt->family_name);
166 socket_close(attempt->socket);
167 attempt->socket = INVALID_SOCKET_VALUE;
168 }
169 mutex_unlock(attempt->lock);
170 } else {
171 // Signal that we're done trying
172 mutex_lock(attempt->lock);
173 cond_signal(attempt->signal);
174 mutex_unlock(attempt->lock);
175 }
176
177done:
178 attempt->done = true;
179 return NULL;
180}
181
183 ASCII_OTEL_SCOPE(PARALLEL_CONNECT);
184 if (!config || !out_socket) {
185 return SET_ERRNO(ERROR_INVALID_PARAM, "config or out_socket is NULL");
186 }
187
188 *out_socket = INVALID_SOCKET_VALUE;
189
190 char ascii_hostname[HOSTNAME_BUFFER_SIZE];
191 asciichat_error_t normalized = hostname_to_ascii(config->hostname, ascii_hostname, sizeof(ascii_hostname));
192 if (normalized != ASCIICHAT_OK)
193 return normalized;
194
195 // Resolve hostname
196 log_debug("PCONN: Resolving %s:%d", config->hostname, config->port);
197
198 struct addrinfo hints;
199 struct addrinfo *result = NULL;
200 memset(&hints, 0, sizeof(hints));
201 hints.ai_family = AF_UNSPEC;
202 hints.ai_socktype = SOCK_STREAM;
203
205 safe_snprintf(port_str, sizeof(port_str), "%d", config->port);
206
207 int gai_result;
208 {
209 ASCII_OTEL_SCOPE(DNS_RESOLVE);
210 if (otel_scope.retained)
211 gotel_attr_string(&otel_scope.scope, "dns.question.name", config->hostname);
212 gai_result = getaddrinfo(ascii_hostname, port_str, &hints, &result);
213 if (gai_result && otel_scope.retained)
214 gotel_error(&otel_scope.scope, "dns.error", "DNS lookup failed");
215 }
216 if (gai_result != 0) {
217 return SET_ERRNO(ERROR_NETWORK, "Failed to resolve %s: %s", config->hostname, gai_strerror(gai_result));
218 }
219
220 // Find first IPv4 and IPv6 addresses
221 struct addrinfo *ipv4_addr = NULL;
222 struct addrinfo *ipv6_addr = NULL;
223
224 for (struct addrinfo *rp = result; rp != NULL; rp = rp->ai_next) {
225 if (rp->ai_family == AF_INET && !ipv4_addr) {
226 ipv4_addr = rp;
227 log_debug("PCONN: Found IPv4 address");
228 } else if (rp->ai_family == AF_INET6 && !ipv6_addr) {
229 ipv6_addr = rp;
230 log_debug("PCONN: Found IPv6 address");
231 }
232 if (ipv4_addr && ipv6_addr)
233 break;
234 }
235
236 // Need at least one address
237 if (!ipv4_addr && !ipv6_addr) {
238 freeaddrinfo(result);
239 return SET_ERRNO(ERROR_NETWORK, "No IPv4 or IPv6 addresses found for %s", config->hostname);
240 }
241
242 // Shared state
243 mutex_t lock;
244 cond_t signal;
245 mutex_init(&lock, "parallel_connect");
246 cond_init(&signal, "parallel_connect");
247
248 volatile socket_t winner_socket = INVALID_SOCKET_VALUE;
249 volatile bool winner_found = false;
250
251 // An unavailable address family never starts a worker. Its cleanup must not
252 // close descriptor zero, which can subsequently be reused by the event loop.
253 connection_attempt_t ipv4_attempt = {.socket = INVALID_SOCKET_VALUE};
254 connection_attempt_t ipv6_attempt = {.socket = INVALID_SOCKET_VALUE};
255 platform_thread_t ipv4_thread;
256 platform_thread_t ipv6_thread;
257
258 thread_init(&ipv4_thread);
259 thread_init(&ipv6_thread);
260
261 // Start IPv4 attempt if available
262 if (ipv4_addr) {
263 ipv4_attempt.family = AF_INET;
264 ipv4_attempt.family_name = "IPv4";
265 ipv4_attempt.timeout_ms = config->timeout_ms;
266 ipv4_attempt.winner_socket = &winner_socket;
267 ipv4_attempt.winner_found = &winner_found;
268 ipv4_attempt.lock = &lock;
269 ipv4_attempt.signal = &signal;
270 ipv4_attempt.should_exit_callback = config->should_exit_callback;
271 ipv4_attempt.callback_data = config->callback_data;
272 memcpy(&ipv4_attempt.addr, ipv4_addr->ai_addr, ipv4_addr->ai_addrlen);
273 ipv4_attempt.addr_len = ipv4_addr->ai_addrlen;
274
275 platform_thread_create(&ipv4_thread, "connect_ipv4", attempt_connection_thread, &ipv4_attempt);
276 }
277
278 // Start IPv6 attempt if available
279 if (ipv6_addr) {
280 ipv6_attempt.family = AF_INET6;
281 ipv6_attempt.family_name = "IPv6";
282 ipv6_attempt.timeout_ms = config->timeout_ms;
283 ipv6_attempt.winner_socket = &winner_socket;
284 ipv6_attempt.winner_found = &winner_found;
285 ipv6_attempt.lock = &lock;
286 ipv6_attempt.signal = &signal;
287 ipv6_attempt.should_exit_callback = config->should_exit_callback;
288 ipv6_attempt.callback_data = config->callback_data;
289 memcpy(&ipv6_attempt.addr, ipv6_addr->ai_addr, ipv6_addr->ai_addrlen);
290 ipv6_attempt.addr_len = ipv6_addr->ai_addrlen;
291
292 platform_thread_create(&ipv6_thread, "connect_ipv6", attempt_connection_thread, &ipv6_attempt);
293 }
294
295 // Wait for winner or both to finish
296 uint32_t max_wait_ms = config->timeout_ms + 1000;
297 uint32_t elapsed_ms = 0;
298
299 mutex_lock(&lock);
300 while (!winner_found && elapsed_ms < max_wait_ms) {
301 cond_timedwait(&signal, &lock, 100 * NS_PER_MS_INT);
302 elapsed_ms += 100;
303
304 // Check if both are done
305 if (ipv4_addr && ipv6_addr) {
306 if (ipv4_attempt.done && ipv6_attempt.done) {
307 break;
308 }
309 } else if ((ipv4_addr && ipv4_attempt.done) || (ipv6_addr && ipv6_attempt.done)) {
310 break;
311 }
312 }
313 mutex_unlock(&lock);
314
315 // Join threads (must wait for both to complete before returning)
316 // The threads access shared state on our stack, so we cannot return until they're done
317 if (thread_is_initialized(&ipv4_thread)) {
318 thread_join(&ipv4_thread, NULL);
319 }
320 if (thread_is_initialized(&ipv6_thread)) {
321 thread_join(&ipv6_thread, NULL);
322 }
323
324 // Close any remaining sockets
325 if (ipv4_attempt.socket != INVALID_SOCKET_VALUE) {
326 socket_close(ipv4_attempt.socket);
327 }
328 if (ipv6_attempt.socket != INVALID_SOCKET_VALUE) {
329 socket_close(ipv6_attempt.socket);
330 }
331
332 // Cleanup
333 mutex_destroy(&lock);
334 cond_destroy(&signal);
335 freeaddrinfo(result);
336
337 // Check result
338 if (winner_socket == INVALID_SOCKET_VALUE) {
339 return SET_ERRNO(ERROR_NETWORK, "Failed to connect to %s:%d (both IPv4 and IPv6 failed)", config->hostname, config->port);
340 }
341
342 *out_socket = (socket_t)winner_socket;
343 log_info("PCONN: Successfully connected to %s:%d", config->hostname, config->port);
344 return ASCIICHAT_OK;
345}
bool(* parallel_connect_should_exit_fn)(void *user_data)
#define SET_ERRNO(code,...)
bool socket_is_would_block_error(int error_code)
int socket_close(socket_t sock)
int socket_get_last_error(void)
unsigned int uint32_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_NETWORK
Definition error_codes.h:76
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define HOSTNAME_BUFFER_SIZE
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
#define NS_PER_MS_INT
Definition time.h:172
asciichat_error_t hostname_to_ascii(const char *hostname, char *output, size_t capacity)
Definition url.c:103
int socket_t
📝 Logging API with multiple log levels and terminal output control
bool should_exit(void)
Definition main.c:248
#define ASCII_OTEL_SCOPE(id)
Definition otel.h:77
asciichat_error_t parallel_connect(const parallel_connect_config_t *config, socket_t *out_socket)
#define NETWORK_PARALLEL_CONNECT_PORT_BUFFER_SIZE
Parallel IPv4/IPv6 connection with race-to-connect semantics.
🔤 String Manipulation and Shell Escaping Utilities
Per-thread connection attempt state for parallel IPv4/IPv6 racing.
volatile bool done
True if this attempt finished.
volatile bool * winner_found
Shared flag indicating a winner exists.
int family
Address family (AF_INET or AF_INET6).
socklen_t addr_len
Length of address structure.
void * callback_data
User data for callback.
mutex_t * lock
Shared mutex for coordination.
parallel_connect_should_exit_fn should_exit_callback
Optional exit callback for graceful shutdown.
const char * family_name
Human-readable family name ("IPv4"/"IPv6").
uint32_t timeout_ms
Connection timeout in milliseconds.
socket_t socket
Socket for this attempt.
volatile bool connected
True if this attempt succeeded.
cond_t * signal
Shared condition variable for signaling.
struct sockaddr_storage addr
Socket address to connect to.
volatile socket_t * winner_socket
Shared pointer to winning socket.
parallel_connect_should_exit_fn should_exit_callback
⏱️ High-precision timing utilities using sokol_time.h and uthash
🌐 Production-Grade URL Validation and Parsing