send.h File Reference

ACIP shared/bidirectional packet sending functions. More...

Go to the source code of this file.

Functions
asciichat_error_t	packet_send_via_transportv (acip_transport_t *transport, packet_type_t type, const socket_buffer_t *payload, size_t count, uint32_t client_id)
	Send arbitrary packet via transport (generic packet sender).
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)
asciichat_error_t	packet_receive_via_transport (acip_transport_t *transport, packet_type_t *type, void **payload, size_t *payload_len, void **alloc_buffer)
	Receive a packet via transport with header parsing and validation.
asciichat_error_t	acip_send_audio_batch (acip_transport_t *transport, const float *samples, uint32_t num_samples, uint32_t batch_count)
	Send audio batch packet.
asciichat_error_t	acip_send_audio_opus (acip_transport_t *transport, const void *opus_data, size_t opus_len)
	Send Opus-encoded audio packet.
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)
	Send batched Opus-encoded audio frames.
asciichat_error_t	acip_send_ping (acip_transport_t *transport)
	Send ping packet.
asciichat_error_t	acip_send_pong (acip_transport_t *transport)
	Send pong packet.
asciichat_error_t	acip_send_error (acip_transport_t *transport, uint32_t error_code, const char *message)
	Send error message packet.
asciichat_error_t	acip_send_remote_log (acip_transport_t *transport, uint8_t log_level, uint8_t direction, const char *message)
	Send remote log packet.
asciichat_error_t	acip_send_session_created (acip_transport_t *transport, const acip_session_created_t *response)
	Send SESSION_CREATED response packet.
asciichat_error_t	acip_send_session_info (acip_transport_t *transport, const acip_session_info_t *info)
	Send SESSION_INFO response packet.
asciichat_error_t	acip_send_session_joined (acip_transport_t *transport, const acip_session_joined_t *response)
	Send SESSION_JOINED response packet.

Detailed Description

ACIP shared/bidirectional packet sending functions.

Provides bidirectional send functions (used by both client and server):

• Audio sending (PCM, Opus, batched)
• Ping/Pong keepalive
• Error messages and remote logging
• Low-level packet_send_via_transport() utility

For client-specific sends (image frames, join/leave, capabilities): → See lib/network/acip/client.h

For server-specific sends (ASCII frames, state updates, console control): → See lib/network/acip/server.h

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

January 2026

Definition in file send.h.

Function Documentation

acip_send_audio_batch()

asciichat_error_t acip_send_audio_batch	(	acip_transport_t *	transport,
		const float *	samples,
		uint32_t	num_samples,
		uint32_t	batch_count )

Send audio batch packet.

Parameters

transport	Transport instance
samples	Audio samples (float array)
num_samples	Number of samples
batch_count	Number of batches aggregated

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 295 of file send.c.

                                                              {
  ASCII_OTEL_SCOPE(ACIP_SEND_AUDIO_BATCH);
  if (!transport || !samples || num_samples == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  if (num_samples > (MAX_PACKET_SIZE - sizeof(audio_batch_packet_t)) / sizeof(uint32_t))
    return SET_ERRNO(ERROR_NETWORK_SIZE, "PCM batch exceeds the packet size limit");
 
  // The receiver consumes network-order signed PCM32, rather than host floats.
  audio_batch_packet_t header;
  header.batch_count = HOST_TO_NET_U32(batch_count);
  header.total_samples = HOST_TO_NET_U32(num_samples);
  header.sample_rate = HOST_TO_NET_U32(AUDIO_SAMPLE_RATE);
  header.channels = HOST_TO_NET_U32(1);
  uint32_t inline_samples[OPUS_FRAME_SAMPLES];
  uint32_t *wire =
      num_samples <= OPUS_FRAME_SAMPLES ? inline_samples : buffer_alloc(NULL, (size_t)num_samples * sizeof(uint32_t));
  if (!wire)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate PCM batch samples");
  defer({
    if (wire != inline_samples)
      buffer_release(wire);
  });
  _Static_assert(sizeof(float) == sizeof(uint32_t), "ACIP audio requires 32-bit floats");
  for (uint32_t i = 0; i < num_samples; ++i) {
    // Inspect the exponent before arithmetic, including builds that assume finite floats.
    uint32_t sample_bits;
    memcpy(&sample_bits, &samples[i], sizeof(sample_bits));
    if ((sample_bits & UINT32_C(0x7f800000)) == UINT32_C(0x7f800000)) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "PCM samples must be finite");
    }
    double sample = fmax(-1.0, fmin(1.0, samples[i]));
    int32_t scaled = (int32_t)(sample * INT32_MAX);
    wire[i] = HOST_TO_NET_U32((uint32_t)scaled);
  }
  socket_buffer_t slices[] = {{&header, sizeof(header)}, {wire, (size_t)num_samples * sizeof(uint32_t)}};
  asciichat_error_t result = packet_send_via_transportv(transport, PACKET_TYPE_AUDIO_BATCH, slices, 2, 0);
  return result;
}

