discovery.c File Reference

Parallel mDNS and ACDS session discovery implementation. More...

Go to the source code of this file.

Data Structures
struct	discovery_thread_state_t
	Thread-safe result sharing between discovery threads. More...
struct	mdns_query_state_t
	Internal state for collecting discovered services. More...
struct	mdns_thread_context_t
	Context for mDNS discovery thread. More...
struct	acds_thread_context_t
	Context for ACDS discovery thread. More...

Functions
void	pubkey_to_hex (const uint8_t pubkey[32], char hex_out[65])
asciichat_error_t	hex_to_pubkey (const char *hex_str, uint8_t pubkey_out[32])
discovery_tui_server_t *	discovery_mdns_query (int timeout_ms, int max_servers, bool quiet, int *out_count)
	Public mDNS query function used by both parallel discovery and TUI wrapper.
void	discovery_mdns_destroy (discovery_tui_server_t *servers)
	Free memory from mDNS discovery results.
void	discovery_config_init_defaults (discovery_config_t *config)
asciichat_error_t	discover_session_parallel (const char *session_string, const discovery_config_t *config, discovery_result_t *result)

Detailed Description

Parallel mDNS and ACDS session discovery implementation.

This module provides automated discovery of ascii-chat servers via parallel mDNS (local LAN) and ACDS (internet) lookups.

Architecture:

• mDNS discovery: discovery_mdns_query() - core implementation (this module)
• ACDS discovery: ACDS client implementation for centralized lookup
• Parallel coordination: Concurrent threads with "race to success" semantics
• TUI wrapper: discovery_tui.c calls discovery_mdns_query() for interactive selection

Definition in file discovery.c.

Function Documentation

discover_session_parallel()

asciichat_error_t discover_session_parallel	(	const char *	session_string,
		const discovery_config_t *	config,
		discovery_result_t *	result
	)

Definition at line 518 of file discovery.c.

                                                                        {
  if (!session_string || !config || !result) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to discover_session_parallel");
    return ERROR_INVALID_PARAM;
  }
 
  // Validate session string format
  if (!is_session_string(session_string)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session string format");
    return ERROR_INVALID_PARAM;
  }
 
  memset(result, 0, sizeof(*result));
  log_info("Discovery: Looking up session '%s'", session_string);
 
  // Initialize thread state
  discovery_thread_state_t state;
  memset(&state, 0, sizeof(state));
  state.result = result;
  mutex_init(&state.lock);
  cond_init(&state.signal);
 
  // Determine which discovery methods to use
  bool use_mdns = true;
  bool use_acds = config->expected_pubkey != NULL || config->insecure_mode;
 
  if (!use_acds) {
    log_debug("Discovery: mDNS-only mode (no --server-key and no --acds-insecure)");
  }
 
  // Spawn mDNS thread
  asciichat_thread_t mdns_thread;
  asciichat_thread_init(&mdns_thread);
 
  if (use_mdns) {
    mdns_thread_context_t *mdns_ctx = SAFE_MALLOC(sizeof(*mdns_ctx), mdns_thread_context_t *);
    if (!mdns_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate mDNS context");
      mutex_destroy(&state.lock);
      cond_destroy(&state.signal);
      return ERROR_MEMORY;
    }
 
    mdns_ctx->session_string = session_string;
    mdns_ctx->state = &state;
    mdns_ctx->expected_pubkey = config->expected_pubkey;
 
    int thread_err = asciichat_thread_create(&mdns_thread, mdns_thread_fn, mdns_ctx);
    if (thread_err != 0) {
      log_warn("Discovery: Failed to spawn mDNS thread");
      SAFE_FREE(mdns_ctx);
      use_mdns = false;
    }
  }
 
  // Spawn ACDS thread
  asciichat_thread_t acds_thread;
  asciichat_thread_init(&acds_thread);
 
  if (use_acds) {
    acds_thread_context_t *acds_ctx = SAFE_MALLOC(sizeof(*acds_ctx), acds_thread_context_t *);
    if (!acds_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate ACDS context");
      if (use_mdns && asciichat_thread_is_initialized(&mdns_thread)) {
        asciichat_thread_join(&mdns_thread, NULL);
      }
      mutex_destroy(&state.lock);
      cond_destroy(&state.signal);
      return ERROR_MEMORY;
    }
 
    acds_ctx->session_string = session_string;
    acds_ctx->state = &state;
    acds_ctx->config = config;
 
    int thread_err = asciichat_thread_create(&acds_thread, acds_thread_fn, acds_ctx);
    if (thread_err != 0) {
      log_warn("Discovery: Failed to spawn ACDS thread");
      SAFE_FREE(acds_ctx);
      use_acds = false;
    }
  }
 
  // Wait for result (mDNS timeout 2s + ACDS timeout 5s max)
  uint32_t wait_timeout_ms = config->acds_timeout_ms + 1000;
  mutex_lock(&state.lock);
  {
    uint32_t elapsed_ms = 0;
    while (!state.found && elapsed_ms < wait_timeout_ms) {
      // Check if both threads are done
      if (state.mdns_done && state.acds_done) {
        break;
      }
 
      // Wait with timeout
      cond_timedwait(&state.signal, &state.lock, 500 * NS_PER_MS_INT);
      elapsed_ms += 500;
    }
  }
  mutex_unlock(&state.lock);
 
  // Join threads
  if (use_mdns && asciichat_thread_is_initialized(&mdns_thread)) {
    asciichat_thread_join(&mdns_thread, NULL);
  }
  if (use_acds && asciichat_thread_is_initialized(&acds_thread)) {
    asciichat_thread_join(&acds_thread, NULL);
  }
 
  // Cleanup
  mutex_destroy(&state.lock);
  cond_destroy(&state.signal);
 
  // Check result
  if (!result->success) {
    SET_ERRNO(ERROR_NOT_FOUND, "Session '%s' not found (mDNS/ACDS timeout)", session_string);
    return ERROR_NOT_FOUND;
  }
 
  log_info("Discovery: Session '%s' discovered via %s", session_string,
           result->source == DISCOVERY_SOURCE_MDNS ? "mDNS" : "ACDS");
 
  return ASCIICHAT_OK;
}

