server_like.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define SESSION_SERVER_LIKE_PUBLIC_ADDR_BUFFER_SIZE 22
 
#include <ascii-chat/crypto/policy.h>
 
#include <ascii-chat/tui/input.h>
#include <ascii-chat/tui/controller.h>
#include "server_like.h"
#include "quic_listeners.h"
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/common.h>
#include <ascii-chat/crypto/handshake/server.h>
#include <ascii-chat/network/quic/quic.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/log/search.h>
#include <ascii-chat/buffer.h>
#include <ascii-chat/debug/named.h>
#include <ascii-chat/network/acip/send.h>
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/options/options.h>
#include <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/terminal.h>
#include <libplatform/systemd.h>
#include <ascii-chat/os/keyboard.h>
#include <libplatform/system.h>
#include <libplatform/terminal.h>
#include <ascii-chat/util/ip.h>
#include <ascii-chat/util/time.h>
#include <signal.h>
#include <string.h>
 
/* ============================================================================
 * Static State
 * ============================================================================ */
 
static network_server_t *g_network_server;
static quic_endpoint_t *g_quic_endpoint;
static quic_endpoint_t *g_webtransport_endpoint;
 
static asciichat_mdns_t *g_mdns_ctx = NULL;
static nat_upnp_context_t *g_upnp_ctx = NULL;
static nat_upnp_context_t *g_ws_upnp_ctx = NULL;
static platform_thread_t g_upnp_thread;
static bool g_upnp_thread_started = false;
static atomic_t g_upnp_stop = {0};
static atomic_t g_upnp_ready = {0};
 
// The worker is the sole mapping writer after mode initialization. Shutdown
// joins it before freeing the context or issuing the delete request.
static void *upnp_renewal_thread(void *unused) {
  (void)unused;
  while (!atomic_load_bool(&g_upnp_stop)) {
    if (atomic_load_bool(&g_upnp_ready)) {
      nat_upnp_context_t *mappings[] = {g_upnp_ctx, g_ws_upnp_ctx};
      for (size_t i = 0; i < sizeof(mappings) / sizeof(mappings[0]); i++) {
        if (mappings[i] && time_get_ns() >= mappings[i]->refresh_at_ns) {
          asciichat_errno_scope_t renewal_scope = errno_scope_begin();
          if (nat_upnp_refresh(mappings[i]) != ASCIICHAT_OK) {
            LOG_ERRNO_IF_SET("Router mapping renewal failed");
          }
          errno_scope_end(renewal_scope, ASCIICHAT_ERRNO_HANDLED);
        }
      }
    }
    time_sleep_ns(100 * NS_PER_MS_INT);
  }
  return NULL;
}
 
static platform_thread_t g_status_screen_thread;
static bool g_status_screen_thread_started = false;

static session_server_like_status_fn g_status_fn = NULL;
static void *g_status_user_data = NULL;
 
/* ============================================================================
 * Signal Handler
 * ============================================================================ */

static atomic_t g_shutdown_requested = {0};
 
static session_server_like_interrupt_fn g_interrupt_fn = NULL;
 
static void server_like_signal_handler(int sig) {
  atomic_store_u64(&g_shutdown_requested, 1);
  if (g_interrupt_fn) {
    g_interrupt_fn(sig);
  }
}
 
/* ============================================================================
 * Keyboard Queue (lock-free SPSC ring buffer)
 * ============================================================================ */
 
/* ============================================================================
 * Status Screen Thread
 * ============================================================================ */

static atomic_t g_status_should_exit = {0};
 
static void *status_screen_thread_func(void *arg) {
  (void)arg;
 
  uint32_t fps = GET_OPTION(fps);
  if (fps == 0) {
    fps = 60;
  }
  uint64_t frame_interval_us = US_PER_SEC_INT / fps;
 
  log_debug("Status screen thread started (target %u FPS)", fps);
 
  int output_fd = platform_isatty(STDOUT_FILENO) ? STDOUT_FILENO : STDERR_FILENO;
 
  // Stderr is the status output when stdout is redirected; retain it in that
  // case. The presentation controller suppresses competing terminal log writes.
  platform_stderr_redirect_handle_t stderr_redirect = {.original_fd = -1, .devnull_fd = -1};
  if (output_fd != STDERR_FILENO) {
    stderr_redirect = platform_stderr_redirect_to_null();
  }
 
  while (!atomic_load_bool(&g_status_should_exit)) {
    uint64_t frame_start = platform_get_monotonic_time_us();
    if (log_search_check_signal_cancel())
      log_search_exit_mode(false);
 
    // Call mode's status callback to populate status data
    // Callbacks outlive the borrowed run configuration until the thread stops.
    if (g_status_fn) {
      ui_status_t status;
      memset(&status, 0, sizeof(status));
      g_status_fn(g_status_user_data, &status);
      ui_status_display_interactive(&status);
    }
 
    // Maintain frame rate
    uint64_t frame_end = platform_get_monotonic_time_us();
    uint64_t frame_time = frame_end - frame_start;
    if (frame_time < frame_interval_us) {
      platform_sleep_us(frame_interval_us - frame_time);
    }
  }
 
  ui_controller_remove(UI_SCREEN_STATUS);
 
  platform_stderr_restore(stderr_redirect);
 
  log_debug("Status screen thread exiting");
  return NULL;
}
 
