packet.c

Go to the documentation of this file.

 
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/network/network.h>
#include <ascii-chat/common.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/platform/socket.h>
#include <ascii-chat/buffer_pool.h>
#include <ascii-chat/network/crc32.h>
#include <ascii-chat/crypto/crypto.h>
#include <ascii-chat/network/compression.h>
#include <ascii-chat/util/endian.h>
#include <ascii-chat/util/overflow.h>
#include <ascii-chat/audio/audio.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/options/rcu.h> // For RCU-based options access
#include <stdint.h>
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// Network timeout constants are defined in packet_types.h
 
/* ============================================================================
 * Packet Protocol Implementation
 * ============================================================================
 * This module handles packet verification, CRC validation, and protocol
 * compliance checking for all network packets.
 */
 
// Use network_network_is_test_environment() from network.h
 
static uint64_t calculate_packet_timeout(size_t packet_size) {
  uint64_t base_timeout = SEND_TIMEOUT * NS_PER_SEC_INT;
 
  // For large packets, increase timeout proportionally
  if (packet_size > LARGE_PACKET_THRESHOLD) {
    // Add extra timeout per MB above the threshold
    uint64_t extra_timeout =
        (uint64_t)(((double)packet_size - LARGE_PACKET_THRESHOLD) / 1000000.0 * LARGE_PACKET_EXTRA_TIMEOUT_PER_MB) +
        NS_PER_MS_INT;
    uint64_t total_timeout = base_timeout + extra_timeout;
 
    // Ensure client timeout is longer than server's RECV_TIMEOUT (30s) to prevent deadlock
    // Add 10 seconds buffer to account for server processing delays
    if (total_timeout < MIN_CLIENT_TIMEOUT) {
      total_timeout = MIN_CLIENT_TIMEOUT;
    }
 
    // Cap at maximum timeout
    return (total_timeout > MAX_CLIENT_TIMEOUT) ? MAX_CLIENT_TIMEOUT : total_timeout;
  }
 
  return base_timeout;
}
 
