server_like.c File Reference

Unified lifecycle for server-like modes (server, discovery-service) More...

Go to the source code of this file.

Macros
#define	KEYBOARD_QUEUE_SIZE   256

Functions
tcp_server_t *	session_server_like_get_tcp_server (void)
asciichat_mdns_t *	session_server_like_get_mdns_ctx (void)
nat_upnp_context_t *	session_server_like_get_upnp_ctx (void)
websocket_server_t *	session_server_like_get_websocket_server (void)
asciichat_error_t	session_server_like_mdns_advertise (const char *name, const char *type, uint16_t port, const char **txt, size_t txt_count)
bool	session_server_like_shutdown_requested (void)
asciichat_error_t	session_server_like_handshake (crypto_handshake_context_t *ctx, acip_transport_t *transport)
asciichat_error_t	session_server_like_run (const session_server_like_config_t *config)

Detailed Description

Unified lifecycle for server-like modes (server, discovery-service)

Owns TCP server, WebSocket server, mDNS, UPnP, status screen, keyboard, and signal handling. Modes plug in via callbacks.

Definition in file server_like.c.

Macro Definition Documentation

KEYBOARD_QUEUE_SIZE

#define KEYBOARD_QUEUE_SIZE   256

Definition at line 73 of file server_like.c.

Function Documentation

session_server_like_get_mdns_ctx()

asciichat_mdns_t * session_server_like_get_mdns_ctx

(

void

)

Get the mDNS context owned by server_like.

READINESS GUARANTEE: Available from step 6 onward (during init_fn and after). Use for deferred advertisement when service_name is not known at config time. NULL if mDNS is disabled or initialization failed (non-fatal).

Returns

Pointer to mDNS context, or NULL if not initialized or disabled

Definition at line 266 of file server_like.c.

                                                         {
  return g_mdns_ctx;
}

session_server_like_get_tcp_server()

tcp_server_t * session_server_like_get_tcp_server

(

void

)

Get the TCP server instance owned by server_like.

READINESS GUARANTEE: Available from step 4 onward (during init_fn, interrupt_fn, cleanup_fn). Modes use this for client registry operations and to close listen sockets in interrupt_fn. The TCP server is guaranteed to be valid during init_fn and in interrupt_fn (async-signal context).

Returns

Pointer to TCP server (never NULL after step 4), or NULL if called before TCP init

Definition at line 262 of file server_like.c.

                                                       {
  return g_tcp_server_initialized ? &g_tcp_server : NULL;
}

Referenced by acds_server_init().

session_server_like_get_upnp_ctx()

nat_upnp_context_t * session_server_like_get_upnp_ctx

(

void

)

Get the UPnP context owned by server_like.

READINESS GUARANTEE: Available from step 5 onward (during init_fn and after). Use for querying the public address. NULL if port mapping failed or was disabled. Failure to map UPnP is non-fatal; WebRTC fallback will be used.

Returns

Pointer to UPnP context, or NULL if not initialized or disabled

Definition at line 270 of file server_like.c.

                                                           {
  return g_upnp_ctx;
}

session_server_like_get_websocket_server()

websocket_server_t * session_server_like_get_websocket_server

(

void

)

Get the WebSocket server instance owned by server_like.

READINESS GUARANTEE: WebSocket object is constructed at step 7, but the event loop thread does NOT start until after mode init succeeds (step 9). Callbacks will not run until after init_fn returns successfully. This prevents client connections before mode state is ready.

Available for configuration during init_fn, and for state queries after init_fn succeeds. The WebSocket object is valid for the lifetime of the session_server_like_run() call.

Returns

Pointer to WebSocket server, or NULL if not initialized or disabled

Definition at line 274 of file server_like.c.

                                                                   {
  return g_websocket_thread_started ? &g_websocket_server : NULL;
}

session_server_like_handshake()

asciichat_error_t session_server_like_handshake	(	crypto_handshake_context_t *	ctx,
		acip_transport_t *	transport
	)

Perform the server-side crypto handshake on a transport.

Runs the full handshake sequence: receive PROTOCOL_VERSION, send parameters, key exchange, auth challenge, and completion. Both server and discovery-service modes use this single implementation.

