connection.h File Reference

Go to the source code of this file.

Data Structures
struct	network_connection_callbacks_t
	Callbacks and operations used by network connection callbacks. Packet payloads are borrowed until return. closing stops application producers; closed releases application state after the transport and callbacks have drained. An open failure still receives closing/closed, including partial application init. More...
struct	network_server_config_t
struct	network_connect_config_t
	For network connect config, this is the live record that ties timeout_ms, callback_data, tls_ca_file, quic_visual_datagrams together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. WebSocket establishes its library-managed transport. Returns one owned object. More...

Typedefs
typedef struct network_connection	network_connection_t
typedef struct network_server	network_server_t
typedef struct quic_endpoint	quic_endpoint_t
typedef void(*	network_connection_visit_fn) (network_connection_t *, void *)

Enumerations
enum	network_connection_state_t { NETWORK_NEGOTIATING , NETWORK_READY , NETWORK_CLOSING , NETWORK_CLOSED }

Functions
asciichat_error_t	network_server_create (const network_server_config_t *, network_server_t **)
asciichat_error_t	network_server_start (network_server_t *)
asciichat_error_t	network_server_run (network_server_t *)
void	network_server_request_stop (network_server_t *)
asciichat_error_t	network_server_stop (network_server_t *)
void	network_server_destroy (network_server_t **)
size_t	network_server_connection_count (network_server_t *)
bool	network_server_websocket_enabled (network_server_t *)
const network_server_config_t *	network_server_config (network_server_t *)
asciichat_error_t	network_server_adopt (network_server_t *, acip_transport_t *, const char *peer, bool secure)
asciichat_error_t	network_server_adopt_negotiating (network_server_t *, acip_transport_t *, const char *peer, bool secure)
void	network_server_foreach (network_server_t *, network_connection_visit_fn, void *)
acip_transport_t *	network_connection_transport (network_connection_t *)
void *	network_connection_context (network_connection_t *)
void	network_connection_set_context (network_connection_t *, void *)
const char *	network_connection_peer (network_connection_t *)
bool	network_connection_secure (network_connection_t *)
network_connection_state_t	network_connection_state (network_connection_t *)
void	network_connection_ready (network_connection_t *)
void	network_connection_request_stop (network_connection_t *)
crypto_handshake_context_t *	network_connection_handshake (network_connection_t *)
asciichat_error_t	network_connection_prepare_security (network_connection_t *, bool server, const char *password)
asciichat_error_t	network_connection_adopt (acip_transport_t *, network_connection_t **)
asciichat_error_t	network_connection_adopt_negotiating (acip_transport_t *, const char *peer, bool secure, network_connection_t **)
asciichat_error_t	network_connection_open (const char *name, const char *address, uint16_t default_port, const network_connect_config_t *, network_connection_t **, connection_endpoint_t *)
void	network_connection_destroy (network_connection_t **)
uint8_t	network_connection_crypto_mode (network_connection_t *)
asciichat_error_t	network_connection_run (network_connection_t *, const network_connection_callbacks_t *, void *)

Typedef Documentation

network_connection_t

typedef struct network_connection network_connection_t

Definition at line 8 of file include/ascii-chat/network/connection.h.

network_connection_visit_fn

typedef void(* network_connection_visit_fn) (network_connection_t *, void *)

Iteration pins connections and application state, without holding registry locks across callbacks or sends. The callback must not wait for server shutdown.

Definition at line 74 of file include/ascii-chat/network/connection.h.

network_server_t

typedef struct network_server network_server_t

Definition at line 9 of file include/ascii-chat/network/connection.h.

quic_endpoint_t

typedef struct quic_endpoint quic_endpoint_t

QUIC endpoint for native ACIP and HTTP/3/WebTransport. Native ACIP transports are returned by quic_accept(); generic HTTP/3 request connections are consumed by the configured http_server and are never exposed as ACIP transports. A listener negotiates the selected ALPN on one UDP socket and requires the platform socket subsystem to be initialized.

Definition at line 10 of file include/ascii-chat/network/connection.h.

Enumeration Type Documentation