static asciichat_error_t packet_validate_header(const packet_header_t *header, uint16_t *pkt_type, uint32_t *pkt_len,
                                                uint32_t *expected_crc) {
  if (!header || !pkt_type || !pkt_len || !expected_crc) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: header=%p, pkt_type=%p, pkt_len=%p, expected_crc=%p",
                     header, pkt_type, pkt_len, expected_crc);
  }
 
  // First validate packet length BEFORE converting from network byte order
  // This prevents potential integer overflow issues
  uint32_t pkt_len_network = header->length;
  if (pkt_len_network == 0xFFFFFFFF) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid packet length in network byte order: 0xFFFFFFFF");
  }
 
  // Convert from network byte order using safe helpers
  uint64_t magic = endian_unpack_u64(header->magic);
  uint16_t type = endian_unpack_u16(header->type);
  uint32_t len = endian_unpack_u32(pkt_len_network);
  uint32_t crc = endian_unpack_u32(header->crc32);
 
  // Validate magic
  if (magic != PACKET_MAGIC) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid packet magic: 0x%x (expected 0x%x)", magic, PACKET_MAGIC);
  }
 
  // Validate packet size with bounds checking
  if (len > MAX_PACKET_SIZE) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: %u > %d", len, MAX_PACKET_SIZE);
  }
 
  // Validate packet type and size constraints
  switch (type) {
  case PACKET_TYPE_PROTOCOL_VERSION:
    // Protocol version packet has fixed size
    if (len != sizeof(protocol_version_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid protocol version packet size: %u, expected %zu", len,
                       sizeof(protocol_version_packet_t));
    }
    break;
  case PACKET_TYPE_ASCII_FRAME:
    // ASCII frame contains header + frame data
    if (len < sizeof(ascii_frame_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid ASCII frame packet size: %u, minimum %zu", len,
                       sizeof(ascii_frame_packet_t));
    }
    break;
  case PACKET_TYPE_IMAGE_FRAME:
    // Image frame contains header + pixel data
    if (len < sizeof(image_frame_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid image frame packet size: %u, minimum %zu", len,
                       sizeof(image_frame_packet_t));
    }
    break;
  case PACKET_TYPE_AUDIO_BATCH:
    // Batch must have at least header + some samples
    if (len < sizeof(audio_batch_packet_t) + sizeof(float)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid audio batch packet size: %u", len);
    }
    break;
  case PACKET_TYPE_PING:
  case PACKET_TYPE_PONG:
    if (len != 0) { // Ping/pong are just header packets and no payload.
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid ping/pong packet size: %u", len);
    }
    break;
  case PACKET_TYPE_CLIENT_CAPABILITIES:
    // Client capabilities packet can be empty or contain capability data
    if (len > 1024) { // Reasonable limit for capability data
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid client capabilities packet size: %u", len);
    }
    break;
  case PACKET_TYPE_CLIENT_JOIN:
    if (len != sizeof(client_info_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid client join packet size: %u, expected %zu", len,
                       sizeof(client_info_packet_t));
    }
    break;
  case PACKET_TYPE_CLIENT_LEAVE:
    // Client leave packet can be empty or contain reason
    if (len > 256) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid client leave packet size: %u", len);
    }
    break;
  case PACKET_TYPE_STREAM_START:
  case PACKET_TYPE_STREAM_STOP:
    if (len != sizeof(uint32_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid stream control packet size: %u, expected %zu", len,
                       sizeof(uint32_t));
    }
    break;
  case PACKET_TYPE_SIZE_MESSAGE:
    // Size message format: "SIZE:width,height"
    if (len == 0 || len > 32) { // Reasonable size for "SIZE:1234,5678"
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid size message packet size: %u", len);
    }
    break;
  case PACKET_TYPE_AUDIO_MESSAGE:
    // Audio message format: "AUDIO:num_samples"
    if (len == 0 || len > 32) { // Reasonable size for "AUDIO:1234"
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid audio message packet size: %u", len);
    }
    break;
  case PACKET_TYPE_TEXT_MESSAGE:
    // Text message can be empty or contain message
    if (len > 1024) { // Reasonable limit for text messages
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid text message packet size: %u", len);
    }
    break;
  case PACKET_TYPE_ERROR_MESSAGE:
    if (len < sizeof(error_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid error packet size: %u (minimum %zu)", len,
                       sizeof(error_packet_t));
    }
    if (len > sizeof(error_packet_t) + MAX_ERROR_MESSAGE_LENGTH) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Error packet message too large: %u (max %zu)", len,
                       sizeof(error_packet_t) + (size_t)MAX_ERROR_MESSAGE_LENGTH);
    }
    break;
  // All crypto handshake packet types - validate using session parameters
  case PACKET_TYPE_CRYPTO_CLIENT_HELLO:
  case PACKET_TYPE_CRYPTO_CAPABILITIES:
  case PACKET_TYPE_CRYPTO_PARAMETERS:
  case PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT:
  case PACKET_TYPE_CRYPTO_KEY_EXCHANGE_RESP:
  case PACKET_TYPE_CRYPTO_AUTH_CHALLENGE:
  case PACKET_TYPE_CRYPTO_AUTH_RESPONSE:
  case PACKET_TYPE_CRYPTO_AUTH_FAILED:
  case PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP:
  case PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE:
  case PACKET_TYPE_CRYPTO_NO_ENCRYPTION:
  case PACKET_TYPE_ENCRYPTED:
    // Crypto packets are validated by the crypto handshake context
    // This is just a basic sanity check for extremely large packets
    if (len > 65536) { // 64KB should be enough for even large post-quantum crypto packets
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Crypto packet too large: %u bytes (max 65536)", len);
    }
    // Note: Proper size validation is done in crypto_handshake_validate_packet_size()
    // which uses the session's crypto parameters for accurate validation
    break;
  // ACIP protocol packets (Discovery Service)
  case PACKET_TYPE_ACIP_SESSION_CREATE:
  case PACKET_TYPE_ACIP_SESSION_CREATED:
  case PACKET_TYPE_ACIP_SESSION_LOOKUP:
  case PACKET_TYPE_ACIP_SESSION_INFO:
  case PACKET_TYPE_ACIP_SESSION_JOIN:
  case PACKET_TYPE_ACIP_SESSION_JOINED:
  case PACKET_TYPE_ACIP_SESSION_LEAVE:
  case PACKET_TYPE_ACIP_SESSION_END:
  case PACKET_TYPE_ACIP_SESSION_RECONNECT:
  case PACKET_TYPE_ACIP_WEBRTC_SDP:
  case PACKET_TYPE_ACIP_WEBRTC_ICE:
  case PACKET_TYPE_ACIP_NETWORK_QUALITY:
  case PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT:
  case PACKET_TYPE_ACIP_HOST_LOST:
  case PACKET_TYPE_ACIP_STRING_RESERVE:
  case PACKET_TYPE_ACIP_STRING_RESERVED:
  case PACKET_TYPE_ACIP_STRING_RENEW:
  case PACKET_TYPE_ACIP_STRING_RELEASE:
  case PACKET_TYPE_ACIP_DISCOVERY_PING:
  case PACKET_TYPE_ACIP_ERROR:
    // ACIP packets - basic size validation
    // Discovery service packets can vary in size (variable-length strings, etc.)
    if (len > 65536) { // 64KB max for discovery packets
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "ACIP packet too large: %u bytes (max 65536)", len);
    }
    break;
  default:
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unknown packet type: %u", type);
  }
 
  // Return parsed values
  *pkt_type = type;
  *pkt_len = len;
  *expected_crc = crc;
 
  return ASCIICHAT_OK;
}
 