The caller must initialize the handshake context (crypto_handshake_init or crypto_handshake_init_with_password) and configure keys/whitelist on it before calling this function.

Parameters

ctx	Initialized handshake context with keys/auth configured
transport	ACIP transport for the client connection

Returns

ASCIICHAT_OK on success, error code on handshake failure

Definition at line 416 of file server_like.c.

                                                                                                              {
  if (!ctx || !transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "handshake context or transport is NULL");
  }
 
  // Crypto key generation and signing can exceed the normal one-second packet
  // polling interval on slower or busy peers. Keep the longer deadline scoped
  // to the handshake so idle-session polling remains responsive.
  const uint64_t previous_receive_timeout_ns = transport->receive_timeout_ns;
  transport->receive_timeout_ns = 30ULL * NS_PER_SEC_INT;
  asciichat_error_t result = session_server_like_handshake_impl(ctx, transport);
  transport->receive_timeout_ns = previous_receive_timeout_ns;
  return result;
}

References ERROR_INVALID_PARAM, NS_PER_SEC_INT, acip_transport::receive_timeout_ns, and SET_ERRNO.

Referenced by acds_client_handler(), and acds_websocket_client_handler().

session_server_like_mdns_advertise()

asciichat_error_t session_server_like_mdns_advertise	(	const char *	name,
		const char *	type,
		uint16_t	port,
		const char **	txt,
		size_t	txt_count
	)

Advertise or re-advertise an mDNS service.

Convenience wrapper for modes that need deferred or updated advertisement (e.g., server mode advertises after ACDS registration provides session string).

Parameters

name	Service instance name
type	Service type (e.g., "_ascii-chat._tcp")
port	Service port
txt	Optional TXT records (NULL-terminated array), or NULL
txt_count	Number of TXT records

Returns

ASCIICHAT_OK on success, error if mDNS is not initialized

Definition at line 282 of file server_like.c.

                                                                                         {
  if (!g_mdns_ctx) {
    return SET_ERRNO(ERROR_INVALID_STATE, "mDNS context not initialized");
  }
 
  char hostname[256] = {0};
  gethostname(hostname, sizeof(hostname) - 1);
 
  asciichat_mdns_service_t service = {
      .name = name,
      .type = type,
      .host = hostname,
      .port = port,
      .txt_records = txt,
      .txt_count = txt_count,
  };
 
  asciichat_error_t result = asciichat_mdns_advertise(g_mdns_ctx, &service);
  if (result != ASCIICHAT_OK) {
    LOG_ERRNO_IF_SET("Failed to advertise mDNS service");
    log_warn("mDNS advertising failed - LAN discovery disabled");
  } else {
    log_info("mDNS: Service advertised as '%s' type '%s' (port=%d)", name, type, port);
  }
 
  return result;
}

References asciichat_mdns_advertise(), ASCIICHAT_OK, ERROR_INVALID_STATE, LOG_ERRNO_IF_SET, log_info, log_warn, asciichat_mdns_service_t::name, and SET_ERRNO.

Referenced by session_server_like_run().

session_server_like_run()

asciichat_error_t session_server_like_run

(

const session_server_like_config_t *

config

)

Run a server-like mode with unified lifecycle management.

Orchestrates the complete lifecycle with proper initialization ordering to ensure mode-specific state is ready before external clients can connect.

Initialization Sequence

1. Keepawake validation and setup
2. File descriptor limit raising (if configured)
3. Signal handler registration (SIGINT, SIGTERM, SIGPIPE) with shutdown persistence
4. TCP server init (binds to GET_OPTION port/address)
5. UPnP port mapping (if enabled)
6. mDNS context init and optional immediate advertisement
7. WebSocket server construction (object created, event loop thread deferred)
8. Mode-specific init_fn() - mode initializes its state (crypto keys, rate limiter, DB, etc.)
9. WebSocket event loop thread start (only if mode init succeeds)
10. Status screen and keyboard threads (if status_fn provided)
11. TCP accept loop (blocks until shutdown)

CRITICAL ORDERING NOTES:

• WebSocket event loop thread ONLY starts after mode init succeeds (step 9, not step 7)
• This prevents clients from arriving before mode state is ready
• If SIGINT/SIGTERM arrives during init, subsequent steps are skipped
• Mode-specific init can check session_server_like_shutdown_requested() for early shutdowns

Cleanup (always runs, in order, guarded against partial init)

1. Join status screen and keyboard threads
2. Stop WebSocket server (only if thread was started, atomic stop, cancel, join with 500ms timeout)
3. Mode-specific cleanup_fn() (TCP registry still available, guarded by mode state flags)
4. Destroy WebSocket server (only if successfully initialized)
5. Destroy TCP server
6. Close UPnP port mapping
7. Destroy mDNS context
8. Disable keepawake

SAFETY GUARANTEES:

• Cleanup operations only touch resources that were successfully initialized
• Signal handler safely sets shutdown flag during early initialization
• Modes can detect early shutdown via session_server_like_shutdown_requested()
• Partial initialization failures do not trigger undefined behavior in cleanup

Parameters

config

Mode configuration (must not be NULL)

Returns

ASCIICHAT_OK on success, or first error from init or accept loop

Definition at line 435 of file server_like.c.

                                                                                      {
  if (!config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "config is NULL");
  }
  if (!config->init_fn) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "init_fn is NULL");
  }
  if (!config->interrupt_fn) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "interrupt_fn is NULL");
  }
  if (!config->tcp_handler) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "tcp_handler is NULL");
  }
 
  g_config = config;
  asciichat_error_t result = ASCIICHAT_OK;
 
  /* === 1. Keepawake === */
 
  bool keepawake_enabled = GET_OPTION(enable_keepawake);
  bool keepawake_disabled = GET_OPTION(disable_keepawake);
  if (keepawake_enabled && keepawake_disabled) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Cannot specify both --keepawake and --no-keepawake");
  }
  if (keepawake_enabled) {
    platform_enable_keepawake();
  }
 
  /* === 2. File descriptor limit === */
 
  if (config->raise_fd_limit) {
    platform_raise_fd_limit(config->fd_limit_target);
  }
 
  /* === 3. Signal handlers === */
 
  atomic_store_u64(&g_shutdown_requested, 0);
  g_interrupt_fn = config->interrupt_fn;
  platform_signal(SIGINT, server_like_signal_handler);
  platform_signal(SIGTERM, server_like_signal_handler);
#ifndef _WIN32
  platform_signal(SIGPIPE, SIG_IGN);
