send.c

Go to the documentation of this file.

 
#include <ascii-chat/network/acip/send.h>
#include <ascii-chat/network/acip/transport.h>
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/buffer_pool.h>
#include <ascii-chat/util/overflow.h>
#include <ascii-chat/util/endian.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/audio/audio.h>
#include <string.h>
#include <ascii-chat/network/crc32.h>
#include <time.h>
// =============================================================================
// Packet Helper (wraps payload with header and sends via transport)
// =============================================================================
 
asciichat_error_t packet_send_via_transport(acip_transport_t *transport, packet_type_t type, const void *payload,
                                            size_t payload_len, uint32_t client_id) {
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
// Sanity check: catch suspiciously large packets (likely a bug)
#define MAX_REASONABLE_PACKET_SIZE (25 * 1024 * 1024) // 25 MB
  if (payload_len > MAX_REASONABLE_PACKET_SIZE) {
    log_error("★ PACKET_SIZE_VALIDATION_FAILURE: Attempting to send %zu bytes (%zu MB) with type=%d (0x%04x), exceeds "
              "max %d bytes (25 MB) - likely a bug in caller's length calculation",
              payload_len, payload_len / (1024 * 1024), type, type, MAX_REASONABLE_PACKET_SIZE);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Packet payload too large: %zu bytes (max 25MB)", payload_len);
  }
 
  log_dev("★ PACKET_SEND_VIA_TRANSPORT START: type=%d (0x%04x), payload_len=%zu bytes, client_id=%u, transport=%p",
          type, type, payload_len, client_id, (void *)transport);
 
  // Build packet header
  packet_header_t header;
  header.magic = HOST_TO_NET_U64(PACKET_MAGIC);
  header.type = HOST_TO_NET_U16(type);
  header.length = HOST_TO_NET_U32((uint32_t)payload_len);
  header.client_id = client_id;
 
  // Calculate CRC32 if we have payload
  if (payload && payload_len > 0) {
    header.crc32 = HOST_TO_NET_U32(asciichat_crc32((const uint8_t *)payload, payload_len));
    log_dev("★ PACKET_SEND: CRC32=0x%08x calculated for %zu byte payload", header.crc32, payload_len);
  } else {
    header.crc32 = 0;
    log_dev("★ PACKET_SEND: No payload, CRC32=0");
  }
 
  log_dev("★ PACKET_SEND: magic=0x%016llx, type=%d, length=%u bytes, client_id=%u", header.magic, type, header.length,
          header.client_id);
 
  // Calculate total packet size
  size_t total_size = sizeof(header) + payload_len;
  log_dev("★ PACKET_SEND: Header=%zu bytes + Payload=%zu bytes = Total=%zu bytes", sizeof(header), payload_len,
          total_size);
 
  // Allocate buffer for complete packet
  uint8_t *packet = SAFE_MALLOC(total_size, uint8_t *);
  if (!packet) {
    log_error("★ PACKET_SEND: Memory allocation FAILED for %zu byte packet buffer", total_size);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate packet buffer");
  }
 
  log_dev("★ PACKET_SEND: Packet buffer allocated at %p", (void *)packet);
 
  // Build complete packet: header + payload
  memcpy(packet, &header, sizeof(header));
  if (payload && payload_len > 0) {
    memcpy(packet + sizeof(header), payload, payload_len);
    log_dev("★ PACKET_SEND: Payload copied to buffer offset %zu", sizeof(header));
  }
 
  // Send via transport (transport handles encryption if crypto_ctx present)
  // Transport does NOT take ownership - it only copies data to its own buffers
  log_dev("★ PACKET_SEND: Calling acip_transport_send with %zu total bytes", total_size);
  asciichat_error_t result = acip_transport_send(transport, packet, total_size);
 
  if (result == ASCIICHAT_OK) {
    log_dev("★ PACKET_SEND_VIA_TRANSPORT COMPLETE: SUCCESS - sent %zu bytes (type=%d, client_id=%u)", total_size, type,
            client_id);
  } else {
    log_error("★ PACKET_SEND_VIA_TRANSPORT FAILED: acip_transport_send returned error %d (%s) when sending %zu bytes "
              "type=%d to client_id=%u",
              result, asciichat_error_string(result), total_size, type, client_id);
  }
 
  // Always free the packet buffer
  SAFE_FREE(packet);
  return result;
}
 
// =============================================================================
// Packet Receive Helper (receives via transport, parses header)
// =============================================================================
 