static asciichat_error_t packet_validate_crc32(const void *data, size_t len, uint32_t expected_crc) {
  if (!data && len > 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: data=%p but len=%zu", data, len);
  }
 
  if (len == 0) {
    // Empty packets should have CRC32 of 0
    if (expected_crc != 0) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid CRC32 for empty packet: 0x%x (expected 0)", expected_crc);
    }
    return 0;
  }
 
  uint32_t calculated_crc = asciichat_crc32(data, len);
  if (calculated_crc != expected_crc) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "CRC32 mismatch: calculated 0x%x, expected 0x%x", calculated_crc,
                     expected_crc);
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t packet_send(socket_t sockfd, packet_type_t type, const void *data, size_t len) {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
  }
 
  if (len > MAX_PACKET_SIZE) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: %zu > %d", len, MAX_PACKET_SIZE);
  }
 
  packet_header_t header = {.magic = HOST_TO_NET_U64(PACKET_MAGIC),
                            .type = HOST_TO_NET_U16((uint16_t)type),
                            .length = HOST_TO_NET_U32((uint32_t)len),
                            .crc32 = HOST_TO_NET_U32(len > 0 ? asciichat_crc32(data, len) : 0),
                            .client_id = HOST_TO_NET_U32(0)}; // Always initialize client_id to 0 in network byte order
 
  // Calculate timeout based on packet size (in nanoseconds)
  uint64_t timeout = calculate_packet_timeout(len);
 
  // Send header first
  ssize_t sent = send_with_timeout(sockfd, &header, sizeof(header), timeout);
  if (sent < 0) {
    // Error context is already set by send_with_timeout
    return ERROR_NETWORK;
  }
  if ((size_t)sent != sizeof(header)) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to fully send packet header. Sent %zd/%zu bytes", sent, sizeof(header));
  }
 
  // Send payload if present
  if (len > 0 && data) {
    // Check socket validity before sending payload to avoid race conditions
    if (!socket_is_valid(sockfd)) {
      return SET_ERRNO(ERROR_NETWORK, "Socket became invalid between header and payload send");
    }
    sent = send_with_timeout(sockfd, data, len, timeout);
    // Check for error first to avoid signed/unsigned comparison issues
    if (sent < 0) {
      // Error context is already set by send_with_timeout
      return ERROR_NETWORK;
    }
    if ((size_t)sent != len) {
      return SET_ERRNO(ERROR_NETWORK, "Failed to fully send packet payload. Sent %zd/%zu bytes", sent, len);
    }
  }
 