/* ============================================================================
 * WebSocket Server Thread
 * ============================================================================ */
 
network_server_t *session_server_like_get_network_server(void) {
  return g_network_server;
}
 
asciichat_mdns_t *session_server_like_get_mdns_ctx(void) {
  return g_mdns_ctx;
}
 
nat_upnp_context_t *session_server_like_get_upnp_ctx(void) {
  return g_upnp_ctx;
}
 
/* ============================================================================
 * Helpers
 * ============================================================================ */
 
asciichat_error_t session_server_like_mdns_advertise(const char *name, const char *type, uint16_t port,
                                                     const char **txt, size_t txt_count) {
  if (!g_mdns_ctx) {
    return SET_ERRNO(ERROR_INVALID_STATE, "mDNS context not initialized");
  }
 
  char hostname[HOSTNAME_BUFFER_SIZE] = {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;
}
 
/* ============================================================================
 * Accessors (shutdown state and network resources)
 * ============================================================================ */
 
void session_server_like_request_shutdown(void) {
  server_like_signal_handler(SIGINT);
}
 
bool session_server_like_shutdown_requested(void) {
  return (bool)atomic_load_u64(&g_shutdown_requested);
}
 
/* ============================================================================
 * Shared Handshake
 * ============================================================================ */
 
asciichat_error_t session_server_like_run(const session_server_like_config_t *config) {
  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->connections.packet) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "connection packet callback is NULL");
  }
 
  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) {
    asciichat_errno_scope_t scope = errno_scope_begin();
    bool suppressed = errno_notifications_suppress(true);
    asciichat_error_t keepawake_result = platform_enable_keepawake();
    errno_notifications_suppress(suppressed);
    if (keepawake_result != ASCIICHAT_OK) {
      log_warn("Unable to inhibit system sleep: %s", asciichat_error_string(keepawake_result));
    }
    errno_scope_end(scope, ASCIICHAT_ERRNO_HANDLED);
  }
 
  /* === 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);
 
  const char *effective_address = (address && strlen(address) > 0) ? address : "127.0.0.1";
  const char *effective_address6 = (address6 && strlen(address6) > 0) ? address6 : "::1";
  bool ipv4_has_value = true;
 
  result = session_quic_listeners_open(port, &g_quic_endpoint, &g_webtransport_endpoint);
  if (result != ASCIICHAT_OK)
    goto cleanup;
 
  network_server_config_t tcp_config = {
      .port = port,
      .ipv4_address = effective_address,
      .ipv6_address = effective_address6,
      .bind_ipv4 = true,
      .bind_ipv6 = true,
      .callbacks = config->connections,
      .max_payload = config->max_payload,
      .partial_timeout_ms = config->partial_timeout_ms,
      .idle_timeout_ms = config->idle_timeout_ms,
      .websocket_enabled = config->websocket_enabled,
      .websocket_port = GET_OPTION(websocket_port),
      .tls_cert_path = GET_OPTION(tls_cert),
      .tls_key_path = GET_OPTION(tls_key),
      .tick = config->tick_fn,
      .tick_context = config->tick_user_data,
      .user_data = config->connection_user_data,
      .quic_endpoint = g_quic_endpoint,
      .webtransport_endpoint = g_webtransport_endpoint,
  };
 
  result = network_server_create(&tcp_config, &g_network_server);
  if (result != ASCIICHAT_OK) {
    log_error("Failed to initialize TCP server on port %d", port);
    goto cleanup;
  }
  log_info("TCP server initialized on port %d", port);
 
  /* === 5. UPnP port mapping === */
 
  bool upnp_requested = config->upnp.enabled && GET_OPTION(enable_upnp);
  bool ipv4_loopback = ipv4_has_value && is_localhost_ipv4(address);
  bool ipv4_listener = tcp_config.bind_ipv4 && !ipv4_loopback;
  if (upnp_requested && ipv4_listener) {
    log_info("UPnP status: discovering (TCP port %d)", port);
    asciichat_errno_scope_t mapping_scope = errno_scope_begin();
    asciichat_error_t upnp_result = nat_upnp_open(port, config->upnp.description, &g_upnp_ctx);
    if (upnp_result == ASCIICHAT_OK && !nat_upnp_matches_bind_address(g_upnp_ctx, tcp_config.ipv4_address)) {
      log_warn("NAT: gateway mapping does not target the bound IPv4 listener; removing it");
      nat_upnp_close(&g_upnp_ctx);
      upnp_result = ERROR_NETWORK;
    }
    if (upnp_result == ASCIICHAT_OK && nat_upnp_is_active(g_upnp_ctx)) {
      char public_addr[SESSION_SERVER_LIKE_PUBLIC_ADDR_BUFFER_SIZE];
      if (nat_upnp_get_address(g_upnp_ctx, public_addr, sizeof(public_addr)) == ASCIICHAT_OK) {
        log_info("UPnP status: mapped at %s (external reachability unverified)", public_addr);
      }
    } else {
      log_warn("UPnP status: unavailable. Listener remains enabled; for Internet access, "
               "check router support or manually forward TCP port %d. External reachability is unverified.",
               port);
    }
    errno_scope_end(mapping_scope, ASCIICHAT_ERRNO_HANDLED);
  } else if (upnp_requested) {
    log_info("UPnP status: disabled (requires a non-loopback IPv4 listener)");
  } else {
    log_info("UPnP status: disabled");
    if (ipv4_listener && (!ipv4_has_value || strcmp(address, "0.0.0.0") == 0 || is_lan_ipv4(address))) {
      log_info("For connections from outside your LAN, try --port-forwarding or forward TCP port %d on your router.",
               port);
    }
  }
 
  /* === 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);
    }
  }
 
  /* === 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 (!atomic_load_u64(&g_shutdown_requested)) {
    result = network_server_start(g_network_server);
    if (result != ASCIICHAT_OK)
      goto cleanup;
    platform_systemd_notify_status("Listener started");
    platform_systemd_notify_ready();
  } else {
    goto cleanup;
  }
 
  if (upnp_requested && network_server_websocket_enabled(g_network_server)) {
    // WebSocket binds independently of the raw TCP listener's address.
    asciichat_errno_scope_t ws_mapping_scope = errno_scope_begin();
    if (nat_upnp_open((uint16_t)GET_OPTION(websocket_port), "ascii-chat WebSocket", &g_ws_upnp_ctx) != ASCIICHAT_OK) {
      log_warn("WebSocket mapping unavailable; manually forward TCP port %d if needed", GET_OPTION(websocket_port));
    }
    errno_scope_end(ws_mapping_scope, ASCIICHAT_ERRNO_HANDLED);
  }
 
  if (g_upnp_ctx || g_ws_upnp_ctx) {
    atomic_store_bool(&g_upnp_stop, false);
    atomic_store_bool(&g_upnp_ready, false);
    if (platform_thread_create(&g_upnp_thread, "upnp_renewal", upnp_renewal_thread, NULL) == 0) {
      g_upnp_thread_started = true;
    } else {
      log_warn("NAT: could not start lease renewal; removing the temporary mapping");
      nat_upnp_close(&g_upnp_ctx);
      nat_upnp_close(&g_ws_upnp_ctx);
    }
  }
 
  // Keep bounded log capture available even when only the stats overlay is used.
  ui_status_log_init();
  /* === 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);
 
      // Store callback and user data for the lifetime of the status thread.
      g_status_fn = config->status_fn;
      g_status_user_data = config->status_user_data;
 
      if (platform_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;
      }
    }
  }
 
  atomic_store_bool(&g_upnp_ready, true);
 
  /* === 10. TCP accept loop (blocks) === */
 
  log_info("Server accepting connections on port %d", port);
  ui_controller_title_ready();
  result = network_server_run(g_network_server);
  if (result != ASCIICHAT_OK) {
    log_error("TCP server exited with error");
  }
 
  /* === CLEANUP === */
 
cleanup:
  if (g_upnp_thread_started) {
    atomic_store_bool(&g_upnp_stop, true);
    thread_join(&g_upnp_thread, NULL);
    g_upnp_thread_started = false;
  }
 
  // Remove the mapping before mode teardown, which can wait on other services.
  if (g_upnp_ctx) {
    nat_upnp_close(&g_upnp_ctx);
    log_debug("UPnP port mapping closed");
  }
 
  nat_upnp_close(&g_ws_upnp_ctx);
 
  /* 11. Stop status screen */
  if (g_status_screen_thread_started) {
    atomic_store_bool(&g_status_should_exit, true);
    int join_result = 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();
 
  asciichat_error_t stopped = network_server_stop(g_network_server);
  if (stopped != ASCIICHAT_OK)
    return stopped;
 
  /* 13. Mode-specific cleanup (only call if config provided) */
  if (config && config->cleanup_fn) {
    config->cleanup_fn(config->cleanup_user_data);
  }
 
  network_server_destroy(&g_network_server);
  stopped = session_quic_listeners_close(&g_quic_endpoint, &g_webtransport_endpoint);
  if (stopped != ASCIICHAT_OK)
    return stopped;
 
  /* 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;
}