asciichat_error_t packet_receive_via_transport(acip_transport_t *transport, packet_type_t *type, void **payload,
                                               size_t *payload_len, void **alloc_buffer) {
  if (!transport || !type || !payload || !payload_len || !alloc_buffer) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for packet_receive_via_transport");
  }
 
  *type = 0;
  *payload = NULL;
  *payload_len = 0;
  *alloc_buffer = NULL;
 
  // Receive raw bytes via transport
  void *recv_buffer = NULL;
  size_t recv_len = 0;
  asciichat_error_t result = acip_transport_recv(transport, &recv_buffer, &recv_len, alloc_buffer);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  // Parse packet header
  if (recv_len < sizeof(packet_header_t)) {
    log_warn("packet_receive_via_transport: packet too small (%zu bytes, need %zu)", recv_len, sizeof(packet_header_t));
    if (*alloc_buffer) {
      buffer_pool_free(NULL, *alloc_buffer, recv_len);
      *alloc_buffer = NULL;
    }
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Received packet smaller than header");
  }
 
  const packet_header_t *header = (const packet_header_t *)recv_buffer;
  *type = (packet_type_t)NET_TO_HOST_U16(header->type);
  size_t plen = NET_TO_HOST_U32(header->length);
 
  if (recv_len < sizeof(packet_header_t) + plen) {
    log_warn("packet_receive_via_transport: truncated packet (header says %zu payload, got %zu total)", plen, recv_len);
    if (*alloc_buffer) {
      buffer_pool_free(NULL, *alloc_buffer, recv_len);
      *alloc_buffer = NULL;
    }
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Truncated packet payload");
  }
 
  if (plen > 0) {
    *payload = (uint8_t *)recv_buffer + sizeof(packet_header_t);
  }
  *payload_len = plen;
 
  return ASCIICHAT_OK;
}
 
// ASCII/Video frame functions moved to:
// - acip_send_ascii_frame → lib/network/acip/server.c (server → client)
// - acip_send_image_frame → lib/network/acip/client.c (client → server)
 
// =============================================================================
// Audio Sending
// =============================================================================
 
asciichat_error_t acip_send_audio_batch(acip_transport_t *transport, const float *samples, uint32_t num_samples,
                                        uint32_t batch_count) {
  if (!transport || !samples || num_samples == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Build batch header
  audio_batch_packet_t header;
  header.batch_count = batch_count;
  header.total_samples = (uint32_t)num_samples;
  header.sample_rate = (uint32_t)AUDIO_SAMPLE_RATE;
  header.channels = 1;
 
  // Calculate total size (header + float samples)
  size_t samples_size = num_samples * sizeof(float);
  size_t total_size = sizeof(header) + samples_size;
 
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer");
  }
 
  // Copy header and samples
  memcpy(buffer, &header, sizeof(header));
  memcpy(buffer + sizeof(header), samples, samples_size);
 
  asciichat_error_t result = packet_send_via_transport(transport, PACKET_TYPE_AUDIO_BATCH, buffer, total_size, 0);
 
  buffer_pool_free(NULL, buffer, total_size);
  return result;
}
 
