connection.h File Reference

Go to the source code of this file.

Data Structures
struct	session_connection_ops_t
struct	session_connection_t
	Groups the callbacks and caller data for session connection ops. The owner invokes these function pointers at lifecycle boundaries, so the referenced context must remain alive until registration is removed. More...

Enumerations
enum	session_connection_state_t { SESSION_CONNECTION_STARTING , SESSION_CONNECTION_RUNNING , SESSION_CONNECTION_STOPPING , SESSION_CONNECTION_STOPPED }

Functions
void	session_connection_init (session_connection_t *connection, session_connection_ops_t ops, void *context)
asciichat_error_t	session_connection_start (session_connection_t *connection)
void	session_connection_request_stop (session_connection_t *connection)
asciichat_error_t	session_connection_stop (session_connection_t *connection)
void	session_connection_interrupt_transport (acip_transport_t *transport)
asciichat_error_t	session_connection_establish (const char *name, const char *address, uint16_t port, const network_connect_config_t *config, network_connection_t **owner, char *password, size_t capacity, network_connection_prepare_fn prepare, void(*detach)(void *), void *context)

Enumeration Type Documentation

session_connection_state_t

enum session_connection_state_t

Enumerator
SESSION_CONNECTION_STARTING
SESSION_CONNECTION_RUNNING
SESSION_CONNECTION_STOPPING
SESSION_CONNECTION_STOPPED

Definition at line 8 of file src/common/session/connection.h.

             {
  SESSION_CONNECTION_STARTING,
  SESSION_CONNECTION_RUNNING,
  SESSION_CONNECTION_STOPPING,
  SESSION_CONNECTION_STOPPED,
} session_connection_state_t;

Function Documentation

session_connection_establish()

asciichat_error_t session_connection_establish	(	const char *	name,
		const char *	address,
		uint16_t	port,
		const network_connect_config_t *	config,
		network_connection_t **	owner,
		char *	password,
		size_t	capacity,
		network_connection_prepare_fn	prepare,
		void(*	detach )(void *),
		void *	context )

Definition at line 14 of file src/common/session/establish.c.

                                                                                      {
  if (!owner || *owner || !password || capacity < PASSWORD_BUFFER_SIZE || !prepare)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session establishment parameters");
  const char *selected_address = address;
  char fallback_address[URL_BUFFER_SIZE];
  int fallback_port = GET_OPTION(quic_fallback_port);
  bool fallback_available = address && strncasecmp(address, "quic://", 7) == 0 && fallback_port > 0;
  if (fallback_available) {
    if (!GET_OPTION(server_key)[0] || GET_OPTION(no_encrypt) || GET_OPTION(no_auth))
      return SET_ERRNO(ERROR_USAGE, "QUIC TCP fallback requires --server-key and ACIP encryption and authentication");
    connection_endpoint_t endpoint;
    asciichat_error_t result = connection_endpoint_resolve(address, port, &endpoint);
    if (result != ASCIICHAT_OK)
      return result;
    if (strchr(endpoint.host, ':'))
      SAFE_SNPRINTF(fallback_address, sizeof(fallback_address), "tcp://[%s]:%d", endpoint.host, fallback_port);
    else
      SAFE_SNPRINTF(fallback_address, sizeof(fallback_address), "tcp://%s:%d", endpoint.host, fallback_port);
  }
  for (;;) {
    network_establish_config_t settings = {.name = name,
                                           .address = selected_address,
                                           .default_port = port,
                                           .connect = config,
                                           .password = password[0] ? password : NULL,
                                           .protocol = NETWORK_PROTOCOL_MEDIA,
                                           // Authentication is resolved by the shared security initializer in
                                           // the prepare callback. Do not force it for unauthenticated defaults;
                                           // discovery participants use this same establishment path.
                                           .authenticate = false,
                                           .prepare = prepare,
                                           .context = context};
    network_establish_result_t attempt;
    asciichat_errno_scope_t attempt_errors = errno_scope_begin();
    asciichat_error_t result = network_connection_establish(&settings, owner, &attempt);
    if (result == ASCIICHAT_OK) {
      errno_scope_end(attempt_errors, ASCIICHAT_ERRNO_HANDLED);
      return ASCIICHAT_OK;
    }
    if (fallback_available && result == ERROR_NETWORK_TIMEOUT && !*owner) {
      errno_scope_end(attempt_errors, ASCIICHAT_ERRNO_DISMISSED);
      selected_address = fallback_address;
      fallback_available = false;
      log_info("QUIC timed out; trying authenticated TCP fallback on port %d", fallback_port);
      continue;
    }
    if (!attempt.password_failure) {
      // A failed negotiation cannot produce the first frame that normally
      // ends the splash. Release it before presenting the connection error.
      splash_intro_done();
      splash_wait_for_animation();
      return result;
    }
    // Recover only the rejected negotiation; caller and cleanup errors remain pending.
    errno_scope_end(attempt_errors, ASCIICHAT_ERRNO_DISMISSED);
    if (detach)
      detach(context);
    network_connection_destroy(owner);
    char target[SESSION_ESTABLISH_TARGET_BUFFER_SIZE];
    snprintf(target, sizeof(target), "%s:%u", attempt.endpoint.host, attempt.endpoint.port);
    result = ui_input_password(target, password, capacity, attempt.password_failure & AUTH_FAIL_PASSWORD_INCORRECT);
    if (result != ASCIICHAT_OK)
      return result;
  }
}