References discovery_thread_state_t::acds_done, asciichat_thread_create(), asciichat_thread_join(), acds_thread_context_t::config, mdns_thread_context_t::expected_pubkey, discovery_thread_state_t::found, is_session_string(), discovery_thread_state_t::lock, discovery_thread_state_t::mdns_done, mutex_destroy(), mutex_init(), discovery_thread_state_t::result, mdns_thread_context_t::session_string, acds_thread_context_t::session_string, discovery_thread_state_t::signal, mdns_thread_context_t::state, and acds_thread_context_t::state.

discovery_config_init_defaults()

void discovery_config_init_defaults

(

discovery_config_t *

config

)

Definition at line 496 of file discovery.c.

                                                                {
  if (!config)
    return;
 
  memset(config, 0, sizeof(*config));
 
  // Check if debug or release build
#ifdef NDEBUG
  // Release: use internet ACDS
  SAFE_STRNCPY(config->acds_server, "discovery.ascii-chat.com", sizeof(config->acds_server) - 1);
#else
  // Debug: use local ACDS
  SAFE_STRNCPY(config->acds_server, "127.0.0.1", sizeof(config->acds_server) - 1);
#endif
 
  config->acds_port = OPT_ACDS_PORT_INT_DEFAULT;
  config->mdns_timeout_ms = 2 * MS_PER_SEC_INT;
  config->acds_timeout_ms = 5 * MS_PER_SEC_INT;
  config->insecure_mode = false;
  config->expected_pubkey = NULL;
}

References discovery_config_t::acds_port.

discovery_mdns_destroy()

void discovery_mdns_destroy

(

discovery_tui_server_t *

servers

)

Free memory from mDNS discovery results.

Definition at line 267 of file discovery.c.

                                                             {
  SAFE_FREE(servers);
}

Referenced by discovery_tui_free_results().

discovery_mdns_query()

discovery_tui_server_t * discovery_mdns_query	(	int	timeout_ms,
		int	max_servers,
		bool	quiet,
		int *	out_count
	)

Public mDNS query function used by both parallel discovery and TUI wrapper.

Parameters

timeout_ms	Query timeout in milliseconds
max_servers	Maximum servers to discover
quiet	If true, suppresses progress messages
out_count	Output: number of servers discovered

Returns

Array of discovered servers, or NULL on error. Use discovery_mdns_destroy() to free.