#ifdef DEBUG_NETWORK
  log_debug("Sent packet type=%d, len=%zu, errno=%d (%s)", type, len, errno, SAFE_STRERROR(errno));
#endif
 
  return 0;
}
 
asciichat_error_t packet_receive(socket_t sockfd, packet_type_t *type, void **data, size_t *len) {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
  }
  if (!type || !data || !len) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: type=%p, data=%p, len=%p", type, data, len);
  }
 
  // Read packet header into memory from network socket
  packet_header_t header;
  uint64_t header_timeout_ns = RECV_TIMEOUT * NS_PER_SEC_INT;
  ssize_t received = recv_with_timeout(sockfd, &header, sizeof(header), header_timeout_ns);
  if (received < 0) {
    // Error context is already set by recv_with_timeout
    return ERROR_NETWORK;
  }
  if ((size_t)received != sizeof(header)) {
    if (received == 0) {
      log_warn("Connection closed while reading packet header");
      return SET_ERRNO(ERROR_NETWORK, "Connection closed by peer while reading packet header");
    }
 
    return SET_ERRNO(ERROR_NETWORK, "Partial packet header received: %zd/%zu bytes", received, sizeof(header));
  }
 
  // Validate packet header
  uint16_t pkt_type;
  uint32_t pkt_len;
  uint32_t expected_crc;
  if (packet_validate_header(&header, &pkt_type, &pkt_len, &expected_crc) != ASCIICHAT_OK) {
    // Error context is already set by packet_validate_header
    return ERROR_NETWORK_PROTOCOL;
  }
 
  // Allocate buffer for payload
  void *payload = NULL;
  if (pkt_len > 0) {
    payload = buffer_pool_alloc(NULL, pkt_len);
 
    // Use adaptive timeout for large packets
    uint64_t recv_timeout = calculate_packet_timeout(pkt_len);
    received = recv_with_timeout(sockfd, payload, pkt_len, recv_timeout);
    if (received < 0) {
      buffer_pool_free(NULL, payload, pkt_len);
      return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to receive packet payload");
    }
    if (received != (ssize_t)pkt_len) {
      buffer_pool_free(NULL, payload, pkt_len);
      return SET_ERRNO(ERROR_NETWORK, "Partial packet payload received: %zd/%u bytes", received, pkt_len);
    }
 
    // Validate CRC32
    if (packet_validate_crc32(payload, pkt_len, expected_crc) != ASCIICHAT_OK) {
      buffer_pool_free(NULL, payload, pkt_len);
      // Error context is already set by packet_validate_crc32
      return ERROR_NETWORK_PROTOCOL;
    }
  }
 
  // Return results
  *type = (packet_type_t)pkt_type;
  *data = payload;
  *len = pkt_len;
 
  return ASCIICHAT_OK;
}
 
/* ============================================================================
 * High-Level Secure Packet Functions
 * ============================================================================
 * These functions handle encryption and compression for secure communication.
 */
 