asciichat_error_t acip_send_audio_opus(acip_transport_t *transport, const void *opus_data, size_t opus_len) {
  if (!transport || !opus_data || opus_len == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Convert single opus frame to batch format (frame_count=1) with standard parameters
  // Standard: 48kHz sample rate, 20ms frame duration
  uint16_t frame_sizes[1] = {(uint16_t)opus_len};
  return acip_send_audio_opus_batch(transport, opus_data, opus_len, frame_sizes, 1, 48000, 20);
}
 
asciichat_error_t acip_send_audio_opus_batch(acip_transport_t *transport, const void *opus_data, size_t opus_len,
                                             const uint16_t *frame_sizes, uint32_t frame_count, uint32_t sample_rate,
                                             uint32_t frame_duration) {
  if (!transport || !opus_data || !frame_sizes || frame_count == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Build batch header (16 bytes)
  uint8_t header[16];
  *(uint32_t *)(header + 0) = HOST_TO_NET_U32(sample_rate);
  *(uint32_t *)(header + 4) = HOST_TO_NET_U32(frame_duration);
  *(uint32_t *)(header + 8) = HOST_TO_NET_U32(frame_count);
  *(uint32_t *)(header + 12) = 0; // reserved
 
  // Calculate sizes array size
  size_t sizes_len = frame_count * sizeof(uint16_t);
  size_t total_size = sizeof(header) + sizes_len + opus_len;
 
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer");
  }
 
  // Build packet: header + sizes + opus_data
  memcpy(buffer, header, sizeof(header));
 
  // Convert frame sizes to network byte order before copying
  // IMPORTANT: Server expects network byte order and will apply NET_TO_HOST_U16()
  uint16_t *sizes_buf = (uint16_t *)(buffer + sizeof(header));
  for (uint32_t i = 0; i < frame_count; i++) {
    sizes_buf[i] = HOST_TO_NET_U16(frame_sizes[i]);
  }
 
  memcpy(buffer + sizeof(header) + sizes_len, opus_data, opus_len);
 
  log_dev("★ OPUS_BATCH_SEND_DEBUG: header=16, frame_count=%u, sizes_len=%zu, opus_len=%zu, TOTAL=%zu", frame_count,
          sizes_len, opus_len, total_size);
 
  asciichat_error_t result = packet_send_via_transport(transport, PACKET_TYPE_AUDIO_OPUS_BATCH, buffer, total_size, 0);
 
  buffer_pool_free(NULL, buffer, total_size);
  return result;
}
 
// =============================================================================
// Control/Signaling
// =============================================================================
 
asciichat_error_t acip_send_ping(acip_transport_t *transport) {
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
  // Ping has no payload
  return packet_send_via_transport(transport, PACKET_TYPE_PING, NULL, 0, 0);
}
 
asciichat_error_t acip_send_pong(acip_transport_t *transport) {
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
  // Pong has no payload
  return packet_send_via_transport(transport, PACKET_TYPE_PONG, NULL, 0, 0);
}
 
// Client control functions moved to lib/network/acip/client.c:
// - acip_send_client_join, acip_send_client_leave
// - acip_send_stream_start, acip_send_stream_stop
// - acip_send_capabilities, acip_send_protocol_version
//
// Server control functions moved to lib/network/acip/server.c:
// - acip_send_clear_console, acip_send_server_state
 
// =============================================================================
// Messages/Errors
// =============================================================================
 
asciichat_error_t acip_send_error(acip_transport_t *transport, uint32_t error_code, const char *message) {
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
  // Calculate message length (max MAX_ERROR_MESSAGE_LENGTH)
  size_t msg_len = 0;
  if (message) {
    msg_len = strlen(message);
    if (msg_len > MAX_ERROR_MESSAGE_LENGTH) {
      msg_len = MAX_ERROR_MESSAGE_LENGTH;
    }
  }
 
  error_packet_t header;
  header.error_code = HOST_TO_NET_U32(error_code);
  header.message_length = HOST_TO_NET_U32((uint32_t)msg_len);
 
  // Allocate buffer for header + message
  size_t total_size = sizeof(header) + msg_len;
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer");
  }
 
  // Build packet
  memcpy(buffer, &header, sizeof(header));
  if (msg_len > 0) {
    memcpy(buffer + sizeof(header), message, msg_len);
  }
 
  asciichat_error_t result = packet_send_via_transport(transport, PACKET_TYPE_ERROR_MESSAGE, buffer, total_size, 0);
 
  buffer_pool_free(NULL, buffer, total_size);
  return result;
}
 
asciichat_error_t acip_send_remote_log(acip_transport_t *transport, uint8_t log_level, uint8_t direction,
                                       const char *message) {
  if (!transport || !message) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or message");
  }
 
  size_t msg_len = strlen(message);
 
  remote_log_packet_t header;
  header.log_level = log_level;
  header.direction = direction;
  header.flags = 0;
  header.message_length = HOST_TO_NET_U32((uint32_t)msg_len);
 
  size_t total_size = sizeof(header) + msg_len;
 
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer");
  }
 
  // Build packet
  memcpy(buffer, &header, sizeof(header));
  // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - binary packet data
  memcpy(buffer + sizeof(header), message, msg_len);
 
  asciichat_error_t result = packet_send_via_transport(transport, PACKET_TYPE_REMOTE_LOG, buffer, total_size, 0);
 
  buffer_pool_free(NULL, buffer, total_size);
  return result;
}
 
// =============================================================================
// ACDS (Discovery Server) Response Sending
// =============================================================================
 
asciichat_error_t acip_send_session_created(acip_transport_t *transport, const acip_session_created_t *response) {
  if (!transport || !response) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or response");
  }
 
  return packet_send_via_transport(transport, PACKET_TYPE_ACIP_SESSION_CREATED, response, sizeof(*response), 0);
}
 
asciichat_error_t acip_send_session_info(acip_transport_t *transport, const acip_session_info_t *info) {
  if (!transport || !info) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or info");
  }
 
  return packet_send_via_transport(transport, PACKET_TYPE_ACIP_SESSION_INFO, info, sizeof(*info), 0);
}
 
asciichat_error_t acip_send_session_joined(acip_transport_t *transport, const acip_session_joined_t *response) {
  if (!transport || !response) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or response");
  }
 
  return packet_send_via_transport(transport, PACKET_TYPE_ACIP_SESSION_JOINED, response, sizeof(*response), 0);
}