Definition at line 179 of file discovery.c.

                                                                                                          {
  if (!out_count) {
    SET_ERRNO(ERROR_INVALID_PARAM, "out_count pointer is NULL");
    return NULL;
  }
 
  *out_count = 0;
 
  // Apply defaults
  if (timeout_ms <= 0) {
    timeout_ms = 2 * MS_PER_SEC_INT;
  }
  if (max_servers <= 0) {
    max_servers = 20;
  }
 
  // Allocate state for collecting servers
  mdns_query_state_t state;
  memset(&state, 0, sizeof(state));
  state.capacity = max_servers;
  state.timeout_ms = timeout_ms;
  state.start_time_ms = (int64_t)time_ns_to_ms(time_get_ns());
 
  // Allocate server array
  state.servers = SAFE_MALLOC((size_t)state.capacity * sizeof(discovery_tui_server_t), discovery_tui_server_t *);
  if (!state.servers) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate mDNS discovery server array");
    return NULL;
  }
  memset(state.servers, 0, state.capacity * sizeof(discovery_tui_server_t));
 
  if (!quiet) {
    log_info("mDNS: Searching for ascii-chat servers on local network (timeout: %dms)", state.timeout_ms);
    printf("🔍 Searching for ascii-chat servers on LAN...\n");
  }
 
  // Initialize mDNS
  asciichat_mdns_t *mdns = asciichat_mdns_init();
  if (!mdns) {
    log_warn("mDNS: Failed to initialize mDNS - discovery unavailable");
    SAFE_FREE(state.servers);
    return NULL;
  }
 
  // Start mDNS query for _ascii-chat._tcp services
  asciichat_error_t query_result =
      asciichat_mdns_query(mdns, "_ascii-chat._tcp.local", discovery_mdns_callback, &state);
 
  if (query_result != ASCIICHAT_OK) {
    log_info("mDNS: Query failed - no servers found via service discovery");
    asciichat_mdns_destroy(mdns);
    SAFE_FREE(state.servers);
    return NULL;
  }
 
  // Poll for responses until timeout
  int64_t deadline = state.start_time_ms + state.timeout_ms;
  while (!state.query_complete && (int64_t)time_ns_to_ms(time_get_ns()) < deadline) {
    int poll_timeout = (int)(deadline - (int64_t)time_ns_to_ms(time_get_ns()));
    if (poll_timeout < 0) {
      poll_timeout = 0;
    }
    if (poll_timeout > 100) {
      poll_timeout = 100; // Check every 100ms
    }
    asciichat_mdns_update(mdns, poll_timeout);
  }
 
  // Cleanup mDNS
  asciichat_mdns_destroy(mdns);
 
  if (!quiet) {
    if (state.count > 0) {
      printf("✅ Found %d ascii-chat server%s on LAN\n", state.count, state.count == 1 ? "" : "s");
      log_info("mDNS: Found %d server(s)", state.count);
    } else {
      printf("❌ No ascii-chat servers found on LAN\n");
      log_info("mDNS: No servers found");
    }
  }
 
  *out_count = state.count;
  return state.servers;
}

References asciichat_mdns_destroy(), asciichat_mdns_init(), asciichat_mdns_query(), asciichat_mdns_update(), mdns_query_state_t::capacity, mdns_query_state_t::count, mdns_query_state_t::query_complete, mdns_query_state_t::servers, mdns_query_state_t::start_time_ms, time_get_ns(), and mdns_query_state_t::timeout_ms.

Referenced by discovery_tui_query().

hex_to_pubkey()

asciichat_error_t hex_to_pubkey	(	const char *	hex_str,
		uint8_t	pubkey_out[32]
	)

Definition at line 58 of file discovery.c.

                                                                             {
  if (!hex_str || !pubkey_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid hex_str or pubkey_out pointer");
    return ERROR_INVALID_PARAM;
  }
 
  if (strlen(hex_str) != 64) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Hex string must be exactly 64 characters");
    return ERROR_INVALID_PARAM;
  }
 
  for (int i = 0; i < 32; i++) {
    char hex_byte[3];
    hex_byte[0] = hex_str[i * 2];
    hex_byte[1] = hex_str[i * 2 + 1];
    hex_byte[2] = '\0';
 
    if (!isxdigit(hex_byte[0]) || !isxdigit(hex_byte[1])) {
      SET_ERRNO(ERROR_INVALID_PARAM, "Invalid hex character in string");
      return ERROR_INVALID_PARAM;
    }
 
    pubkey_out[i] = (uint8_t)strtol(hex_byte, NULL, 16);
  }
 
  return ASCIICHAT_OK;
}

pubkey_to_hex()

void pubkey_to_hex	(	const uint8_t	pubkey[32],
		char	hex_out[65]
	)

Definition at line 49 of file discovery.c.

                                                               {
  if (!pubkey || !hex_out)
    return;
  for (int i = 0; i < 32; i++) {
    safe_snprintf(hex_out + (i * 2), 3, "%02x", pubkey[i]);
  }
  hex_out[64] = '\0';
}

References safe_snprintf().

Referenced by client_crypto_handshake(), and server_crypto_handshake().