asciichat_error_t send_packet_secure(socket_t sockfd, packet_type_t type, const void *data, size_t len,
                                     crypto_context_t *crypto_ctx) {
  if (len > MAX_PACKET_SIZE) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: %zu > %d", len, MAX_PACKET_SIZE);
  }
 
  // Handshake packets are ALWAYS sent unencrypted
  if (packet_is_handshake_type(type)) {
    return packet_send(sockfd, type, data, len);
  }
 
  // Apply compression if beneficial for large packets
  const void *final_data = data;
  size_t final_len = len;
  void *compressed_data = NULL;
 
  // Skip compression for pre-compressed data (Opus audio) or if --no-compress flag is set
  bool should_skip_compression = packet_is_precompressed(type) || GET_OPTION(no_compress);
  if (!should_skip_compression && len > COMPRESSION_MIN_SIZE && should_compress(len, len)) {
    void *temp_compressed = NULL;
    size_t compressed_size = 0;
 
    // Use configured compression level from options (default: 1 for fastest compression)
    int compression_level = (GET_OPTION(compression_level) > 0) ? GET_OPTION(compression_level) : 1;
    asciichat_error_t compress_result = compress_data(data, len, &temp_compressed, &compressed_size, compression_level);
    if (compress_result == ASCIICHAT_OK) {
      double ratio = (double)compressed_size / (double)len;
      if (ratio < COMPRESSION_RATIO_THRESHOLD) {
        final_data = temp_compressed;
        final_len = compressed_size;
        compressed_data = temp_compressed;
        log_debug("Compressed packet: %zu -> %zu bytes (%.1f%%)", len, compressed_size, ratio * 100.0);
      } else {
        SAFE_FREE(temp_compressed);
      }
    }
  }
 
  // If no crypto context or crypto not ready, send unencrypted
  bool ready = crypto_ctx ? crypto_is_ready(crypto_ctx) : false;
  if (!crypto_ctx || !ready) {
    log_warn_every(LOG_RATE_FAST, "CRYPTO_DEBUG: Sending packet type %d UNENCRYPTED (crypto_ctx=%p, ready=%d)", type,
                   (void *)crypto_ctx, ready);
    asciichat_error_t result = packet_send(sockfd, type, final_data, final_len);
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    if (result != ASCIICHAT_OK) {
      SET_ERRNO(ERROR_NETWORK, "Failed to send packet: %s", asciichat_error_string(result));
    }
    return result;
  }
 
  // Encrypt the packet: create header + payload, encrypt everything, wrap in PACKET_TYPE_ENCRYPTED
  packet_header_t header = {.magic = HOST_TO_NET_U64(PACKET_MAGIC),
                            .type = HOST_TO_NET_U16((uint16_t)type),
                            .length = HOST_TO_NET_U32((uint32_t)final_len),
                            .crc32 = HOST_TO_NET_U32(final_len > 0 ? asciichat_crc32(final_data, final_len) : 0),
                            .client_id = HOST_TO_NET_U32(0)}; // Always 0 - client_id is not used in practice
 
  // Combine header + payload for encryption
  // Check for integer overflow before addition
  if (final_len > SIZE_MAX - sizeof(header)) {
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: would overflow plaintext buffer size");
  }
  size_t plaintext_len = sizeof(header) + final_len;
  uint8_t *plaintext = buffer_pool_alloc(NULL, plaintext_len);
  if (!plaintext) {
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for plaintext packet");
  }
 
  memcpy(plaintext, &header, sizeof(header));
  if (final_len > 0 && final_data) {
    memcpy(plaintext + sizeof(header), final_data, final_len);
  }
 
  // Encrypt
  // Check for integer overflow before calculating ciphertext size
  if (plaintext_len > SIZE_MAX - CRYPTO_NONCE_SIZE - CRYPTO_MAC_SIZE) {
    buffer_pool_free(NULL, plaintext, plaintext_len);
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet too large: would overflow ciphertext buffer size");
  }
  size_t ciphertext_size = plaintext_len + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE;
  uint8_t *ciphertext = buffer_pool_alloc(NULL, ciphertext_size);
  if (!ciphertext) {
    buffer_pool_free(NULL, plaintext, plaintext_len);
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for ciphertext");
  }
 
  size_t ciphertext_len;
  crypto_result_t result =
      crypto_encrypt(crypto_ctx, plaintext, plaintext_len, ciphertext, ciphertext_size, &ciphertext_len);
  buffer_pool_free(NULL, plaintext, plaintext_len);
 
  if (result != CRYPTO_OK) {
    buffer_pool_free(NULL, ciphertext, ciphertext_size);
    if (compressed_data) {
      SAFE_FREE(compressed_data);
    }
    return SET_ERRNO(ERROR_CRYPTO, "Failed to encrypt packet: %s", crypto_result_to_string(result));
  }
 
  // Send as PACKET_TYPE_ENCRYPTED
  log_debug_every(LOG_RATE_SLOW, "CRYPTO_DEBUG: Sending encrypted packet (original type %d as PACKET_TYPE_ENCRYPTED)",
                  type);
  asciichat_error_t send_result = packet_send(sockfd, PACKET_TYPE_ENCRYPTED, ciphertext, ciphertext_len);
  buffer_pool_free(NULL, ciphertext, ciphertext_size);
 
  if (compressed_data) {
    SAFE_FREE(compressed_data);
  }
 
  return send_result;
}
 