References ASCII_OTEL_SCOPE, AUDIO_SAMPLE_RATE, audio_batch_packet_t::batch_count, buffer_alloc(), buffer_release, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_SIZE, HOST_TO_NET_U32, MAX_PACKET_SIZE, OPUS_FRAME_SAMPLES, packet_send_via_transportv(), PACKET_TYPE_AUDIO_BATCH, and SET_ERRNO.

Referenced by threaded_send_audio_batch_packet().

acip_send_audio_opus()

asciichat_error_t acip_send_audio_opus	(	acip_transport_t *	transport,
		const void *	opus_data,
		size_t	opus_len )

Send Opus-encoded audio packet.

Parameters

transport	Transport instance
opus_data	Opus-encoded audio data
opus_len	Length of encoded data

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 337 of file send.c.

                                                                                                            {
  ASCII_OTEL_SCOPE(ACIP_SEND_AUDIO_OPUS);
  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, AUDIO_SAMPLE_RATE,
                                    CLIENT_AUDIO_PIPELINE_FRAME_MS);
}

References acip_send_audio_opus_batch(), ASCII_OTEL_SCOPE, AUDIO_SAMPLE_RATE, CLIENT_AUDIO_PIPELINE_FRAME_MS, ERROR_INVALID_PARAM, and SET_ERRNO.

acip_send_audio_opus_batch()

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 )

Send batched Opus-encoded audio frames.

Parameters

transport	Transport instance
opus_data	Opus-encoded data (multiple frames concatenated)
opus_len	Total length of encoded data
frame_sizes	Array of individual frame sizes
frame_count	Number of frames in batch
sample_rate	Sample rate in Hz
frame_duration	Duration per frame in milliseconds

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 350 of file send.c.

                                                                      {
  ASCII_OTEL_SCOPE(ACIP_SEND_AUDIO_OPUS_BATCH);
  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[ACIP_OPUS_BATCH_HEADER_SIZE];
  *(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
 
  if (frame_count > MAX_PACKET_SIZE / sizeof(uint16_t) || opus_len > MAX_PACKET_SIZE)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Opus batch too large");
  size_t sizes_len = (size_t)frame_count * sizeof(uint16_t);
  uint16_t inline_sizes[ACIP_OPUS_INLINE_FRAME_CAPACITY];
  uint16_t *sizes = frame_count <= ACIP_OPUS_INLINE_FRAME_CAPACITY ? inline_sizes : buffer_alloc(NULL, sizes_len);
  if (!sizes)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate Opus lengths");
  for (uint32_t i = 0; i < frame_count; ++i)
    sizes[i] = HOST_TO_NET_U16(frame_sizes[i]);
  socket_buffer_t slices[] = {{header, sizeof(header)}, {sizes, sizes_len}, {opus_data, opus_len}};
  asciichat_error_t result = packet_send_via_transportv(transport, PACKET_TYPE_AUDIO_OPUS_BATCH, slices, 3, 0);
  if (sizes != inline_sizes)
    buffer_release(sizes);
  return result;
}

References ACIP_OPUS_BATCH_HEADER_SIZE, ACIP_OPUS_INLINE_FRAME_CAPACITY, ASCII_OTEL_SCOPE, buffer_alloc(), buffer_release, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_SIZE, HOST_TO_NET_U16, HOST_TO_NET_U32, MAX_PACKET_SIZE, packet_send_via_transportv(), PACKET_TYPE_AUDIO_OPUS_BATCH, and SET_ERRNO.

Referenced by acip_send_audio_opus(), session_host_render_audio(), threaded_send_audio_opus(), and threaded_send_audio_opus_batch().

acip_send_error()

asciichat_error_t acip_send_error	(	acip_transport_t *	transport,
		uint32_t	error_code,
		const char *	message )

Send error message packet.

Parameters

transport	Transport instance
error_code	Error code from asciichat_error_t
message	Legacy argument; fixed public text is sent for the allowlisted error code

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 415 of file send.c.

                                                                                                         {
  ASCII_OTEL_SCOPE(ACIP_SEND_ERROR);
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
  error_code = network_error_public_code((asciichat_error_t)error_code);
  // Error packets can be sent before authentication. Never let a caller's
  // context or source locations cross the network boundary.
  (void)message;
  message = asciichat_error_string((asciichat_error_t)error_code);
 
  // 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_alloc(buffer_control_domain(), 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_release(buffer);
  return result;
}

References ASCII_OTEL_SCOPE, buffer_alloc(), buffer_control_domain(), buffer_release, error_packet_t::error_code, ERROR_INVALID_PARAM, ERROR_MEMORY, HOST_TO_NET_U32, MAX_ERROR_MESSAGE_LENGTH, network_error_public_code(), packet_send_via_transport(), PACKET_TYPE_ERROR_MESSAGE, and SET_ERRNO.

Referenced by acds_on_host_announcement_ex(), disconnect_client_for_bad_data(), and process_decrypted_packet().

acip_send_ping()

asciichat_error_t acip_send_ping

(

acip_transport_t *

transport

)

Send ping packet.

Parameters

transport

Transport instance

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 385 of file send.c.

                                                              {
  ASCII_OTEL_SCOPE(ACIP_SEND_PING);
  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);
}

