acds_protocol.h File Reference

Go to the source code of this file.

Data Structures
struct	acds_protocol

Macros
#define	NETWORK_ACIP_ACDS_PROTOCOL_ERROR_BUFFER_SIZE   256
#define	NETWORK_ACIP_ACDS_PROTOCOL_NAME_BUFFER_SIZE   49

Typedefs
typedef asciichat_error_t(*	acds_protocol_send_fn) (void *, packet_type_t, const void *, size_t)
typedef struct acds_protocol	acds_protocol_t

Enumerations
enum	acds_protocol_state_t {   ACDS_IDLE , ACDS_CREATING , ACDS_LOOKING_UP , ACDS_JOINING ,   ACDS_CREATED , ACDS_FOUND , ACDS_JOINED , ACDS_ENDED ,   ACDS_FAILED }

Functions
void	acds_protocol_init (acds_protocol_t *protocol, acds_protocol_send_fn send, void *user_data)
void	acds_protocol_destroy (acds_protocol_t *protocol)
asciichat_error_t	acds_protocol_create (acds_protocol_t *protocol, const acds_session_create_params_t *params, uint8_t total_keys, uint8_t key_index)
asciichat_error_t	acds_protocol_lookup (acds_protocol_t *protocol, const char *name)
asciichat_error_t	acds_protocol_join (acds_protocol_t *protocol, const acds_session_join_params_t *params)
asciichat_error_t	acds_protocol_enter (acds_protocol_t *protocol, bool create, const char *name, const char *password)
asciichat_error_t	acds_protocol_receive (acds_protocol_t *protocol, packet_type_t type, const void *payload, size_t length)
asciichat_error_t	acds_protocol_leave (acds_protocol_t *protocol)
asciichat_error_t	acds_handshake_begin (acip_transport_t *transport, uint8_t mode)
asciichat_error_t	acds_handshake_receive (crypto_handshake_context_t *context, acip_transport_t *transport, packet_type_t type, const void *payload, size_t length)
asciichat_error_t	acds_receive_packet (acip_transport_t *transport, packet_type_t *type, void **payload, size_t *length, void **allocation)

Macro Definition Documentation

NETWORK_ACIP_ACDS_PROTOCOL_ERROR_BUFFER_SIZE

#define NETWORK_ACIP_ACDS_PROTOCOL_ERROR_BUFFER_SIZE   256

Definition at line 4 of file acds_protocol.h.

NETWORK_ACIP_ACDS_PROTOCOL_NAME_BUFFER_SIZE

#define NETWORK_ACIP_ACDS_PROTOCOL_NAME_BUFFER_SIZE   49

Definition at line 5 of file acds_protocol.h.

Typedef Documentation

acds_protocol_send_fn

typedef asciichat_error_t(* acds_protocol_send_fn) (void *, packet_type_t, const void *, size_t)

Event-driven discovery protocol. Callbacks consume borrowed data before returning. The caller owns transport I/O, deadlines, and serialization of calls to this object. No function waits for input or owns the transport.

Definition at line 13 of file acds_protocol.h.

acds_protocol_t

typedef struct acds_protocol acds_protocol_t

Enumeration Type Documentation

acds_protocol_state_t

enum acds_protocol_state_t

Enumerator
ACDS_IDLE
ACDS_CREATING
ACDS_LOOKING_UP
ACDS_JOINING
ACDS_CREATED
ACDS_FOUND
ACDS_JOINED
ACDS_ENDED
ACDS_FAILED

Definition at line 14 of file acds_protocol.h.

             {
  ACDS_IDLE,
  ACDS_CREATING,
  ACDS_LOOKING_UP,
  ACDS_JOINING,
  ACDS_CREATED,
  ACDS_FOUND,
  ACDS_JOINED,
  ACDS_ENDED,
  ACDS_FAILED
} acds_protocol_state_t;

Function Documentation

acds_handshake_begin()

asciichat_error_t acds_handshake_begin	(	acip_transport_t *	transport,
		uint8_t	mode )