packet_recv_result_t receive_packet_secure(socket_t sockfd, void *crypto_ctx, bool enforce_encryption,
                                           packet_envelope_t *envelope) {
  return receive_packet_secure_with_timeout(sockfd, crypto_ctx, enforce_encryption, envelope,
                                            RECV_TIMEOUT * NS_PER_SEC_INT);
}
 
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) {
 
  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;
}
 
/* ============================================================================
 * Basic Packet Functions (Non-Secure)
 * ============================================================================
 * These are the basic packet send/receive functions without encryption.
 */
 
int send_packet(socket_t sockfd, packet_type_t type, const void *data, size_t len) {
  asciichat_error_t result = packet_send(sockfd, type, data, len);
  return result == ASCIICHAT_OK ? 0 : -1;
}
 
int receive_packet(socket_t sockfd, packet_type_t *type, void **data, size_t *len) {
  asciichat_error_t result = packet_receive(sockfd, type, data, len);
  return result == ASCIICHAT_OK ? 0 : -1;
}
 
/* ============================================================================
 * Protocol Message Functions
 * ============================================================================
 * These functions send specific protocol messages.
 */
 
int send_ping_packet(socket_t sockfd) {
  return send_packet(sockfd, PACKET_TYPE_PING, NULL, 0);
}
 
int send_pong_packet(socket_t sockfd) {
  return send_packet(sockfd, PACKET_TYPE_PONG, NULL, 0);
}
 
asciichat_error_t packet_decrypt_envelope(packet_envelope_t *envelope, void *crypto_ctx) {
  if (!envelope) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid envelope");
  }
 
  // Only decrypt if this is an encrypted packet
  if (envelope->type != PACKET_TYPE_ENCRYPTED) {
    return ASCIICHAT_OK; // Not encrypted, nothing to do
  }
 
  if (!crypto_ctx) {
    return SET_ERRNO(ERROR_CRYPTO, "Received encrypted packet but no crypto context");
  }
 
  uint8_t *ciphertext = (uint8_t *)envelope->data;
  size_t ciphertext_len = envelope->len;
 
  // Allocate plaintext buffer with extra space for decryption
  size_t plaintext_size = ciphertext_len + 1024;
  uint8_t *plaintext = buffer_pool_alloc(NULL, plaintext_size);
  if (!plaintext) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate plaintext buffer for decryption");
  }
 
  size_t plaintext_len;
  crypto_result_t result =
      crypto_decrypt(crypto_ctx, ciphertext, ciphertext_len, plaintext, plaintext_size, &plaintext_len);
 
  if (result != CRYPTO_OK) {
    buffer_pool_free(NULL, plaintext, plaintext_size);
    return SET_ERRNO(ERROR_CRYPTO, "Failed to decrypt packet: %s", crypto_result_to_string(result));
  }
 
  if (plaintext_len < sizeof(packet_header_t)) {
    buffer_pool_free(NULL, plaintext, plaintext_size);
    return SET_ERRNO(ERROR_CRYPTO, "Decrypted packet too small: %zu < %zu", plaintext_len, sizeof(packet_header_t));
  }
 
  // Parse inner packet header
  const packet_header_t *inner_header = (const packet_header_t *)plaintext;
  packet_type_t inner_type = NET_TO_HOST_U16(inner_header->type);
  uint32_t inner_len = NET_TO_HOST_U32(inner_header->length);
 
  // Validate inner packet length
  if (inner_len != plaintext_len - sizeof(packet_header_t)) {
    buffer_pool_free(NULL, plaintext, plaintext_size);
    return SET_ERRNO(ERROR_CRYPTO, "Inner packet length mismatch: header=%u, actual=%zu", inner_len,
                     plaintext_len - sizeof(packet_header_t));
  }
 
  // Free the original encrypted buffer if it's different from plaintext
  if (envelope->allocated_buffer && envelope->allocated_buffer != plaintext) {
    buffer_pool_free(NULL, envelope->allocated_buffer, envelope->allocated_size);
  }
 
  // Update envelope with decrypted packet info
  envelope->type = inner_type;
  envelope->data = (uint8_t *)plaintext + sizeof(packet_header_t);
  envelope->len = inner_len;
  envelope->allocated_buffer = plaintext;
  envelope->allocated_size = plaintext_size;
 
  log_info("[PACKET_DECRYPT] 🔐 Decrypted PACKET_TYPE_ENCRYPTED: inner_type=%u (0x%04x), len=%u", inner_type,
           inner_type, inner_len);
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t packet_send_error(socket_t sockfd, const crypto_context_t *crypto_ctx, asciichat_error_t error_code,
                                    const char *message) {
  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;
}
 
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) {
  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;
}
 
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) {
  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;
}
 
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) {
  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;
}
 
