ACIP client-side protocol library and ACDS client connection API. More...

Data Structures
struct	acds_client_config_t
	acds client config is intentionally a small, concrete record. Fields such as server_port, timeout_ms, security_policy, identity_key give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. More...
struct	acds_client_t
	ACDS client connection handle. More...
struct	acds_session_create_params_t
	Session creation request parameters. More...
struct	acds_session_create_result_t
	Session creation result. More...
struct	acds_session_lookup_result_t
	Session lookup result. More...
struct	acds_session_join_params_t
	Session join parameters. More...
struct	acds_session_join_result_t
	Session join result. More...

Macros
#define	ACDS_TRANSPORT_METADATA_MAX 521

Typedefs
typedef bool(*	parallel_connect_should_exit_fn) (void *user_data)

Functions
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 session_string, 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.
asciichat_error_t	acds_sign_session_create (const uint8_t identity_seckey[64], uint64_t timestamp, uint8_t capabilities, uint8_t max_participants, uint8_t signature_out[64])
	Sign a SESSION_CREATE message.
asciichat_error_t	acds_verify_session_create (const uint8_t identity_pubkey[32], uint64_t timestamp, uint8_t capabilities, uint8_t max_participants, const uint8_t signature[64])
	Verify SESSION_CREATE signature.
asciichat_error_t	acds_sign_session_join (const uint8_t identity_seckey[64], uint64_t timestamp, const char *session_string, uint8_t signature_out[64])
	Sign a SESSION_JOIN message.
asciichat_error_t	acds_verify_session_join (const uint8_t identity_pubkey[32], uint64_t timestamp, const char *session_string, const uint8_t signature[64])
	Verify SESSION_JOIN signature.
bool	acds_validate_timestamp (uint64_t timestamp_ms, uint32_t window_seconds)
	Check if timestamp is within acceptable window.
void	acds_client_config_init_defaults (acds_client_config_t *config)
	Initialize ACDS client configuration with defaults.
asciichat_error_t	acds_transport_metadata_encode (uint16_t quic_port, const char url, void output, size_t capacity, size_t *length)
asciichat_error_t	acds_transport_metadata_decode (const void bytes, size_t length, uint16_t quic_port, char *url, size_t capacity)

Detailed Description

ACIP client-side protocol library and ACDS client connection API.

Definition in file acds_client.h.

Macro Definition Documentation

◆ ACDS_TRANSPORT_METADATA_MAX

#define ACDS_TRANSPORT_METADATA_MAX 521

Definition at line 405 of file acds_client.h.

Typedef Documentation

◆ parallel_connect_should_exit_fn

typedef bool(* parallel_connect_should_exit_fn) (void *user_data)

Definition at line 135 of file acds_client.h.

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

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

Referenced by client_crypto_init().

◆ acds_sign_session_create()

asciichat_error_t acds_sign_session_create	(	const uint8_t	identity_seckey[64],
		uint64_t	timestamp,
		uint8_t	capabilities,
		uint8_t	max_participants,
		uint8_t	signature_out[64] )

Sign a SESSION_CREATE message.

Computes Ed25519 signature over: type || timestamp || capabilities || max_participants

Parameters

identity_seckey	Ed25519 secret key (64 bytes)
timestamp	Unix milliseconds timestamp
capabilities	Capabilities bitfield
max_participants	Maximum participants (1-128)
signature_out	Output buffer for signature (64 bytes)

Returns: ASCIICHAT_OK on success, error code on failure

Definition at line 45 of file acds_client.c.

                                                                                          {
  if (!identity_seckey || !signature_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL parameter");
  }
 
  // Build message: type (1 byte) || timestamp (8 bytes) || capabilities (1 byte) || max_participants (1 byte)
  uint8_t message[ACDS_CREATE_SIGNATURE_MESSAGE_SIZE];
  message[0] = (uint8_t)PACKET_TYPE_ACIP_SESSION_CREATE;
 
  // Convert timestamp to network byte order and pack into message
  uint64_t timestamp_net = HOST_TO_NET_U64(timestamp);
  memcpy(&message[1], &timestamp_net, sizeof(timestamp_net));
 
  message[9] = capabilities;
  message[10] = max_participants;
 
  // Sign using Ed25519
  if (crypto_sign_detached(signature_out, NULL, message, sizeof(message), identity_seckey) != 0) {
    return SET_ERRNO(ERROR_CRYPTO, "Ed25519 signature generation failed");
  }
 
  log_debug("Generated SESSION_CREATE signature (timestamp=%llu, caps=%u, max=%u)", (unsigned long long)timestamp,
            capabilities, max_participants);
 
  return ASCIICHAT_OK;
}

