acds_client_io.c File Reference

Go to the source code of this file.

Macros
#define	NETWORK_ACIP_ACDS_CLIENT_IO_ACDS_NAME_BUFFER_SIZE   64

Functions
void	acds_client_config_init_defaults (acds_client_config_t *config)
	Initialize ACDS client configuration with defaults.
asciichat_error_t	acds_client_connect (acds_client_t *client, const acds_client_config_t *config)
	Connect to ACDS server.
void	acds_client_disconnect (acds_client_t *client)
	Disconnect from ACDS server.
asciichat_error_t	acds_session_create (acds_client_t *client, const acds_session_create_params_t *params, acds_session_create_result_t *result)
	Create a new session on the discovery server.
asciichat_error_t	acds_session_lookup (acds_client_t *client, const char *name, acds_session_lookup_result_t *result)
	Look up session by string.
asciichat_error_t	acds_session_join (acds_client_t *client, const acds_session_join_params_t *params, acds_session_join_result_t *result)
	Join an existing session.

Macro Definition Documentation

NETWORK_ACIP_ACDS_CLIENT_IO_ACDS_NAME_BUFFER_SIZE

#define NETWORK_ACIP_ACDS_CLIENT_IO_ACDS_NAME_BUFFER_SIZE   64

Definition at line 3 of file acds_client_io.c.

Referenced by acds_client_connect().

Function Documentation

acds_client_config_init_defaults()

void acds_client_config_init_defaults

(

acds_client_config_t *

config

)

Initialize ACDS client configuration with defaults.

Sets default values:

• server_address: "127.0.0.1"
• server_port: 27225
• timeout_ms: 5000

Parameters

config

Configuration to initialize

Definition at line 78 of file acds_client_io.c.

                                                                    {
  if (!config) {
    return;
  }
 
  memset(config, 0, sizeof(*config));
  SAFE_STRNCPY(config->server_address, "127.0.0.1", sizeof(config->server_address));
  config->server_port = ACIP_DISCOVERY_DEFAULT_PORT;
  config->timeout_ms = 5 * MS_PER_SEC_INT;
}

References ACIP_DISCOVERY_DEFAULT_PORT, MS_PER_SEC_INT, SAFE_STRNCPY, acds_client_config_t::server_address, acds_client_config_t::server_port, and acds_client_config_t::timeout_ms.

Referenced by client_crypto_init().

acds_client_connect()

asciichat_error_t acds_client_connect	(	acds_client_t *	client,
		const acds_client_config_t *	config )

Connect to ACDS server.

Establishes TCP connection to the discovery server.

Parameters

client	Client handle (output)
config	Connection configuration

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 93 of file acds_client_io.c.

                                                                                                 {
  if (!client || !config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "client or config is NULL");
  }
 
  memset(client, 0, sizeof(*client));
  memcpy(&client->config, config, sizeof(acds_client_config_t));
  client->connected = false;
 
  network_connect_config_t settings = {.timeout_ms = config->timeout_ms,
                                       .should_exit_callback = config->should_exit_callback,
                                       .callback_data = config->callback_data};
  asciichat_error_t pconn_result = network_connection_open("acds", config->server_address, config->server_port,
                                                           &settings, &client->connection, NULL);
  if (pconn_result == ASCIICHAT_OK) {
    client->connected = true;
    client->transport = network_connection_transport(client->connection);
 
    asciichat_error_t handshake_result = acds_client_handshake(client);
    if (handshake_result != ASCIICHAT_OK) {
      network_connection_destroy(&client->connection);
      client->transport = NULL;
      client->connected = false;
      client->handshake_ctx = NULL;
      return handshake_result;
    }
 
    network_connection_ready(client->connection);
 
    /* Register ACDS client with named registry */
    char acds_name[NETWORK_ACIP_ACDS_CLIENT_IO_ACDS_NAME_BUFFER_SIZE];
    snprintf(acds_name, sizeof(acds_name), "acds_client:%s:%d", config->server_address, config->server_port);
    NAMED_REGISTER(client, acds_name, "acds_client_t", "0x%tx", NULL);
 
    log_info("Connected to ACDS server at %s:%d", config->server_address, config->server_port);
    return ASCIICHAT_OK;
  }
 
  return pconn_result;
}

References ASCIICHAT_OK, acds_client_config_t::callback_data, acds_client_t::config, acds_client_t::connected, acds_client_t::connection, ERROR_INVALID_PARAM, acds_client_t::handshake_ctx, log_info, NAMED_REGISTER, NETWORK_ACIP_ACDS_CLIENT_IO_ACDS_NAME_BUFFER_SIZE, network_connection_destroy(), network_connection_open(), network_connection_ready(), network_connection_transport(), acds_client_config_t::server_address, acds_client_config_t::server_port, SET_ERRNO, acds_client_config_t::should_exit_callback, acds_client_config_t::timeout_ms, and acds_client_t::transport.

Referenced by client_crypto_init().

acds_client_disconnect()

void acds_client_disconnect

(

acds_client_t *

client

)

Disconnect from ACDS server.

Closes the connection and cleans up resources.

Parameters

client

Client handle

Definition at line 134 of file acds_client_io.c.

                                                   {
  if (!client) {
    return;
  }
 
  network_connection_destroy(&client->connection);
  client->transport = NULL;
  client->handshake_ctx = NULL;
 
  client->connected = false;
  log_debug("Disconnected from ACDS server");
}

References acds_client_t::connected, acds_client_t::connection, acds_client_t::handshake_ctx, log_debug, network_connection_destroy(), and acds_client_t::transport.

Referenced by client_crypto_init().

acds_session_create()

asciichat_error_t acds_session_create	(	acds_client_t *	client,
		const acds_session_create_params_t *	params,
		acds_session_create_result_t *	result )