int send_protocol_version_packet(socket_t sockfd, const protocol_version_packet_t *version) {
  if (!version) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: version=%p", version);
    return -1;
  }
  return send_packet(sockfd, PACKET_TYPE_PROTOCOL_VERSION, version, sizeof(*version));
}
 
int send_crypto_capabilities_packet(socket_t sockfd, const crypto_capabilities_packet_t *caps) {
  if (!caps) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: caps=%p", caps);
    return -1;
  }
  return send_packet(sockfd, PACKET_TYPE_CRYPTO_CAPABILITIES, caps, sizeof(*caps));
}
 
int send_crypto_parameters_packet(socket_t sockfd, const crypto_parameters_packet_t *params) {
  if (!params) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: params=%p", params);
    return -1;
  }
 
  // Create a copy and convert uint16_t fields to network byte order
  crypto_parameters_packet_t net_params = *params;
  log_debug("NETWORK_DEBUG: Before htons: kex=%u, auth=%u, sig=%u, secret=%u", params->kex_public_key_size,
            params->auth_public_key_size, params->signature_size, params->shared_secret_size);
  net_params.kex_public_key_size = HOST_TO_NET_U16(params->kex_public_key_size);
  net_params.auth_public_key_size = HOST_TO_NET_U16(params->auth_public_key_size);
  net_params.signature_size = HOST_TO_NET_U16(params->signature_size);
  net_params.shared_secret_size = HOST_TO_NET_U16(params->shared_secret_size);
  log_debug("NETWORK_DEBUG: After htons: kex=%u, auth=%u, sig=%u, secret=%u", net_params.kex_public_key_size,
            net_params.auth_public_key_size, net_params.signature_size, net_params.shared_secret_size);
 
  return send_packet(sockfd, PACKET_TYPE_CRYPTO_PARAMETERS, &net_params, sizeof(net_params));
}
 