References ACDS_CREATE_SIGNATURE_MESSAGE_SIZE, ASCIICHAT_OK, ED25519_PRIVATE_KEY_SIZE, ED25519_SIGNATURE_SIZE, ERROR_CRYPTO, ERROR_INVALID_PARAM, HOST_TO_NET_U64, log_debug, PACKET_TYPE_ACIP_SESSION_CREATE, and SET_ERRNO.

Referenced by acds_protocol_create().

◆ acds_sign_session_join()

asciichat_error_t acds_sign_session_join	(	const uint8_t	identity_seckey[64],
		uint64_t	timestamp,
		const char *	session_string,
		uint8_t	signature_out[64] )

Sign a SESSION_JOIN message.

Computes Ed25519 signature over: type || timestamp || session_string

Parameters

identity_seckey	Ed25519 secret key (64 bytes)
timestamp	Unix milliseconds timestamp
session_string	Session string (null-terminated)
signature_out	Output buffer for signature (64 bytes)

Returns: ASCIICHAT_OK on success, error code on failure

Definition at line 102 of file acds_client.c.

                                                                                                                    {
  if (!identity_seckey || !session_string || !signature_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL parameter");
  }
 
  size_t session_len = strlen(session_string);
  if (session_len > ACIP_MAX_SESSION_STRING_LEN) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Session string too long (max 48 chars)");
  }
 
  // Build message: type (1 byte) || timestamp (8 bytes) || session_string (variable length)
  uint8_t message[ACDS_SIGNATURE_PREFIX_SIZE + ACIP_MAX_SESSION_STRING_LEN];
  message[0] = (uint8_t)PACKET_TYPE_ACIP_SESSION_JOIN;
 
  // Convert timestamp to network byte order and pack into message
  uint64_t timestamp_net = HOST_TO_NET_U64(timestamp);
  memcpy(&message[1], &timestamp_net, sizeof(timestamp_net));
 
  // Copy session string (copy exactly session_len bytes, no null terminator in signature)
  memcpy(&message[9], session_string, session_len);
 
  size_t message_len = ACDS_SIGNATURE_PREFIX_SIZE + session_len;
 
  // Sign using Ed25519
  if (crypto_sign_detached(signature_out, NULL, message, message_len, identity_seckey) != 0) {
    return SET_ERRNO(ERROR_CRYPTO, "Ed25519 signature generation failed");
  }
 
  log_debug("Generated SESSION_JOIN signature (timestamp=%llu, session='%s')", (unsigned long long)timestamp,
            session_string);
 
  return ASCIICHAT_OK;
}

References ACDS_SIGNATURE_PREFIX_SIZE, ACIP_MAX_SESSION_STRING_LEN, ASCIICHAT_OK, ED25519_PRIVATE_KEY_SIZE, ED25519_SIGNATURE_SIZE, ERROR_CRYPTO, ERROR_INVALID_PARAM, HOST_TO_NET_U64, log_debug, PACKET_TYPE_ACIP_SESSION_JOIN, and SET_ERRNO.

Referenced by acds_protocol_join().

◆ acds_transport_metadata_decode()

asciichat_error_t acds_transport_metadata_decode	(	const void *	bytes,
		size_t	length,
		uint16_t *	quic_port,
		char *	url,
		size_t	capacity )