References ASCIICHAT_ERRNO_DISMISSED, ASCIICHAT_ERRNO_HANDLED, ASCIICHAT_OK, AUTH_FAIL_PASSWORD_INCORRECT, connection_endpoint_resolve(), network_establish_result_t::endpoint, errno_scope_begin(), errno_scope_end(), ERROR_INVALID_PARAM, ERROR_NETWORK_TIMEOUT, ERROR_USAGE, GET_OPTION, connection_endpoint_t::host, log_info, network_connection_destroy(), network_connection_establish(), NETWORK_PROTOCOL_MEDIA, PASSWORD_BUFFER_SIZE, network_establish_result_t::password_failure, connection_endpoint_t::port, SAFE_SNPRINTF, SESSION_ESTABLISH_TARGET_BUFFER_SIZE, SET_ERRNO, splash_intro_done(), splash_wait_for_animation(), ui_input_password(), and URL_BUFFER_SIZE.

Referenced by client_connection_start(), and session_participant_connect().

session_connection_init()

void session_connection_init	(	session_connection_t *	connection,
		session_connection_ops_t	ops,
		void *	context )

Definition at line 3 of file src/common/session/connection.c.

                                                                                                            {
  connection->owner_thread = thread_self();
  connection->ops = ops;
  connection->context = context;
  atomic_store_int(&connection->state, SESSION_CONNECTION_STARTING);
}

References session_connection_t::context, session_connection_t::ops, session_connection_t::owner_thread, SESSION_CONNECTION_STARTING, and session_connection_t::state.

Referenced by client_connection_create().

session_connection_interrupt_transport()

void session_connection_interrupt_transport

(

acip_transport_t *

transport

)

Definition at line 44 of file src/common/session/connection.c.

                                                                         {
  acip_transport_interrupt(transport);
}

Referenced by server_connection_shutdown().

session_connection_request_stop()

void session_connection_request_stop

(

session_connection_t *

connection

)

Definition at line 19 of file src/common/session/connection.c.

                                                                       {
  if (!connection || atomic_load_int(&connection->state) == SESSION_CONNECTION_STOPPED)
    return;
  atomic_store_int(&connection->state, SESSION_CONNECTION_STOPPING);
  if (connection->ops.interrupt)
    connection->ops.interrupt(connection->context);
}

References session_connection_t::context, session_connection_ops_t::interrupt, session_connection_t::ops, SESSION_CONNECTION_STOPPED, SESSION_CONNECTION_STOPPING, and session_connection_t::state.

Referenced by client_connection_request_stop(), and session_connection_stop().

session_connection_start()

asciichat_error_t session_connection_start

(

session_connection_t *

connection

)

Definition at line 10 of file src/common/session/connection.c.

                                                                             {
  if (!connection || !thread_equal(connection->owner_thread, thread_self()))
    return SET_ERRNO(ERROR_INVALID_STATE, "Connection startup requires its controlling thread");
  int expected = SESSION_CONNECTION_STARTING;
  if (!atomic_cas_int(&connection->state, &expected, SESSION_CONNECTION_RUNNING))
    return SET_ERRNO(ERROR_INVALID_STATE, "Connection was stopped during startup");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, session_connection_t::owner_thread, SESSION_CONNECTION_RUNNING, SESSION_CONNECTION_STARTING, SET_ERRNO, and session_connection_t::state.

Referenced by client_connection_start(), session_participant_connect(), session_participant_set_connection(), and session_participant_set_transport().

session_connection_stop()

asciichat_error_t session_connection_stop

(

session_connection_t *

connection

)

Definition at line 27 of file src/common/session/connection.c.

                                                                            {
  if (!connection || atomic_load_int(&connection->state) == SESSION_CONNECTION_STOPPED)
    return ASCIICHAT_OK;
  session_connection_request_stop(connection);
  if (!thread_equal(connection->owner_thread, thread_self()))
    return SET_ERRNO(ERROR_INVALID_STATE, "Connection cleanup requires its controlling thread");
  if (connection->ops.join) {
    asciichat_error_t result = connection->ops.join(connection->context);
    if (result != ASCIICHAT_OK)
      return result;
  }
  if (connection->ops.release)
    connection->ops.release(connection->context);
  atomic_store_int(&connection->state, SESSION_CONNECTION_STOPPED);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, session_connection_t::context, ERROR_INVALID_STATE, session_connection_ops_t::join, session_connection_t::ops, session_connection_t::owner_thread, session_connection_ops_t::release, session_connection_request_stop(), SESSION_CONNECTION_STOPPED, SET_ERRNO, and session_connection_t::state.

Referenced by client_connection_stop(), session_participant_connect(), session_participant_disconnect(), and session_participant_set_transport().