Handshake event steps shared by native receive loops and browser socket events. Context must already be initialized and configured with any identity options. Input remains caller-owned.

Definition at line 451 of file acds_client.c.

                                                                                  {
  protocol_version_packet_t version;
  protocol_version_packet_init(&version, mode);
  return packet_send_via_transport(transport, PACKET_TYPE_PROTOCOL_VERSION, &version, sizeof(version), 0);
}

References packet_send_via_transport(), PACKET_TYPE_PROTOCOL_VERSION, and protocol_version_packet_init().

Referenced by client_acds_handshake_begin(), and client_handshake_begin().

acds_handshake_receive()

asciichat_error_t acds_handshake_receive	(	crypto_handshake_context_t *	context,
		acip_transport_t *	transport,
		packet_type_t	type,
		const void *	payload,
		size_t	length )

<No encryption (plaintext mode)

Definition at line 456 of file acds_client.c.

                                                                                                 {
  if (!ctx || !transport || (!payload && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid handshake packet");
  switch (type) {
  case PACKET_TYPE_CRYPTO_PARAMETERS:
    if (ctx->state != CRYPTO_HANDSHAKE_INIT || length != sizeof(crypto_parameters_packet_t))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid discovery crypto parameters");
    if ((((const crypto_parameters_packet_t *)payload)->selected_cipher != CIPHER_ALGO_NONE) !=
        ctx->crypto_ctx.encrypt_data)
      return SET_ERRNO(ERROR_CRYPTO, "Discovery server changed requested encryption");
    return crypto_handshake_set_parameters(ctx, payload);
  case PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT:
    return crypto_handshake_client_key_exchange(ctx, transport, type, payload, length);
  case PACKET_TYPE_CRYPTO_AUTH_CHALLENGE:
    return crypto_handshake_client_auth_response(ctx, transport, type, payload, length);
  case PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE:
  case PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP:
  case PACKET_TYPE_CRYPTO_AUTH_FAILED:
    return crypto_handshake_client_complete(ctx, transport, type, payload, length);
  default:
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unexpected discovery handshake packet: %u", type);
  }
}

References CIPHER_ALGO_NONE, crypto_handshake_context_t::crypto_ctx, crypto_handshake_client_auth_response(), crypto_handshake_client_complete(), crypto_handshake_client_key_exchange(), CRYPTO_HANDSHAKE_INIT, crypto_handshake_set_parameters(), crypto_context_t::encrypt_data, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, PACKET_TYPE_CRYPTO_AUTH_CHALLENGE, PACKET_TYPE_CRYPTO_AUTH_FAILED, PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE, PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT, PACKET_TYPE_CRYPTO_PARAMETERS, PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP, SET_ERRNO, and crypto_handshake_context_t::state.

Referenced by client_acds_handshake_receive().

acds_protocol_create()

asciichat_error_t acds_protocol_create	(	acds_protocol_t *	protocol,
		const acds_session_create_params_t *	params,
		uint8_t	total_keys,
		uint8_t	key_index )

Definition at line 240 of file acds_client.c.

                                                                              {
  if (!p || !params)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery create parameters");
  if (total_keys > MAX_SESSION_KEYS || key_index >= (total_keys ? total_keys : 1) || params->max_participants == 0 ||
      params->max_participants > MAX_SESSION_PARTICIPANTS)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session key count/index or participant limit");
  if (params->reserved_string && params->reserved_string[0])
    return protocol_fail(p, ERROR_NOT_SUPPORTED, "Reserved session names are not supported", true);
  acip_session_create_t req = {0};
  memcpy(req.identity_pubkey, params->identity_pubkey, sizeof(req.identity_pubkey));
  req.timestamp = time_ns_to_ms(time_get_realtime_ns());
  req.capabilities = params->capabilities;
  req.max_participants = params->max_participants;
  req.session_type = params->session_type;
  req.total_keys = total_keys;
  req.key_index = key_index;
  req.has_password = params->has_password;
  req.expose_ip_publicly = params->acds_expose_ip;
  SAFE_STRNCPY(req.server_address, params->server_address, sizeof(req.server_address));
  req.server_port = params->server_port;
  asciichat_error_t result = acds_sign_session_create(params->identity_seckey, req.timestamp, req.capabilities,
                                                      req.max_participants, req.signature);
  if (result != ASCIICHAT_OK)
    return protocol_fail(p, result, "Could not sign session creation", true);
  if (params->has_password &&
      crypto_pwhash_str((char *)req.password_hash, params->password,
                        strnlen(params->password, sizeof(params->password)), crypto_pwhash_OPSLIMIT_INTERACTIVE,
                        crypto_pwhash_MEMLIMIT_INTERACTIVE) != 0)
    return protocol_fail(p, ERROR_CRYPTO, "Could not hash session password", true);
  p->state = ACDS_CREATING;
  size_t endpoint_length = strnlen(params->webtransport_url, sizeof(params->webtransport_url));
  if (endpoint_length == sizeof(params->webtransport_url) ||
      (endpoint_length &&
       (endpoint_length < 9 || strncmp(params->webtransport_url, "https://", sizeof("https://") - 1)))) {
    sodium_memzero(&req, sizeof(req));
    return protocol_fail(p, ERROR_INVALID_PARAM, "Invalid public WebTransport endpoint", true);
  }
  if (endpoint_length || params->quic_port) {
    uint8_t payload[sizeof(req) + 10 + sizeof(params->webtransport_url)];
    memcpy(payload, &req, sizeof(req));
    uint8_t *extension = payload + sizeof(req);
    memcpy(extension, "ACQT", sizeof("ACQT") - 1);
    extension[4] = 1;
    extension[5] = 0;
    extension[6] = (uint8_t)(params->quic_port >> 8);
    extension[7] = (uint8_t)params->quic_port;
    extension[8] = (uint8_t)(endpoint_length >> 8);
    extension[9] = (uint8_t)endpoint_length;
    memcpy(extension + 10, params->webtransport_url, endpoint_length);
    result = protocol_send(p, PACKET_TYPE_ACIP_SESSION_CREATE, payload, sizeof(req) + 10 + endpoint_length);
    sodium_memzero(payload, sizeof(payload));
  } else {
    result = protocol_send(p, PACKET_TYPE_ACIP_SESSION_CREATE, &req, sizeof(req));
  }
  sodium_memzero(&req, sizeof(req));
  return result;
}

References ACDS_CREATING, acds_session_create_params_t::acds_expose_ip, acds_sign_session_create(), acip_session_create_t, ASCIICHAT_OK, acds_session_create_params_t::capabilities, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_NOT_SUPPORTED, acds_session_create_params_t::has_password, acds_session_create_params_t::identity_pubkey, acds_session_create_params_t::identity_seckey, acds_session_create_params_t::max_participants, MAX_SESSION_KEYS, MAX_SESSION_PARTICIPANTS, PACKET_TYPE_ACIP_SESSION_CREATE, acds_session_create_params_t::password, acds_session_create_params_t::quic_port, acds_session_create_params_t::reserved_string, SAFE_STRNCPY, acds_session_create_params_t::server_address, acds_session_create_params_t::server_port, acds_session_create_params_t::session_type, SET_ERRNO, acds_protocol::state, and acds_session_create_params_t::webtransport_url.

Referenced by acds_protocol_enter(), and acds_session_create().

acds_protocol_destroy()

void acds_protocol_destroy

(

acds_protocol_t *

protocol

)

Definition at line 219 of file acds_client.c.

                                               {
  if (p)
    sodium_memzero(p, sizeof(*p));
}

Referenced by acds_session_create(), acds_session_join(), acds_session_lookup(), and DiscoveryBinding::~DiscoveryBinding().

acds_protocol_enter()

asciichat_error_t acds_protocol_enter	(	acds_protocol_t *	protocol,
		bool	create,
		const char *	name,
		const char *	password )

Create then join, or look up then join, using the same identity throughout.

Definition at line 332 of file acds_client.c.

                                                                                                               {
  if (!p || !password)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery parameters");
  if (strlen(password) > 127)
    return protocol_fail(p, ERROR_INVALID_PARAM, "Password is too long", true);
  if (crypto_sign_keypair(p->join.identity_pubkey, p->join.identity_seckey) != 0)
    return protocol_fail(p, ERROR_CRYPTO, "Could not generate discovery identity", true);
  p->auto_join = true;
  p->require_webrtc = true;
  p->join.has_password = password[0] != 0;
  SAFE_STRNCPY(p->join.password, password, sizeof(p->join.password));
  p->join.session_string = p->name;
  if (!create)
    return acds_protocol_lookup(p, name);
  acds_session_create_params_t params = {.capabilities = 3,
                                         .max_participants = MAX_SESSION_PARTICIPANTS,
                                         .session_type = SESSION_TYPE_WEBRTC,
                                         .has_password = p->join.has_password};
  memcpy(params.identity_pubkey, p->join.identity_pubkey, sizeof(params.identity_pubkey));
  memcpy(params.identity_seckey, p->join.identity_seckey, sizeof(params.identity_seckey));
  memcpy(params.password, p->join.password, sizeof(params.password));
  asciichat_error_t result = acds_protocol_create(p, &params, 0, 0);
  sodium_memzero(&params, sizeof(params));
  return result;
}

References acds_protocol_create(), acds_protocol_lookup(), acds_protocol::auto_join, ERROR_CRYPTO, ERROR_INVALID_PARAM, acds_session_join_params_t::has_password, acds_session_create_params_t::identity_pubkey, acds_session_join_params_t::identity_pubkey, acds_session_create_params_t::identity_seckey, acds_session_join_params_t::identity_seckey, acds_protocol::join, MAX_SESSION_PARTICIPANTS, acds_protocol::name, acds_session_create_params_t::password, acds_session_join_params_t::password, acds_protocol::require_webrtc, SAFE_STRNCPY, acds_session_join_params_t::session_string, SESSION_TYPE_WEBRTC, and SET_ERRNO.

Referenced by DiscoveryBinding::enter().

acds_protocol_init()

void acds_protocol_init	(	acds_protocol_t *	protocol,
		acds_protocol_send_fn	send,
		void *	user_data )

Definition at line 214 of file acds_client.c.

                                                                                         {
  memset(p, 0, sizeof(*p));
  p->send = send;
  p->user_data = user_data;
}

References acds_protocol::send, and acds_protocol::user_data.

Referenced by acds_session_create(), acds_session_join(), acds_session_lookup(), and DiscoveryBinding::DiscoveryBinding().

acds_protocol_join()

asciichat_error_t acds_protocol_join	(	acds_protocol_t *	protocol,
		const acds_session_join_params_t *	params )

Definition at line 310 of file acds_client.c.

                                                                                                   {
  if (!p || !params)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery join parameters");
  if (!valid_name(params->session_string))
    return protocol_fail(p, ERROR_INVALID_PARAM, "Invalid session name", true);
  acip_session_join_t req = {0};
  req.session_string_len = (uint8_t)strlen(params->session_string);
  memcpy(req.session_string, params->session_string, req.session_string_len);
  memcpy(req.identity_pubkey, params->identity_pubkey, sizeof(req.identity_pubkey));
  req.timestamp = time_ns_to_ms(time_get_realtime_ns());
  req.has_password = params->has_password;
  if (params->has_password)
    SAFE_STRNCPY(req.password, params->password, sizeof(req.password));
  asciichat_error_t result =
      acds_sign_session_join(params->identity_seckey, req.timestamp, params->session_string, req.signature);
  if (result != ASCIICHAT_OK)
    return protocol_fail(p, result, "Could not sign session join", true);
  p->state = ACDS_JOINING;
  result = protocol_send(p, PACKET_TYPE_ACIP_SESSION_JOIN, &req, sizeof(req));
  sodium_memzero(&req, sizeof(req));
  return result;
}

References ACDS_JOINING, acds_sign_session_join(), acip_session_join_t, ASCIICHAT_OK, ERROR_INVALID_PARAM, acds_session_join_params_t::has_password, acds_session_join_params_t::identity_pubkey, acds_session_join_params_t::identity_seckey, PACKET_TYPE_ACIP_SESSION_JOIN, acds_session_join_params_t::password, SAFE_STRNCPY, acds_session_join_params_t::session_string, SET_ERRNO, and acds_protocol::state.

Referenced by acds_protocol_receive(), and acds_session_join().

acds_protocol_leave()

asciichat_error_t acds_protocol_leave

(

acds_protocol_t *

protocol

)

Definition at line 440 of file acds_client.c.

                                                          {
  if (!p)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing discovery protocol");
  if (p->state != ACDS_JOINED)
    return ASCIICHAT_OK;
  acip_session_leave_t req = {0};
  memcpy(req.session_id, p->joined.session_id, sizeof(req.session_id));
  memcpy(req.participant_id, p->joined.participant_id, sizeof(req.participant_id));
  p->state = ACDS_ENDED;
  return protocol_send(p, PACKET_TYPE_ACIP_SESSION_LEAVE, &req, sizeof(req));
}

References ACDS_ENDED, ACDS_JOINED, acip_session_leave_t, ASCIICHAT_OK, ERROR_INVALID_PARAM, acds_protocol::joined, PACKET_TYPE_ACIP_SESSION_LEAVE, SET_ERRNO, and acds_protocol::state.

Referenced by DiscoveryBinding::leave().

acds_protocol_lookup()

asciichat_error_t acds_protocol_lookup	(	acds_protocol_t *	protocol,
		const char *	name )

Definition at line 298 of file acds_client.c.

                                                                             {
  if (!p)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing discovery protocol");
  if (!valid_name(name))
    return protocol_fail(p, ERROR_INVALID_PARAM, "Invalid session name", true);
  acip_session_lookup_t req = {0};
  req.session_string_len = (uint8_t)strlen(name);
  memcpy(req.session_string, name, req.session_string_len);
  SAFE_STRNCPY(p->name, name, sizeof(p->name));
  p->state = ACDS_LOOKING_UP;
  return protocol_send(p, PACKET_TYPE_ACIP_SESSION_LOOKUP, &req, sizeof(req));
}

References ACDS_LOOKING_UP, acip_session_lookup_t, ERROR_INVALID_PARAM, acds_protocol::name, PACKET_TYPE_ACIP_SESSION_LOOKUP, SAFE_STRNCPY, SET_ERRNO, and acds_protocol::state.

Referenced by acds_protocol_enter(), and acds_session_lookup().

acds_protocol_receive()

asciichat_error_t acds_protocol_receive	(	acds_protocol_t *	protocol,
		packet_type_t	type,
		const void *	payload,
		size_t	length )

Definition at line 357 of file acds_client.c.

                                                                                                                    {
  if (!p || (!payload && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery packet");
  if (p->state == ACDS_FAILED || p->state == ACDS_ENDED)
    return SET_ERRNO(ERROR_INVALID_STATE, "Discovery session has ended");
  if (type == PACKET_TYPE_ACIP_ERROR || type == PACKET_TYPE_ERROR_MESSAGE) {
    asciichat_error_t result = network_error_decode(type, payload, length);
    return protocol_fail(p, result, asciichat_error_string(result), true);
  }
  if (type == PACKET_TYPE_ACIP_SESSION_END) {
    p->state = ACDS_ENDED;
    p->terminal = true;
    SAFE_STRNCPY(p->error, "Session ended", sizeof(p->error));
    return SET_ERRNO(ERROR_NETWORK, "Session ended");
  }
  if (type == PACKET_TYPE_ACIP_SESSION_CREATED && p->state == ACDS_CREATING) {
    if (length < sizeof(p->created))
      return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Truncated created session", true);
    memcpy(&p->created, payload, sizeof(p->created));
    if (!p->created.session_string_len || p->created.session_string_len > 47)
      return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Invalid created session name", true);
    memcpy(p->name, p->created.session_string, p->created.session_string_len);
    p->name[p->created.session_string_len] = 0;
    p->state = ACDS_CREATED;
    if (p->auto_join)
      return acds_protocol_join(p, &p->join);
    return ASCIICHAT_OK;
  }
  if (type == PACKET_TYPE_ACIP_SESSION_INFO && p->state == ACDS_LOOKING_UP) {
    if (length < sizeof(p->info))
      return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Truncated session information", true);
    memcpy(&p->info, payload, sizeof(p->info));
    p->state = ACDS_FOUND;
    if (!p->auto_join)
      return ASCIICHAT_OK;
    if (!p->info.found)
      return protocol_fail(p, ERROR_NETWORK, "Session not found", true);
    if (p->info.require_server_verify || p->info.require_client_verify)
      return protocol_fail(p, ERROR_NOT_SUPPORTED, "This session requires an authorized identity", true);
    if (p->info.has_password && !p->join.has_password)
      return protocol_fail(p, ERROR_CRYPTO_AUTH, "This session requires a password", true);
    return acds_protocol_join(p, &p->join);
  }
  if (type == PACKET_TYPE_ACIP_SESSION_JOINED && p->state == ACDS_JOINING) {
    if (length < sizeof(p->joined))
      return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Truncated discovery join response", true);
    memcpy(&p->joined, payload, sizeof(p->joined));
    p->quic_port = 0;
    p->webtransport_url[0] = 0;
    if (length > sizeof(p->joined)) {
      const uint8_t *extension = (const uint8_t *)payload + sizeof(p->joined);
      size_t extra = length - sizeof(p->joined);
      if (extra < 10 || memcmp(extension, "ACQT", sizeof("ACQT") - 1) || extension[4] != 1 || extension[5])
        return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Invalid discovery transport extension", true);
      size_t url_length = ((size_t)extension[8] << 8) | extension[9];
      if (url_length >= sizeof(p->webtransport_url) || extra != 10 + url_length ||
          (url_length && (url_length < 9 || memcmp(extension + 10, "https://", sizeof("https://") - 1) ||
                          memchr(extension + 10, 0, url_length))))
        return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Invalid discovery WebTransport endpoint", true);
      p->quic_port = (uint16_t)((uint16_t)extension[6] << 8 | extension[7]);
      memcpy(p->webtransport_url, extension + 10, url_length);
      p->webtransport_url[url_length] = 0;
    }
    p->joined.error_message[sizeof(p->joined.error_message) - 1] = 0;
    p->joined.server_address[sizeof(p->joined.server_address) - 1] = 0;
    p->joined.turn_username[sizeof(p->joined.turn_username) - 1] = 0;
    p->joined.turn_password[sizeof(p->joined.turn_password) - 1] = 0;
    if (!p->joined.success)
      return protocol_fail(p, network_error_from_acip(p->joined.error_code),
                           p->joined.error_message[0] ? p->joined.error_message : "Session join rejected", true);
    if (p->require_webrtc && p->joined.session_type != SESSION_TYPE_WEBRTC && !p->webtransport_url[0])
      return protocol_fail(p, ERROR_NOT_SUPPORTED, "This session does not offer WebTransport or WebRTC", true);
    p->state = ACDS_JOINED;
    sodium_memzero(p->join.identity_seckey, sizeof(p->join.identity_seckey));
    sodium_memzero(p->join.password, sizeof(p->join.password));
    return ASCIICHAT_OK;
  }
  // Signaling and participant notifications are delivered by the caller's transport adapter.
  if (p->state == ACDS_JOINED && type != PACKET_TYPE_ACIP_SESSION_CREATED && type != PACKET_TYPE_ACIP_SESSION_INFO &&
      type != PACKET_TYPE_ACIP_SESSION_JOINED)
    return ASCIICHAT_OK;
  return protocol_fail(p, ERROR_NETWORK_PROTOCOL, "Unexpected discovery response", true);
}

References ACDS_CREATED, ACDS_CREATING, ACDS_ENDED, ACDS_FAILED, ACDS_FOUND, ACDS_JOINED, ACDS_JOINING, ACDS_LOOKING_UP, acds_protocol_join(), ASCIICHAT_OK, acds_protocol::auto_join, acds_protocol::created, acds_protocol::error, ERROR_CRYPTO_AUTH, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, ERROR_NETWORK_PROTOCOL, ERROR_NOT_SUPPORTED, acds_session_join_params_t::has_password, acds_session_join_params_t::identity_seckey, acds_protocol::info, acds_protocol::join, acds_protocol::joined, acds_protocol::name, network_error_decode(), network_error_from_acip(), PACKET_TYPE_ACIP_ERROR, PACKET_TYPE_ACIP_SESSION_CREATED, PACKET_TYPE_ACIP_SESSION_END, PACKET_TYPE_ACIP_SESSION_INFO, PACKET_TYPE_ACIP_SESSION_JOINED, PACKET_TYPE_ERROR_MESSAGE, acds_session_join_params_t::password, acds_protocol::quic_port, acds_protocol::require_webrtc, SAFE_STRNCPY, SESSION_TYPE_WEBRTC, SET_ERRNO, acds_protocol::state, acds_protocol::terminal, and acds_protocol::webtransport_url.

Referenced by DiscoveryBinding::receive().

acds_receive_packet()

asciichat_error_t acds_receive_packet	(	acip_transport_t *	transport,
		packet_type_t *	type,
		void **	payload,
		size_t *	length,
		void **	allocation )

Receive discovery traffic, including WS application encryption. TCP decrypts in its transport.

Definition at line 481 of file acds_client.c.

                                                         {
  asciichat_error_t result = packet_receive_via_transport(transport, type, payload, length, allocation);
  if (result != ASCIICHAT_OK || acip_transport_get_type(transport) != ACIP_TRANSPORT_WEBSOCKET ||
      !transport->crypto_ctx || !transport->crypto_ctx->encrypt_data)
    return result;
  if (*type != PACKET_TYPE_ENCRYPTED)
    return SET_ERRNO(ERROR_CRYPTO, "Discovery signaling requires encrypted packets");
  packet_envelope_t envelope = {.type = *type, .data = *payload, .len = *length, .allocated_buffer = *allocation};
  result = packet_decrypt_envelope(&envelope, transport->crypto_ctx);
  *allocation = envelope.allocated_buffer;
  *type = envelope.type;
  *payload = envelope.data;
  *length = envelope.len;
  if (result == ASCIICHAT_OK) {
    const packet_header_t *inner = envelope.allocated_buffer;
    if (NET_TO_HOST_U64(inner->magic) != PACKET_MAGIC || envelope.type == PACKET_TYPE_ENCRYPTED ||
        asciichat_crc32(envelope.data, envelope.len) != NET_TO_HOST_U32(inner->crc32))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid encrypted discovery packet");
  }
  return result;
}

References ACIP_TRANSPORT_WEBSOCKET, asciichat_crc32, ASCIICHAT_OK, packet_header_t::crc32, acip_transport::crypto_ctx, crypto_context_t::encrypt_data, ERROR_CRYPTO, ERROR_NETWORK_PROTOCOL, packet_header_t::magic, NET_TO_HOST_U32, NET_TO_HOST_U64, packet_decrypt_envelope(), PACKET_MAGIC, packet_receive_via_transport(), PACKET_TYPE_ENCRYPTED, and SET_ERRNO.