Create a new session on the discovery server.

Sends SESSION_CREATE packet and receives SESSION_CREATED response.

Parameters

client	Connected ACDS client
params	Session creation parameters
result	Session creation result (output)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 165 of file acds_client_io.c.

                                                                            {
  if (!client || !client->connected || !params || !result)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery create parameters");
  acds_protocol_t protocol;
  acds_protocol_init(&protocol, client_protocol_send, client);
  asciichat_error_t error = acds_protocol_create(&protocol, params, 0, 0);
  if (error == ASCIICHAT_OK)
    error = client_protocol_receive(client, &protocol);
  if (error == ASCIICHAT_OK) {
    memset(result, 0, sizeof(*result));
    SAFE_STRNCPY(result->session_string, protocol.name, sizeof(result->session_string));
    memcpy(result->session_id, protocol.created.session_id, sizeof(result->session_id));
    result->expires_at = protocol.created.expires_at;
  }
  acds_protocol_destroy(&protocol);
  return error;
}

References acds_protocol_create(), acds_protocol_destroy(), acds_protocol_init(), ASCIICHAT_OK, acds_client_t::connected, acds_protocol::created, ERROR_INVALID_PARAM, acds_session_create_result_t::expires_at, acds_protocol::name, SAFE_STRNCPY, acds_session_create_result_t::session_id, acds_session_create_result_t::session_string, and SET_ERRNO.

acds_session_join()

asciichat_error_t acds_session_join	(	acds_client_t *	client,
		const acds_session_join_params_t *	params,
		acds_session_join_result_t *	result )

Join an existing session.

Sends SESSION_JOIN packet and receives SESSION_JOINED response.

Parameters

client	Connected ACDS client
params	Join parameters
result	Join result (output)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 210 of file acds_client_io.c.

                                                                        {
  if (!client || !client->connected || !params || !result)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery join parameters");
  acds_protocol_t protocol;
  acds_protocol_init(&protocol, client_protocol_send, client);
  memset(result, 0, sizeof(*result));
  asciichat_error_t error = acds_protocol_join(&protocol, params);
  if (error == ASCIICHAT_OK)
    error = client_protocol_receive(client, &protocol);
  result->success = protocol.joined.success;
  result->error_code = protocol.joined.error_code;
  SAFE_STRNCPY(result->error_message, protocol.joined.error_message, sizeof(result->error_message));
  if (error == ASCIICHAT_OK) {
    memcpy(result->participant_id, protocol.joined.participant_id, sizeof(result->participant_id));
    memcpy(result->session_id, protocol.joined.session_id, sizeof(result->session_id));
    result->session_type = protocol.joined.session_type;
    SAFE_STRNCPY(result->server_address, protocol.joined.server_address, sizeof(result->server_address));
    result->server_port = protocol.joined.server_port;
  }
  acds_protocol_destroy(&protocol);
  return error;
}

References acds_protocol_destroy(), acds_protocol_init(), acds_protocol_join(), ASCIICHAT_OK, acds_client_t::connected, acds_session_join_result_t::error_code, ERROR_INVALID_PARAM, acds_session_join_result_t::error_message, acds_protocol::joined, acds_session_join_result_t::participant_id, SAFE_STRNCPY, acds_session_join_result_t::server_address, acds_session_join_result_t::server_port, acds_session_join_result_t::session_id, acds_session_join_result_t::session_type, SET_ERRNO, and acds_session_join_result_t::success.

acds_session_lookup()

asciichat_error_t acds_session_lookup	(	acds_client_t *	client,
		const char *	session_string,
		acds_session_lookup_result_t *	result )

Look up session by string.

Sends SESSION_LOOKUP packet and receives SESSION_INFO response.

Parameters

client	Connected ACDS client
session_string	Session string to look up
result	Lookup result (output)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 183 of file acds_client_io.c.

                                                                                                                     {
  if (!client || !client->connected || !name || !result)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery lookup parameters");
  acds_protocol_t protocol;
  acds_protocol_init(&protocol, client_protocol_send, client);
  asciichat_error_t error = acds_protocol_lookup(&protocol, name);
  if (error == ASCIICHAT_OK)
    error = client_protocol_receive(client, &protocol);
  if (error == ASCIICHAT_OK) {
    memset(result, 0, sizeof(*result));
    result->found = protocol.info.found;
    if (result->found) {
      memcpy(result->session_id, protocol.info.session_id, sizeof(result->session_id));
      memcpy(result->host_pubkey, protocol.info.host_pubkey, sizeof(result->host_pubkey));
      result->capabilities = protocol.info.capabilities;
      result->max_participants = protocol.info.max_participants;
      result->current_participants = protocol.info.current_participants;
      result->has_password = protocol.info.has_password;
      result->created_at = protocol.info.created_at;
      result->expires_at = protocol.info.expires_at;
      result->require_server_verify = protocol.info.require_server_verify;
      result->require_client_verify = protocol.info.require_client_verify;
    }
  }
  acds_protocol_destroy(&protocol);
  return error;
}

References acds_protocol_destroy(), acds_protocol_init(), acds_protocol_lookup(), ASCIICHAT_OK, acds_session_lookup_result_t::capabilities, acds_client_t::connected, acds_session_lookup_result_t::created_at, acds_session_lookup_result_t::current_participants, ERROR_INVALID_PARAM, acds_session_lookup_result_t::expires_at, acds_session_lookup_result_t::found, acds_session_lookup_result_t::has_password, acds_session_lookup_result_t::host_pubkey, acds_protocol::info, acds_session_lookup_result_t::max_participants, acds_session_lookup_result_t::require_client_verify, acds_session_lookup_result_t::require_server_verify, acds_session_lookup_result_t::session_id, and SET_ERRNO.

Referenced by client_crypto_init().