negotiation.c File Reference

Go to the source code of this file.

Functions
asciichat_error_t	network_negotiation_receive (network_negotiation_t *n, acip_transport_t *transport, packet_type_t type, const void *payload, size_t length)
asciichat_error_t	network_client_negotiate (acip_transport_t *transport, crypto_handshake_context_t *ctx, uint8_t mode, network_protocol_t protocol)

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.