References ASCII_OTEL_SCOPE, ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_PING, and SET_ERRNO.

Referenced by discovery_session_check_host_alive().

acip_send_pong()

asciichat_error_t acip_send_pong

(

acip_transport_t *

transport

)

Send pong packet.

Parameters

transport

Transport instance

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 395 of file send.c.

                                                              {
  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);
}

References ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_PONG, and SET_ERRNO.

Referenced by handle_ping_packet(), session_host_receive_packet(), and session_protocol_dispatch().

acip_send_remote_log()

asciichat_error_t acip_send_remote_log	(	acip_transport_t *	transport,
		uint8_t	log_level,
		uint8_t	direction,
		const char *	message )

Send remote log packet.

Parameters

transport	Transport instance
log_level	Log level (0=DEBUG, 1=INFO, 2=WARN, 3=ERROR)
direction	Direction hint (0=client->server, 1=server->client)
message	Log message

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 459 of file send.c.

                                                            {
  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_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_release(buffer);
  return result;
}

References buffer_alloc(), buffer_release, ERROR_INVALID_PARAM, ERROR_MEMORY, HOST_TO_NET_U32, remote_log_packet_t::log_level, packet_send_via_transport(), PACKET_TYPE_REMOTE_LOG, and SET_ERRNO.

Referenced by log_net_message().

acip_send_session_created()

asciichat_error_t acip_send_session_created	(	acip_transport_t *	transport,
		const acip_session_created_t *	response )

Send SESSION_CREATED response packet.

Parameters

transport	Transport instance
response	Session created response structure

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 495 of file send.c.

                                                                                                                 {
  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);
}

References acip_session_created_t, ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_ACIP_SESSION_CREATED, and SET_ERRNO.

acip_send_session_info()

asciichat_error_t acip_send_session_info	(	acip_transport_t *	transport,
		const acip_session_info_t *	info )

Send SESSION_INFO response packet.

Parameters

transport	Transport instance
info	Session info structure

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 503 of file send.c.

                                                                                                       {
  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);
}

References acip_session_info_t, ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_ACIP_SESSION_INFO, and SET_ERRNO.

acip_send_session_joined()

asciichat_error_t acip_send_session_joined	(	acip_transport_t *	transport,
		const acip_session_joined_t *	response )

Send SESSION_JOINED response packet.

Parameters

transport	Transport instance
response	Session joined response structure

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 511 of file send.c.

                                                                                                               {
  if (!transport || !response) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or response");
  }
 
  if (!response->success)
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_REQUEST_FAILURES, 1);
  return packet_send_via_transport(transport, PACKET_TYPE_ACIP_SESSION_JOINED, response, sizeof(*response), 0);
}

References acip_session_joined_t, ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_ACIP_SESSION_JOINED, SET_ERRNO, stats_counter_add(), STATS_COUNTER_REQUEST_FAILURES, and stats_runtime_scope().

packet_receive_via_transport()

asciichat_error_t packet_receive_via_transport	(	acip_transport_t *	transport,
		packet_type_t *	type,
		void **	payload,
		size_t *	payload_len,
		void **	alloc_buffer )

Receive a packet via transport with header parsing and validation.

Transport counterpart to packet_receive(). Receives raw bytes via transport, parses the packet header, validates magic/CRC32, and returns the packet type and payload separately.

Parameters

	transport	Transport instance
