packet.c File Reference

Go to the source code of this file.

Functions
asciichat_error_t	packet_send (socket_t sockfd, packet_type_t type, const void *data, size_t len)
	Send a packet with proper header and CRC32.
asciichat_error_t	packet_receive (socket_t sockfd, packet_type_t *type, void **data, size_t *len)
	Receive a packet with proper header validation and CRC32 checking.
asciichat_error_t	send_packet_secure (socket_t sockfd, packet_type_t type, const void *data, size_t len, crypto_context_t *crypto_ctx)
	Send a packet with encryption and compression support.
packet_recv_result_t	receive_packet_secure (socket_t sockfd, void *crypto_ctx, bool enforce_encryption, packet_envelope_t *envelope)
	Receive a packet with decryption and decompression support.
packet_recv_result_t	receive_packet_secure_with_timeout (socket_t sockfd, void *crypto_ctx, bool enforce_encryption, packet_envelope_t *envelope, uint64_t timeout_ns)
int	send_packet (socket_t sockfd, packet_type_t type, const void *data, size_t len)
	Send a basic packet without encryption.
int	receive_packet (socket_t sockfd, packet_type_t *type, void **data, size_t *len)
	Receive a basic packet without encryption.
int	send_ping_packet (socket_t sockfd)
	Send a ping packet.
int	send_pong_packet (socket_t sockfd)
	Send a pong packet.
asciichat_error_t	packet_decrypt_envelope (packet_envelope_t *envelope, void *crypto_ctx)
	Send a clear console packet.
asciichat_error_t	packet_send_error (socket_t sockfd, const crypto_context_t *crypto_ctx, asciichat_error_t error_code, const char *message)
	Send an error packet with optional encryption context.
asciichat_error_t	packet_parse_error_message (const void *data, size_t len, asciichat_error_t *out_error_code, char *message_buffer, size_t message_buffer_size, size_t *out_message_length)
	Parse an error packet payload into components.
asciichat_error_t	packet_send_remote_log (socket_t sockfd, const crypto_context_t *crypto_ctx, log_level_t level, remote_log_direction_t direction, uint16_t flags, const char *message)
	Send a remote log packet with optional encryption context.
asciichat_error_t	packet_parse_remote_log (const void *data, size_t len, log_level_t *out_level, remote_log_direction_t *out_direction, uint16_t *out_flags, char *message_buffer, size_t message_buffer_size, size_t *out_message_length)
	Parse a remote log packet payload into components.
int	send_protocol_version_packet (socket_t sockfd, const protocol_version_packet_t *version)
	Send protocol version packet.
int	send_crypto_capabilities_packet (socket_t sockfd, const crypto_capabilities_packet_t *caps)
	Send crypto capabilities packet.
int	send_crypto_parameters_packet (socket_t sockfd, const crypto_parameters_packet_t *params)
	Send crypto parameters packet.
asciichat_error_t	av_send_audio_opus_batch (socket_t sockfd, const uint8_t *opus_data, size_t opus_size, const uint16_t *frame_sizes, int sample_rate, int frame_duration, int frame_count, crypto_context_t *crypto_ctx)
	Send Opus-encoded audio batch packet with encryption support.
asciichat_error_t	send_image_frame_packet (socket_t sockfd, const void *image_data, uint16_t width, uint16_t height, uint8_t format)
	Send image frame packet.

Function Documentation

packet_parse_error_message()

asciichat_error_t packet_parse_error_message	(	const void *	data,
		size_t	len,
		asciichat_error_t *	out_error_code,
		char *	message_buffer,
		size_t	message_buffer_size,
		size_t *	out_message_length
	)

Parse an error packet payload into components.

Parameters