#endif
 
  /* === 4. TCP server init === */
 
  int port = GET_OPTION(port);
  const char *address = GET_OPTION(address);
  const char *address6 = GET_OPTION(address6);
 
  bool ipv4_has_value = (address && strlen(address) > 0);
  bool ipv6_has_value = (address6 && strlen(address6) > 0);
 
  tcp_server_config_t tcp_config = {
      .port = port,
      .ipv4_address = ipv4_has_value ? address : NULL,
      .ipv6_address = ipv6_has_value ? address6 : NULL,
      .bind_ipv4 = ipv4_has_value || !ipv6_has_value,
      .bind_ipv6 = ipv6_has_value || !ipv4_has_value,
      .accept_timeout_sec = 1,
      .client_handler = config->tcp_handler,
      .user_data = config->tcp_user_data,
      .status_update_fn = NULL,
      .status_update_data = NULL,
  };
 
  result = tcp_server_init(&g_tcp_server, &tcp_config);
  if (result != ASCIICHAT_OK) {
    log_error("Failed to initialize TCP server on port %d", port);
    goto cleanup;
  }
  g_tcp_server_initialized = true;
  log_info("TCP server initialized on port %d", port);
 
  /* === 5. UPnP port mapping === */
 
  if (config->upnp.enabled && GET_OPTION(enable_upnp)) {
    asciichat_error_t upnp_result = nat_upnp_open(port, config->upnp.description, &g_upnp_ctx);
 
    if (upnp_result == ASCIICHAT_OK && g_upnp_ctx) {
      char public_addr[22];
      if (nat_upnp_get_address(g_upnp_ctx, public_addr, sizeof(public_addr)) == ASCIICHAT_OK) {
        char msg[256];
        safe_snprintf(msg, sizeof(msg), "Public endpoint: %s (direct TCP)", public_addr);
        log_console(LOG_INFO, msg);
        log_info("UPnP: Port mapping successful, public endpoint: %s", public_addr);
      }
    } else {
      log_info("UPnP: Port mapping unavailable or failed - will use WebRTC fallback");
    }
  }
 
  /* === 6. mDNS === */
 
  if (config->mdns.enabled) {
    g_mdns_ctx = asciichat_mdns_init();
    if (!g_mdns_ctx) {
      LOG_ERRNO_IF_SET("Failed to initialize mDNS (non-fatal, LAN discovery disabled)");
      log_warn("mDNS disabled - LAN discovery will not be available");
    } else if (config->mdns.service_name) {
      // Immediate advertisement if service_name is provided
      session_server_like_mdns_advertise(config->mdns.service_name, config->mdns.service_type, port, NULL, 0);
    }
  }
 
  /* === 7. WebSocket server construction (thread deferred until after mode init) === */
 
  if (config->websocket.enabled) {
    websocket_server_config_t ws_config = {
        .port = GET_OPTION(websocket_port),
        .client_handler = config->websocket.handler,
        .user_data = config->websocket.user_data,
        .tls_cert_path = GET_OPTION(websocket_tls_cert),
        .tls_key_path = GET_OPTION(websocket_tls_key),
    };
 
    memset(&g_websocket_server, 0, sizeof(g_websocket_server));
    asciichat_error_t ws_result = websocket_server_init(&g_websocket_server, &ws_config);
    if (ws_result != ASCIICHAT_OK) {
      log_warn("Failed to initialize WebSocket server - browser clients will not be supported");
    } else {
      g_websocket_initialized = true;
      log_info("WebSocket server initialized on port %d (event loop deferred until after mode init)",
               GET_OPTION(websocket_port));
    }
  }
 
  /* === 8. Mode-specific init === */
 
  result = config->init_fn(config->init_user_data);
  if (result != ASCIICHAT_OK) {
    log_error("Mode initialization failed");
    goto cleanup;
  }
 
  /* === 8b. WebSocket event loop thread start (after mode init succeeds) === */
 
  if (g_websocket_initialized && !atomic_load_u64(&g_shutdown_requested)) {
    if (asciichat_thread_create(&g_websocket_thread, "websocket_event_loop", websocket_server_thread_wrapper,
                                &g_websocket_server) == 0) {
      g_websocket_thread_started = true;
      log_info("WebSocket event loop thread started");
    } else {
      log_error("Failed to start WebSocket event loop thread");
    }
  }
 
  /* === 9. Status screen === */
 
  if (config->status_fn) {
    bool status_opt = GET_OPTION(status_screen);
    bool status_explicit = GET_OPTION(status_screen_explicitly_set);
    if ((status_opt && terminal_is_interactive()) || (status_explicit && status_opt)) {
      atomic_store_bool(&g_status_should_exit, false);
      ui_status_log_init();
 
      // Store callback and user data for status thread (avoids reliance on g_config lifetime)
      g_status_fn = config->status_fn;
      g_status_user_data = config->status_user_data;
 
      if (asciichat_thread_create(&g_status_screen_thread, "status_screen", status_screen_thread_func, NULL) == 0) {
        g_status_screen_thread_started = true;
        log_info("Status screen thread started");
      } else {
        log_error("Failed to start status screen thread");
        ui_status_log_destroy();
        g_status_fn = NULL;
        g_status_user_data = NULL;
      }
    }
  }
 
  /* === 10. TCP accept loop (blocks) === */
 
  log_info("Server accepting connections on port %d", port);
  result = tcp_server_run(&g_tcp_server);
  if (result != ASCIICHAT_OK) {
    log_error("TCP server exited with error");
  }
 
  /* === CLEANUP === */
 