[out]	type	Packet type from header
[out]	payload	Pointer to payload data within the received buffer
[out]	payload_len	Payload length from header
[out]	alloc_buffer	Buffer to free when done (caller must free with SAFE_FREE)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 200 of file send.c.

                                                                                         {
  ASCII_OTEL_SCOPE(PACKET_RECEIVE_VIA_TRANSPORT);
  if (!transport || !type || !payload || !payload_len || !alloc_buffer) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  *type = 0;
  *payload = NULL;
  *payload_len = 0;
  *alloc_buffer = NULL;
 
receive_again:;
  // 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 == ERROR_NETWORK_INCOMPLETE)
    goto receive_again;
  if (result != ASCIICHAT_OK) {
    if (result != ERROR_NETWORK_TIMEOUT)
      stats_runtime_packet(transport->stats_peer, 0, 0, false, false);
    return result;
  }
 
  // Parse packet header
  if (recv_len < sizeof(packet_header_t)) {
    log_warn("packet too small (%zu bytes, need %zu)", recv_len, sizeof(packet_header_t));
    if (*alloc_buffer) {
      buffer_release(*alloc_buffer);
      *alloc_buffer = NULL;
    }
    stats_runtime_packet(transport->stats_peer, 0, 0, false, false);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Received packet smaller than header");
  }
 
  packet_header_t wire_header;
  result = packet_validate(recv_buffer, recv_len, 0, &wire_header);
  if (result != ASCIICHAT_OK) {
    buffer_release(*alloc_buffer);
    *alloc_buffer = NULL;
    return result;
  }
  if (NET_TO_HOST_U16(wire_header.type) == PACKET_TYPE_ENCRYPTED) {
    packet_envelope_t envelope = {.type = PACKET_TYPE_ENCRYPTED,
                                  .data = (uint8_t *)recv_buffer + sizeof(wire_header),
                                  .len = recv_len - sizeof(wire_header),
                                  .allocated_buffer = *alloc_buffer,
                                  .allocated_size = *alloc_buffer ? buffer_capacity(*alloc_buffer) : 0};
    result = packet_decrypt_envelope(&envelope, transport->crypto_ctx);
    *alloc_buffer = envelope.allocated_buffer;
    if (result != ASCIICHAT_OK || envelope.consumed) {
      buffer_release(*alloc_buffer);
      *alloc_buffer = NULL;
      if (result == ASCIICHAT_OK)
        goto receive_again;
      return result;
    }
    recv_buffer = envelope.allocated_buffer;
    recv_len = sizeof(packet_header_t) + envelope.len;
  }
  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("truncated packet (header says %zu payload, got %zu total)", plen, recv_len);
    if (*alloc_buffer) {
      buffer_release(*alloc_buffer);
      *alloc_buffer = NULL;
    }
    stats_runtime_packet(transport->stats_peer, 0, 0, false, false);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Truncated packet payload");
  }
 
  if (plen > 0) {
    *payload = (uint8_t *)recv_buffer + sizeof(packet_header_t);
  }
  *payload_len = plen;
#ifndef __EMSCRIPTEN__
  ASCII_OTEL_PACKET(*type, plen, "receive", acip_transport_get_type(transport));
#endif
  stats_runtime_packet(transport->stats_peer, *type, plen, false, true);
 
  return ASCIICHAT_OK;
}

References ASCII_OTEL_PACKET, ASCII_OTEL_SCOPE, ASCIICHAT_OK, buffer_capacity(), buffer_release, acip_transport::crypto_ctx, ERROR_INVALID_PARAM, ERROR_NETWORK_INCOMPLETE, ERROR_NETWORK_PROTOCOL, ERROR_NETWORK_TIMEOUT, log_warn, NET_TO_HOST_U16, NET_TO_HOST_U32, packet_decrypt_envelope(), PACKET_TYPE_ENCRYPTED, packet_validate(), SET_ERRNO, acip_transport::stats_peer, stats_runtime_packet(), and packet_header_t::type.

Referenced by acds_receive_packet(), acip_client_receive_packet(), and acip_server_receive_and_dispatch().

packet_send_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 )

Definition at line 190 of file send.c.

                                                                                    {
  socket_buffer_t slice = {payload, payload_len};
  return packet_send_via_transportv(transport, type, &slice, 1, client_id);
}

References packet_send_via_transportv().

