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_transport (acip_transport_t *transport, packet_type_t type, const void *payload, size_t payload_len, uint32_t client_id)
	Send arbitrary packet via transport (generic packet sender)
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 180 of file send.c.

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

References AUDIO_SAMPLE_RATE, audio_batch_packet_t::batch_count, buffer_pool_alloc(), buffer_pool_free(), audio_batch_packet_t::channels, ERROR_INVALID_PARAM, ERROR_MEMORY, packet_send_via_transport(), PACKET_TYPE_AUDIO_BATCH, audio_batch_packet_t::sample_rate, SET_ERRNO, and audio_batch_packet_t::total_samples.

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 212 of file send.c.

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

References acip_send_audio_opus_batch(), 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 223 of file send.c.

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

References buffer_pool_alloc(), buffer_pool_free(), ERROR_INVALID_PARAM, ERROR_MEMORY, HOST_TO_NET_U16, HOST_TO_NET_U32, log_dev, packet_send_via_transport(), PACKET_TYPE_AUDIO_OPUS_BATCH, and SET_ERRNO.

Referenced by acip_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	Error message (will be truncated to MAX_ERROR_MESSAGE_LENGTH)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 301 of file send.c.

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

References buffer_pool_alloc(), buffer_pool_free(), error_packet_t::error_code, error_code, ERROR_INVALID_PARAM, ERROR_MEMORY, HOST_TO_NET_U32, MAX_ERROR_MESSAGE_LENGTH, error_packet_t::message_length, packet_send_via_transport(), PACKET_TYPE_ERROR_MESSAGE, and SET_ERRNO.

Referenced by acds_client_handler(), acds_websocket_client_handler(), and disconnect_client_for_bad_data().

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 271 of file send.c.

                                                              {
  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 ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_PING, and SET_ERRNO.

Referenced by discovery_session_process().

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 280 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().

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 338 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_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;
}

References buffer_pool_alloc(), buffer_pool_free(), remote_log_packet_t::direction, ERROR_INVALID_PARAM, ERROR_MEMORY, remote_log_packet_t::flags, HOST_TO_NET_U32, remote_log_packet_t::log_level, remote_log_packet_t::message_length, packet_send_via_transport(), PACKET_TYPE_REMOTE_LOG, and SET_ERRNO.

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 374 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 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 382 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 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 390 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_JOINED, response, sizeof(*response), 0);
}

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

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 122 of file send.c.

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

References ASCIICHAT_OK, buffer_pool_free(), ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, packet_header_t::length, log_warn, NET_TO_HOST_U16, NET_TO_HOST_U32, SET_ERRNO, and packet_header_t::type.

Referenced by __attribute__(), client_crypto_handshake(), discovery_session_process(), and discovery_session_start().

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
	)

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 arbitrary packet via transport (generic packet sender)

Wraps payload in ACIP packet header and sends via transport. Handles CRC32 calculation and network byte order conversion.

Parameters

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

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 41 of file send.c.

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

References asciichat_crc32, ASCIICHAT_OK, packet_header_t::client_id, packet_header_t::crc32, ERROR_INVALID_PARAM, ERROR_MEMORY, HOST_TO_NET_U16, HOST_TO_NET_U32, HOST_TO_NET_U64, packet_header_t::length, log_dev, log_error, packet_header_t::magic, MAX_REASONABLE_PACKET_SIZE, PACKET_MAGIC, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, and packet_header_t::type.

Referenced by acip_send_ascii_frame(), acip_send_audio_batch(), acip_send_audio_opus_batch(), acip_send_capabilities(), acip_send_clear_console(), acip_send_client_join(), acip_send_client_leave(), acip_send_error(), acip_send_image_frame(), 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(), client_crypto_handshake(), client_send_thread_func(), crypto_handshake_client_key_exchange(), crypto_handshake_rekey_complete(), crypto_handshake_rekey_request(), crypto_handshake_rekey_response(), crypto_handshake_server_auth_challenge(), crypto_handshake_server_complete(), crypto_handshake_server_send_parameters(), crypto_handshake_server_start(), discovery_session_become_host(), discovery_session_handle_host_disconnect(), discovery_session_process(), discovery_session_start(), discovery_session_stop(), signaling_relay_ice(), signaling_relay_sdp(), threaded_send_audio_opus(), threaded_send_image_frame_h265(), threaded_send_packet(), and websocket_client_send_packet().