parallel_connect.c File Reference

Parallel IPv4/IPv6 connection implementation. More...

Go to the source code of this file.

Data Structures
struct	connection_attempt_t
	Per-thread connection attempt state for parallel IPv4/IPv6 racing. More...

Functions
asciichat_error_t	parallel_connect (const parallel_connect_config_t *config, socket_t *out_socket)

Detailed Description

Parallel IPv4/IPv6 connection implementation.

Definition in file parallel_connect.c.

Function Documentation

parallel_connect()

asciichat_error_t parallel_connect	(	const parallel_connect_config_t *	config,
		socket_t *	out_socket
	)

Definition at line 174 of file parallel_connect.c.

                                                                                                  {
  if (!config || !out_socket) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "config or out_socket is NULL");
  }
 
  *out_socket = INVALID_SOCKET_VALUE;
 
  // Resolve hostname
  log_debug("PCONN: Resolving %s:%d", config->hostname, config->port);
 
  struct addrinfo hints;
  struct addrinfo *result = NULL;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
 
  char port_str[16];
  safe_snprintf(port_str, sizeof(port_str), "%d", config->port);
 
  int gai_result = getaddrinfo(config->hostname, port_str, &hints, &result);
  if (gai_result != 0) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to resolve %s: %s", config->hostname, gai_strerror(gai_result));
  }
 
  // Find first IPv4 and IPv6 addresses
  struct addrinfo *ipv4_addr = NULL;
  struct addrinfo *ipv6_addr = NULL;
 
  for (struct addrinfo *rp = result; rp != NULL; rp = rp->ai_next) {
    if (rp->ai_family == AF_INET && !ipv4_addr) {
      ipv4_addr = rp;
      log_debug("PCONN: Found IPv4 address");
    } else if (rp->ai_family == AF_INET6 && !ipv6_addr) {
      ipv6_addr = rp;
      log_debug("PCONN: Found IPv6 address");
    }
    if (ipv4_addr && ipv6_addr)
      break;
  }
 
  // Need at least one address
  if (!ipv4_addr && !ipv6_addr) {
    freeaddrinfo(result);
    return SET_ERRNO(ERROR_NETWORK, "No IPv4 or IPv6 addresses found for %s", config->hostname);
  }
 
  // Shared state
  mutex_t lock;
  cond_t signal;
  mutex_init(&lock);
  cond_init(&signal);
 
  volatile socket_t winner_socket = INVALID_SOCKET_VALUE;
  volatile bool winner_found = false;
 
  connection_attempt_t ipv4_attempt = {0};
  connection_attempt_t ipv6_attempt = {0};
  asciichat_thread_t ipv4_thread;
  asciichat_thread_t ipv6_thread;
 
  asciichat_thread_init(&ipv4_thread);
  asciichat_thread_init(&ipv6_thread);
 
  // Start IPv4 attempt if available
  if (ipv4_addr) {
    ipv4_attempt.family = AF_INET;
    ipv4_attempt.family_name = "IPv4";
    ipv4_attempt.timeout_ms = config->timeout_ms;
    ipv4_attempt.winner_socket = &winner_socket;
    ipv4_attempt.winner_found = &winner_found;
    ipv4_attempt.lock = &lock;
    ipv4_attempt.signal = &signal;
    ipv4_attempt.should_exit_callback = config->should_exit_callback;
    ipv4_attempt.callback_data = config->callback_data;
    memcpy(&ipv4_attempt.addr, ipv4_addr->ai_addr, ipv4_addr->ai_addrlen);
    ipv4_attempt.addr_len = ipv4_addr->ai_addrlen;
 
    asciichat_thread_create(&ipv4_thread, attempt_connection_thread, &ipv4_attempt);
  }
 
  // Start IPv6 attempt if available
  if (ipv6_addr) {
    ipv6_attempt.family = AF_INET6;
    ipv6_attempt.family_name = "IPv6";
    ipv6_attempt.timeout_ms = config->timeout_ms;
    ipv6_attempt.winner_socket = &winner_socket;
    ipv6_attempt.winner_found = &winner_found;
    ipv6_attempt.lock = &lock;
    ipv6_attempt.signal = &signal;
    ipv6_attempt.should_exit_callback = config->should_exit_callback;
    ipv6_attempt.callback_data = config->callback_data;
    memcpy(&ipv6_attempt.addr, ipv6_addr->ai_addr, ipv6_addr->ai_addrlen);
    ipv6_attempt.addr_len = ipv6_addr->ai_addrlen;
 
    asciichat_thread_create(&ipv6_thread, attempt_connection_thread, &ipv6_attempt);
  }
 
  // Wait for winner or both to finish
  uint32_t max_wait_ms = config->timeout_ms + 1000;
  uint32_t elapsed_ms = 0;
 
  mutex_lock(&lock);
  while (!winner_found && elapsed_ms < max_wait_ms) {
    cond_timedwait(&signal, &lock, 100 * NS_PER_MS_INT);
    elapsed_ms += 100;
 
    // Check if both are done
    if (ipv4_addr && ipv6_addr) {
      if (ipv4_attempt.done && ipv6_attempt.done) {
        break;
      }
    } else if (ipv4_addr && ipv4_attempt.done) {
      break;
    } else if (ipv6_addr && ipv6_attempt.done) {
      break;
    }
  }
  mutex_unlock(&lock);
 
  // Join threads (must wait for both to complete before returning)
  // The threads access shared state on our stack, so we cannot return until they're done
  if (asciichat_thread_is_initialized(&ipv4_thread)) {
    asciichat_thread_join(&ipv4_thread, NULL);
  }
  if (asciichat_thread_is_initialized(&ipv6_thread)) {
    asciichat_thread_join(&ipv6_thread, NULL);
  }
 
  // Close any remaining sockets
  if (ipv4_attempt.socket != INVALID_SOCKET_VALUE) {
    socket_close(ipv4_attempt.socket);
  }
  if (ipv6_attempt.socket != INVALID_SOCKET_VALUE) {
    socket_close(ipv6_attempt.socket);
  }
 
  // Cleanup
  mutex_destroy(&lock);
  cond_destroy(&signal);
  freeaddrinfo(result);
 
  // Check result
  if (winner_socket == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to connect to %s:%d (both IPv4 and IPv6 failed)", config->hostname,
                     config->port);
  }
 
  *out_socket = (socket_t)winner_socket;
  log_info("PCONN: Successfully connected to %s:%d", config->hostname, config->port);
  return ASCIICHAT_OK;
}

References connection_attempt_t::addr, connection_attempt_t::addr_len, asciichat_thread_create(), asciichat_thread_join(), connection_attempt_t::callback_data, connection_attempt_t::done, connection_attempt_t::family, connection_attempt_t::family_name, connection_attempt_t::lock, mutex_destroy(), mutex_init(), safe_snprintf(), connection_attempt_t::should_exit_callback, connection_attempt_t::signal, connection_attempt_t::socket, connection_attempt_t::timeout_ms, connection_attempt_t::winner_found, and connection_attempt_t::winner_socket.

Referenced by acds_client_connect().