data	Packet payload buffer
len	Payload length in bytes
out_error_code	Output pointer for asciichat_error_t value (must not be NULL)
message_buffer	Destination buffer for message string (must not be NULL)
message_buffer_size	Size of destination buffer in bytes (must be > 0)
out_message_length	Optional output for message length reported by sender

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 957 of file packet.c.

                                                                         {
  if (!data || len < sizeof(error_packet_t) || !out_error_code || !message_buffer || message_buffer_size == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM,
                     "Invalid parameters: data=%p len=%zu out_error_code=%p message_buffer=%p buffer_size=%zu", data,
                     len, out_error_code, message_buffer, message_buffer_size);
  }
 
  const error_packet_t *packet = (const error_packet_t *)data;
  uint32_t raw_error_code = NET_TO_HOST_U32(packet->error_code);
  uint32_t raw_message_length = NET_TO_HOST_U32(packet->message_length);
 
  if (raw_message_length > MAX_ERROR_MESSAGE_LENGTH) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Error message length too large: %u", raw_message_length);
  }
 
  size_t total_required = sizeof(error_packet_t) + (size_t)raw_message_length;
  if (total_required > len) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Error packet truncated: expected %zu bytes, have %zu", total_required,
                     len);
  }
 
  const uint8_t *message_bytes = (const uint8_t *)data + sizeof(error_packet_t);
  size_t copy_len = raw_message_length;
  if (copy_len >= message_buffer_size) {
    copy_len = message_buffer_size - 1;
  }
 
  if (copy_len > 0) {
    memcpy(message_buffer, message_bytes, copy_len);
  }
  message_buffer[copy_len] = '\0';
 
  if (out_message_length) {
    *out_message_length = raw_message_length;
  }
 
  *out_error_code = (asciichat_error_t)raw_error_code;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, error_packet_t::error_code, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, MAX_ERROR_MESSAGE_LENGTH, error_packet_t::message_length, NET_TO_HOST_U32, and SET_ERRNO.

packet_parse_remote_log()

asciichat_error_t packet_parse_remote_log	(	const void *	data,
		size_t	len,
		log_level_t *	out_level,
		remote_log_direction_t *	out_direction,
		uint16_t *	out_flags,
		char *	message_buffer,
		size_t	message_buffer_size,
		size_t *	out_message_length
	)

Parse a remote log packet payload into components.

Parameters

