server_like.h File Reference

Go to the source code of this file.

Data Structures
struct	session_server_like_config
	The useful part of session server like config is in [struct].mdns, [struct].upnp, init_fn, init_user_data: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. More...

Typedefs
typedef asciichat_error_t(*	session_server_like_init_fn) (void *user_data)
typedef void(*	session_server_like_interrupt_fn) (int sig)
typedef void(*	session_server_like_cleanup_fn) (void *user_data)
typedef void(*	session_server_like_status_fn) (void *user_data, ui_status_t *out_status)
typedef struct session_server_like_config	session_server_like_config_t
	The useful part of session server like config is in [struct].mdns, [struct].upnp, init_fn, init_user_data: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

Functions
asciichat_error_t	session_server_like_run (const session_server_like_config_t *config)
network_server_t *	session_server_like_get_network_server (void)
asciichat_mdns_t *	session_server_like_get_mdns_ctx (void)
nat_upnp_context_t *	session_server_like_get_upnp_ctx (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)
void	session_server_like_request_shutdown (void)

Typedef Documentation

session_server_like_cleanup_fn

typedef void(* session_server_like_cleanup_fn) (void *user_data)

Definition at line 23 of file server_like.h.

session_server_like_config_t

typedef struct session_server_like_config session_server_like_config_t

The useful part of session server like config is in [struct].mdns, [struct].upnp, init_fn, init_user_data: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

session_server_like_init_fn

typedef asciichat_error_t(* session_server_like_init_fn) (void *user_data)

Shared server-mode orchestration. Networking is owned by network_server_t; modes supply one callback set for TCP, WebSocket, and authenticated peers. Listeners are constructed before init_fn and started only after it succeeds. All connections drain before cleanup_fn releases mode dependencies. The interrupt callback only publishes atomic shutdown requests.

Definition at line 19 of file server_like.h.

session_server_like_interrupt_fn

typedef void(* session_server_like_interrupt_fn) (int sig)

Definition at line 21 of file server_like.h.

session_server_like_status_fn

typedef void(* session_server_like_status_fn) (void *user_data, ui_status_t *out_status)

Definition at line 25 of file server_like.h.

Function Documentation

session_server_like_get_mdns_ctx()

asciichat_mdns_t * session_server_like_get_mdns_ctx

(

void

)

Definition at line 172 of file server_like.c.

                                                         {
  return g_mdns_ctx;
}

session_server_like_get_network_server()

network_server_t * session_server_like_get_network_server

(

void

)

Definition at line 168 of file server_like.c.

                                                               {
  return g_network_server;
}

Referenced by acds_server_init(), and broadcast_server_state_to_all_clients().

session_server_like_get_upnp_ctx()

nat_upnp_context_t * session_server_like_get_upnp_ctx

(

void

)

Definition at line 176 of file server_like.c.

                                                           {
  return g_upnp_ctx;
}

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 )

Definition at line 184 of file server_like.c.

                                                                                         {
  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;
}

References asciichat_mdns_advertise(), ASCIICHAT_OK, ERROR_INVALID_STATE, HOSTNAME_BUFFER_SIZE, LOG_ERRNO_IF_SET, log_info, log_warn, and SET_ERRNO.

Referenced by session_server_like_run().

session_server_like_request_shutdown()

void session_server_like_request_shutdown

(

void

)

Definition at line 217 of file server_like.c.

                                                {
  server_like_signal_handler(SIGINT);
}

Referenced by acds_main().

session_server_like_run()

asciichat_error_t session_server_like_run

(

const session_server_like_config_t *

config

)

Definition at line 229 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->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;
}

References ASCIICHAT_ERRNO_HANDLED, asciichat_mdns_destroy(), asciichat_mdns_init(), ASCIICHAT_OK, network_server_config_t::bind_ipv4, session_server_like_config::cleanup_fn, session_server_like_config::cleanup_user_data, session_server_like_config::connection_user_data, session_server_like_config::connections, session_server_like_config::description, session_server_like_config::enabled, errno_notifications_suppress(), errno_scope_begin(), errno_scope_end(), ERROR_INVALID_PARAM, ERROR_NETWORK, session_server_like_config::fd_limit_target, GET_OPTION, session_server_like_config::idle_timeout_ms, session_server_like_config::init_fn, session_server_like_config::init_user_data, session_server_like_config::interrupt_fn, network_server_config_t::ipv4_address, is_lan_ipv4(), is_localhost_ipv4(), log_debug, LOG_ERRNO_IF_SET, log_error, log_info, log_warn, session_server_like_config::max_payload, session_server_like_config::mdns, nat_upnp_close(), nat_upnp_get_address(), nat_upnp_is_active(), nat_upnp_matches_bind_address(), nat_upnp_open(), network_server_create(), network_server_destroy(), network_server_run(), network_server_start(), network_server_stop(), network_server_websocket_enabled(), NS_PER_MS_INT, network_connection_callbacks_t::packet, session_server_like_config::partial_timeout_ms, platform_disable_keepawake(), platform_enable_keepawake(), platform_raise_fd_limit(), platform_signal(), session_server_like_config::raise_fd_limit, session_server_like_config::service_name, session_server_like_config::service_type, session_quic_listeners_close(), session_quic_listeners_open(), session_server_like_mdns_advertise(), SESSION_SERVER_LIKE_PUBLIC_ADDR_BUFFER_SIZE, SET_ERRNO, session_server_like_config::status_fn, session_server_like_config::status_user_data, session_server_like_config::tick_fn, session_server_like_config::tick_user_data, ui_controller_title_ready(), ui_status_log_destroy(), ui_status_log_init(), session_server_like_config::upnp, and session_server_like_config::websocket_enabled.

Referenced by acds_main(), and server_main().

session_server_like_shutdown_requested()

bool session_server_like_shutdown_requested

(

void

)

Definition at line 221 of file server_like.c.

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