negotiation.h File Reference

Go to the source code of this file.

Data Structures
struct	network_negotiation_t
	When code needs to work with network negotiation, it keeps protocol, handshake, identity_keys, identity_key_count here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. are borrowed from server configuration until all connections have drained. The application context retains handshake storage until the closed callback. More...

Enumerations
enum	network_protocol_t { NETWORK_PROTOCOL_MEDIA , NETWORK_PROTOCOL_DISCOVERY }

Functions
asciichat_error_t	network_negotiation_receive (network_negotiation_t *, acip_transport_t *, packet_type_t, const void *, size_t)
asciichat_error_t	network_client_negotiate (acip_transport_t *, crypto_handshake_context_t *, uint8_t mode, network_protocol_t protocol)

Enumeration Type Documentation

network_protocol_t

enum network_protocol_t

Enumerator
NETWORK_PROTOCOL_MEDIA
NETWORK_PROTOCOL_DISCOVERY

Definition at line 5 of file negotiation.h.

{ NETWORK_PROTOCOL_MEDIA, NETWORK_PROTOCOL_DISCOVERY } network_protocol_t;

Function Documentation

network_client_negotiate()

asciichat_error_t network_client_negotiate	(	acip_transport_t *	transport,
		crypto_handshake_context_t *	ctx,
		uint8_t	mode,
		network_protocol_t	protocol )

Drive a client wire profile using connection-owned security storage. A single absolute deadline covers negotiation; the caller retains transport and credentials until cancellation and all users have drained.

Definition at line 414 of file negotiation.c.

                                                                        {
  if (!transport || !ctx || mode > ACIP_CRYPTO_FULL || protocol > NETWORK_PROTOCOL_DISCOVERY)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client negotiation");
  if (is_quic(transport) && !ACIP_CRYPTO_HAS_ENCRYPT(mode))
    return SET_ERRNO(ERROR_CRYPTO, "QUIC requires ACIP encryption");
  uint64_t timeout = transport->receive_timeout_ns;
  asciichat_error_t result = protocol == NETWORK_PROTOCOL_DISCOVERY ? discovery_client_negotiate(transport, ctx, mode)
                                                                    : client_negotiate(transport, ctx, mode);
  transport->receive_timeout_ns = timeout;
  if (result == ASCIICHAT_OK)
    result = finish_transport_security(transport, ctx);
  return result;
}

References ACIP_CRYPTO_FULL, ACIP_CRYPTO_HAS_ENCRYPT, ASCIICHAT_OK, ERROR_CRYPTO, ERROR_INVALID_PARAM, NETWORK_PROTOCOL_DISCOVERY, acip_transport::receive_timeout_ns, and SET_ERRNO.

Referenced by discovery_session_start(), and network_connection_establish().

network_negotiation_receive()

asciichat_error_t network_negotiation_receive	(	network_negotiation_t *	n,
		acip_transport_t *	transport,
		packet_type_t	type,
		const void *	payload,
		size_t	length )

Definition at line 200 of file negotiation.c.

                                                                                  {
  if (!n || !n->handshake || !transport || n->ready)
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid connection negotiation state");
  if (is_quic(transport) && n->step == 0 && type == PACKET_TYPE_PROTOCOL_VERSION &&
      length == sizeof(protocol_version_packet_t)) {
    protocol_version_packet_t version;
    memcpy(&version, payload, sizeof(version));
    if (!ACIP_CRYPTO_HAS_ENCRYPT(version.supports_encryption))
      return SET_ERRNO(ERROR_CRYPTO, "QUIC requires ACIP encryption");
  }
  if (n->protocol == NETWORK_PROTOCOL_MEDIA) {
    asciichat_error_t result = media_receive(n, transport, type, payload, length);
    if (result == ASCIICHAT_OK && n->ready) {
      result = finish_transport_security(transport, n->handshake);
      if (result != ASCIICHAT_OK)
        n->ready = false;
    }
    return result;
  }
  crypto_handshake_context_t *ctx = n->handshake;
  asciichat_error_t result;
  switch (n->step) {
  case 0: {
    if (type != PACKET_TYPE_PROTOCOL_VERSION || length != sizeof(protocol_version_packet_t))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Expected discovery protocol version");
    protocol_version_packet_t version;
    memcpy(&version, payload, sizeof(version));
    if (NET_TO_HOST_U16(version.protocol_version) != PROTOCOL_VERSION_MAJOR)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unsupported discovery protocol version");
    uint8_t mode = version.supports_encryption;
    result = crypto_policy_check_mode(n->secure, n->require_encryption, n->forbid_encryption, n->require_auth, mode);
    if (result != ASCIICHAT_OK)
      return result;
    ctx->crypto_ctx.encrypt_data = n->encrypt_data = ACIP_CRYPTO_HAS_ENCRYPT(mode);
    if (mode == ACIP_CRYPTO_NONE) {
      ctx->state = CRYPTO_HANDSHAKE_DISABLED;
      n->ready = true;
      return ASCIICHAT_OK;
    }
    result = crypto_handshake_server_send_parameters(ctx, transport);
    if (result == ASCIICHAT_OK)
      result = crypto_handshake_server_start(ctx, transport);
    break;
  }
  case 1:
    result = crypto_handshake_server_auth_challenge(ctx, transport, type, payload, length);
    break;
  case 2:
    result = crypto_handshake_server_complete(ctx, transport, type, payload, length);
    break;
  default:
    return SET_ERRNO(ERROR_CRYPTO, "Invalid discovery negotiation state");
  }
  if (result != ASCIICHAT_OK)
    return result;
  ++n->step;
  n->ready = ctx->state == CRYPTO_HANDSHAKE_READY;
  if (n->ready)
    transport->crypto_ctx = &ctx->crypto_ctx;
  if (n->ready) {
    result = finish_transport_security(transport, ctx);
    if (result != ASCIICHAT_OK)
      n->ready = false;
  }
  return result;
}

References ACIP_CRYPTO_HAS_ENCRYPT, ACIP_CRYPTO_NONE, ASCIICHAT_OK, acip_transport::crypto_ctx, crypto_handshake_context_t::crypto_ctx, CRYPTO_HANDSHAKE_DISABLED, CRYPTO_HANDSHAKE_READY, crypto_handshake_server_auth_challenge(), crypto_handshake_server_complete(), crypto_handshake_server_send_parameters(), crypto_handshake_server_start(), crypto_policy_check_mode(), crypto_context_t::encrypt_data, network_negotiation_t::encrypt_data, ERROR_CRYPTO, ERROR_INVALID_STATE, ERROR_NETWORK_PROTOCOL, network_negotiation_t::forbid_encryption, network_negotiation_t::handshake, NET_TO_HOST_U16, NETWORK_PROTOCOL_MEDIA, PACKET_TYPE_PROTOCOL_VERSION, network_negotiation_t::protocol, protocol_version_packet_t::protocol_version, PROTOCOL_VERSION_MAJOR, network_negotiation_t::ready, network_negotiation_t::require_auth, network_negotiation_t::require_encryption, network_negotiation_t::secure, SET_ERRNO, crypto_handshake_context_t::state, network_negotiation_t::step, and protocol_version_packet_t::supports_encryption.