network_connection_state_t

enum network_connection_state_t

Enumerator
NETWORK_NEGOTIATING
NETWORK_READY
NETWORK_CLOSING
NETWORK_CLOSED

Definition at line 12 of file include/ascii-chat/network/connection.h.

             {
  NETWORK_NEGOTIATING,
  NETWORK_READY,
  NETWORK_CLOSING,
  NETWORK_CLOSED,
} network_connection_state_t;

Function Documentation

network_connection_adopt()

asciichat_error_t network_connection_adopt	(	acip_transport_t *	transport,
		network_connection_t **	out )

Wrap an already authenticated transport in the same ownership contract.

Definition at line 873 of file lib/network/connection.c.

                                                                                                    {
  if (!transport || !out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing connection adoption parameters");
  *out = connection_create(NULL, transport, "peer", true, true);
  return *out ? ASCIICHAT_OK : SET_ERRNO(ERROR_MEMORY, "Cannot own authenticated transport");
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_MEMORY, out, and SET_ERRNO.

Referenced by session_participant_set_transport().

network_connection_adopt_negotiating()

asciichat_error_t network_connection_adopt_negotiating	(	acip_transport_t *	transport,
		const char *	peer,
		bool	secure,
		network_connection_t **	out )

Wrap a connected transport before application negotiation. Ownership transfers only on success. The caller drives negotiation before run().

Definition at line 879 of file lib/network/connection.c.

                                                                                   {
  if (!transport || !out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing connection adoption parameters");
  *out = connection_create(NULL, transport, peer, secure, false);
  return *out ? ASCIICHAT_OK : SET_ERRNO(ERROR_MEMORY, "Cannot own negotiating transport");
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_MEMORY, out, and SET_ERRNO.

network_connection_context()

void * network_connection_context

(

network_connection_t *

c

)

Definition at line 87 of file lib/network/connection.c.

                                                          {
  return c ? atomic_ptr_load(&c->context) : NULL;
}

References network_connection::context.

network_connection_crypto_mode()

uint8_t network_connection_crypto_mode

(

network_connection_t *

c

)

Definition at line 896 of file lib/network/connection.c.

                                                                {
  return c->adopted_security ? c->adopted_security->mode : c->security.mode;
}

References network_connection::adopted_security, acip_security::mode, and network_connection::security.

Referenced by client_crypto_init(), and network_connection_establish().

network_connection_destroy()

void network_connection_destroy

(

network_connection_t **

owner

)

Definition at line 886 of file lib/network/connection.c.

                                                              {
  if (!owner || !*owner)
    return;
  connection_finish(*owner);
  if ((*owner)->cleanup_failed)
    return;
  connection_free(*owner);
  *owner = NULL;
}

Referenced by acds_client_connect(), acds_client_disconnect(), discovery_session_destroy(), and session_connection_establish().

network_connection_handshake()

crypto_handshake_context_t * network_connection_handshake

(

network_connection_t *

c

)

Security storage follows connection ownership, including a retained fallback.

Definition at line 113 of file lib/network/connection.c.

                                                                                  {
  if (c->adopted_security)
    return &c->adopted_security->handshake;
  c->security_claimed = true;
  return &c->security.handshake;
}

References network_connection::adopted_security, acip_security::handshake, network_connection::security, and network_connection::security_claimed.

Referenced by client_connection_start(), client_crypto_init(), discovery_session_start(), and network_connection_establish().

network_connection_open()

asciichat_error_t network_connection_open	(	const char *	name,
		const char *	address,
		uint16_t	default_port,
		const network_connect_config_t *	settings,
		network_connection_t **	out,
		connection_endpoint_t *	resolved )

A NULL config uses backend defaults and the application's exit callback. A supplied config preserves its timeout, including zero, and also checks its cancellation callback before dialing and while waiting for establishment.

Definition at line 806 of file lib/network/connection.c.

                                                                           {
  ASCII_OTEL_SCOPE(CONNECTION_CREATE);
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing connection output");
  *out = NULL;
  if (connect_cancelled((void *)settings))
    return SET_ERRNO(ERROR_NETWORK_CONNECT, "Connection establishment cancelled");
  connection_endpoint_t endpoint;
  asciichat_error_t result = connection_endpoint_resolve(address, port, &endpoint);
  if (result != ASCIICHAT_OK)
    return result;
  acip_transport_t *transport = NULL;
  quic_endpoint_t *quic_endpoint = NULL;
  ASCII_OTEL_ATTR_STRING("network.connection.endpoint_protocol",
                         endpoint.protocol == CONNECTION_ENDPOINT_WEBSOCKET ? "websocket"
                         : endpoint.protocol == CONNECTION_ENDPOINT_QUIC    ? "quic"
                                                                            : "tcp");
  ASCII_OTEL_ATTR_INT("server.port", endpoint.port);
  ASCII_OTEL_ATTR_INT("network.connection.timeout_ms", settings ? settings->timeout_ms
                                                       : endpoint.protocol == CONNECTION_ENDPOINT_WEBSOCKET ? 15000
                                                                                                            : 3000);
  if (endpoint.protocol == CONNECTION_ENDPOINT_QUIC) {
    result = connection_open_quic(&endpoint, settings, &quic_endpoint, &transport);
    if (result != ASCIICHAT_OK)
      return result;
    log_info("Connected to %s:%u using native QUIC", endpoint.host, (unsigned)endpoint.port);
  } else if (endpoint.protocol == CONNECTION_ENDPOINT_WEBSOCKET) {
    transport = acip_websocket_client_transport_create(name, endpoint.input, NULL);
  } else {
    result = connection_open_tcp(name, &endpoint, settings, NULL, &transport);
    if (result != ASCIICHAT_OK)
      return result;
  }
  if (!transport)
    return SET_ERRNO(ERROR_NETWORK_CONNECT, "Cannot establish connection to %s", address);
  if (endpoint.protocol == CONNECTION_ENDPOINT_WEBSOCKET) {
    uint64_t deadline =
        time_get_ns() + (settings ? (uint64_t)settings->timeout_ms * NS_PER_MS_INT : 15 * NS_PER_SEC_INT);
    while (!acip_transport_is_connected(transport) && time_get_ns() < deadline && !connect_cancelled((void *)settings))
      platform_sleep_ms(10);
    if (!acip_transport_is_connected(transport)) {
      acip_transport_destroy(transport);
      return SET_ERRNO(ERROR_NETWORK_CONNECT, "WebSocket establishment failed or cancelled");
    }
  }
  network_connection_t *c = connection_create(NULL, transport, endpoint.host,
                                              endpoint.protocol == CONNECTION_ENDPOINT_QUIC ||
                                                  strncmp(endpoint.input, "wss://", sizeof("wss://") - 1) == 0,
                                              false);
  if (!c) {
    acip_transport_destroy(transport);
    if (quic_endpoint) {
      (void)quic_endpoint_stop(quic_endpoint);
      (void)quic_endpoint_destroy(&quic_endpoint);
    }
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate connection");
  }
  if (resolved)
    *resolved = endpoint;
  c->port = endpoint.port;
  c->owned_quic_endpoint = quic_endpoint;
  *out = c;
  ascii_otel_metric(ASCII_OTEL_METRIC_CONNECTION_ESTABLISHED, 1);
  return ASCIICHAT_OK;
}

References acip_transport_destroy(), acip_websocket_client_transport_create(), ASCII_OTEL_ATTR_INT, ASCII_OTEL_ATTR_STRING, ascii_otel_metric(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, CONNECTION_ENDPOINT_QUIC, connection_endpoint_resolve(), CONNECTION_ENDPOINT_WEBSOCKET, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_CONNECT, connection_endpoint_t::host, connection_endpoint_t::input, log_info, NS_PER_MS_INT, NS_PER_SEC_INT, out, network_connection::owned_quic_endpoint, platform_sleep_ms(), connection_endpoint_t::port, network_connection::port, connection_endpoint_t::protocol, quic_endpoint_destroy(), quic_endpoint_stop(), SET_ERRNO, and network_connect_config_t::timeout_ms.

Referenced by acds_client_connect(), and network_connection_establish().

network_connection_peer()

const char * network_connection_peer

(

network_connection_t *

c

)

Definition at line 93 of file lib/network/connection.c.

                                                             {
  return c->peer;
}

References network_connection::peer.

network_connection_prepare_security()

asciichat_error_t network_connection_prepare_security	(	network_connection_t *	c,
		bool	server,
		const char *	password )

Definition at line 119 of file lib/network/connection.c.

                                                                                                                  {
  if (!c || c->security_claimed || network_connection_state(c) != NETWORK_NEGOTIATING)
    return SET_ERRNO(ERROR_INVALID_STATE, "Connection security already configured");
  c->security_claimed = c->security_options = true;
  /* QUIC protects its own endpoints, but ACIP encryption is also required
   * for the application identity and intermediary trust boundary. */
  bool transport_satisfies_acip_encryption = c->secure && acip_transport_get_type(c->transport) != ACIP_TRANSPORT_QUIC;
  asciichat_error_t result =
      acip_security_init_options(&c->security, server, transport_satisfies_acip_encryption, password);
  if (result == ASCIICHAT_OK && !server) {
    crypto_handshake_context_t *ctx = &c->security.handshake;
    SAFE_STRNCPY(ctx->server_hostname, c->peer, sizeof(ctx->server_hostname));
    SAFE_STRNCPY(ctx->server_ip, c->peer, sizeof(ctx->server_ip));
    ctx->server_port = c->port;
  }
  return result;
}

References acip_security_init_options(), ACIP_TRANSPORT_QUIC, ASCIICHAT_OK, ERROR_INVALID_STATE, acip_security::handshake, network_connection_state(), NETWORK_NEGOTIATING, network_connection::peer, network_connection::port, SAFE_STRNCPY, network_connection::secure, network_connection::security, network_connection::security_claimed, network_connection::security_options, crypto_handshake_context_t::server_hostname, crypto_handshake_context_t::server_ip, crypto_handshake_context_t::server_port, SET_ERRNO, and network_connection::transport.

Referenced by client_crypto_init().

network_connection_ready()

void network_connection_ready

(

network_connection_t *

c

)

Definition at line 102 of file lib/network/connection.c.

                                                       {
  int expected = NETWORK_NEGOTIATING;
  atomic_cas_int(&c->state, &expected, NETWORK_READY);
}

References NETWORK_NEGOTIATING, NETWORK_READY, and network_connection::state.

Referenced by acds_client_connect(), and network_connection_establish().

network_connection_request_stop()

void network_connection_request_stop

(

network_connection_t *

c

)

Definition at line 106 of file lib/network/connection.c.

                                                              {
  if (!c)
    return;
  atomic_store_int(&c->state, NETWORK_CLOSING);
  acip_transport_interrupt(c->transport);
}

References NETWORK_CLOSING, network_connection::state, and network_connection::transport.

Referenced by disconnect_client_for_bad_data(), handle_client_leave_packet(), and session_host_remove_client().

network_connection_run()

asciichat_error_t network_connection_run	(	network_connection_t *	c,
		const network_connection_callbacks_t *	callbacks,
		void *	context )

Execute an outbound connection on its controlling worker. The owner joins that worker before destroy; this call retains all resources on return.

Definition at line 900 of file lib/network/connection.c.

                                                        {
  if (!c || c->server || !callbacks || !callbacks->packet || c->opened)
    return SET_ERRNO(ERROR_INVALID_STATE, "Connection already has an execution owner");
  c->callbacks = *callbacks;
  c->callback_context = context;
  connection_receive(c);
  return c->result;
}

References network_connection::callback_context, network_connection::callbacks, ERROR_INVALID_STATE, network_connection::opened, network_connection_callbacks_t::packet, network_connection::result, network_connection::server, and SET_ERRNO.

network_connection_secure()

bool network_connection_secure

(

network_connection_t *

c

)

Definition at line 96 of file lib/network/connection.c.

                                                        {
  return c->secure;
}

References network_connection::secure.

network_connection_set_context()

void network_connection_set_context	(	network_connection_t *	c,
		void *	context )

Definition at line 90 of file lib/network/connection.c.

                                                                            {
  atomic_ptr_store(&c->context, context);
}

References network_connection::context.

network_connection_state()

network_connection_state_t network_connection_state

(

network_connection_t *

c

)

Definition at line 99 of file lib/network/connection.c.

                                                                             {
  return atomic_load_int(&c->state);
}

References network_connection::state.

Referenced by network_connection_prepare_security().

network_connection_transport()

acip_transport_t * network_connection_transport

(

network_connection_t *

c

)

Definition at line 84 of file lib/network/connection.c.

                                                                        {
  return c ? c->transport : NULL;
}

References network_connection::transport.

Referenced by acds_client_connect(), client_connection_start(), network_connection_establish(), session_participant_connect(), and session_participant_set_connection().

network_server_adopt()

asciichat_error_t network_server_adopt	(	network_server_t *	s,
		acip_transport_t *	transport,
		const char *	peer,
		bool	secure )

Adopt an authenticated peer transport on success; the caller retains it on failure.

Definition at line 491 of file lib/network/connection.c.

                                                    {
  return server_adopt(s, transport, peer, secure, true);
}

Referenced by session_host_accept_peer().

network_server_adopt_negotiating()

asciichat_error_t network_server_adopt_negotiating	(	network_server_t *	s,
		acip_transport_t *	transport,
		const char *	peer,
		bool	secure )

Adopt a connected transport before application authentication. The caller retains it on failure; on success the server owns it and drives negotiation.

Definition at line 495 of file lib/network/connection.c.

                                                                {
  return server_adopt(s, transport, peer, secure, false);
}

network_server_config()

const network_server_config_t * network_server_config

(

network_server_t *

s

)

Definition at line 695 of file lib/network/connection.c.

                                                                          {
  return s ? &s->config : NULL;
}

References network_server::config.

network_server_connection_count()

size_t network_server_connection_count

(

network_server_t *

s

)

Definition at line 684 of file lib/network/connection.c.

                                                            {
  if (!s)
    return 0;
  mutex_lock(&s->registry_mutex);
  size_t count = s->count;
  mutex_unlock(&s->registry_mutex);
  return count;
}

References network_server::count, and network_server::registry_mutex.

Referenced by ui_status_gather().

network_server_create()

asciichat_error_t network_server_create	(	const network_server_config_t *	config,
		network_server_t **	out )

Definition at line 553 of file lib/network/connection.c.

                                                                                                       {
  if (!config || !out || !config->callbacks.packet)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing network server configuration");
  *out = NULL;
  network_server_t *s = SAFE_CALLOC(1, sizeof(*s), network_server_t *);
  if (!s)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate network server");
  s->config = *config;
  s->config.max_connections =
      config->max_connections ? MIN(config->max_connections, NETWORK_CONNECTION_LIMIT) : NETWORK_CONNECTION_LIMIT;
  if (!s->config.handshake_timeout_ms)
    s->config.handshake_timeout_ms = 30000;
  if (!s->config.partial_timeout_ms)
    s->config.partial_timeout_ms = 5000;
  asciichat_error_t result = mutex_init(&s->registry_mutex, "network_registry");
  if (result != ASCIICHAT_OK) {
    SAFE_FREE(s);
    return result;
  }
  s->peers = thread_pool_create("network_peers");
  if (!s->peers) {
    mutex_destroy(&s->registry_mutex);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_THREAD, "Cannot create peer workers");
  }
  tcp_server_config_t tcp = {.port = config->port,
                             .ipv4_address = config->ipv4_address,
                             .ipv6_address = config->ipv6_address,
                             .bind_ipv4 = config->bind_ipv4,
                             .bind_ipv6 = config->bind_ipv6,
                             .event_handler = listener_accept,
                             .user_data = s,
                             .tick_fn = server_tick,
                             .tick_user_data = s};
  result = tcp_server_init(&s->listener, &tcp);
  s->listener_initialized = result == ASCIICHAT_OK;
  if (result == ASCIICHAT_OK && config->websocket_enabled) {
    websocket_server_config_t ws = {.port = config->websocket_port,
                                    .bind_address = config->ipv4_address ? config->ipv4_address : config->ipv6_address,
                                    .client_handler = websocket_accept,
                                    .user_data = s,
                                    .tls_cert_path = config->tls_cert_path,
                                    .tls_key_path = config->tls_key_path};
    result = websocket_server_init(&s->websocket, &ws);
    s->websocket_initialized = result == ASCIICHAT_OK;
  }
  if (result != ASCIICHAT_OK) {
    network_server_destroy(&s);
    return result;
  }
  *out = s;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, network_server_config_t::bind_ipv4, network_server_config_t::bind_ipv6, network_server_config_t::callbacks, network_server::config, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_THREAD, network_server_config_t::handshake_timeout_ms, network_server_config_t::ipv4_address, network_server_config_t::ipv6_address, network_server::listener, network_server::listener_initialized, network_server_config_t::max_connections, MIN, NETWORK_CONNECTION_LIMIT, network_server_destroy(), out, network_connection_callbacks_t::packet, network_server_config_t::partial_timeout_ms, network_server::peers, network_server_config_t::port, network_server::registry_mutex, SAFE_CALLOC, SAFE_FREE, SET_ERRNO, tcp_server_init(), thread_pool_create(), network_server_config_t::tls_cert_path, network_server_config_t::tls_key_path, network_server::websocket, network_server_config_t::websocket_enabled, network_server::websocket_initialized, network_server_config_t::websocket_port, and websocket_server_init().

Referenced by session_host_start(), and session_server_like_run().

network_server_destroy()

void network_server_destroy

(

network_server_t **

owner

)

Definition at line 669 of file lib/network/connection.c.

                                                      {
  if (!owner || !*owner)
    return;
  network_server_t *s = *owner;
  if (network_server_stop(s) != ASCIICHAT_OK)
    return;
  if (s->listener_initialized)
    tcp_server_destroy(&s->listener);
  thread_pool_destroy(s->peers);
  mutex_destroy(&s->registry_mutex);
  NAMED_UNREGISTER(&s->stopping);
  NAMED_UNREGISTER(&s->executing);
  SAFE_FREE(*owner);
  *owner = NULL;
}

References ASCIICHAT_OK, network_server::executing, network_server::listener, network_server::listener_initialized, NAMED_UNREGISTER, network_server_stop(), network_server::peers, network_server::registry_mutex, SAFE_FREE, network_server::stopping, tcp_server_destroy(), and thread_pool_destroy().

Referenced by network_server_create(), session_host_start(), session_host_stop(), and session_server_like_run().

network_server_foreach()

void network_server_foreach	(	network_server_t *	s,
		network_connection_visit_fn	visit,
		void *	context )

Definition at line 172 of file lib/network/connection.c.

                                                                                                   {
  if (!s || !visit)
    return;
  network_connection_t *snapshot[NETWORK_CONNECTION_LIMIT];
  size_t count = 0;
  mutex_lock(&s->registry_mutex);
  for (network_connection_t *c = s->connections; c; c = c->next) {
    if (atomic_load_int(&c->state) < NETWORK_CLOSING) {
      atomic_fetch_add_int(&c->pins, 1);
      snapshot[count++] = c;
    }
  }
  mutex_unlock(&s->registry_mutex);
  for (size_t i = 0; i < count; ++i) {
    visit(snapshot[i], context);
    atomic_fetch_sub_int(&snapshot[i]->pins, 1);
  }
}

References network_server::connections, NETWORK_CLOSING, NETWORK_CONNECTION_LIMIT, network_connection::next, network_connection::pins, network_server::registry_mutex, and network_connection::state.

Referenced by broadcast_server_state_to_all_clients(), network_server_stop(), signaling_broadcast(), signaling_relay_ice(), and signaling_relay_sdp().

network_server_request_stop()

void network_server_request_stop

(

network_server_t *

s

)

Atomic-only request, including from a native signal handler.

Definition at line 626 of file lib/network/connection.c.

                                                      {
  if (s)
    atomic_store_bool(&s->stopping, true);
}

References network_server::stopping.

Referenced by network_server_stop(), and session_host_stop().

network_server_run()

asciichat_error_t network_server_run

(

network_server_t *

s

)

Definition at line 618 of file lib/network/connection.c.

                                                          {
  int expected = false;
  if (!s || !atomic_cas_int(&s->executing, &expected, true))
    return SET_ERRNO(ERROR_INVALID_STATE, "Network server already has an execution owner");
  asciichat_error_t result = tcp_server_run(&s->listener);
  atomic_store_bool(&s->executing, false);
  return result;
}

References ERROR_INVALID_STATE, network_server::executing, network_server::listener, SET_ERRNO, and tcp_server_run().

Referenced by session_server_like_run().

network_server_start()

asciichat_error_t network_server_start

(

network_server_t *

s

)

Definition at line 606 of file lib/network/connection.c.

                                                            {
  if (!s || atomic_load_bool(&s->stopping))
    return SET_ERRNO(ERROR_INVALID_STATE, "Network server stopped before startup");
  if (s->websocket_initialized && !s->websocket_started) {
    asciichat_error_t result =
        platform_thread_create(&s->websocket_thread, "websocket_io", websocket_run, &s->websocket);
    if (result != ASCIICHAT_OK)
      return result;
    s->websocket_started = true;
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, SET_ERRNO, network_server::stopping, network_server::websocket, network_server::websocket_initialized, network_server::websocket_started, and network_server::websocket_thread.

Referenced by session_host_start(), and session_server_like_run().

network_server_stop()

asciichat_error_t network_server_stop

(

network_server_t *

s

)

Call after run returns (join its owner when running on another thread). Drains backend workers and connections, retaining dependencies on failure.

Definition at line 634 of file lib/network/connection.c.

                                                           {
  if (!s)
    return ASCIICHAT_OK;
  network_server_request_stop(s);
  if (atomic_load_bool(&s->executing))
    return SET_ERRNO(ERROR_THREAD, "Join the network execution owner before releasing server dependencies");
  network_server_foreach(s, stop_connection, NULL);
  if (s->websocket_started) {
    atomic_store_bool(&s->websocket.running, false);
    websocket_server_cancel_service(&s->websocket);
    asciichat_error_t result = thread_join(&s->websocket_thread, NULL);
    if (result != ASCIICHAT_OK)
      return result;
    s->websocket_started = false;
  }
  if (s->websocket_initialized) {
    websocket_server_destroy(&s->websocket);
    s->websocket_initialized = false;
  }
  asciichat_error_t result = thread_pool_stop_all(s->peers);
  if (result != ASCIICHAT_OK)
    return result;
  network_connection_t *c = s->connections;
  while (c) {
    network_connection_t *next = c->next;
    if (c->cleanup_failed) {
      connection_finish(c);
      if (c->cleanup_failed)
        return c->result;
      connection_free(c);
    }
    c = next;
  }
  return s->count ? SET_ERRNO(ERROR_THREAD, "Connections still retain server dependencies") : ASCIICHAT_OK;
}

References ASCIICHAT_OK, network_connection::cleanup_failed, network_server::connections, network_server::count, ERROR_THREAD, network_server::executing, network_server_foreach(), network_server_request_stop(), network_connection::next, network_server::peers, network_connection::result, websocket_server::running, SET_ERRNO, thread_pool_stop_all(), network_server::websocket, network_server::websocket_initialized, websocket_server_cancel_service(), websocket_server_destroy(), network_server::websocket_started, and network_server::websocket_thread.

Referenced by network_server_destroy(), session_host_stop(), and session_server_like_run().

network_server_websocket_enabled()

bool network_server_websocket_enabled

(

network_server_t *

s

)

Definition at line 692 of file lib/network/connection.c.

                                                           {
  return s && s->config.websocket_enabled;
}

References network_server::config, and network_server_config_t::websocket_enabled.

Referenced by session_server_like_run().