Referenced by acds_handshake_begin(), acip_security_receive(), acip_security_start(), acip_send_capabilities(), acip_send_clear_console(), acip_send_error(), acip_send_image_frame_h265(), acip_send_ping(), acip_send_pong(), acip_send_protocol_version(), acip_send_remote_log(), acip_send_server_state(), acip_send_session_created(), acip_send_session_info(), acip_send_session_joined(), acip_send_stream_start(), acip_send_stream_stop(), acip_settings_send(), client_handshake_receive(), crypto_handshake_client_key_exchange(), crypto_handshake_server_auth_challenge(), crypto_handshake_server_complete(), crypto_handshake_server_send_parameters(), crypto_handshake_server_start(), discovery_session_handle_host_disconnect(), discovery_session_stop(), handle_runtime_settings(), peer_crypto_receive(), server_send_audio(), session_host_receive_packet(), threaded_send_image_frame_encoded(), and threaded_send_packet().

packet_send_via_transportv()

asciichat_error_t packet_send_via_transportv	(	acip_transport_t *	transport,
		packet_type_t	type,
		const socket_buffer_t *	payload,
		size_t	count,
		uint32_t	client_id )

Send arbitrary packet via transport (generic packet sender).

Low-level function that builds packet header and sends via transport. Most code should use the type-specific functions (acip_send_ping, etc.), but this is useful for generic wrappers that handle multiple packet types.

Parameters

transport	Transport instance
type	Packet type
payload	Packet payload (can be NULL if payload_len==0)
payload_len	Payload length
client_id	Client ID to include in packet header

Returns

ASCIICHAT_OK on success, error code on failure Send payload slices without assembling an intermediate media packet.

Definition at line 155 of file send.c.

                                                                                                               {
  ASCII_OTEL_SCOPE(PACKET_SEND_VIA_TRANSPORTV);
  if (!transport || !payload || !count || count >= SOCKET_IOV_MAX)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid packet vectors");
  packet_header_t header;
  asciichat_error_t result = packet_header_build(&header, type, payload, count, client_id);
  if (result != ASCIICHAT_OK)
    return result;
  size_t len = NET_TO_HOST_U32(header.length);
  socket_buffer_t slices[SOCKET_IOV_MAX] = {{&header, sizeof(header)}};
  memcpy(slices + 1, payload, count * sizeof(*payload));
  acip_send_options_t options = {.traffic_class = acip_packet_traffic_class(type), .delivery = ACIP_DELIVERY_RELIABLE};
  bool encoded = type == PACKET_TYPE_IMAGE_FRAME_H264 || type == PACKET_TYPE_IMAGE_FRAME_H265;
  bool prefer_datagram = (transport->prefer_audio_datagrams && options.traffic_class == ACIP_TRAFFIC_AUDIO) ||
                         (transport->prefer_visual_datagrams && options.traffic_class == ACIP_TRAFFIC_VISUAL &&
                          (!encoded || client_id == 0));
  if (prefer_datagram) {
    acip_transport_capabilities_t caps;
    asciichat_error_t result = acip_transport_get_capabilities(transport, &caps);
    if (result != ASCIICHAT_OK)
      return result;
    if (caps.datagrams) {
      options.delivery = ACIP_DELIVERY_DATAGRAM;
      options.deadline_ns = time_get_ns() + 100 * NS_PER_MS_INT;
    }
  }
  result = acip_transport_sendv_ex(transport, slices, count + 1, &options);
  stats_runtime_packet(transport->stats_peer, type, len, true, result == ASCIICHAT_OK);
#ifndef __EMSCRIPTEN__
  ASCII_OTEL_PACKET(type, len, "send", acip_transport_get_type(transport));
#endif
  return result;
}

References ACIP_DELIVERY_DATAGRAM, ACIP_DELIVERY_RELIABLE, acip_packet_traffic_class(), ACIP_TRAFFIC_AUDIO, ACIP_TRAFFIC_VISUAL, acip_transport_get_capabilities(), acip_transport_sendv_ex(), ASCII_OTEL_PACKET, ASCII_OTEL_SCOPE, ASCIICHAT_OK, acip_transport_capabilities_t::datagrams, acip_send_options_t::deadline_ns, acip_send_options_t::delivery, ERROR_INVALID_PARAM, NET_TO_HOST_U32, NS_PER_MS_INT, packet_header_build(), PACKET_TYPE_IMAGE_FRAME_H264, PACKET_TYPE_IMAGE_FRAME_H265, acip_transport::prefer_audio_datagrams, acip_transport::prefer_visual_datagrams, SET_ERRNO, acip_transport::stats_peer, stats_runtime_packet(), and acip_send_options_t::traffic_class.

Referenced by acip_send_ascii_frame_contract(), acip_send_audio_batch(), acip_send_audio_opus_batch(), acip_send_image_frame(), and packet_send_via_transport().