// =============================================================================
// Audio Batch Packet Sending
// =============================================================================
// These functions were moved from lib/network/av.c during refactoring.
// They provide socket-level audio packet sending with encryption support.
// For transport-agnostic sending, use acip_send_audio_batch() instead.
// =============================================================================
 
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) {
  if (!opus_data || opus_size == 0 || !frame_sizes || sample_rate <= 0 || frame_duration <= 0 || frame_count <= 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM,
                     "Invalid Opus batch parameters: opus_data=%p, opus_size=%zu, frame_sizes=%p, sample_rate=%d, "
                     "frame_duration=%d, frame_count=%d",
                     (const void *)opus_data, opus_size, (const void *)frame_sizes, sample_rate, frame_duration,
                     frame_count);
  }
 
  // Validate frame_count to prevent integer overflow in size calculations
  // Max reasonable frames per batch: ~1 second of 10ms frames = 100 frames
  if (frame_count > 1000) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Too many Opus frames: %d (max 1000)", frame_count);
  }
 
  // Allocate buffer for header + frame sizes + encoded data
  size_t header_size = 16; // sample_rate (4), frame_duration (4), frame_count (4), reserved (4)
  size_t frame_sizes_bytes = (size_t)frame_count * sizeof(uint16_t);
  size_t total_size = header_size + frame_sizes_bytes + opus_size;
  void *packet_data = buffer_pool_alloc(NULL, total_size);
  if (!packet_data) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for Opus batch packet: %zu bytes", total_size);
  }
 
  // Write header (network byte order for cross-platform compatibility)
  uint8_t *buf = (uint8_t *)packet_data;
  uint32_t sr = HOST_TO_NET_U32((uint32_t)sample_rate);
  uint32_t fd = HOST_TO_NET_U32((uint32_t)frame_duration);
  uint32_t fc = HOST_TO_NET_U32((uint32_t)frame_count);
  memcpy(buf, &sr, 4);
  memcpy(buf + 4, &fd, 4);
  memcpy(buf + 8, &fc, 4);
  memset(buf + 12, 0, 4); // Reserved
 
  // Write frame sizes array (convert each to network byte order)
  uint16_t *frame_sizes_out = (uint16_t *)(buf + header_size);
  for (int i = 0; i < frame_count; i++) {
    frame_sizes_out[i] = HOST_TO_NET_U16(frame_sizes[i]);
  }
 
  // Copy Opus data
  memcpy(buf + header_size + frame_sizes_bytes, opus_data, opus_size);
 
  // Send packet (with encryption support)
  asciichat_error_t result =
      send_packet_secure(sockfd, PACKET_TYPE_AUDIO_OPUS_BATCH, packet_data, total_size, crypto_ctx);
 
  // Clean up
  buffer_pool_free(NULL, packet_data, total_size);
 
  return result;
}
 
asciichat_error_t send_image_frame_packet(socket_t sockfd, const void *image_data, uint16_t width, uint16_t height,
                                          uint8_t format) {
  if (!image_data || width == 0 || height == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: image_data=%p, width=%u, height=%u", image_data, width,
                     height);
  }
 
  // Validate dimensions to prevent integer overflow
  // Max reasonable dimensions: 4K (3840x2160) = ~25MB per frame
  if (width > 4096 || height > 4096) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Image dimensions too large: %ux%u (max 4096x4096)", width, height);
  }
 
  // Create image frame packet
  image_frame_packet_t packet;
  packet.width = width;
  packet.height = height;
  packet.pixel_format = format;
  packet.compressed_size = 0;
  packet.checksum = 0;
  packet.timestamp = 0; // Will be set by receiver
 
  // Calculate total packet size
  // Cast to size_t before multiplication to prevent integer overflow
  // Use overflow-checked multiplication
  size_t width_times_height;
  if (checked_size_mul((size_t)width, (size_t)height, &width_times_height) != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Image dimensions too large: %d x %d", width, height);
  }
 
  size_t frame_size;
  if (checked_size_mul(width_times_height, 3u, &frame_size) != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Frame size overflow for RGB format");
  }
 
  size_t total_size;
  if (checked_size_add(sizeof(image_frame_packet_t), frame_size, &total_size) != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Total packet size overflow");
  }
 
  // Allocate buffer for complete packet
  void *packet_data = buffer_pool_alloc(NULL, total_size);
  if (!packet_data) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for image frame packet: %zu bytes", total_size);
  }
 
  // Copy packet header and image data
  memcpy(packet_data, &packet, sizeof(image_frame_packet_t));
  memcpy((char *)packet_data + sizeof(image_frame_packet_t), image_data, frame_size);
 
  // Send packet
  asciichat_error_t result = packet_send(sockfd, PACKET_TYPE_IMAGE_FRAME, packet_data, total_size);
 
  // Clean up
  buffer_pool_free(NULL, packet_data, total_size);
 
  return result;
}