data	Packet payload buffer
len	Payload length in bytes
out_level	Output pointer for log level (must not be NULL)
out_direction	Output pointer for direction (must not be NULL)
out_flags	Output pointer for flags (must not be NULL)
message_buffer	Destination buffer for message string (must not be NULL)
message_buffer_size	Size of destination buffer in bytes (must be > 0)
out_message_length	Optional output for message length reported by sender

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 1056 of file packet.c.

                                                                      {
  if (!data || len < sizeof(remote_log_packet_t) || !out_level || !out_direction || !out_flags || !message_buffer ||
      message_buffer_size == 0) {
    return SET_ERRNO(
        ERROR_INVALID_PARAM,
        "Invalid parameters: data=%p len=%zu out_level=%p out_direction=%p out_flags=%p buffer=%p size=%zu", data, len,
        out_level, out_direction, out_flags, message_buffer, message_buffer_size);
  }
 
  const remote_log_packet_t *packet = (const remote_log_packet_t *)data;
  uint8_t raw_level = packet->log_level;
  if (raw_level > LOG_FATAL) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid remote log level: %u", raw_level);
  }
  *out_level = (log_level_t)raw_level;
 
  uint8_t raw_direction = packet->direction;
  if (raw_direction > REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER) {
    raw_direction = REMOTE_LOG_DIRECTION_UNKNOWN;
  }
  *out_direction = (remote_log_direction_t)raw_direction;
 
  uint16_t raw_flags = NET_TO_HOST_U16(packet->flags);
  *out_flags = raw_flags;
 
  uint32_t raw_message_length = NET_TO_HOST_U32(packet->message_length);
  if (raw_message_length > MAX_REMOTE_LOG_MESSAGE_LENGTH) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Remote log message length too large: %u", raw_message_length);
  }
 
  size_t total_required = sizeof(remote_log_packet_t) + (size_t)raw_message_length;
  if (total_required > len) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Remote log packet truncated: expected %zu bytes, have %zu",
                     total_required, len);
  }
 
  const uint8_t *message_bytes = (const uint8_t *)data + sizeof(remote_log_packet_t);
  size_t copy_len = raw_message_length;
  if (copy_len >= message_buffer_size) {
    copy_len = message_buffer_size - 1;
  }
 
  if (copy_len > 0) {
    memcpy(message_buffer, message_bytes, copy_len);
  }
  message_buffer[copy_len] = '\0';
 
  if (out_message_length) {
    *out_message_length = raw_message_length;
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, remote_log_packet_t::direction, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, remote_log_packet_t::flags, LOG_FATAL, remote_log_packet_t::log_level, MAX_REMOTE_LOG_MESSAGE_LENGTH, remote_log_packet_t::message_length, NET_TO_HOST_U16, NET_TO_HOST_U32, REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER, REMOTE_LOG_DIRECTION_UNKNOWN, and SET_ERRNO.

Referenced by handle_remote_log_packet_from_client().

packet_send_error()

asciichat_error_t packet_send_error	(	socket_t	sockfd,
		const crypto_context_t *	crypto_ctx,
		asciichat_error_t	error_code,
		const char *	message
	)

Send an error packet with optional encryption context.

Parameters

sockfd	Socket file descriptor
crypto_ctx	Crypto context for encryption (NULL or not ready sends plaintext)
error_code	Error code from asciichat_error_t enumeration
message	Human-readable message to accompany the error (can be NULL)

Returns

ASCIICHAT_OK on success, error code otherwise

When the crypto context is ready, the packet is encrypted automatically. During the handshake (or when encryption is disabled), the packet is sent in plaintext so protocol errors can be delivered before encryption is active.

Definition at line 910 of file packet.c.

                                                         {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
  }
 
  if (!message) {
    message = "";
  }
 
  size_t message_len = strnlen(message, MAX_ERROR_MESSAGE_LENGTH);
  if (message_len == MAX_ERROR_MESSAGE_LENGTH) {
    log_warn("Error message truncated to %zu bytes", (size_t)MAX_ERROR_MESSAGE_LENGTH);
  }
 
  size_t payload_len = sizeof(error_packet_t) + message_len;
  uint8_t *payload = SAFE_MALLOC(payload_len, uint8_t *);
  if (!payload) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate %zu bytes for error packet", payload_len);
  }
 
  error_packet_t *packet = (error_packet_t *)payload;
  packet->error_code = HOST_TO_NET_U32((uint32_t)error_code);
  packet->message_length = HOST_TO_NET_U32((uint32_t)message_len);
 
  if (message_len > 0) {
    memcpy(payload + sizeof(error_packet_t), message, message_len);
  }
 
  bool encryption_ready = crypto_ctx && crypto_is_ready(crypto_ctx);
  asciichat_error_t send_result;
 
  if (encryption_ready) {
    send_result =
        send_packet_secure(sockfd, PACKET_TYPE_ERROR_MESSAGE, payload, payload_len, (crypto_context_t *)crypto_ctx);
  } else {
    send_result = packet_send(sockfd, PACKET_TYPE_ERROR_MESSAGE, payload, payload_len);
  }
  SAFE_FREE(payload);
 
  if (send_result != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to send error packet: %s", asciichat_error_string(send_result));
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_is_ready(), error_packet_t::error_code, error_code, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, HOST_TO_NET_U32, INVALID_SOCKET_VALUE, log_warn, MAX_ERROR_MESSAGE_LENGTH, error_packet_t::message_length, packet_send(), PACKET_TYPE_ERROR_MESSAGE, SAFE_FREE, SAFE_MALLOC, send_packet_secure(), and SET_ERRNO.

Referenced by disconnect_client_for_bad_data().

packet_send_remote_log()

asciichat_error_t packet_send_remote_log	(	socket_t	sockfd,
		const crypto_context_t *	crypto_ctx,
		log_level_t	level,
		remote_log_direction_t	direction,
		uint16_t	flags,
		const char *	message
	)

Send a remote log packet with optional encryption context.

Parameters

sockfd	Socket file descriptor
crypto_ctx	Crypto context for encryption (NULL or not ready sends plaintext)
level	Log level to transmit
direction	Direction flag (REMOTE_LOG_DIRECTION_*)
flags	Additional flags (REMOTE_LOG_FLAG_*)
message	Log message text

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 999 of file packet.c.

                                                                                                                {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
  }
 
  if (level < LOG_DEV || level > LOG_FATAL) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid log level: %d", level);
  }
 
  const char *safe_message = message ? message : "";
  bool truncated = false;
  size_t message_len = strnlen(safe_message, MAX_REMOTE_LOG_MESSAGE_LENGTH);
  if (message_len == MAX_REMOTE_LOG_MESSAGE_LENGTH && safe_message[message_len] != '\0') {
    truncated = true;
  }
 
  size_t payload_len = sizeof(remote_log_packet_t) + message_len;
  uint8_t *payload = SAFE_MALLOC(payload_len, uint8_t *);
  if (!payload) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate %zu bytes for remote log packet", payload_len);
  }
 
  remote_log_packet_t *packet = (remote_log_packet_t *)payload;
  packet->log_level = (uint8_t)level;
  packet->direction = (uint8_t)direction;
  uint16_t final_flags = flags;
  if (truncated) {
    final_flags |= REMOTE_LOG_FLAG_TRUNCATED;
  }
  packet->flags = HOST_TO_NET_U16(final_flags);
  packet->message_length = HOST_TO_NET_U32((uint32_t)message_len);
 
  if (message_len > 0) {
    memcpy(payload + sizeof(remote_log_packet_t), safe_message, message_len);
  }
 
  bool encryption_ready = crypto_ctx && crypto_is_ready(crypto_ctx);
  asciichat_error_t send_result;
 
  if (encryption_ready) {
    int secure_result =
        send_packet_secure(sockfd, PACKET_TYPE_REMOTE_LOG, payload, payload_len, (crypto_context_t *)crypto_ctx);
    send_result = secure_result == 0 ? ASCIICHAT_OK : ERROR_NETWORK;
  } else {
    send_result = packet_send(sockfd, PACKET_TYPE_REMOTE_LOG, payload, payload_len);
  }
 
  SAFE_FREE(payload);
 
  if (send_result != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to send remote log packet: %d", send_result);
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_is_ready(), remote_log_packet_t::direction, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, remote_log_packet_t::flags, HOST_TO_NET_U16, HOST_TO_NET_U32, INVALID_SOCKET_VALUE, LOG_FATAL, remote_log_packet_t::log_level, MAX_REMOTE_LOG_MESSAGE_LENGTH, remote_log_packet_t::message_length, packet_send(), PACKET_TYPE_REMOTE_LOG, REMOTE_LOG_FLAG_TRUNCATED, SAFE_FREE, SAFE_MALLOC, send_packet_secure(), and SET_ERRNO.

receive_packet_secure_with_timeout()

packet_recv_result_t receive_packet_secure_with_timeout	(	socket_t	sockfd,
		void *	crypto_ctx,
		bool	enforce_encryption,
		packet_envelope_t *	envelope,
		uint64_t	timeout_ns
	)

Definition at line 575 of file packet.c.

                                                                                                          {
 
  if (!envelope) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: envelope=%p", envelope);
    return PACKET_RECV_ERROR;
  }
 
  // Initialize envelope
  memset(envelope, 0, sizeof(*envelope));
 
  // Receive packet header
  packet_header_t header;
  ssize_t received = recv_with_timeout(sockfd, &header, sizeof(header), timeout_ns);
 
  // Check for errors first (before comparing signed with unsigned)
  if (received < 0) {
    /* Preserve a poll timeout so callers can wait for the next signaling packet
     * without treating an idle connection as a receive failure. */
    asciichat_error_context_t error_context;
    if (HAS_ERRNO(&error_context) && error_context.code == ERROR_NETWORK_TIMEOUT) {
      return PACKET_RECV_ERROR;
    }
    SET_ERRNO(ERROR_NETWORK, "Failed to receive packet header: %zd/%zu bytes", received, sizeof(header));
    return PACKET_RECV_ERROR;
  }
 
  if (received == 0) {
    return PACKET_RECV_EOF;
  }
 
  if ((size_t)received != sizeof(header)) {
    SET_ERRNO(ERROR_NETWORK, "Failed to receive packet header: %zd/%zu bytes", received, sizeof(header));
    return PACKET_RECV_ERROR;
  }
 
  // Convert from network byte order
  uint64_t magic = NET_TO_HOST_U64(header.magic);
  uint16_t pkt_type = NET_TO_HOST_U16(header.type);
  uint32_t pkt_len = NET_TO_HOST_U32(header.length);
  uint32_t expected_crc = NET_TO_HOST_U32(header.crc32);
 
  // DEBUG: Log raw header bytes for debugging packet misalignment
  char header_hex[95];
  for (size_t i = 0; i < sizeof(header); i++) {
    snprintf(&header_hex[i * 2], 3, "%02x", ((uint8_t *)&header)[i]);
  }
  header_hex[94] = '\0';
 
  // DEBUG: Log all received packet types in detail
  log_info("[RECV_PKT_HEADER] 🔍 Received packet: type=%u (0x%04x), len=%u, client_id=%u, raw=%s", pkt_type, pkt_type,
           pkt_len, header.client_id, header_hex);
 
  // Validate magic number
  if (magic != PACKET_MAGIC) {
    SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid packet magic: 0x%llx (expected 0x%llx)", magic, PACKET_MAGIC);
    return PACKET_RECV_ERROR;
  }
 
  // Validate packet size
  if (pkt_len > MAX_PACKET_SIZE) {
    SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: %u > %d", pkt_len, MAX_PACKET_SIZE);
    return PACKET_RECV_ERROR;
  }
 
  // Handle encrypted packets
  if (pkt_type == PACKET_TYPE_ENCRYPTED) {
    if (!crypto_ctx) {
      SET_ERRNO(ERROR_CRYPTO, "Received encrypted packet but no crypto context");
      return PACKET_RECV_ERROR;
    }
 
    // Read encrypted payload
    uint8_t *ciphertext = buffer_pool_alloc(NULL, pkt_len);
    if (!ciphertext) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for ciphertext");
      return PACKET_RECV_ERROR;
    }
 
    uint64_t recv_timeout = MAX(timeout_ns, calculate_packet_timeout(pkt_len));
    received = recv_with_timeout(sockfd, ciphertext, pkt_len, recv_timeout);
    if (received != (ssize_t)pkt_len) {
      SET_ERRNO(ERROR_NETWORK, "Failed to receive encrypted payload: %zd/%u bytes", received, pkt_len);
      buffer_pool_free(NULL, ciphertext, pkt_len);
      return PACKET_RECV_ERROR;
    }
 
    // Decrypt - allocate plaintext buffer with extra space
    // pkt_len is already validated to be <= MAX_PACKET_SIZE, so adding 1024 cannot overflow
    size_t plaintext_size = (size_t)pkt_len + 1024;
    uint8_t *plaintext = buffer_pool_alloc(NULL, plaintext_size);
    if (!plaintext) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for plaintext");
      buffer_pool_free(NULL, ciphertext, pkt_len);
      return PACKET_RECV_ERROR;
    }
 
    size_t plaintext_len;
    crypto_result_t result = crypto_decrypt(crypto_ctx, ciphertext, pkt_len, plaintext, plaintext_size, &plaintext_len);
    buffer_pool_free(NULL, ciphertext, pkt_len);
 
    if (result != CRYPTO_OK) {
      SET_ERRNO(ERROR_CRYPTO, "Failed to decrypt packet: %s", crypto_result_to_string(result));
      buffer_pool_free(NULL, plaintext, plaintext_size);
      return PACKET_RECV_ERROR;
    }
 
    if (plaintext_len < sizeof(packet_header_t)) {
      SET_ERRNO(ERROR_CRYPTO, "Decrypted packet too small: %zu < %zu", plaintext_len, sizeof(packet_header_t));
      buffer_pool_free(NULL, plaintext, plaintext_size);
      return PACKET_RECV_ERROR;
    }
 
    // Parse decrypted header
    packet_header_t *decrypted_header = (packet_header_t *)plaintext;
    pkt_type = NET_TO_HOST_U16(decrypted_header->type);
 
    // DEBUG: Log decrypted packet type
    log_info("[RECV_PKT_DECRYPTED] 🔐 After decryption: actual_type=%u (0x%04x), len=%u", pkt_type, pkt_type,
             NET_TO_HOST_U32(decrypted_header->length));
    pkt_len = NET_TO_HOST_U32(decrypted_header->length);
    expected_crc = NET_TO_HOST_U32(decrypted_header->crc32);
 
    // Extract payload
    size_t payload_len = plaintext_len - sizeof(packet_header_t);
    if (payload_len != pkt_len) {
      SET_ERRNO(ERROR_CRYPTO, "Decrypted payload size mismatch: %zu != %u", payload_len, pkt_len);
      buffer_pool_free(NULL, plaintext, plaintext_size);
      return PACKET_RECV_ERROR;
    }
 
    // Verify CRC
    if (pkt_len > 0) {
      uint32_t actual_crc = asciichat_crc32(plaintext + sizeof(packet_header_t), pkt_len);
      if (actual_crc != expected_crc) {
        SET_ERRNO(ERROR_CRYPTO, "Decrypted packet CRC mismatch: 0x%x != 0x%x", actual_crc, expected_crc);
        buffer_pool_free(NULL, plaintext, plaintext_size);
        return PACKET_RECV_ERROR;
      }
    }
 
    // Set envelope
    envelope->type = (packet_type_t)pkt_type;
    envelope->data = plaintext + sizeof(packet_header_t);
    envelope->len = pkt_len;
    envelope->allocated_buffer = plaintext;
    envelope->allocated_size = plaintext_size;
 
    return PACKET_RECV_SUCCESS;
  }
 
  // Handle unencrypted packets
  if (enforce_encryption && !packet_is_handshake_type(pkt_type)) {
    SET_ERRNO(ERROR_CRYPTO, "Received unencrypted packet type %d but encryption is required", pkt_type);
    return PACKET_RECV_ERROR;
  }
 
  // Read payload and return header+payload in envelope (matching encrypted path format)
  size_t total_size = sizeof(packet_header_t) + pkt_len;
  uint8_t *packet_buf = buffer_pool_alloc(NULL, total_size);
  if (!packet_buf) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for packet");
    return PACKET_RECV_ERROR;
  }
 
  // Copy header into buffer
  memcpy(packet_buf, &header, sizeof(packet_header_t));
 
  if (pkt_len > 0) {
    uint64_t recv_timeout = calculate_packet_timeout(pkt_len);
    received = recv_with_timeout(sockfd, packet_buf + sizeof(packet_header_t), pkt_len, recv_timeout);
    if (received != (ssize_t)pkt_len) {
      SET_ERRNO(ERROR_NETWORK, "Failed to receive payload: %zd/%u bytes", received, pkt_len);
      buffer_pool_free(NULL, packet_buf, total_size);
      return PACKET_RECV_ERROR;
    }
 
    // Verify CRC
    uint32_t actual_crc = asciichat_crc32(packet_buf + sizeof(packet_header_t), pkt_len);
    if (actual_crc != expected_crc) {
      SET_ERRNO(ERROR_NETWORK, "Packet CRC mismatch: 0x%x != 0x%x", actual_crc, expected_crc);
      buffer_pool_free(NULL, packet_buf, total_size);
      return PACKET_RECV_ERROR;
    }
  }
 
  envelope->data = packet_buf;
  envelope->allocated_buffer = packet_buf;
  envelope->allocated_size = total_size;
  envelope->type = (packet_type_t)pkt_type;
  envelope->len = total_size;
 
  return PACKET_RECV_SUCCESS;
}

References packet_envelope_t::allocated_buffer, packet_envelope_t::allocated_size, asciichat_crc32, buffer_pool_alloc(), buffer_pool_free(), packet_header_t::client_id, asciichat_error_context_t::code, packet_header_t::crc32, crypto_decrypt(), CRYPTO_OK, crypto_result_to_string(), packet_envelope_t::data, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, ERROR_NETWORK_PROTOCOL, ERROR_NETWORK_SIZE, ERROR_NETWORK_TIMEOUT, HAS_ERRNO, packet_envelope_t::len, packet_header_t::length, log_info, packet_header_t::magic, MAX, MAX_PACKET_SIZE, NET_TO_HOST_U16, NET_TO_HOST_U32, NET_TO_HOST_U64, PACKET_MAGIC, PACKET_RECV_EOF, PACKET_RECV_ERROR, PACKET_RECV_SUCCESS, PACKET_TYPE_ENCRYPTED, recv_with_timeout(), SET_ERRNO, packet_header_t::type, and packet_envelope_t::type.

Referenced by receive_packet_secure().