Definition at line 525 of file acds_client.c.

                                                                  {
  if (!port || !url || !capacity || (!data && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing discovery transport input or output");
  *port = 0;
  url[0] = 0;
  if (!length)
    return ASCIICHAT_OK;
  const uint8_t *bytes = data;
  if (length < 10 || memcmp(bytes, "ACQT", sizeof("ACQT") - 1) || bytes[4] != 1 || bytes[5])
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid discovery transport extension");
  size_t size = ((size_t)bytes[8] << 8) | bytes[9];
  if (size >= 512 || size >= capacity || length != 10 + size ||
      (size && (size < 9 || memcmp(bytes + 10, "https://", sizeof("https://") - 1) || memchr(bytes + 10, 0, size))))
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid discovery WebTransport endpoint");
  *port = (uint16_t)((uint16_t)bytes[6] << 8 | bytes[7]);
  memcpy(url, bytes + 10, size);
  url[size] = 0;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, and SET_ERRNO.

Referenced by acds_on_host_announcement_ex().

◆ acds_transport_metadata_encode()

asciichat_error_t acds_transport_metadata_encode	(	uint16_t	quic_port,
		const char *	url,
		void *	output,
		size_t	capacity,
		size_t *	length )

Definition at line 504 of file acds_client.c.

                                                                 {
  if (!url || !output || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing discovery transport output");
  *length = 0;
  size_t size = strnlen(url, (size_t)512);
  if (size >= 512 || capacity < 10 + size || (size && (size < 9 || strncmp(url, "https://", sizeof("https://") - 1))))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery transport endpoint or capacity");
  uint8_t *bytes = output;
  memcpy(bytes, "ACQT", sizeof("ACQT") - 1);
  bytes[4] = 1;
  bytes[5] = 0;
  bytes[6] = (uint8_t)(port >> 8);
  bytes[7] = (uint8_t)port;
  bytes[8] = (uint8_t)(size >> 8);
  bytes[9] = (uint8_t)size;
  memcpy(bytes + 10, url, size);
  *length = 10 + size;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, and SET_ERRNO.

◆ acds_validate_timestamp()

bool acds_validate_timestamp	(	uint64_t	timestamp_ms,
		uint32_t	window_seconds )

Check if timestamp is within acceptable window.

Validates timestamp is recent (within window_seconds of current time) and not in the future.

Parameters

timestamp_ms	Unix milliseconds timestamp
window_seconds	Acceptable age window (e.g., 300 for 5 minutes)

Returns: true if timestamp is valid, false if too old or in the future

Definition at line 172 of file acds_client.c.

                                                                             {
  uint64_t now_ms = time_ns_to_ms(time_get_realtime_ns());
  uint64_t window_ms = (uint64_t)window_seconds * 1000;
 
  if (timestamp_ms > now_ms + 60000) {
    int64_t skew = (int64_t)timestamp_ms - (int64_t)now_ms;
    log_warn("Timestamp is in the future: %llu > %llu (skew: %lld ms)", (unsigned long long)timestamp_ms,
             (unsigned long long)now_ms, (long long)skew);
    return false;
  }
 
  uint64_t min_valid_timestamp = (now_ms >= window_ms) ? (now_ms - window_ms) : 0;
  if (timestamp_ms < min_valid_timestamp) {
    int64_t age = (int64_t)now_ms - (int64_t)timestamp_ms;
    log_warn("Timestamp is too old: %llu < %llu (age: %lld ms, max: %u seconds)", (unsigned long long)timestamp_ms,
             (unsigned long long)min_valid_timestamp, (long long)age, window_seconds);
    return false;
  }
 
  int64_t age = (int64_t)now_ms - (int64_t)timestamp_ms;
  log_debug("Timestamp validation passed (age: %lld ms, window: %u seconds)", (long long)age, window_seconds);
  return true;
}

References log_debug, and log_warn.

Referenced by acds_create_key_set_collect().

◆ acds_verify_session_create()

asciichat_error_t acds_verify_session_create	(	const uint8_t	identity_pubkey[32],
		uint64_t	timestamp,
		uint8_t	capabilities,
		uint8_t	max_participants,
		const uint8_t	signature[64] )

Verify SESSION_CREATE signature.

Verifies Ed25519 signature matches the message fields.

Parameters

identity_pubkey	Ed25519 public key (32 bytes)
timestamp	Unix milliseconds timestamp
capabilities	Capabilities bitfield
max_participants	Maximum participants
signature	Signature to verify (64 bytes)

Returns: ASCIICHAT_OK if valid, ERROR_CRYPTO_VERIFY_FAILED if invalid

Definition at line 74 of file acds_client.c.

                                                                                              {
  if (!identity_pubkey || !signature) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL parameter");
  }
 
  // Build message: type (1 byte) || timestamp (8 bytes) || capabilities (1 byte) || max_participants (1 byte)
  uint8_t message[ACDS_CREATE_SIGNATURE_MESSAGE_SIZE];
  message[0] = (uint8_t)PACKET_TYPE_ACIP_SESSION_CREATE;
 
  // Convert timestamp to network byte order and pack into message
  uint64_t timestamp_net = HOST_TO_NET_U64(timestamp);
  memcpy(&message[1], &timestamp_net, sizeof(timestamp_net));
 
  message[9] = capabilities;
  message[10] = max_participants;
 
  // Verify using Ed25519
  if (crypto_sign_verify_detached(signature, message, sizeof(message), identity_pubkey) != 0) {
    log_warn("SESSION_CREATE signature verification failed");
    return SET_ERRNO(ERROR_CRYPTO_VERIFICATION, "Invalid SESSION_CREATE signature");
  }
 
  log_debug("SESSION_CREATE signature verified successfully");
  return ASCIICHAT_OK;
}

References ACDS_CREATE_SIGNATURE_MESSAGE_SIZE, ASCIICHAT_OK, ED25519_PUBLIC_KEY_SIZE, ED25519_SIGNATURE_SIZE, ERROR_CRYPTO_VERIFICATION, ERROR_INVALID_PARAM, HOST_TO_NET_U64, log_debug, log_warn, PACKET_TYPE_ACIP_SESSION_CREATE, and SET_ERRNO.

Referenced by acds_create_key_set_collect().

◆ acds_verify_session_join()

asciichat_error_t acds_verify_session_join	(	const uint8_t	identity_pubkey[32],
		uint64_t	timestamp,
		const char *	session_string,
		const uint8_t	signature[64] )

Verify SESSION_JOIN signature.

Verifies Ed25519 signature matches the message fields.

Parameters

identity_pubkey	Ed25519 public key (32 bytes)
timestamp	Unix milliseconds timestamp
session_string	Session string (null-terminated)
signature	Signature to verify (64 bytes)

Returns: ASCIICHAT_OK if valid, ERROR_CRYPTO_VERIFY_FAILED if invalid

Definition at line 137 of file acds_client.c.

                                                                                            {
  if (!identity_pubkey || !session_string || !signature) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL parameter");
  }
 
  size_t session_len = strlen(session_string);
  if (session_len > ACIP_MAX_SESSION_STRING_LEN) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Session string too long (max 48 chars)");
  }
 
  // Build message: type (1 byte) || timestamp (8 bytes) || session_string (variable length)
  uint8_t message[ACDS_SIGNATURE_PREFIX_SIZE + ACIP_MAX_SESSION_STRING_LEN];
  message[0] = (uint8_t)PACKET_TYPE_ACIP_SESSION_JOIN;
 
  // Convert timestamp to network byte order and pack into message
  uint64_t timestamp_net = HOST_TO_NET_U64(timestamp);
  memcpy(&message[1], &timestamp_net, sizeof(timestamp_net));
 
  // Copy session string (copy exactly session_len bytes, no null terminator in signature)
  memcpy(&message[9], session_string, session_len);
 
  size_t message_len = ACDS_SIGNATURE_PREFIX_SIZE + session_len;
 
  // Verify using Ed25519
  if (crypto_sign_verify_detached(signature, message, message_len, identity_pubkey) != 0) {
    log_warn("SESSION_JOIN signature verification failed");
    return SET_ERRNO(ERROR_CRYPTO_VERIFICATION, "Invalid SESSION_JOIN signature");
  }
 
  log_debug("SESSION_JOIN signature verified successfully");
  return ASCIICHAT_OK;
}

References ACDS_SIGNATURE_PREFIX_SIZE, ACIP_MAX_SESSION_STRING_LEN, ASCIICHAT_OK, ED25519_PUBLIC_KEY_SIZE, ED25519_SIGNATURE_SIZE, ERROR_CRYPTO_VERIFICATION, ERROR_INVALID_PARAM, HOST_TO_NET_U64, log_debug, log_warn, PACKET_TYPE_ACIP_SESSION_JOIN, and SET_ERRNO.

Data Structures

Macros

Typedefs

Functions

Detailed Description

Macro Definition Documentation

◆ ACDS_TRANSPORT_METADATA_MAX

Typedef Documentation

◆ parallel_connect_should_exit_fn

Function Documentation

◆ acds_client_config_init_defaults()

◆ acds_client_connect()

◆ acds_client_disconnect()

◆ acds_session_create()

◆ acds_session_join()

◆ acds_session_lookup()

◆ acds_sign_session_create()

◆ acds_sign_session_join()

◆ acds_transport_metadata_decode()

◆ acds_transport_metadata_encode()

◆ acds_validate_timestamp()

◆ acds_verify_session_create()

◆ acds_verify_session_join()