cleanup:
  g_config = NULL;
 
  /* 11. Stop status screen */
  if (g_status_screen_thread_started) {
    atomic_store_bool(&g_status_should_exit, true);
    int join_result = asciichat_thread_join_timeout(&g_status_screen_thread, NULL, 2000 * NS_PER_MS_INT);
    if (join_result != 0) {
      log_warn("Status screen thread did not exit within 2s");
    }
    g_status_screen_thread_started = false;
    g_status_fn = NULL;
    g_status_user_data = NULL;
    ui_status_log_destroy();
  }
 
  /* 12. Stop WebSocket server (only if thread was started, i.e., init succeeded) */
  if (g_websocket_thread_started) {
    atomic_store_bool(&g_websocket_server.running, false);
    websocket_server_cancel_service(&g_websocket_server);
    int ws_join = asciichat_thread_join_timeout(&g_websocket_thread, NULL, 500 * NS_PER_MS_INT);
    if (ws_join != 0) {
      log_warn("WebSocket event loop thread did not exit within 500ms");
    }
    g_websocket_thread_started = false;
  }
 
  /* 13. Mode-specific cleanup (only call if config provided) */
  if (config && config->cleanup_fn) {
    config->cleanup_fn(config->cleanup_user_data);
  }
 
  /* 14. Destroy WebSocket server (only if successfully initialized) */
  if (g_websocket_initialized) {
    websocket_server_destroy(&g_websocket_server);
    g_websocket_initialized = false;
    log_debug("WebSocket server destroyed");
  }
 
  /* 15. Destroy TCP server */
  if (g_tcp_server_initialized) {
    tcp_server_destroy(&g_tcp_server);
    g_tcp_server_initialized = false;
    log_debug("TCP server destroyed");
  }
 
  /* 16. UPnP cleanup */
  if (g_upnp_ctx) {
    nat_upnp_close(&g_upnp_ctx);
    log_debug("UPnP port mapping closed");
  }
 
  /* 17. mDNS cleanup */
  if (g_mdns_ctx) {
    asciichat_mdns_destroy(g_mdns_ctx);
    g_mdns_ctx = NULL;
    log_debug("mDNS context destroyed");
  }
 
  /* 18. Keepawake */
  if (keepawake_enabled) {
    platform_disable_keepawake();
  }
 
  return result;
}

References asciichat_mdns_destroy(), asciichat_mdns_init(), ASCIICHAT_OK, asciichat_thread_create, asciichat_thread_join_timeout(), atomic_load_u64(), atomic_store_bool(), atomic_store_u64(), session_server_like_config::cleanup_fn, session_server_like_config::cleanup_user_data, session_server_like_config::description, session_server_like_config::enabled, ERROR_INVALID_PARAM, session_server_like_config::fd_limit_target, GET_OPTION, session_server_like_config::handler, session_server_like_config::init_fn, session_server_like_config::init_user_data, session_server_like_config::interrupt_fn, log_console, log_debug, LOG_ERRNO_IF_SET, log_error, log_info, LOG_INFO, log_warn, session_server_like_config::mdns, nat_upnp_close(), nat_upnp_get_address(), nat_upnp_open(), NS_PER_MS_INT, platform_disable_keepawake(), platform_enable_keepawake(), platform_raise_fd_limit(), platform_signal(), tcp_server_config_t::port, websocket_server_config_t::port, session_server_like_config::raise_fd_limit, websocket_server::running, safe_snprintf(), session_server_like_config::service_name, session_server_like_config::service_type, session_server_like_mdns_advertise(), SET_ERRNO, session_server_like_config::status_fn, session_server_like_config::status_user_data, session_server_like_config::tcp_handler, tcp_server_destroy(), tcp_server_init(), tcp_server_run(), session_server_like_config::tcp_user_data, terminal_is_interactive(), ui_status_log_destroy(), ui_status_log_init(), session_server_like_config::upnp, session_server_like_config::user_data, session_server_like_config::websocket, websocket_server_cancel_service(), websocket_server_destroy(), and websocket_server_init().

Referenced by acds_main(), and server_main().

session_server_like_shutdown_requested()

bool session_server_like_shutdown_requested

(

void

)

Check if a shutdown request was received during initialization.

Modes can use this during init_fn to detect early SIGINT/SIGTERM signals and exit gracefully instead of proceeding with partial initialization.

Returns

true if SIGINT or SIGTERM was received, false otherwise

Definition at line 315 of file server_like.c.

                                                  {
  return (bool)atomic_load_u64(&g_shutdown_requested);
}

References atomic_load_u64().