Network Module

🌐 Core network I/O operations with timeout support More...

Files
file	protocol.h
	ASCII-Chat IP Protocol (ACIP) packet type definitions.
file	http_client.c
	🌐 HTTPS client with BearSSL for fetching public keys from GitHub/GitLab with CA validation
file	http_client.h
	Simple HTTPS client for fetching public keys from GitHub/GitLab.
file	network.c
	🌐 Cross-platform socket I/O with timeout management and connection handling
file	network.h
	🌐 Core network I/O operations with timeout support
file	packet.c
	📦 Packet protocol handler with CRC validation, encryption, and compression
file	packet.h
	Packet protocol implementation with encryption and compression support.
file	protocol.h
	Server packet processing and protocol implementation.

Data Structures
struct	packet_header_t
	Network packet header structure. More...
struct	size_packet_t
	Terminal size update packet. More...
struct	client_info_packet_t
	Client information packet structure. More...
struct	stream_header_t
	Stream header packet structure. More...
struct	client_list_packet_t
	Client list packet structure. More...
struct	server_state_packet_t
	Server state packet structure. More...
struct	error_packet_t
	Error packet structure carrying error code and textual description. More...
struct	remote_log_packet_t
	Remote log packet structure carrying log level and message text. More...
struct	auth_failure_packet_t
	Authentication failure packet structure. More...
struct	protocol_version_packet_t
	Protocol version negotiation packet structure (Packet Type 1) More...
struct	ascii_frame_packet_t
	ASCII frame packet structure (Packet Type 2) More...
struct	image_frame_packet_t
	Image frame packet structure (Packet Type 3) More...
struct	audio_batch_packet_t
	Audio batch packet structure (Packet Type 28) More...
struct	crypto_capabilities_packet_t
	Crypto capabilities packet structure (Packet Type 14) More...
struct	crypto_parameters_packet_t
	Crypto parameters packet structure (Packet Type 15) More...
struct	terminal_capabilities_packet_t
	Terminal capabilities packet structure (Packet Type 5) More...
struct	packet_envelope_t
	Packet envelope containing received packet data. More...

Macros
#define	REMOTE_LOG_FLAG_TRUNCATED   0x0001U
	Remote log packet flag definitions.

Enumerations
enum	packet_recv_result_t { PACKET_RECV_SUCCESS = 0 , PACKET_RECV_EOF = -1 , PACKET_RECV_ERROR = -2 , PACKET_RECV_SECURITY_VIOLATION = -3 }
	Packet reception result codes. More...

Variables
uint32_t	packet_header_t::magic
	Magic number (PACKET_MAGIC) for packet validation.
uint16_t	packet_header_t::type
	Packet type (packet_type_t enumeration)
uint32_t	packet_header_t::length
	Payload data length in bytes (0 for header-only packets)
uint32_t	packet_header_t::crc32
	CRC32 checksum of payload data (0 if length == 0)
uint32_t	packet_header_t::client_id
	Client ID (0 = server, >0 = client identifier)
uint32_t	size_packet_t::width
	Terminal width in characters.
uint32_t	size_packet_t::height
	Terminal height in characters.
uint32_t	client_info_packet_t::client_id
	Unique client identifier (1-9, 0 = server)
char	client_info_packet_t::display_name [MAX_DISPLAY_NAME_LEN]
	User display name (null-terminated, max MAX_DISPLAY_NAME_LEN bytes)
uint32_t	client_info_packet_t::capabilities
	Client capabilities bitmask (CLIENT_CAP_VIDEO | CLIENT_CAP_AUDIO | CLIENT_CAP_COLOR | CLIENT_CAP_STRETCH)
uint32_t	stream_header_t::client_id
	Client ID that this stream originates from (1-9)
uint32_t	stream_header_t::stream_type
	Stream type bitmask (STREAM_TYPE_VIDEO | STREAM_TYPE_AUDIO)
uint32_t	stream_header_t::timestamp
	Timestamp when frame/audio was captured (milliseconds since epoch)
uint32_t	client_list_packet_t::client_count
	Number of clients in the list (0 to MAX_CLIENTS)
client_info_packet_t	client_list_packet_t::clients [MAX_CLIENTS]
	Array of client information structures.
uint32_t	server_state_packet_t::connected_client_count
	Total number of currently connected clients.
uint32_t	server_state_packet_t::active_client_count
	Number of clients actively sending video/audio streams.
uint32_t	server_state_packet_t::reserved [6]
	Reserved fields for future use (must be zero)
uint32_t	error_packet_t::error_code
	Error code from asciichat_error_t enumeration.
uint32_t	error_packet_t::message_length
	Length of message payload in bytes (0-512)
uint8_t	remote_log_packet_t::log_level
	Log level associated with the message (log_level_t cast to uint8_t)
uint8_t	remote_log_packet_t::direction
	Direction hint so receivers can annotate origin.
uint16_t	remote_log_packet_t::flags
	Additional flags (REMOTE_LOG_FLAG_*)
uint32_t	remote_log_packet_t::message_length
	Message payload length in bytes (0-512)
uint8_t	auth_failure_packet_t::reason_flags
	Bitmask of auth_failure_reason_t values indicating failure causes.
uint8_t	auth_failure_packet_t::reserved [7]
	Reserved bytes for future use (must be zero)
uint16_t	protocol_version_packet_t::protocol_version
	Major protocol version (must match for compatibility)
uint16_t	protocol_version_packet_t::protocol_revision
	Minor protocol revision (server can be newer)
uint8_t	protocol_version_packet_t::supports_encryption
	Encryption support flag (1=support encryption, 0=plaintext only)
uint8_t	protocol_version_packet_t::compression_algorithms
	Supported compression algorithms bitmask (COMPRESS_ALGO_*)
uint8_t	protocol_version_packet_t::compression_threshold
	Compression threshold percentage (0-100, e.g., 80 = compress if >80% size reduction)
uint16_t	protocol_version_packet_t::feature_flags
	Feature flags bitmask (FEATURE_RLE_ENCODING, etc.)
uint8_t	protocol_version_packet_t::reserved [7]
	Reserved bytes for future expansion (must be zero)
uint32_t	ascii_frame_packet_t::width
	Terminal width in characters.
uint32_t	ascii_frame_packet_t::height
	Terminal height in characters.
uint32_t	ascii_frame_packet_t::original_size
	Size of original uncompressed ASCII data in bytes.
uint32_t	ascii_frame_packet_t::compressed_size
	Size of compressed data (0 = not compressed)
uint32_t	ascii_frame_packet_t::checksum
	CRC32 checksum of original ASCII data.
uint32_t	ascii_frame_packet_t::flags
	Frame flags bitmask (HAS_COLOR, IS_COMPRESSED, etc.)
uint32_t	image_frame_packet_t::width
	Image width in pixels.
uint32_t	image_frame_packet_t::height
	Image height in pixels.
uint32_t	image_frame_packet_t::pixel_format
	Pixel format enum (0=RGB24, 1=RGBA32, 2=BGR24, etc.)
uint32_t	image_frame_packet_t::compressed_size
	Compressed data size (0 = not compressed, >0 = compressed)
uint32_t	image_frame_packet_t::checksum
	CRC32 checksum of pixel data.
uint32_t	image_frame_packet_t::timestamp
	Timestamp when frame was captured (milliseconds since epoch)
uint32_t	audio_batch_packet_t::batch_count
	Number of audio chunks in this batch (usually AUDIO_BATCH_COUNT = 32)
uint32_t	audio_batch_packet_t::total_samples
	Total audio samples across all chunks (typically 8192)
uint32_t	audio_batch_packet_t::sample_rate
	Sample rate in Hz (e.g., 44100, 48000)
uint32_t	audio_batch_packet_t::channels
	Number of audio channels (1=mono, 2=stereo)
uint16_t	crypto_capabilities_packet_t::supported_kex_algorithms
	Supported key exchange algorithms bitmask (KEX_ALGO_*)
uint16_t	crypto_capabilities_packet_t::supported_auth_algorithms
	Supported authentication algorithms bitmask (AUTH_ALGO_*)
uint16_t	crypto_capabilities_packet_t::supported_cipher_algorithms
	Supported cipher algorithms bitmask (CIPHER_ALGO_*)
uint8_t	crypto_capabilities_packet_t::requires_verification
	Server verification requirement flag (1=required, 0=optional)
uint8_t	crypto_capabilities_packet_t::preferred_kex
	Preferred key exchange algorithm (KEX_ALGO_*)
uint8_t	crypto_capabilities_packet_t::preferred_auth
	Preferred authentication algorithm (AUTH_ALGO_*)
uint8_t	crypto_capabilities_packet_t::preferred_cipher
	Preferred cipher algorithm (CIPHER_ALGO_*)
uint8_t	crypto_parameters_packet_t::selected_kex
	Selected key exchange algorithm (KEX_ALGO_*)
uint8_t	crypto_parameters_packet_t::selected_auth
	Selected authentication algorithm (AUTH_ALGO_*)
uint8_t	crypto_parameters_packet_t::selected_cipher
	Selected cipher algorithm (CIPHER_ALGO_*)
uint8_t	crypto_parameters_packet_t::verification_enabled
	Server verification enabled flag (1=enabled, 0=disabled)
uint16_t	crypto_parameters_packet_t::kex_public_key_size
	Key exchange public key size in bytes (e.g., 32 for X25519, 1568 for Kyber1024)
uint16_t	crypto_parameters_packet_t::auth_public_key_size
	Authentication public key size in bytes (e.g., 32 for Ed25519, 1952 for Dilithium3)
uint16_t	crypto_parameters_packet_t::signature_size
	Signature size in bytes (e.g., 64 for Ed25519, 3309 for Dilithium3)
uint16_t	crypto_parameters_packet_t::shared_secret_size
	Shared secret size in bytes (e.g., 32 for X25519)
uint8_t	crypto_parameters_packet_t::nonce_size
	Nonce size in bytes (e.g., 24 for XSalsa20)
uint8_t	crypto_parameters_packet_t::mac_size
	MAC size in bytes (e.g., 16 for Poly1305)
uint8_t	crypto_parameters_packet_t::hmac_size
	HMAC size in bytes (e.g., 32 for HMAC-SHA256)
uint8_t	crypto_parameters_packet_t::reserved [3]
	Reserved bytes for future use (must be zero)
uint32_t	terminal_capabilities_packet_t::capabilities
	Terminal capabilities bitmask (TERM_CAP_* flags)
uint32_t	terminal_capabilities_packet_t::color_level
	Color level enum value (terminal_color_mode_t)
uint32_t	terminal_capabilities_packet_t::color_count
	Actual color count (16, 256, or 16777216)
uint32_t	terminal_capabilities_packet_t::render_mode
	Render mode enum value (foreground/background/half-block)
uint16_t	terminal_capabilities_packet_t::width
	Terminal width in characters.
uint16_t	terminal_capabilities_packet_t::height
	Terminal height in characters.
char	terminal_capabilities_packet_t::term_type [32]
	$TERM environment variable value (for debugging)
char	terminal_capabilities_packet_t::colorterm [32]
	$COLORTERM environment variable value (for debugging)
uint8_t	terminal_capabilities_packet_t::detection_reliable
	Detection reliability flag (1=reliable detection, 0=best guess)
uint32_t	terminal_capabilities_packet_t::utf8_support
	UTF-8 support flag (0=no UTF-8, 1=UTF-8 supported)
uint32_t	terminal_capabilities_packet_t::palette_type
	Palette type enum value (palette_type_t)
char	terminal_capabilities_packet_t::palette_custom [64]
	Custom palette characters (if palette_type == PALETTE_CUSTOM)
uint8_t	terminal_capabilities_packet_t::desired_fps
	Client's desired frame rate (1-144 FPS)
uint8_t	terminal_capabilities_packet_t::reserved [2]
	Reserved bytes for alignment (must be zero)
packet_type_t	packet_envelope_t::type
	Packet type (from packet_types.h)
void *	packet_envelope_t::data
	Packet payload data (decrypted and decompressed if applicable)
size_t	packet_envelope_t::len
	Length of payload data in bytes.
bool	packet_envelope_t::was_encrypted
	True if packet was encrypted (decrypted before envelope creation)
void *	packet_envelope_t::allocated_buffer
	Buffer that needs to be freed by caller (may be NULL if not allocated)
size_t	packet_envelope_t::allocated_size
	Size of allocated buffer in bytes.

HTTPS Client
char *	https_get (const char *hostname, const char *path)
	Perform HTTPS GET request.

Socket I/O Operations
ssize_t	send_with_timeout (socket_t sockfd, const void *data, size_t len, int timeout_seconds)
	Send data with timeout using chunked transmission.
ssize_t	recv_with_timeout (socket_t sockfd, void *buf, size_t len, int timeout_seconds)
	Receive data with timeout.
int	accept_with_timeout (socket_t listenfd, struct sockaddr *addr, socklen_t *addrlen, int timeout_seconds)
	Accept connection with timeout.
bool	connect_with_timeout (socket_t sockfd, const struct sockaddr *addr, socklen_t addrlen, int timeout_seconds)
	Connect to server with timeout.

Socket Configuration Functions
asciichat_error_t	set_socket_timeout (socket_t sockfd, int timeout_seconds)
	Set socket timeout for send/receive operations.
asciichat_error_t	set_socket_keepalive (socket_t sockfd)
	Enable TCP keepalive on socket.
asciichat_error_t	set_socket_nonblocking (socket_t sockfd)
	Set socket to non-blocking mode.
asciichat_error_t	socket_configure_buffers (socket_t sockfd)
	Configure socket buffers and TCP_NODELAY for optimal performance.

Error Reporting Functions
const char *	network_error_string ()
	Get human-readable error string for network errors.

Packet Validation Functions
asciichat_error_t	packet_validate_header (const packet_header_t *header, uint16_t *pkt_type, uint32_t *pkt_len, uint32_t *expected_crc)
	Validate packet header and extract information.
asciichat_error_t	packet_validate_crc32 (const void *data, size_t len, uint32_t expected_crc)
	Validate packet CRC32 checksum.

Basic Packet I/O Functions
asciichat_error_t	packet_send (socket_t sockfd, packet_type_t type, const void *data, size_t len)
	Send a packet with header and CRC32 checksum.
asciichat_error_t	packet_receive (socket_t sockfd, packet_type_t *type, void **data, size_t *len)
	Receive a packet with header validation and CRC32 checking.

Secure Packet I/O Functions
asciichat_error_t	send_packet_secure (socket_t sockfd, packet_type_t type, const void *data, size_t len, crypto_context_t *crypto_ctx)
	Send a packet with encryption and compression support.
packet_recv_result_t	receive_packet_secure (socket_t sockfd, void *crypto_ctx, bool enforce_encryption, packet_envelope_t *envelope)
	Receive a packet with decryption and decompression support.

Legacy Packet I/O Functions
These functions provide basic packet I/O without encryption support. Use send_packet_secure() and receive_packet_secure() for encryption support.
int	send_packet (socket_t sockfd, packet_type_t type, const void *data, size_t len)
	Send a basic packet without encryption.
int	receive_packet (socket_t sockfd, packet_type_t *type, void **data, size_t *len)
	Receive a basic packet without encryption.

Protocol Packet Functions
Convenience functions for sending specific protocol packets. These functions construct the appropriate packet structure and send it over the socket.
int	send_ping_packet (socket_t sockfd)
	Send a ping packet (keepalive)
int	send_pong_packet (socket_t sockfd)
	Send a pong packet (keepalive response)
int	send_clear_console_packet (socket_t sockfd)
	Send a clear console packet.
asciichat_error_t	packet_send_error (socket_t sockfd, const crypto_context_t *crypto_ctx, asciichat_error_t error_code, const char *message)
	Send an error packet with optional encryption context.
asciichat_error_t	packet_parse_error_message (const void *data, size_t len, asciichat_error_t *out_error_code, char *message_buffer, size_t message_buffer_size, size_t *out_message_length)
	Parse an error packet payload into components.
asciichat_error_t	packet_send_remote_log (socket_t sockfd, const crypto_context_t *crypto_ctx, log_level_t level, remote_log_direction_t direction, uint16_t flags, const char *message)
	Send a remote log packet with optional encryption context.
asciichat_error_t	packet_parse_remote_log (const void *data, size_t len, log_level_t *out_level, remote_log_direction_t *out_direction, uint16_t *out_flags, char *message_buffer, size_t message_buffer_size, size_t *out_message_length)
	Parse a remote log packet payload into components.
int	send_protocol_version_packet (socket_t sockfd, const protocol_version_packet_t *version)
	Send protocol version negotiation packet.
int	send_crypto_capabilities_packet (socket_t sockfd, const crypto_capabilities_packet_t *caps)
	Send crypto capabilities packet.
int	send_crypto_parameters_packet (socket_t sockfd, const crypto_parameters_packet_t *params)
	Send crypto parameters packet.
asciichat_error_t	send_audio_batch_packet (socket_t sockfd, const float *samples, int num_samples, int batch_count, crypto_context_t *crypto_ctx)
	Send a batched audio packet with encryption support.
asciichat_error_t	av_send_audio_opus_batch (socket_t sockfd, const uint8_t *opus_data, size_t opus_size, const uint16_t *frame_sizes, int sample_rate, int frame_duration, int frame_count, crypto_context_t *crypto_ctx)
	Send Opus-encoded audio batch packet with encryption support.
asciichat_error_t	send_ascii_frame_packet (socket_t sockfd, const char *frame_data, size_t frame_size)
	Send ASCII frame packet.
asciichat_error_t	send_image_frame_packet (socket_t sockfd, const void *image_data, uint16_t width, uint16_t height, uint8_t format)
	Send image frame packet.

Network Timeout Constants
Timeout values tuned for real-time video streaming. All timeouts are specified in seconds.
#define	CONNECT_TIMEOUT   3
	Connection timeout in seconds (3 seconds)
#define	SEND_TIMEOUT   5
	Send timeout in seconds (5 seconds)
#define	RECV_TIMEOUT   15
	Receive timeout in seconds (15 seconds)
#define	ACCEPT_TIMEOUT   3
	Accept timeout in seconds (3 seconds)

Test Environment Detection
#define	network_is_test_environment()   ((int)is_test_environment())
	Check if we're in a test environment.

Socket Keepalive Settings
Keepalive settings to detect dead connections. TCP keepalive probes are sent when connection is idle to detect broken connections.
#define	KEEPALIVE_IDLE   60
	Keepalive idle time in seconds (60 seconds)
#define	KEEPALIVE_INTERVAL   10
	Keepalive interval in seconds (10 seconds)
#define	KEEPALIVE_COUNT   8
	Keepalive probe count (8 probes)

Network Protocol Constants
#define	MAX_ERROR_MESSAGE_LENGTH   512
	Maximum error message length (512 bytes)
#define	MAX_REMOTE_LOG_MESSAGE_LENGTH   512
	Maximum remote log message length (512 bytes)

Protocol Negotiation Constants
#define	FEATURE_RLE_ENCODING   0x01
	Feature flags for protocol_version_packet_t.
#define	FEATURE_DELTA_FRAMES   0x02
	Delta frame encoding (future)

Client Capability Flags
Bitmask flags for client capabilities in multi-user protocol.
#define	CLIENT_CAP_VIDEO   0x01
	Client can send/receive video.
#define	CLIENT_CAP_AUDIO   0x02
	Client can send/receive audio.
#define	CLIENT_CAP_COLOR   0x04
	Client supports color rendering.
#define	CLIENT_CAP_STRETCH   0x08
	Client can stretch frames to fill terminal.

Stream Type Flags
Bitmask flags for stream types in multi-user protocol.
#define	STREAM_TYPE_VIDEO   0x01
	Video stream.
#define	STREAM_TYPE_AUDIO   0x02
	Audio stream.

Crypto Algorithm Constants
Algorithm identifiers for key exchange, authentication, and encryption. Used in crypto handshake packet negotiation.
#define	KEX_ALGO_X25519   0x01
	X25519 key exchange (Curve25519)
#define	AUTH_ALGO_ED25519   0x01
	Ed25519 authentication (Edwards-curve signatures)
#define	AUTH_ALGO_NONE   0x00
	No authentication (plaintext mode)
#define	CIPHER_ALGO_XSALSA20_POLY1305   0x01
	XSalsa20-Poly1305 authenticated encryption.

Detailed Description

🌐 Core network I/O operations with timeout support

This module provides basic HTTPS GET functionality using BearSSL for TLS. It's designed specifically for fetching SSH/GPG public keys from GitHub and GitLab.

Note

TLS library: Uses BearSSL for TLS connections. BearSSL is a minimal TLS implementation with system CA certificate support.

Security: Uses system CA certificates for trust validation (20-year longevity). Validates server certificates against system trust store.

Key fetching: Fetches keys from GitHub/GitLab endpoints:

• GitHub SSH keys: https://github.com/username.keys
• GitHub GPG keys: https://github.com/username.gpg
• GitLab SSH keys: https://gitlab.com/username.keys
• GitLab GPG keys: https://gitlab.com/username.gpg

Key fetching functions: fetch_github_ssh_keys, fetch_gitlab_ssh_keys, fetch_github_gpg_keys, and fetch_gitlab_gpg_keys are in crypto/keys/https_keys.h. They properly belong in the keys module.

Author

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

Date

October 2025

This module provides fundamental network I/O operations including socket management, timeout handling, and basic send/receive operations. All operations support configurable timeouts to prevent indefinite blocking, critical for real-time video streaming applications.

CORE RESPONSIBILITIES:

1. Socket I/O operations with timeout support
2. Connection management (connect, accept) with timeouts
3. Socket configuration (keepalive, non-blocking, timeouts)
4. Chunked transmission for large data transfers
5. Error reporting and diagnostics

ARCHITECTURAL OVERVIEW:

TIMEOUT SYSTEM:

• All I/O operations support configurable timeouts
• Timeouts are tuned for real-time video streaming requirements
• Chunked transmission prevents large data from blocking indefinitely
• Platform-specific timeout implementation (select/poll/epoll)

SOCKET CONFIGURATION:

• Keepalive settings to detect dead connections
• Non-blocking mode support for asynchronous I/O
• Socket-level timeout configuration
• Platform abstraction for cross-platform compatibility

ERROR HANDLING:

• Comprehensive error reporting with human-readable messages
• Platform-specific error code translation
• Network error string utilities

INTEGRATION WITH OTHER MODULES:

• platform/socket.h: Uses platform socket abstraction
• Used by packet.h for packet transmission
• Used by av.h for media packet sending
• Used by handshake.c for crypto handshake operations

PERFORMANCE CHARACTERISTICS:

• Chunked transmission enables progressive sending of large frames
• Timeout handling prevents indefinite blocking
• Keepalive settings detect dead connections efficiently
• Platform-specific optimizations where available

Note

Timeout values are tuned for real-time video streaming. Adjust CONNECT_TIMEOUT, SEND_TIMEOUT, and RECV_TIMEOUT if needed for different network conditions.

Chunked transmission is used automatically for large data to prevent timeouts and enable progress tracking.

Warning

Timeout values that are too short may cause false positives on slow networks. Values that are too long may delay error detection unnecessarily.

Author

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

Date

September 2025

Version

2.0 (Post-Modularization)

This module provides comprehensive packet protocol implementation including packet verification, CRC validation, protocol compliance checking, encryption support, and compression integration. It serves as the core network protocol layer for ascii-chat's communication system.

CORE RESPONSIBILITIES:

1. Packet header validation and CRC32 checksum verification
2. Secure packet transmission with encryption support
3. Secure packet reception with decryption and validation
4. Protocol compliance checking and error handling
5. Integration with cryptographic and compression subsystems

ARCHITECTURAL OVERVIEW:

PACKET STRUCTURE:

• Header: Magic number, type, length, CRC32, client ID
• Payload: Variable-length data (may be encrypted/compressed)
• Validation: CRC32 checksum for integrity verification

ENCRYPTION INTEGRATION:

• Automatic encryption/decryption when crypto context provided
• Handshake packets always sent unencrypted (plaintext)
• Session packets encrypted after handshake completion
• Encryption policy enforcement (require/optional encryption)

COMPRESSION INTEGRATION:

• Automatic compression for large packets (frames, audio)
• Compression threshold-based decision making
• Decompression on receive path

PROTOCOL VALIDATION:

• Magic number validation to detect corruption
• CRC32 checksum verification for integrity
• Packet size validation to prevent attacks
• Type validation for protocol compliance

INTEGRATION WITH OTHER MODULES:

• crypto/crypto.h: Encryption/decryption operations
• compression.h: Compression/decompression support
• network/network.h: Socket I/O operations

PERFORMANCE CHARACTERISTICS:

• Zero-copy operation when possible
• Automatic memory management for packet buffers
• Efficient CRC32 validation (hardware-accelerated when available)
• Compression reduces bandwidth for large frames

Note

All packet functions handle encryption automatically when crypto context is provided. Plaintext packets are used for handshake.

Compression is automatically applied to large packets (frames, audio batches) based on size thresholds.

Warning

Packet buffers are allocated by receive functions and must be freed by caller using the allocated_buffer pointer.

Author

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

Date

September 2025

Version

2.0 (Post-Modularization)

Network README

Overview

Welcome to the Network I/O module! This is where all the network communication happens—everything from basic socket operations to packet transmission. The network module is designed for real-time video streaming, which means it's optimized for low latency, reliability, and handling large data transfers smoothly.

What does the network module do?

The Network I/O module provides fundamental network operations that everything else builds on. Think of it as the foundation for all network communication. Here's what it handles:

• Socket I/O operations with timeout support (so operations don't hang forever)
• Connection management (connect, accept) with timeouts (critical for reliable connections)
• Socket configuration (keepalive, non-blocking mode, timeouts) to keep connections healthy
• Chunked transmission for large data transfers (so big video frames don't block the connection)
• Packet protocol with encryption and compression support (built on top of the basic I/O)
• Error reporting and diagnostics (so you know what went wrong when things break)

All operations support configurable timeouts, which is critical for real-time video streaming—we can't afford to wait forever when something goes wrong. The timeout system ensures that operations fail fast rather than hanging indefinitely.

Implementation: lib/network/network.h, lib/network/packet.h

Architecture

The network module is built around a few key concepts: timeouts to prevent hanging, socket configuration to keep connections healthy, and a packet protocol that handles the complexity of reliable data transmission. Let's walk through how everything fits together.

Timeout System

All I/O operations support configurable timeouts—this is probably the most important feature for real-time video streaming. Without timeouts, operations can hang forever when the network is flaky, which would freeze your video stream.

What timeouts do we have?

• Connection timeout: 3 seconds (CONNECT_TIMEOUT)—when you're trying to connect to a server, we'll give up after 3 seconds rather than waiting forever
• Send timeout: 5 seconds (SEND_TIMEOUT)—when sending data, we'll give up after 5 seconds if it's not going through
• Receive timeout: 15 seconds (RECV_TIMEOUT)—when receiving data, we'll wait up to 15 seconds (this is longer because network delays are more common on receive)
• Accept timeout: 3 seconds (ACCEPT_TIMEOUT)—when waiting for incoming connections, we'll check every 3 seconds rather than blocking forever

Why these values?

These timeouts are tuned specifically for real-time video streaming. They're short enough that you notice problems quickly, but long enough that normal network hiccups don't cause false positives. Chunked transmission prevents large data from blocking indefinitely—even if a single chunk times out, we can still make progress on the rest.

Socket Configuration

Socket configuration is about keeping your connections healthy and efficient. We configure sockets with several important settings:

What socket options do we set?

• TCP keepalive: This detects dead connections automatically—if the connection has been idle for a while, keepalive probes check if it's still alive. If the other end doesn't respond, we know the connection is dead and can clean it up. We use KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, and KEEPALIVE_COUNT to tune this.
• Non-blocking mode: This enables asynchronous I/O patterns—instead of blocking and waiting for data, we can check if data is available and do other work while waiting
• Socket-level timeouts: We set SO_SNDTIMEO and SO_RCVTIMEO at the socket level, so even if the application doesn't explicitly check timeouts, the socket itself will time out
• Platform abstraction: All of this works cross-platform (Linux, macOS, Windows) through our platform abstraction layer

Packet Protocol

The packet protocol sits on top of the basic socket I/O and adds structure, validation, encryption, and compression. It's how we reliably transmit data even when the network is unreliable.

What does the packet protocol do?

The packet protocol provides:

• Packet header validation: Every packet starts with a magic number and CRC32 checksum, so we can detect corrupted packets immediately
• Secure packet transmission: Packets can be encrypted using the crypto context (automatic encryption/decryption)
• Secure packet reception: Packets are automatically decrypted and validated when received
• Automatic compression: Large packets are automatically compressed to save bandwidth
• Protocol compliance checking: We verify that packets follow the protocol specification, so malformed packets are rejected early

How are packets structured?

Packet Structure:

• Header: Contains a magic number (so we know it's really our packet), type (what kind of packet it is), length (how much data follows), CRC32 (to detect corruption), and client ID (which client this is from)
• Payload: The actual data, which can be encrypted and/or compressed
• Validation: The CRC32 checksum in the header lets us verify packet integrity before we even try to decrypt or decompress

This structure makes it easy to detect problems early—if the magic number is wrong or the CRC32 doesn't match, we know the packet is corrupted before we waste time trying to decrypt it.

Operations

Socket I/O Operations

Send/Receive Operations:

// Send data with timeout
ssize_t sent = send_with_timeout(sockfd, data, len, SEND_TIMEOUT);
if (sent < 0) {
    log_error("Send failed: %s", network_error_string());
}
 
// Receive data with timeout
ssize_t received = recv_with_timeout(sockfd, buffer, len, RECV_TIMEOUT);
if (received < 0) {
    log_error("Receive failed: %s", network_error_string());
}

Connection Operations:

// Connect to server with timeout
if (!connect_with_timeout(sockfd, &addr, addrlen, CONNECT_TIMEOUT)) {
    log_error("Connection failed: %s", network_error_string());
}
 
// Accept connection with timeout
int client_fd = accept_with_timeout(listenfd, NULL, NULL, ACCEPT_TIMEOUT);
if (client_fd < 0) {
    log_error("Accept failed: %s", network_error_string());
}

Packet Operations

Basic Packet I/O:

// Send a packet
asciichat_error_t err = packet_send(sockfd, PACKET_TYPE_PING, NULL, 0);
if (err != ASCIICHAT_OK) {
    log_error("Packet send failed");
}
 
// Receive a packet
packet_type_t type;
void *data;
size_t len;
err = packet_receive(sockfd, &type, &data, &len);
if (err == ASCIICHAT_OK) {
    // Process packet
    process_packet(type, data, len);
    free(data);  // Free allocated buffer
}

Secure Packet I/O:

// Send encrypted packet
int result = send_packet_secure(sockfd, PACKET_TYPE_ASCII_FRAME,
                                 frame_data, frame_size, crypto_ctx);
if (result < 0) {
    log_error("Secure send failed");
}
 
// Receive and decrypt packet
packet_envelope_t envelope;
packet_recv_result_t result = receive_packet_secure(sockfd, crypto_ctx,
                                                     true, &envelope);
if (result == PACKET_RECV_SUCCESS) {
    // Process decrypted packet
    process_packet(envelope.type, envelope.data, envelope.len);
    free(envelope.allocated_buffer);  // Free allocated buffer
}

Socket Configuration

Socket Setup:

// Set socket timeout
if (set_socket_timeout(sockfd, SEND_TIMEOUT) < 0) {
    log_error("Failed to set socket timeout");
}
 
// Enable TCP keepalive
if (set_socket_keepalive(sockfd) < 0) {
    log_error("Failed to enable keepalive");
}
 
// Set non-blocking mode
if (set_socket_nonblocking(sockfd) < 0) {
    log_error("Failed to set non-blocking mode");
}

Integration

The Network I/O module integrates with:

• platform/socket.h: Uses platform socket abstraction
• network/packet_types.h: Packet type definitions
• crypto/crypto.h: Encryption/decryption operations
• compression.h: Compression/decompression support
• network/av.h: Media packet sending
• crypto/handshake.h: Crypto handshake operations

Performance

Chunked Transmission:

• Enables progressive sending of large frames
• Prevents timeout issues with large data
• Allows progress tracking

Timeout Handling:

• Prevents indefinite blocking
• Tuned for real-time video streaming
• Platform-specific optimizations (select/poll/epoll)

Keepalive Settings:

• Efficiently detects dead connections
• No application-level heartbeats required
• Configurable idle time and probe count

Error Handling

Error Reporting:

// Get human-readable error string
const char *error_msg = network_error_string();
log_error("Network error: %s", error_msg);

Error Codes:

• Function return values: -1 indicates error
• asciichat_error_t codes: ASCIICHAT_OK on success, error codes on failure
• packet_recv_result_t codes: PACKET_RECV_SUCCESS, PACKET_RECV_EOF, etc.

Timeout Configuration

Timeout configuration is all about balance—too short and you get false positives on slow networks, too long and you delay error detection unnecessarily. We've tuned these values specifically for real-time video streaming.

What timeouts do we use?

• CONNECT_TIMEOUT (3 seconds): Reduced from the default for faster connection attempts. If a connection doesn't work, we want to know quickly so we can try again or report the error
• SEND_TIMEOUT (5 seconds): This gives enough time for timely delivery of video frames. It's long enough that network hiccups don't cause false positives, but short enough that stuck sends are detected quickly
• RECV_TIMEOUT (15 seconds): This is longer than send timeout because network delays are more common on receive. We want to give the network time to deliver data, but not so much time that we hang forever
• ACCEPT_TIMEOUT (3 seconds): This is balanced between responsiveness (we don't want to waste CPU checking too often) and quick detection of problems

⚠️ Important timeout notes:

Timeout values that are too short may cause false positives on slow networks—you might think the connection is dead when it's just slow. Values that are too long may delay error detection unnecessarily—you might wait too long before realizing something is wrong.

If you're running on a very slow network (like satellite internet), you might want to increase these timeouts. If you're running on a very fast network (like a local LAN), you could decrease them for faster error detection.

Chunked Transmission

Large data transfers are automatically chunked—this is how we send big video frames without blocking the connection. Instead of sending everything at once (which could cause timeouts or block other operations), we break large data into smaller chunks.

How does chunked transmission work?

• Prevents timeout issues: Large frames can be several megabytes—if we try to send it all at once, we might timeout before it finishes. Chunking lets us send the frame in pieces, so each piece can complete quickly
• Enables progress tracking: We can report progress as chunks are sent, so you know things are working even when sending large frames
• Handles partial sends automatically: Sometimes send() doesn't send everything you ask it to—chunking handles this gracefully by retrying until the chunk is sent
• Retries until complete: If a chunk fails to send, we retry until all data is sent or the timeout occurs

This is used automatically for large data—you don't need to do anything special. The system detects when data is large enough to benefit from chunking and handles it automatically.

Packet Security

The packet protocol supports:

• Encryption: Automatic encryption/decryption when crypto context provided
• Compression: Automatic compression for large packets
• Validation: Magic number and CRC32 checksum verification
• Policy Enforcement: Encryption requirement enforcement

Handshake Packets:

• Always sent unencrypted (plaintext)
• Use packet_is_handshake_type() to check before encryption
• Required for crypto handshake establishment

Best Practices

1. Always check return values:

   if (send_with_timeout(sockfd, data, len, timeout) < 0) {
       // Handle error
   }

2. Free allocated packet buffers:

   void *data;
   size_t len;
   packet_receive(sockfd, &type, &data, &len);
   // ... use data ...
   free(data);  // Always free

3. Use secure packet functions for encryption:

   send_packet_secure(sockfd, type, data, len, crypto_ctx);
   receive_packet_secure(sockfd, crypto_ctx, true, &envelope);

4. Enable keepalive for long-lived connections:

   set_socket_keepalive(sockfd);

5. Configure timeouts appropriately:

   set_socket_timeout(sockfd, SEND_TIMEOUT);

See also

network/network.h

network/packet.h

network/packet_types.h

Macro Definition Documentation

ACCEPT_TIMEOUT

#define ACCEPT_TIMEOUT   3

#include <network.h>

Accept timeout in seconds (3 seconds)

Maximum time to wait for incoming connections. Balanced between responsiveness and CPU usage.

Definition at line 128 of file network.h.

AUTH_ALGO_ED25519

#define AUTH_ALGO_ED25519   0x01

#include <packet.h>

Ed25519 authentication (Edwards-curve signatures)

Definition at line 950 of file packet.h.

AUTH_ALGO_NONE

#define AUTH_ALGO_NONE   0x00

#include <packet.h>

No authentication (plaintext mode)

Definition at line 951 of file packet.h.

CIPHER_ALGO_XSALSA20_POLY1305

#define CIPHER_ALGO_XSALSA20_POLY1305   0x01

#include <packet.h>

XSalsa20-Poly1305 authenticated encryption.

Definition at line 952 of file packet.h.

CLIENT_CAP_AUDIO

#define CLIENT_CAP_AUDIO   0x02

#include <packet.h>

Client can send/receive audio.

Definition at line 816 of file packet.h.

CLIENT_CAP_COLOR

#define CLIENT_CAP_COLOR   0x04

#include <packet.h>

Client supports color rendering.

Definition at line 817 of file packet.h.

CLIENT_CAP_STRETCH

#define CLIENT_CAP_STRETCH   0x08

#include <packet.h>

Client can stretch frames to fill terminal.

Definition at line 818 of file packet.h.

CLIENT_CAP_VIDEO

#define CLIENT_CAP_VIDEO   0x01

#include <packet.h>

Client can send/receive video.

Definition at line 815 of file packet.h.

CONNECT_TIMEOUT

#define CONNECT_TIMEOUT   3

#include <network.h>

Connection timeout in seconds (3 seconds)

Maximum time to wait for connection establishment. Reduced from default for faster connection attempts and quicker failure detection.

Definition at line 98 of file network.h.

FEATURE_DELTA_FRAMES

#define FEATURE_DELTA_FRAMES   0x02

#include <packet.h>

Delta frame encoding (future)

Definition at line 695 of file packet.h.

FEATURE_RLE_ENCODING

#define FEATURE_RLE_ENCODING   0x01

#include <packet.h>

Feature flags for protocol_version_packet_t.

Bitmask values for optional protocol features. Used in protocol negotiation to enable advanced capabilities.

Run-length encoding support

Definition at line 694 of file packet.h.

KEEPALIVE_COUNT

#define KEEPALIVE_COUNT   8

#include <network.h>

Keepalive probe count (8 probes)

Number of keepalive probes to send before considering connection dead.

Definition at line 186 of file network.h.

KEEPALIVE_IDLE

#define KEEPALIVE_IDLE   60

#include <network.h>

Keepalive idle time in seconds (60 seconds)

Time to wait before sending first keepalive probe after connection becomes idle.

Definition at line 168 of file network.h.

KEEPALIVE_INTERVAL

#define KEEPALIVE_INTERVAL   10

#include <network.h>

Keepalive interval in seconds (10 seconds)

Interval between subsequent keepalive probes.

Definition at line 177 of file network.h.

KEX_ALGO_X25519

#define KEX_ALGO_X25519   0x01

#include <packet.h>

X25519 key exchange (Curve25519)

Definition at line 949 of file packet.h.

MAX_ERROR_MESSAGE_LENGTH

#define MAX_ERROR_MESSAGE_LENGTH   512

#include <packet.h>

Maximum error message length (512 bytes)

Error packets include a message payload. This defines the maximum number of bytes allowed in the message portion to prevent excessive allocations and potential abuse.

Definition at line 122 of file packet.h.

MAX_REMOTE_LOG_MESSAGE_LENGTH

#define MAX_REMOTE_LOG_MESSAGE_LENGTH   512

#include <packet.h>

Maximum remote log message length (512 bytes)

Remote logging packets mirror the error packet structure but are intended for diagnostic log forwarding between client and server. Limiting the payload size keeps allocations predictable and prevents log flooding over the network.

Definition at line 132 of file packet.h.

network_is_test_environment

#define network_is_test_environment

(

)

((int)is_test_environment())

#include <network.h>

Check if we're in a test environment.

Compatibility macro that calls is_test_environment() from tests/test_env.h. Used to adjust timeouts for faster test execution.

Returns

1 if test environment, 0 otherwise

Definition at line 147 of file network.h.

RECV_TIMEOUT

#define RECV_TIMEOUT   15

#include <network.h>

Receive timeout in seconds (15 seconds)

Maximum time to wait for incoming data. If no data is received within this time, connection is considered dead.

Definition at line 118 of file network.h.

REMOTE_LOG_FLAG_TRUNCATED

#define REMOTE_LOG_FLAG_TRUNCATED   0x0001U

#include <packet.h>

Remote log packet flag definitions.

Message payload was truncated to fit the maximum length

Definition at line 628 of file packet.h.

SEND_TIMEOUT

#define SEND_TIMEOUT   5

#include <network.h>

Send timeout in seconds (5 seconds)

Maximum time to wait for data transmission. Video frames need timely delivery to maintain real-time performance.

Definition at line 108 of file network.h.

STREAM_TYPE_AUDIO

#define STREAM_TYPE_AUDIO   0x02

#include <packet.h>

Audio stream.

Definition at line 830 of file packet.h.

STREAM_TYPE_VIDEO

#define STREAM_TYPE_VIDEO   0x01

#include <packet.h>

Video stream.

Definition at line 829 of file packet.h.

Enumeration Type Documentation

packet_recv_result_t

enum packet_recv_result_t

#include <packet.h>

Packet reception result codes.

Result codes for packet reception operations. Negative values indicate errors, zero indicates success.

Enumerator
PACKET_RECV_SUCCESS	Packet received successfully.
PACKET_RECV_EOF	Connection closed (EOF)
PACKET_RECV_ERROR	Network error occurred.
PACKET_RECV_SECURITY_VIOLATION	Encryption policy violation (e.g., unencrypted packet when encryption required)

Definition at line 1003 of file packet.h.

             {
  PACKET_RECV_SUCCESS = 0,
  PACKET_RECV_EOF = -1,
  PACKET_RECV_ERROR = -2,
  PACKET_RECV_SECURITY_VIOLATION = -3
} packet_recv_result_t;

Function Documentation

accept_with_timeout()

int accept_with_timeout	(	socket_t	listenfd,
		struct sockaddr *	addr,
		socklen_t *	addrlen,
		int	timeout_seconds
	)

#include <network.h>

Accept connection with timeout.

Parameters

listenfd	Listening socket file descriptor
addr	Output: Client address structure (can be NULL)
addrlen	Input/output: Length of address structure
timeout_seconds	Timeout in seconds

Returns

Client socket file descriptor on success, -1 on error

Accepts incoming connection with timeout support. Waits up to timeout_seconds for incoming connection.

Note

If addr is NULL, client address information is not returned.

addrlen must point to initialized value containing size of addr buffer. On return, contains actual size of address.

Parameters

listenfd	Listening socket
addr	Client address structure
addrlen	Length of address structure
timeout_seconds	Timeout in seconds

Returns

Client socket, or -1 on error

Definition at line 346 of file network.c.

                                                                                                           {
  fd_set read_fds;
  struct timeval timeout;
 
  socket_fd_zero(&read_fds);
  socket_fd_set(listenfd, &read_fds);
 
  timeout.tv_sec = timeout_seconds;
  timeout.tv_usec = 0;
 
  int result = socket_select(listenfd, &read_fds, NULL, NULL, &timeout);
 
  if (result <= 0) {
    if (result == 0) {
      // Timeout is expected behavior for server waiting for connections
      asciichat_errno = ERROR_NETWORK_TIMEOUT;
      asciichat_errno_context.code = ERROR_NETWORK_TIMEOUT;
      asciichat_errno_context.has_system_error = true;
      asciichat_errno_context.system_errno = ETIMEDOUT;
      return -1;
    }
 
    if (network_handle_select_error(result)) {
      return -1; // Don't retry for accept
    }
    return -1;
  }
 
  // Check if socket is ready
  if (!socket_fd_isset(listenfd, &read_fds)) {
    asciichat_errno = ERROR_NETWORK_TIMEOUT;
    asciichat_errno_context.code = ERROR_NETWORK_TIMEOUT;
    asciichat_errno_context.has_system_error = true;
    asciichat_errno_context.system_errno = ETIMEDOUT;
    return -1;
  }
 
  // Check if socket is still valid before attempting accept
  if (listenfd == INVALID_SOCKET_VALUE) {
    SET_ERRNO(ERROR_NETWORK, "accept_with_timeout: listening socket is closed");
    return -1;
  }
 
  socket_t accept_result = socket_accept(listenfd, addr, addrlen);
 
  if (accept_result == INVALID_SOCKET_VALUE) {
    // Check if this is a socket closed error (common during shutdown)
#ifdef _WIN32
    // On Windows, use WSAGetLastError() instead of errno
    int error_code = WSAGetLastError();
    // Windows-specific error codes for closed/invalid sockets
    // WSAENOTSOCK = 10038, WSAEBADF = 10009, WSAENOTCONN = 10057
    if (error_code == WSAENOTSOCK || error_code == WSAEBADF || error_code == WSAENOTCONN) {
      // During shutdown, don't log this as an error since it's expected behavior
      asciichat_errno = ERROR_NETWORK;
      asciichat_errno_context.code = ERROR_NETWORK;
      asciichat_errno_context.has_system_error = false;
    } else {
      // Save Windows socket error to WSA error field for debugging
      errno = EIO; // Set a generic errno
#ifdef NDEBUG
      asciichat_set_errno_with_wsa_error(ERROR_NETWORK_BIND, NULL, 0, NULL, error_code);
#else
      asciichat_set_errno_with_wsa_error(ERROR_NETWORK_BIND, __FILE__, __LINE__, __func__, error_code);
#endif
    }
#else
    // POSIX error codes for closed/invalid sockets
    int error_code = errno;
    if (error_code == EBADF || error_code == ENOTSOCK) {
      // During shutdown, don't log this as an error since it's expected behavior
      asciichat_errno = ERROR_NETWORK;
      asciichat_errno_context.code = ERROR_NETWORK;
      asciichat_errno_context.has_system_error = false;
    } else {
      SET_ERRNO_SYS(ERROR_NETWORK_BIND, "accept_with_timeout accept failed: %s", network_get_error_string(errno));
    }
#endif
    return -1;
  }
 
  return (int)accept_result;
}

References asciichat_errno, asciichat_errno_context, asciichat_set_errno_with_wsa_error(), asciichat_error_context_t::code, EBADF, ENOTSOCK, errno, error_code, ERROR_NETWORK, ERROR_NETWORK_BIND, ERROR_NETWORK_TIMEOUT, ETIMEDOUT, asciichat_error_context_t::has_system_error, INVALID_SOCKET_VALUE, SET_ERRNO, SET_ERRNO_SYS, socket_accept(), socket_fd_isset(), socket_fd_set(), socket_fd_zero(), socket_select(), and asciichat_error_context_t::system_errno.

av_send_audio_opus_batch()

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
	)

#include <packet.h>

Send Opus-encoded audio batch packet with encryption support.

Parameters

sockfd	Socket file descriptor
opus_data	Opus-encoded audio data buffer
opus_size	Size of Opus-encoded data in bytes
frame_sizes	Array of frame sizes (one per Opus frame)
sample_rate	Sample rate in Hz (e.g., 48000)
frame_duration	Frame duration in milliseconds (e.g., 20)
frame_count	Number of Opus frames in batch
crypto_ctx	Cryptographic context for encryption (NULL for plaintext)

Returns

ASCIICHAT_OK on success, error code on failure

Sends PACKET_TYPE_AUDIO_OPUS_BATCH with multiple Opus-encoded frames. Opus provides better compression than raw audio (30-100 bytes per 20ms frame).

Note

Opus packets are NOT compressed again (already compressed by Opus codec).

Encryption is applied automatically when crypto_ctx is provided.

Definition at line 1136 of file packet.c.

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

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

Referenced by client_send_thread_func(), and tcp_client_send_audio_opus_batch().

connect_with_timeout()

bool connect_with_timeout	(	socket_t	sockfd,
		const struct sockaddr *	addr,
		socklen_t	addrlen,
		int	timeout_seconds
	)

#include <network.h>

Connect to server with timeout.

Parameters

sockfd	Socket file descriptor
addr	Server address structure
addrlen	Address structure length
timeout_seconds	Timeout in seconds

Returns

true on success, false on failure

Establishes connection to server with timeout support. Waits up to timeout_seconds for connection to complete.

Note

Uses platform-specific connection timeout mechanism (select/poll).

Returns false on timeout or connection failure. Use network_error_string() to get human-readable error description.

Connect to server with timeout.

Parameters

sockfd	Socket file descriptor
addr	Address to connect to
addrlen	Address length
timeout_seconds	Timeout in seconds

Returns

true on success, false on failure

Definition at line 547 of file network.c.

                                                                                                                {
  if (sockfd == INVALID_SOCKET_VALUE) {
    errno = EBADF;
    return false;
  }
 
  // Set socket to non-blocking for timeout control
  if (set_socket_nonblocking(sockfd) != ASCIICHAT_OK) {
    return false;
  }
 
  // Attempt connection
  int result = connect(sockfd, addr, addrlen);
 
  if (result == 0) {
    // Connected immediately
    return true;
  }
 
#ifdef _WIN32
  int error = WSAGetLastError();
  if (error != WSAEWOULDBLOCK && error != WSAEINPROGRESS) {
    return false;
  }
#else
  if (errno != EINPROGRESS && errno != EWOULDBLOCK) {
    return false;
  }
#endif
 
  // Use select to wait for connection with timeout
  fd_set write_fds;
  struct timeval timeout;
 
  socket_fd_zero(&write_fds);
  socket_fd_set(sockfd, &write_fds);
 
  timeout.tv_sec = timeout_seconds;
  timeout.tv_usec = 0;
 
  result = socket_select(sockfd, NULL, &write_fds, NULL, &timeout);
 
  if (result <= 0) {
    return false; // Timeout or error
  }
 
  if (!socket_fd_isset(sockfd, &write_fds)) {
    return false; // Socket not ready
  }
 
  // Check if connection was successful
  int error_code = 0;
  socklen_t error_len = sizeof(error_code);
 
  if (socket_getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error_code, &error_len) != 0) {
    return false;
  }
 
  if (error_code != 0) {
    return false;
  }
 
  // Connection successful - restore blocking mode
  if (socket_set_blocking(sockfd) != 0) {
    log_warn("Failed to restore socket to blocking mode after connect");
    // Continue anyway - non-blocking mode works but may cause issues with send/recv
  }
 
  return true;
}

References ASCIICHAT_OK, EBADF, errno, error_code, EWOULDBLOCK, INVALID_SOCKET_VALUE, log_warn, set_socket_nonblocking(), socket_fd_isset(), socket_fd_set(), socket_fd_zero(), socket_getsockopt(), socket_select(), and socket_set_blocking().

Referenced by server_connection_establish(), and tcp_client_connect().

https_get()

char * https_get	(	const char *	hostname,
		const char *	path
	)

#include <http_client.h>

Perform HTTPS GET request.

Parameters

hostname	Server hostname (e.g., "github.com", must not be NULL)
path	Resource path (e.g., "/username.keys", must not be NULL)

Returns

Allocated string containing response body (caller must free), or NULL on error

Makes a secure HTTPS connection to the specified hostname and fetches the resource at the given path. Uses system CA certificates for validation.

Note

TLS connection: Uses BearSSL for TLS connections. Validates server certificate against system CA certificates.

Memory management: Returns allocated string that caller must free. Use SAFE_FREE() to free the returned string.

Error handling: Returns NULL on error (network error, TLS error, etc.). Error messages are logged via logging system.

Hostname format: Hostname should be domain name only (no "https://" prefix). Example: "github.com", not "https://github.com".

Path format: Path should start with "/" for absolute paths. Example: "/username.keys", not "username.keys".

Response body: Returns complete response body as null-terminated string. Response may contain multiple keys (one per line for SSH keys).

Warning

Network dependency: Requires network connectivity and valid hostname. May fail if network is unavailable or hostname is unreachable.

Memory leak: Caller must free returned string using SAFE_FREE(). Function allocates memory that must be freed.

Certificate validation: Uses system CA certificates for validation. May fail if system CA certificates are missing or outdated.

Definition at line 109 of file http_client.c.

                                                        {
  if (!hostname || !path) {
    log_error("Invalid arguments to https_get");
    return NULL;
  }
 
  log_info("HTTPS GET https://%s%s", hostname, path);
 
  // Load system CA certificates
  char *pem_data = NULL;
  size_t pem_size = 0;
  if (platform_load_system_ca_certs(&pem_data, &pem_size) != 0) {
    log_error("Failed to load system CA certificates");
    return NULL;
  }
 
  // Parse PEM certificates into BearSSL trust anchors
  anchor_list anchors = ANCHOR_LIST_INIT;
  size_t num_anchors = read_trust_anchors_from_memory(&anchors, (unsigned char *)pem_data, pem_size);
  SAFE_FREE(pem_data);
 
  if (num_anchors == 0) {
    log_error("No trust anchors loaded");
    // Free anchors before returning to prevent leak
    goto cleanup_anchors;
  }
  log_info("Loaded %zu trust anchors", num_anchors);
 
  // Resolve hostname using getaddrinfo (modern, non-deprecated API)
  struct addrinfo hints, *result;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_INET; // IPv4
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = IPPROTO_TCP;
 
  if (getaddrinfo(hostname, "443", &hints, &result) != 0) {
    log_error("Failed to resolve hostname: %s", hostname);
    goto cleanup_anchors;
  }
 
  // Create TCP socket
  socket_t sock = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
  if (sock == INVALID_SOCKET_VALUE) {
    log_error("Failed to create socket");
    freeaddrinfo(result);
    goto cleanup_anchors;
  }
 
  // Connect to server
  if (connect(sock, result->ai_addr, (int)result->ai_addrlen) != 0) {
    log_error("Failed to connect to %s:443", hostname);
    socket_close(sock);
    freeaddrinfo(result);
    goto cleanup_anchors;
  }
 
  freeaddrinfo(result);
 
  log_info("Connected to %s:443", hostname);
 
  // Initialize BearSSL X.509 minimal validator
  br_x509_minimal_context xc;
  br_x509_minimal_init(&xc, &br_sha256_vtable, anchors.buf, anchors.ptr);
 
  // Initialize BearSSL client context
  br_ssl_client_context sc;
  br_ssl_client_init_full(&sc, &xc, anchors.buf, anchors.ptr);
 
  // Set I/O buffer
  unsigned char *iobuf;
  iobuf = SAFE_MALLOC(BR_SSL_BUFSIZE_BIDI, unsigned char *);
  br_ssl_engine_set_buffer(&sc.eng, iobuf, BR_SSL_BUFSIZE_BIDI, 1);
 
  // Initialize I/O context
  br_sslio_context ioc;
  br_sslio_init(&ioc, &sc.eng, sock_read, &sock, sock_write, &sock);
 
  // Start TLS handshake
  br_ssl_client_reset(&sc, hostname, 0);
 
  log_info("Starting TLS handshake with %s", hostname);
 
  // Build HTTP request
  char request[BUFFER_SIZE_LARGE];
  int request_len = safe_snprintf(request, sizeof(request),
                                  "GET %s HTTP/1.1\r\n"
                                  "Host: %s\r\n"
                                  "Connection: close\r\n"
                                  "User-Agent: ascii-chat/" ASCII_CHAT_VERSION_STRING "\r\n"
                                  "\r\n",
                                  path, hostname);
 
  // Send HTTP request over TLS
  if (br_sslio_write_all(&ioc, request, (size_t)request_len) != 0) {
    log_error("Failed to send HTTP request");
    SAFE_FREE(iobuf);
    socket_close(sock);
    goto cleanup_anchors;
  }
 
  br_sslio_flush(&ioc);
  log_info("Sent HTTP request");
 
  // Read HTTP response
  char *response_buf = NULL;
  size_t response_capacity = 8192;
  size_t response_len = 0;
  response_buf = SAFE_MALLOC(response_capacity, char *);
 
  while (1) {
    // Ensure we have space to read
    if (response_len + 1024 > response_capacity) {
      response_capacity *= 2;
      response_buf = SAFE_REALLOC(response_buf, response_capacity, char *);
    }
 
    // Read data
    int n = br_sslio_read(&ioc, response_buf + response_len, response_capacity - response_len);
    if (n < 0) {
      // Check for TLS errors
      int err = br_ssl_engine_last_error(&sc.eng);
      if (err != BR_ERR_OK) {
        log_error("TLS error: %d", err);
        SAFE_FREE(response_buf);
        SAFE_FREE(iobuf);
        socket_close(sock);
        goto cleanup_anchors;
      }
      // EOF or connection closed
      break;
    }
    if (n == 0) {
      break; // EOF
    }
 
    response_len += (size_t)n;
  }
 
  response_buf[response_len] = '\0';
  log_info("Received %zu bytes", response_len);
 
  // Close connection
  br_sslio_close(&ioc);
  socket_close(sock);
 
  // Parse HTTP response
  asciichat_error_t status = check_http_status(response_buf);
  if (status != ASCIICHAT_OK) {
    SAFE_FREE(response_buf);
    SAFE_FREE(iobuf);
    goto cleanup_anchors;
  }
 
  char *body = extract_http_body(response_buf, response_len);
  SAFE_FREE(response_buf);
  SAFE_FREE(iobuf);
 
  // Cleanup trust anchors
  for (size_t i = 0; i < anchors.ptr; i++) {
    free_ta_contents(&anchors.buf[i]);
  }
  SAFE_FREE(anchors.buf);
 
  return body;
 
cleanup_anchors:
  for (size_t i = 0; i < anchors.ptr; i++) {
    free_ta_contents(&anchors.buf[i]);
  }
  SAFE_FREE(anchors.buf);
  return NULL;
}

References ANCHOR_LIST_INIT, ASCIICHAT_OK, anchor_list::buf, BUFFER_SIZE_LARGE, free_ta_contents(), INVALID_SOCKET_VALUE, log_error, log_info, platform_load_system_ca_certs(), anchor_list::ptr, read_trust_anchors_from_memory(), SAFE_FREE, SAFE_MALLOC, SAFE_REALLOC, safe_snprintf(), and socket_close().

network_error_string()

const char * network_error_string

(

)

#include <network.h>

Get human-readable error string for network errors.

Returns

Error string describing last network error

Returns a human-readable description of the last network error. Useful for error logging and user-facing error messages.

Note

Error string is thread-local - each thread has its own error state.

Parameters

error_code

Error code

Returns

Error string

Definition at line 535 of file network.c.

                                   {
  return socket_get_error_string();
}

References socket_get_error_string().

Referenced by server_connection_establish(), socket_configure_buffers(), and tcp_client_connect().

packet_parse_error_message()

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

#include <packet.h>

Parse an error packet payload into components.

Parameters

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

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 854 of file packet.c.

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

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

packet_parse_remote_log()

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

#include <packet.h>

Parse a remote log packet payload into components.

Parameters

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

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 953 of file packet.c.

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

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

Referenced by handle_remote_log_packet_from_client().

packet_receive()

asciichat_error_t packet_receive	(	socket_t	sockfd,
		packet_type_t *	type,
		void **	data,
		size_t *	len
	)

#include <packet.h>

Receive a packet with header validation and CRC32 checking.

Parameters

sockfd	Socket file descriptor
type	Output: Packet type
data	Output: Packet payload data (allocated by function, freed by caller)
len	Output: Payload data length in bytes

Returns

ASCIICHAT_OK on success, error code on failure

Receives a complete packet, validates header, and verifies CRC32 checksum. Allocates buffer for payload data which must be freed by caller.

Note

Allocates buffer for payload data - caller must free when done.

Validates magic number and CRC32 checksum before returning data.

Warning

Allocated data buffer must be freed by caller to prevent memory leaks.

Receive a packet with header validation and CRC32 checking.

Parameters

sockfd	Socket file descriptor
type	Output: packet type
data	Output: packet data (allocated by caller, freed by caller)
len	Output: data length

Returns

0 on success, -1 on error

Definition at line 351 of file packet.c.

                                                                                                 {
  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;
  ssize_t received =
      recv_with_timeout(sockfd, &header, sizeof(header), network_is_test_environment() ? 1 : RECV_TIMEOUT);
  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
    int recv_timeout = network_is_test_environment() ? 1 : 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;
}

References ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), ERROR_INVALID_PARAM, ERROR_NETWORK, ERROR_NETWORK_PROTOCOL, INVALID_SOCKET_VALUE, log_warn, network_is_test_environment, packet_validate_crc32(), packet_validate_header(), RECV_TIMEOUT, recv_with_timeout(), SET_ERRNO, and SET_ERRNO_SYS.

Referenced by receive_packet().

packet_send()

asciichat_error_t packet_send	(	socket_t	sockfd,
		packet_type_t	type,
		const void *	data,
		size_t	len
	)

#include <packet.h>

Send a packet with header and CRC32 checksum.

Parameters

sockfd	Socket file descriptor
type	Packet type (from packet_types.h)
data	Packet payload data (can be NULL for header-only packets)
len	Payload data length in bytes

Returns

ASCIICHAT_OK on success, error code on failure

Sends a complete packet with header (magic, type, length, CRC32) and optional payload. CRC32 is computed automatically and included in header.

Note

Packet header is constructed with all required fields including magic number, type, length, CRC32, and client ID.

CRC32 is computed over payload data (or zero if data is NULL).

Send a packet with header and CRC32 checksum.

Parameters

sockfd	Socket file descriptor
type	Packet type
data	Packet data
len	Data length

Returns

0 on success, -1 on error

Definition at line 291 of file packet.c.

                                                                                                 {
  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_U32(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
  int 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;
}

References asciichat_crc32, errno, ERROR_INVALID_PARAM, ERROR_NETWORK, ERROR_NETWORK_SIZE, HOST_TO_NET_U16, HOST_TO_NET_U32, INVALID_SOCKET_VALUE, log_debug, packet_header_t::magic, MAX_PACKET_SIZE, PACKET_MAGIC, SAFE_STRERROR, send_with_timeout(), SET_ERRNO, and socket_is_valid().

Referenced by packet_send_error(), packet_send_remote_log(), send_ascii_frame_packet(), send_image_frame_packet(), send_packet(), send_packet_secure(), and tcp_client_send_audio_opus().

packet_send_error()

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

#include <packet.h>

Send an error packet with optional encryption context.

Parameters

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

Returns

ASCIICHAT_OK on success, error code otherwise

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

Definition at line 807 of file packet.c.

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

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

Referenced by disconnect_client_for_bad_data().

packet_send_remote_log()

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

#include <packet.h>

Send a remote log packet with optional encryption context.

Parameters

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

Returns

ASCIICHAT_OK on success, error code otherwise

<Message payload was truncated to fit the maximum length

Definition at line 896 of file packet.c.

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

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

packet_validate_crc32()

asciichat_error_t packet_validate_crc32	(	const void *	data,
		size_t	len,
		uint32_t	expected_crc
	)

#include <packet.h>

Validate packet CRC32 checksum.

Parameters

data	Packet payload data
len	Data length in bytes
expected_crc	Expected CRC32 checksum value

Returns

ASCIICHAT_OK on success, error code on failure

Validates packet integrity by computing CRC32 checksum of payload and comparing with expected value. Uses hardware acceleration when available for optimal performance.

Note

CRC32 validation prevents corrupted packets from being processed.

Uses hardware-accelerated CRC32 when available (automatic fallback to software implementation).

Validate packet CRC32 checksum.

Parameters

data	Packet data
len	Data length
expected_crc	Expected CRC32 value

Returns

0 on success, -1 on error

Definition at line 261 of file packet.c.

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

References asciichat_crc32, ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, and SET_ERRNO.

Referenced by packet_receive().

packet_validate_header()

asciichat_error_t packet_validate_header	(	const packet_header_t *	header,
		uint16_t *	pkt_type,
		uint32_t *	pkt_len,
		uint32_t *	expected_crc
	)

#include <packet.h>

Validate packet header and extract information.

Parameters

header	Packet header to validate
pkt_type	Output: Packet type
pkt_len	Output: Packet payload length
expected_crc	Output: Expected CRC32 checksum

Returns

ASCIICHAT_OK on success, error code on failure

Validates packet header structure including magic number, type, and length fields. Extracts packet information for further processing.

Note

Validates magic number to detect corrupted packets.

All output parameters must be non-NULL.

Validate packet header and extract information.

Parameters

header	Packet header to validate
pkt_type	Output: packet type
pkt_len	Output: packet length
expected_crc	Output: expected CRC32

Returns

0 on success, -1 on error

Definition at line 75 of file packet.c.

                                                                 {
  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
  uint32_t magic = endian_unpack_u32(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:
    if (len == 0 || len > AUDIO_SAMPLES_PER_PACKET * sizeof(float) * 2) { // Max stereo samples
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid audio packet size: %u", len);
    }
    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_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_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;
}

References ASCIICHAT_OK, AUDIO_SAMPLES_PER_PACKET, packet_header_t::crc32, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, ERROR_NETWORK_SIZE, packet_header_t::length, packet_header_t::magic, MAX_ERROR_MESSAGE_LENGTH, MAX_PACKET_SIZE, PACKET_MAGIC, PACKET_TYPE_ACIP_DISCOVERY_PING, PACKET_TYPE_ACIP_ERROR, PACKET_TYPE_ACIP_SESSION_CREATE, PACKET_TYPE_ACIP_SESSION_CREATED, PACKET_TYPE_ACIP_SESSION_END, PACKET_TYPE_ACIP_SESSION_INFO, PACKET_TYPE_ACIP_SESSION_JOIN, PACKET_TYPE_ACIP_SESSION_JOINED, PACKET_TYPE_ACIP_SESSION_LEAVE, PACKET_TYPE_ACIP_SESSION_LOOKUP, PACKET_TYPE_ACIP_SESSION_RECONNECT, PACKET_TYPE_ACIP_STRING_RELEASE, PACKET_TYPE_ACIP_STRING_RENEW, PACKET_TYPE_ACIP_STRING_RESERVE, PACKET_TYPE_ACIP_STRING_RESERVED, PACKET_TYPE_ACIP_WEBRTC_ICE, PACKET_TYPE_ACIP_WEBRTC_SDP, PACKET_TYPE_ASCII_FRAME, PACKET_TYPE_AUDIO, PACKET_TYPE_AUDIO_BATCH, PACKET_TYPE_AUDIO_MESSAGE, PACKET_TYPE_CLIENT_CAPABILITIES, PACKET_TYPE_CLIENT_JOIN, PACKET_TYPE_CLIENT_LEAVE, PACKET_TYPE_CRYPTO_AUTH_CHALLENGE, PACKET_TYPE_CRYPTO_AUTH_FAILED, PACKET_TYPE_CRYPTO_AUTH_RESPONSE, PACKET_TYPE_CRYPTO_CAPABILITIES, PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE, PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT, PACKET_TYPE_CRYPTO_KEY_EXCHANGE_RESP, PACKET_TYPE_CRYPTO_NO_ENCRYPTION, PACKET_TYPE_CRYPTO_PARAMETERS, PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP, PACKET_TYPE_ENCRYPTED, PACKET_TYPE_ERROR_MESSAGE, PACKET_TYPE_IMAGE_FRAME, PACKET_TYPE_PING, PACKET_TYPE_PONG, PACKET_TYPE_PROTOCOL_VERSION, PACKET_TYPE_SIZE_MESSAGE, PACKET_TYPE_STREAM_START, PACKET_TYPE_STREAM_STOP, PACKET_TYPE_TEXT_MESSAGE, SET_ERRNO, and packet_header_t::type.

Referenced by packet_receive().

receive_packet()

int receive_packet	(	socket_t	sockfd,
		packet_type_t *	type,
		void **	data,
		size_t *	len
	)

#include <packet.h>

Receive a basic packet without encryption.

Parameters

sockfd	Socket file descriptor
type	Output: Packet type
data	Output: Packet payload data (allocated by function)
len	Output: Payload data length in bytes

Returns

0 on success, -1 on error

Receives a plaintext packet without decryption. Allocates buffer for payload data which must be freed by caller.

Note

Use receive_packet_secure() if decryption support is needed.

Warning

Allocated data buffer must be freed by caller.

Parameters

sockfd	Socket file descriptor
type	Output: packet type
data	Output: packet data
len	Output: data length

Returns

0 on success, -1 on error

Definition at line 767 of file packet.c.

                                                                                   {
  asciichat_error_t result = packet_receive(sockfd, type, data, len);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, and packet_receive().

Referenced by acds_client_handler(), acds_session_create(), acds_session_join(), acds_session_lookup(), client_crypto_handshake(), crypto_handshake_client_auth_response(), crypto_handshake_client_complete(), crypto_handshake_client_key_exchange(), crypto_handshake_server_auth_challenge(), crypto_handshake_server_complete(), and server_crypto_handshake().

receive_packet_secure()

packet_recv_result_t receive_packet_secure	(	socket_t	sockfd,
		void *	crypto_ctx,
		bool	enforce_encryption,
		packet_envelope_t *	envelope
	)

#include <packet.h>

Receive a packet with decryption and decompression support.

Parameters

sockfd	Socket file descriptor
crypto_ctx	Cryptographic context for decryption (NULL for plaintext)
enforce_encryption	If true, reject unencrypted packets (except handshake)
envelope	Output: Received packet envelope with all metadata

Returns

PACKET_RECV_SUCCESS on success, error code on failure

Receives a packet with automatic decryption (if encrypted) and decompression (if compressed). Validates encryption policy and packet integrity.

Note

Decryption is applied automatically when packet is encrypted and crypto_ctx is provided.

Decompression is applied automatically when packet is compressed.

If enforce_encryption is true, unencrypted packets (except handshake packets) cause PACKET_RECV_SECURITY_VIOLATION.

Warning

Envelope's allocated_buffer must be freed by caller to prevent memory leaks.

Parameters

sockfd	Socket file descriptor
crypto_ctx	Crypto context for decryption
enforce_encryption	Whether to require encryption
envelope	Output: received packet envelope

Returns

Packet receive result

Definition at line 568 of file packet.c.

                                                                        {
 
  if (!envelope) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: envelope=%p", envelope);
    return PACKET_RECV_ERROR;
  }
 
  // Initialize envelope
  memset(envelope, 0, sizeof(*envelope));
 
  // Receive packet header
  packet_header_t header;
  ssize_t received =
      recv_with_timeout(sockfd, &header, sizeof(header), network_is_test_environment() ? 1 : RECV_TIMEOUT);
 
  // Check for errors first (before comparing signed with unsigned)
  if (received < 0) {
    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
  uint32_t magic = NET_TO_HOST_U32(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);
 
  // Validate magic number
  if (magic != PACKET_MAGIC) {
    SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid packet magic: 0x%x (expected 0x%x)", 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;
    }
 
    int recv_timeout = network_is_test_environment() ? 1 : 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);
    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
  if (pkt_len > 0) {
    uint8_t *payload = buffer_pool_alloc(NULL, pkt_len);
    if (!payload) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for payload");
      return PACKET_RECV_ERROR;
    }
 
    int recv_timeout = network_is_test_environment() ? 1 : calculate_packet_timeout(pkt_len);
    received = recv_with_timeout(sockfd, payload, 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, payload, pkt_len);
      return PACKET_RECV_ERROR;
    }
 
    // Verify CRC
    uint32_t actual_crc = asciichat_crc32(payload, 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, payload, pkt_len);
      return PACKET_RECV_ERROR;
    }
 
    envelope->data = payload;
    envelope->allocated_buffer = payload;
    envelope->allocated_size = pkt_len;
  }
 
  envelope->type = (packet_type_t)pkt_type;
  envelope->len = pkt_len;
 
  return PACKET_RECV_SUCCESS;
}

References packet_envelope_t::allocated_buffer, packet_envelope_t::allocated_size, asciichat_crc32, buffer_pool_alloc(), buffer_pool_free(), packet_header_t::crc32, crypto_decrypt(), CRYPTO_OK, crypto_result_to_string(), packet_envelope_t::data, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, ERROR_NETWORK_PROTOCOL, ERROR_NETWORK_SIZE, packet_envelope_t::len, packet_header_t::length, packet_header_t::magic, MAX_PACKET_SIZE, NET_TO_HOST_U16, NET_TO_HOST_U32, network_is_test_environment, PACKET_MAGIC, PACKET_RECV_EOF, PACKET_RECV_ERROR, PACKET_RECV_SUCCESS, PACKET_TYPE_ENCRYPTED, RECV_TIMEOUT, recv_with_timeout(), SET_ERRNO, packet_header_t::type, and packet_envelope_t::type.

Referenced by acip_client_receive_and_dispatch(), and acip_server_receive_and_dispatch().

recv_with_timeout()

ssize_t recv_with_timeout	(	socket_t	sockfd,
		void *	buf,
		size_t	len,
		int	timeout_seconds
	)

#include <network.h>

Receive data with timeout.

Parameters

sockfd	Socket file descriptor
buf	Buffer to receive data
len	Length of buffer in bytes
timeout_seconds	Timeout in seconds

Returns

Number of bytes received on success, -1 on error

Receives data from socket with timeout support. Waits up to timeout_seconds for data to arrive.

Note

Partial receives are possible - function returns number of bytes actually received.

Returns -1 on timeout or error. Use network_error_string() to get human-readable error description.

Parameters

sockfd	Socket file descriptor
buf	Buffer to receive data
len	Length of buffer
timeout_seconds	Timeout in seconds

Returns

Number of bytes received, or -1 on error

Definition at line 272 of file network.c.

                                                                                       {
  if (sockfd == INVALID_SOCKET_VALUE) {
    log_error("NETWORK_DEBUG: recv_with_timeout called with INVALID_SOCKET_VALUE");
    errno = EBADF;
    return -1;
  }
 
  fd_set read_fds;
  struct timeval timeout;
  ssize_t total_received = 0;
  char *data = (char *)buf;
 
  while (total_received < (ssize_t)len) {
    // Set up select for read timeout
    socket_fd_zero(&read_fds);
    socket_fd_set(sockfd, &read_fds);
 
    timeout.tv_sec = network_is_test_environment() ? 1 : timeout_seconds;
    timeout.tv_usec = 0;
 
    int result = socket_select(sockfd, &read_fds, NULL, NULL, &timeout);
    if (result <= 0) {
      if (result == 0) {
        SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "recv_with_timeout timed out after %d seconds", timeout_seconds);
        return -1;
      }
      if (network_handle_select_error(result)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    // Check if socket is ready
    if (!socket_fd_isset(sockfd, &read_fds)) {
      SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "recv_with_timeout socket not ready after select");
      return -1;
    }
 
    // Calculate how much we still need to receive
    size_t bytes_to_recv = len - (size_t)total_received;
    ssize_t received = network_platform_recv(sockfd, data + total_received, bytes_to_recv);
 
    if (received < 0) {
      int error = errno;
      log_error("NETWORK_DEBUG: network_platform_recv failed with error %d (errno=%d), sockfd=%d, buf=%p, len=%zu",
                received, error, sockfd, data + total_received, bytes_to_recv);
      if (network_handle_recv_error(error)) {
        log_debug("NETWORK_DEBUG: retrying after error %d", error);
        continue; // Retry
      }
      log_error("NETWORK_DEBUG: fatal error %d, giving up", error);
      return -1; // Fatal error
    }
 
    if (received == 0) {
      // Connection closed by peer
      log_debug("Connection closed by peer during recv");
      return total_received; // Return what we got so far
    }
 
    total_received += received;
  }
 
  return total_received;
}

References EBADF, errno, ERROR_NETWORK_TIMEOUT, INVALID_SOCKET_VALUE, log_debug, log_error, network_is_test_environment, SET_ERRNO_SYS, socket_fd_isset(), socket_fd_set(), socket_fd_zero(), and socket_select().

Referenced by packet_receive(), and receive_packet_secure().

send_ascii_frame_packet()

asciichat_error_t send_ascii_frame_packet	(	socket_t	sockfd,
		const char *	frame_data,
		size_t	frame_size
	)

#include <packet.h>

Send ASCII frame packet.

Parameters

sockfd	Socket file descriptor
frame_data	ASCII frame data buffer
frame_size	Size of frame data in bytes

Returns

ASCIICHAT_OK on success, error code on failure

Sends PACKET_TYPE_ASCII_FRAME with ASCII text data. Used for transmitting terminal output or text-based frames.

Note

Frame dimensions (width, height) are set to 0 and determined by receiver.

Definition at line 1191 of file packet.c.

                                                                                                      {
  if (!frame_data || frame_size == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: frame_data=%p, frame_size=%zu", frame_data, frame_size);
  }
 
  // Create ASCII frame packet
  ascii_frame_packet_t packet;
  packet.width = 0;  // Will be set by receiver
  packet.height = 0; // Will be set by receiver
  packet.original_size = (uint32_t)frame_size;
  packet.compressed_size = 0;
  packet.checksum = 0;
  packet.flags = 0;
 
  // Calculate total packet size with overflow checking
  size_t total_size;
  if (checked_size_add(sizeof(ascii_frame_packet_t), frame_size, &total_size) != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Packet size calculation would 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 ASCII frame packet: %zu bytes", total_size);
  }
 
  // Copy packet header and frame data
  memcpy(packet_data, &packet, sizeof(ascii_frame_packet_t));
  memcpy((char *)packet_data + sizeof(ascii_frame_packet_t), frame_data, frame_size);
 
  // Send packet
  asciichat_error_t result = packet_send(sockfd, PACKET_TYPE_ASCII_FRAME, packet_data, total_size);
 
  // Clean up
  buffer_pool_free(NULL, packet_data, total_size);
 
  return result;
}

References ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), ascii_frame_packet_t::checksum, ascii_frame_packet_t::compressed_size, ERROR_INVALID_PARAM, ERROR_MEMORY, ascii_frame_packet_t::flags, ascii_frame_packet_t::height, ascii_frame_packet_t::original_size, packet_send(), PACKET_TYPE_ASCII_FRAME, SET_ERRNO, and ascii_frame_packet_t::width.

send_audio_batch_packet()

asciichat_error_t send_audio_batch_packet	(	socket_t	sockfd,
		const float *	samples,
		int	num_samples,
		int	batch_count,
		crypto_context_t *	crypto_ctx
	)

#include <packet.h>

Send a batched audio packet with encryption support.

Parameters

sockfd	Socket file descriptor
samples	Float audio samples buffer
num_samples	Total number of audio samples
batch_count	Number of chunks in batch
crypto_ctx	Cryptographic context for encryption (NULL for plaintext)

Returns

ASCIICHAT_OK on success, error code on failure

Sends PACKET_TYPE_AUDIO_BATCH with multiple audio chunks batched together. Reduces packet overhead by sending 32 chunks (~186ms) per packet. Uses system-defined AUDIO_SAMPLE_RATE and mono audio.

Note

Encryption is applied automatically when crypto_ctx is provided.

Definition at line 1072 of file packet.c.

                                                                        {
  if (!samples || num_samples <= 0 || batch_count <= 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid audio batch: samples=%p, num_samples=%d, batch_count=%d", samples,
                     num_samples, batch_count);
  }
 
  // Build batch header
  audio_batch_packet_t header;
  header.batch_count = HOST_TO_NET_U32((u_long)batch_count);
  header.total_samples = HOST_TO_NET_U32((u_long)num_samples);
  header.sample_rate = HOST_TO_NET_U32(AUDIO_SAMPLE_RATE); // Use system-defined sample rate
  header.channels = HOST_TO_NET_U32(1UL);                  // Mono for now
 
  // Calculate total payload size
  size_t data_size = (size_t)num_samples * sizeof(uint32_t); // Send as 32-bit integers for portability
  size_t total_size = sizeof(header) + data_size;
 
  // Allocate buffer for header + data
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for audio batch packet");
  }
 
  // Copy header
  memcpy(buffer, &header, sizeof(header));
 
  // Convert floats to network byte order (as 32-bit integers with scaling)
  // Floats in range [-1.0, 1.0] are scaled to INT32 range for transmission
  // Use memcpy to avoid alignment issues when casting from uint8_t* to uint32_t*
  uint8_t *sample_data_ptr = buffer + sizeof(header);
  for (int i = 0; i < num_samples; i++) {
    // Clamp samples to [-1.0, 1.0] range before scaling to prevent overflow
    float clamped_sample = samples[i];
    if (clamped_sample > 1.0f)
      clamped_sample = 1.0f;
    if (clamped_sample < -1.0f)
      clamped_sample = -1.0f;
 
    // Scale float [-1.0, 1.0] to int32 range and convert to network byte order
    int32_t scaled = (int32_t)(clamped_sample * 2147483647.0f);
    uint32_t network_value = HOST_TO_NET_U32((uint32_t)scaled);
    memcpy(sample_data_ptr + (size_t)i * sizeof(uint32_t), &network_value, sizeof(uint32_t));
  }
 
#ifndef NDEBUG
  // Debug: Log first few samples to verify conversion
  static int send_count = 0;
  send_count++;
  if (send_count % 100 == 0) {
    log_info("SEND: samples[0]=%.6f, samples[1]=%.6f, samples[2]=%.6f", (double)samples[0], (double)samples[1],
             (double)samples[2]);
    log_info("SEND: scaled[0]=%d, scaled[1]=%d, scaled[2]=%d", (int32_t)(samples[0] * 2147483647.0f),
             (int32_t)(samples[1] * 2147483647.0f), (int32_t)(samples[2] * 2147483647.0f));
  }
#endif
 
  // Send packet with encryption support
  asciichat_error_t result = send_packet_secure(sockfd, PACKET_TYPE_AUDIO_BATCH, buffer, total_size, crypto_ctx);
  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, HOST_TO_NET_U32, log_info, PACKET_TYPE_AUDIO_BATCH, audio_batch_packet_t::sample_rate, send_packet_secure(), SET_ERRNO, and audio_batch_packet_t::total_samples.

Referenced by client_send_thread_func(), tcp_client_send_audio_batch(), and threaded_send_audio_batch_packet().

send_clear_console_packet()

int send_clear_console_packet

(

socket_t

sockfd

)

#include <packet.h>

Send a clear console packet.

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_CLEAR_CONSOLE packet to request client to clear terminal display.

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Definition at line 803 of file packet.c.

                                               {
  return send_packet(sockfd, PACKET_TYPE_CLEAR_CONSOLE, NULL, 0);
}

References PACKET_TYPE_CLEAR_CONSOLE, and send_packet().

send_crypto_capabilities_packet()

int send_crypto_capabilities_packet	(	socket_t	sockfd,
		const crypto_capabilities_packet_t *	caps
	)

#include <packet.h>

Send crypto capabilities packet.

Parameters

sockfd	Socket file descriptor
caps	Crypto capabilities packet structure

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_CRYPTO_CAPABILITIES packet to advertise supported cryptographic algorithms (key exchange, authentication, cipher).

Note

Crypto capabilities packets are always sent unencrypted (handshake packets).

Parameters

sockfd	Socket file descriptor
caps	Crypto capabilities packet

Returns

0 on success, -1 on error

Definition at line 1030 of file packet.c.

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

References ERROR_INVALID_PARAM, PACKET_TYPE_CRYPTO_CAPABILITIES, send_packet(), and SET_ERRNO.

Referenced by client_crypto_handshake().

send_crypto_parameters_packet()

int send_crypto_parameters_packet	(	socket_t	sockfd,
		const crypto_parameters_packet_t *	params
	)

#include <packet.h>

Send crypto parameters packet.

Parameters

sockfd	Socket file descriptor
params	Crypto parameters packet structure

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_CRYPTO_PARAMETERS packet containing chosen cryptographic algorithms and data sizes for handshake continuation.

Note

Crypto parameters packets are always sent unencrypted (handshake packets).

Parameters

sockfd	Socket file descriptor
params	Crypto parameters packet

Returns

0 on success, -1 on error

Definition at line 1044 of file packet.c.

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

References crypto_parameters_packet_t::auth_public_key_size, ERROR_INVALID_PARAM, HOST_TO_NET_U16, crypto_parameters_packet_t::kex_public_key_size, log_debug, PACKET_TYPE_CRYPTO_PARAMETERS, send_packet(), SET_ERRNO, crypto_parameters_packet_t::shared_secret_size, and crypto_parameters_packet_t::signature_size.

Referenced by server_crypto_handshake().

send_image_frame_packet()

asciichat_error_t send_image_frame_packet	(	socket_t	sockfd,
		const void *	image_data,
		uint16_t	width,
		uint16_t	height,
		uint8_t	format
	)

#include <packet.h>

Send image frame packet.

Parameters

sockfd	Socket file descriptor
image_data	Image pixel data buffer
width	Image width in pixels
height	Image height in pixels
format	Pixel format (0=RGB24)

Returns

ASCIICHAT_OK on success, error code on failure

Sends PACKET_TYPE_IMAGE_FRAME with RGB image data. Used for transmitting camera frames or video input.

Note

Maximum dimensions: 4096x4096 pixels (~25MB per frame).

Pixel data must be in RGB24 format (3 bytes per pixel).

Definition at line 1230 of file packet.c.

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

References ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), image_frame_packet_t::checksum, image_frame_packet_t::compressed_size, ERROR_BUFFER_OVERFLOW, ERROR_INVALID_PARAM, ERROR_MEMORY, image_frame_packet_t::height, packet_send(), PACKET_TYPE_IMAGE_FRAME, image_frame_packet_t::pixel_format, SET_ERRNO, image_frame_packet_t::timestamp, and image_frame_packet_t::width.

send_packet()

int send_packet	(	socket_t	sockfd,
		packet_type_t	type,
		const void *	data,
		size_t	len
	)

#include <packet.h>

Send a basic packet without encryption.

Parameters

sockfd	Socket file descriptor
type	Packet type (from packet_types.h)
data	Packet payload data
len	Payload data length in bytes

Returns

0 on success, -1 on error

Sends a plaintext packet without encryption. Equivalent to packet_send() but returns int instead of asciichat_error_t for compatibility.

Note

Use send_packet_secure() if encryption support is needed.

Parameters

sockfd	Socket file descriptor
type	Packet type
data	Packet data
len	Data length

Returns

0 on success, -1 on error

Definition at line 754 of file packet.c.

                                                                                   {
  asciichat_error_t result = packet_send(sockfd, type, data, len);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, and packet_send().

Referenced by acds_session_create(), acds_session_join(), acds_session_lookup(), acip_server_send_error(), 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_start(), send_clear_console_packet(), send_crypto_capabilities_packet(), send_crypto_parameters_packet(), send_error_packet_message(), send_ping_packet(), send_pong_packet(), send_protocol_version_packet(), signaling_relay_ice(), and signaling_relay_sdp().

send_packet_secure()

asciichat_error_t send_packet_secure	(	socket_t	sockfd,
		packet_type_t	type,
		const void *	data,
		size_t	len,
		crypto_context_t *	crypto_ctx
	)

#include <packet.h>

Send a packet with encryption and compression support.

Parameters

sockfd	Socket file descriptor
type	Packet type (from packet_types.h)
data	Packet payload data
len	Payload data length in bytes
crypto_ctx	Cryptographic context for encryption (NULL for plaintext)

Returns

0 on success, negative on error

Sends a packet with automatic encryption (if crypto context provided) and compression (if packet is large enough). Handshake packets are never encrypted.

Note

Encryption is applied automatically when crypto_ctx is provided and packet type is not a handshake packet.

Compression is applied automatically to large packets based on size thresholds and compression ratios.

Handshake packets (packet_is_handshake_type(type) == true) are always sent unencrypted, even when crypto_ctx is provided.

Parameters

sockfd	Socket file descriptor
type	Packet type
data	Packet data
len	Data length
crypto_ctx	Crypto context for encryption

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 433 of file packet.c.

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

References asciichat_crc32, ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), compress_data(), COMPRESSION_MIN_SIZE, COMPRESSION_RATIO_THRESHOLD, crypto_encrypt(), crypto_is_ready(), CRYPTO_MAC_SIZE, CRYPTO_NONCE_SIZE, CRYPTO_OK, crypto_result_to_string(), ERROR_CRYPTO, ERROR_MEMORY, ERROR_NETWORK, ERROR_NETWORK_SIZE, GET_OPTION, HOST_TO_NET_U16, HOST_TO_NET_U32, log_debug, log_debug_every, LOG_RATE_FAST, LOG_RATE_SLOW, log_warn_every, packet_header_t::magic, MAX_PACKET_SIZE, PACKET_MAGIC, packet_send(), PACKET_TYPE_ENCRYPTED, SAFE_FREE, SET_ERRNO, and should_compress().

Referenced by av_send_audio_opus_batch(), packet_send_error(), packet_send_remote_log(), send_audio_batch_packet(), tcp_client_send_audio_opus(), and tcp_client_send_packet().

send_ping_packet()

int send_ping_packet

(

socket_t

sockfd

)

#include <packet.h>

Send a ping packet (keepalive)

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_PING packet to keep connection alive. Server/client responds with PACKET_TYPE_PONG.

Note

Ping packets are always sent unencrypted (handshake packets).

Send a ping packet (keepalive)

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Definition at line 783 of file packet.c.

                                      {
  asciichat_error_t result = send_packet(sockfd, PACKET_TYPE_PING, NULL, 0);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, PACKET_TYPE_PING, and send_packet().

send_pong_packet()

int send_pong_packet

(

socket_t

sockfd

)

#include <packet.h>

Send a pong packet (keepalive response)

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_PONG packet in response to PACKET_TYPE_PING. Indicates that connection is alive and responsive.

Note

Pong packets are always sent unencrypted (handshake packets).

Send a pong packet (keepalive response)

Parameters

sockfd

Socket file descriptor

Returns

0 on success, -1 on error

Definition at line 793 of file packet.c.

                                      {
  asciichat_error_t result = send_packet(sockfd, PACKET_TYPE_PONG, NULL, 0);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, PACKET_TYPE_PONG, and send_packet().

send_protocol_version_packet()

int send_protocol_version_packet	(	socket_t	sockfd,
		const protocol_version_packet_t *	version
	)

#include <packet.h>

Send protocol version negotiation packet.

Parameters

sockfd	Socket file descriptor
version	Protocol version packet structure

Returns

0 on success, -1 on error

Sends a PACKET_TYPE_PROTOCOL_VERSION packet for protocol capability negotiation. Both client and server send this during handshake.

Note

Protocol version packets are always sent unencrypted (handshake packets).

Send protocol version negotiation packet.

Parameters

sockfd	Socket file descriptor
version	Protocol version packet

Returns

0 on success, -1 on error

Definition at line 1016 of file packet.c.

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

References ERROR_INVALID_PARAM, PACKET_TYPE_PROTOCOL_VERSION, send_packet(), and SET_ERRNO.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

send_with_timeout()

ssize_t send_with_timeout	(	socket_t	sockfd,
		const void *	data,
		size_t	len,
		int	timeout_seconds
	)

#include <network.h>

Send data with timeout using chunked transmission.

Parameters

sockfd	Socket file descriptor
data	Data to send
len	Length of data in bytes
timeout_seconds	Timeout in seconds

Returns

Number of bytes sent on success, -1 on error

Sends data to socket with timeout support. Uses chunked transmission for large data to prevent blocking and enable progress tracking.

Note

Chunked transmission automatically handles large frames by sending in smaller chunks, preventing timeout issues.

Partial sends are handled automatically - function retries until all data is sent or timeout occurs.

Parameters

sockfd	Socket file descriptor
data	Data to send
len	Length of data
timeout_seconds	Timeout in seconds

Returns

Number of bytes sent, or -1 on error

Definition at line 200 of file network.c.

                                                                                              {
  if (sockfd == INVALID_SOCKET_VALUE) {
    errno = EBADF;
    return -1;
  }
 
  size_t total_sent = 0;
  const char *data_ptr = (const char *)data;
 
  while (total_sent < len) {
    // Calculate chunk size
    size_t bytes_to_send = len - total_sent;
    const size_t MAX_CHUNK_SIZE = 65536; // 64KB chunks for reliable TCP transmission
    if (bytes_to_send > MAX_CHUNK_SIZE) {
      bytes_to_send = MAX_CHUNK_SIZE;
    }
 
    // Set up select for write timeout
    fd_set write_fds;
    struct timeval timeout;
 
    socket_fd_zero(&write_fds);
    socket_fd_set(sockfd, &write_fds);
 
    timeout.tv_sec = network_is_test_environment() ? 1 : timeout_seconds;
    timeout.tv_usec = 0;
 
    int result = socket_select(sockfd, NULL, &write_fds, NULL, &timeout);
    if (result <= 0) {
      if (result == 0) {
        SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "send_with_timeout timed out after %d seconds", timeout_seconds);
        return -1;
      }
      if (network_handle_select_error(result)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    // Check if socket is ready for writing
    if (!socket_fd_isset(sockfd, &write_fds)) {
      SET_ERRNO_SYS(ERROR_NETWORK_TIMEOUT, "send_with_timeout socket not ready for writing after select");
      return -1;
    }
 
    // Use platform-specific send
    ssize_t sent = network_platform_send(sockfd, data_ptr + total_sent, bytes_to_send);
 
    if (sent < 0) {
      int error = errno;
      if (network_handle_send_error(error)) {
        continue; // Retry
      }
      return -1; // Fatal error
    }
 
    if (sent > 0) {
      total_sent += (size_t)sent;
    }
  }
 
  return (ssize_t)total_sent;
}

References EBADF, errno, ERROR_NETWORK_TIMEOUT, INVALID_SOCKET_VALUE, network_is_test_environment, SET_ERRNO_SYS, socket_fd_isset(), socket_fd_set(), socket_fd_zero(), and socket_select().

Referenced by packet_send().

set_socket_keepalive()

asciichat_error_t set_socket_keepalive

(

socket_t

sockfd

)

#include <network.h>

Enable TCP keepalive on socket.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Enables TCP keepalive probes on socket using KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, and KEEPALIVE_COUNT settings.

Note

Keepalive helps detect dead connections (broken network path) without application-level heartbeats.

Enable TCP keepalive on socket.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 461 of file network.c.

                                                        {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
  int result = socket_set_keepalive_params(sockfd, true, KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, KEEPALIVE_COUNT);
  if (result != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket keepalive parameters");
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, INVALID_SOCKET_VALUE, KEEPALIVE_COUNT, KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, SET_ERRNO, SET_ERRNO_SYS, and socket_set_keepalive_params().

set_socket_nonblocking()

asciichat_error_t set_socket_nonblocking

(

socket_t

sockfd

)

#include <network.h>

Set socket to non-blocking mode.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Sets socket to non-blocking mode. I/O operations return immediately with error if data is not available.

Note

Non-blocking sockets require different error handling - EAGAIN/EWOULDBLOCK indicates operation would block.

Useful for asynchronous I/O patterns with select/poll/epoll.

Set socket to non-blocking mode.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 477 of file network.c.

                                                          {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
  int result = socket_set_nonblocking(sockfd, true);
  if (result != 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket non-blocking mode");
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, INVALID_SOCKET_VALUE, SET_ERRNO, SET_ERRNO_SYS, and socket_set_nonblocking().

Referenced by connect_with_timeout().

set_socket_timeout()

asciichat_error_t set_socket_timeout	(	socket_t	sockfd,
		int	timeout_seconds
	)

#include <network.h>

Set socket timeout for send/receive operations.

Parameters

sockfd	Socket file descriptor
timeout_seconds	Timeout in seconds

Returns

ASCIICHAT_OK on success, error code on failure

Configures socket-level timeout for send and receive operations. This sets SO_SNDTIMEO and SO_RCVTIMEO socket options.

Note

Socket-level timeouts work in addition to application-level timeouts in send_with_timeout() and recv_with_timeout().

Set socket timeout for send/receive operations.

Parameters

sockfd	Socket file descriptor
timeout_seconds	Timeout in seconds

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 436 of file network.c.

                                                                           {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket file descriptor");
  }
 
  struct timeval timeout;
  timeout.tv_sec = timeout_seconds;
  timeout.tv_usec = 0;
 
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket receive timeout");
  }
 
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to set socket send timeout");
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, INVALID_SOCKET_VALUE, SET_ERRNO, SET_ERRNO_SYS, and socket_setsockopt().

socket_configure_buffers()

asciichat_error_t socket_configure_buffers

(

socket_t

sockfd

)

#include <network.h>

Configure socket buffers and TCP_NODELAY for optimal performance.

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, or ERROR_NETWORK if all options fail

Configures socket with large send/receive buffers (1MB each) and enables TCP_NODELAY for low-latency real-time video streaming.

CONFIGURATION:

• Send buffer: 1MB (SO_SNDBUF)
• Receive buffer: 1MB (SO_RCVBUF)
• TCP_NODELAY: enabled (disables Nagle's algorithm)

BEHAVIOR: Attempts to set all three socket options independently. Individual failures are logged as warnings but do not prevent attempting other options. This ensures TCP_NODELAY is always set even if buffer size configuration fails (common on systems with strict limits). Only returns error if ALL options fail.

Note

Large buffers prevent packet loss during frame bursts

TCP_NODELAY ensures frames are sent immediately without buffering

Call this immediately after socket creation/connection

Parameters

sockfd

Socket file descriptor

Returns

ASCIICHAT_OK on success, ERROR_NETWORK_CONFIG on failure

Definition at line 493 of file network.c.

                                                            {
  if (sockfd == INVALID_SOCKET_VALUE) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Invalid socket file descriptor");
  }
 
  int failed_options = 0;
 
  // Attempt to configure 1MB send buffer for optimal frame transmission
  int send_buffer_size = 1024 * 1024;
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &send_buffer_size, sizeof(send_buffer_size)) < 0) {
    log_warn("Failed to set send buffer size to 1MB: %s", network_error_string());
    failed_options++;
  }
 
  // Attempt to configure 1MB receive buffer for optimal frame reception
  int recv_buffer_size = 1024 * 1024;
  if (socket_setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recv_buffer_size, sizeof(recv_buffer_size)) < 0) {
    log_warn("Failed to set receive buffer size to 1MB: %s", network_error_string());
    failed_options++;
  }
 
  // Attempt to enable TCP_NODELAY to disable Nagle's algorithm for low-latency transmission
  // CRITICAL: This must be set even if buffer configuration fails, as it's essential for real-time video
  int tcp_nodelay = 1;
  if (socket_setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay, sizeof(tcp_nodelay)) < 0) {
    log_warn("Failed to set TCP_NODELAY: %s", network_error_string());
    failed_options++;
  }
 
  // Return error only if ALL options failed
  if (failed_options >= 3) {
    return SET_ERRNO_SYS(ERROR_NETWORK, "Failed to configure all socket options");
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_NETWORK, INVALID_SOCKET_VALUE, log_warn, network_error_string(), SET_ERRNO_SYS, and socket_setsockopt().

Referenced by server_connection_establish(), and tcp_client_connect().

Variable Documentation

active_client_count

uint32_t server_state_packet_t::active_client_count

Number of clients actively sending video/audio streams.

Definition at line 602 of file packet.h.

Referenced by broadcast_server_state_to_all_clients(), and send_server_state_to_client().

allocated_buffer

void* packet_envelope_t::allocated_buffer

Buffer that needs to be freed by caller (may be NULL if not allocated)

Definition at line 990 of file packet.h.

Referenced by acip_client_receive_and_dispatch(), acip_server_receive_and_dispatch(), and receive_packet_secure().

allocated_size

size_t packet_envelope_t::allocated_size

Size of allocated buffer in bytes.

Definition at line 992 of file packet.h.

Referenced by acip_client_receive_and_dispatch(), acip_server_receive_and_dispatch(), and receive_packet_secure().

auth_public_key_size

uint16_t crypto_parameters_packet_t::auth_public_key_size

Authentication public key size in bytes (e.g., 32 for Ed25519, 1952 for Dilithium3)

Definition at line 885 of file packet.h.

Referenced by client_crypto_handshake(), crypto_handshake_set_parameters(), send_crypto_parameters_packet(), and server_crypto_handshake().

batch_count

uint32_t audio_batch_packet_t::batch_count

Number of audio chunks in this batch (usually AUDIO_BATCH_COUNT = 32)

Definition at line 798 of file packet.h.

Referenced by acip_send_audio_batch(), audio_parse_batch_header(), and send_audio_batch_packet().

capabilities [1/2]

uint32_t client_info_packet_t::capabilities

Client capabilities bitmask (CLIENT_CAP_VIDEO | CLIENT_CAP_AUDIO | CLIENT_CAP_COLOR | CLIENT_CAP_STRETCH)

Definition at line 552 of file packet.h.

Referenced by handle_client_join_packet(), tcp_client_send_join(), and threaded_send_client_join_packet().

capabilities [2/2]

uint32_t terminal_capabilities_packet_t::capabilities

Terminal capabilities bitmask (TERM_CAP_* flags)

Definition at line 911 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

channels

uint32_t audio_batch_packet_t::channels

Number of audio channels (1=mono, 2=stereo)

Definition at line 804 of file packet.h.

Referenced by acip_send_audio_batch(), audio_parse_batch_header(), and send_audio_batch_packet().

checksum [1/2]

uint32_t ascii_frame_packet_t::checksum

CRC32 checksum of original ASCII data.

Definition at line 750 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

checksum [2/2]

uint32_t image_frame_packet_t::checksum

CRC32 checksum of pixel data.

Definition at line 778 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

client_count

uint32_t client_list_packet_t::client_count

Number of clients in the list (0 to MAX_CLIENTS)

Definition at line 584 of file packet.h.

client_id [1/3]

uint32_t packet_header_t::client_id

Client ID (0 = server, >0 = client identifier)

Definition at line 500 of file packet.h.

Referenced by packet_queue_enqueue(), packet_send_via_transport(), and process_encrypted_packet().

client_id [2/3]

uint32_t client_info_packet_t::client_id

Unique client identifier (1-9, 0 = server)

Definition at line 547 of file packet.h.

Referenced by tcp_client_send_join(), and threaded_send_client_join_packet().

client_id [3/3]

uint32_t stream_header_t::client_id

Client ID that this stream originates from (1-9)

Definition at line 566 of file packet.h.

clients

client_info_packet_t client_list_packet_t::clients[MAX_CLIENTS]

Array of client information structures.

Definition at line 586 of file packet.h.

color_count

uint32_t terminal_capabilities_packet_t::color_count

Actual color count (16, 256, or 16777216)

Definition at line 915 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

color_level

uint32_t terminal_capabilities_packet_t::color_level

Color level enum value (terminal_color_mode_t)

Definition at line 913 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

colorterm

char terminal_capabilities_packet_t::colorterm[32]

$COLORTERM environment variable value (for debugging)

Definition at line 925 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

compressed_size [1/2]

uint32_t ascii_frame_packet_t::compressed_size

Size of compressed data (0 = not compressed)

Definition at line 748 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

compressed_size [2/2]

uint32_t image_frame_packet_t::compressed_size

Compressed data size (0 = not compressed, >0 = compressed)

Definition at line 776 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

compression_algorithms

uint8_t protocol_version_packet_t::compression_algorithms

Supported compression algorithms bitmask (COMPRESS_ALGO_*)

Definition at line 718 of file packet.h.

Referenced by client_crypto_handshake(), handle_protocol_version_packet(), and server_crypto_handshake().

compression_threshold

uint8_t protocol_version_packet_t::compression_threshold

Compression threshold percentage (0-100, e.g., 80 = compress if >80% size reduction)

Definition at line 720 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

connected_client_count

uint32_t server_state_packet_t::connected_client_count

Total number of currently connected clients.

Definition at line 600 of file packet.h.

Referenced by broadcast_server_state_to_all_clients(), and send_server_state_to_client().

crc32

uint32_t packet_header_t::crc32

CRC32 checksum of payload data (0 if length == 0)

Definition at line 498 of file packet.h.

Referenced by packet_queue_enqueue(), packet_queue_try_dequeue(), packet_queue_validate_packet(), packet_send_via_transport(), packet_validate_header(), and receive_packet_secure().

data

void* packet_envelope_t::data

Packet payload data (decrypted and decompressed if applicable)

Definition at line 984 of file packet.h.

Referenced by acip_client_receive_and_dispatch(), acip_server_receive_and_dispatch(), and receive_packet_secure().

desired_fps

uint8_t terminal_capabilities_packet_t::desired_fps

Client's desired frame rate (1-144 FPS)

Definition at line 935 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

detection_reliable

uint8_t terminal_capabilities_packet_t::detection_reliable

Detection reliability flag (1=reliable detection, 0=best guess)

Definition at line 927 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

direction

uint8_t remote_log_packet_t::direction

Direction hint so receivers can annotate origin.

Definition at line 637 of file packet.h.

Referenced by acip_send_remote_log(), packet_parse_remote_log(), and packet_send_remote_log().

display_name

char client_info_packet_t::display_name[MAX_DISPLAY_NAME_LEN]

User display name (null-terminated, max MAX_DISPLAY_NAME_LEN bytes)

Definition at line 549 of file packet.h.

Referenced by handle_client_join_packet(), tcp_client_send_join(), and threaded_send_client_join_packet().

error_code

uint32_t error_packet_t::error_code

Error code from asciichat_error_t enumeration.

Definition at line 621 of file packet.h.

Referenced by acip_send_error(), packet_parse_error_message(), and packet_send_error().

feature_flags

uint16_t protocol_version_packet_t::feature_flags

Feature flags bitmask (FEATURE_RLE_ENCODING, etc.)

Definition at line 722 of file packet.h.

Referenced by client_crypto_handshake(), handle_protocol_version_packet(), and server_crypto_handshake().

flags [1/2]

uint16_t remote_log_packet_t::flags

Additional flags (REMOTE_LOG_FLAG_*)

Definition at line 639 of file packet.h.

Referenced by acip_send_remote_log(), packet_parse_remote_log(), and packet_send_remote_log().

flags [2/2]

uint32_t ascii_frame_packet_t::flags

Frame flags bitmask (HAS_COLOR, IS_COMPRESSED, etc.)

Definition at line 752 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

height [1/4]

uint32_t size_packet_t::height

Terminal height in characters.

Definition at line 533 of file packet.h.

Referenced by handle_size_packet().

height [2/4]

uint32_t ascii_frame_packet_t::height

Terminal height in characters.

Definition at line 744 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

height [3/4]

uint32_t image_frame_packet_t::height

Image height in pixels.

Definition at line 772 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

height [4/4]

uint16_t terminal_capabilities_packet_t::height

Terminal height in characters.

Definition at line 921 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

hmac_size

uint8_t crypto_parameters_packet_t::hmac_size

HMAC size in bytes (e.g., 32 for HMAC-SHA256)

Definition at line 895 of file packet.h.

Referenced by crypto_handshake_set_parameters(), and server_crypto_handshake().

kex_public_key_size

uint16_t crypto_parameters_packet_t::kex_public_key_size

Key exchange public key size in bytes (e.g., 32 for X25519, 1568 for Kyber1024)

Definition at line 883 of file packet.h.

Referenced by client_crypto_handshake(), crypto_handshake_set_parameters(), send_crypto_parameters_packet(), and server_crypto_handshake().

len

size_t packet_envelope_t::len

Length of payload data in bytes.

Definition at line 986 of file packet.h.

Referenced by acip_client_receive_and_dispatch(), acip_server_receive_and_dispatch(), and receive_packet_secure().

length

uint32_t packet_header_t::length

Payload data length in bytes (0 for header-only packets)

Definition at line 496 of file packet.h.

Referenced by packet_queue_enqueue(), packet_queue_validate_packet(), packet_send_via_transport(), packet_validate_header(), and receive_packet_secure().

log_level

uint8_t remote_log_packet_t::log_level

Log level associated with the message (log_level_t cast to uint8_t)

Definition at line 635 of file packet.h.

Referenced by acip_send_remote_log(), packet_parse_remote_log(), and packet_send_remote_log().

mac_size

uint8_t crypto_parameters_packet_t::mac_size

MAC size in bytes (e.g., 16 for Poly1305)

Definition at line 893 of file packet.h.

Referenced by crypto_handshake_set_parameters(), and server_crypto_handshake().

magic

uint32_t packet_header_t::magic

Magic number (PACKET_MAGIC) for packet validation.

Definition at line 492 of file packet.h.

Referenced by packet_queue_enqueue(), packet_queue_free_packet(), packet_queue_try_dequeue(), packet_queue_validate_packet(), packet_send(), packet_send_via_transport(), packet_validate_header(), receive_packet_secure(), and send_packet_secure().

message_length [1/2]

uint32_t error_packet_t::message_length

Length of message payload in bytes (0-512)

Definition at line 623 of file packet.h.

Referenced by acip_send_error(), packet_parse_error_message(), and packet_send_error().

message_length [2/2]

uint32_t remote_log_packet_t::message_length

Message payload length in bytes (0-512)

Definition at line 641 of file packet.h.

Referenced by acip_send_remote_log(), packet_parse_remote_log(), and packet_send_remote_log().

nonce_size

uint8_t crypto_parameters_packet_t::nonce_size

Nonce size in bytes (e.g., 24 for XSalsa20)

Definition at line 891 of file packet.h.

Referenced by crypto_handshake_set_parameters(), and server_crypto_handshake().

original_size

uint32_t ascii_frame_packet_t::original_size

Size of original uncompressed ASCII data in bytes.

Definition at line 746 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

palette_custom

char terminal_capabilities_packet_t::palette_custom[64]

Custom palette characters (if palette_type == PALETTE_CUSTOM)

Definition at line 933 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

palette_type

uint32_t terminal_capabilities_packet_t::palette_type

Palette type enum value (palette_type_t)

Definition at line 931 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

pixel_format

uint32_t image_frame_packet_t::pixel_format

Pixel format enum (0=RGB24, 1=RGBA32, 2=BGR24, etc.)

Definition at line 774 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

preferred_auth

uint8_t crypto_capabilities_packet_t::preferred_auth

Preferred authentication algorithm (AUTH_ALGO_*)

Definition at line 856 of file packet.h.

Referenced by client_crypto_handshake().

preferred_cipher

uint8_t crypto_capabilities_packet_t::preferred_cipher

Preferred cipher algorithm (CIPHER_ALGO_*)

Definition at line 858 of file packet.h.

Referenced by client_crypto_handshake().

preferred_kex

uint8_t crypto_capabilities_packet_t::preferred_kex

Preferred key exchange algorithm (KEX_ALGO_*)

Definition at line 854 of file packet.h.

Referenced by client_crypto_handshake().

protocol_revision

uint16_t protocol_version_packet_t::protocol_revision

Minor protocol revision (server can be newer)

Definition at line 714 of file packet.h.

Referenced by client_crypto_handshake(), handle_protocol_version_packet(), and server_crypto_handshake().

protocol_version

uint16_t protocol_version_packet_t::protocol_version

Major protocol version (must match for compatibility)

Definition at line 712 of file packet.h.

Referenced by client_crypto_handshake(), handle_protocol_version_packet(), and server_crypto_handshake().

reason_flags

uint8_t auth_failure_packet_t::reason_flags

Bitmask of auth_failure_reason_t values indicating failure causes.

Definition at line 676 of file packet.h.

Referenced by crypto_handshake_client_complete(), crypto_handshake_server_auth_challenge(), and crypto_handshake_server_complete().

render_mode

uint32_t terminal_capabilities_packet_t::render_mode

Render mode enum value (foreground/background/half-block)

Definition at line 917 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

requires_verification

uint8_t crypto_capabilities_packet_t::requires_verification

Server verification requirement flag (1=required, 0=optional)

Definition at line 852 of file packet.h.

Referenced by client_crypto_handshake().

reserved [1/5]

uint8_t terminal_capabilities_packet_t::reserved[2]

Reserved bytes for alignment (must be zero)

Definition at line 937 of file packet.h.

Referenced by tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

reserved [2/5]

uint8_t crypto_parameters_packet_t::reserved[3]

Reserved bytes for future use (must be zero)

Definition at line 897 of file packet.h.

reserved [3/5]

uint32_t server_state_packet_t::reserved[6]

Reserved fields for future use (must be zero)

Definition at line 604 of file packet.h.

Referenced by broadcast_server_state_to_all_clients(), and send_server_state_to_client().

reserved [4/5]

uint8_t auth_failure_packet_t::reserved[7]

Reserved bytes for future use (must be zero)

Definition at line 678 of file packet.h.

reserved [5/5]

uint8_t protocol_version_packet_t::reserved[7]

Reserved bytes for future expansion (must be zero)

Definition at line 724 of file packet.h.

Referenced by handle_protocol_version_packet().

sample_rate

uint32_t audio_batch_packet_t::sample_rate

Sample rate in Hz (e.g., 44100, 48000)

Definition at line 802 of file packet.h.

Referenced by acip_send_audio_batch(), audio_parse_batch_header(), and send_audio_batch_packet().

selected_auth

uint8_t crypto_parameters_packet_t::selected_auth

Selected authentication algorithm (AUTH_ALGO_*)

Definition at line 877 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

selected_cipher

uint8_t crypto_parameters_packet_t::selected_cipher

Selected cipher algorithm (CIPHER_ALGO_*)

Definition at line 879 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

selected_kex

uint8_t crypto_parameters_packet_t::selected_kex

Selected key exchange algorithm (KEX_ALGO_*)

Definition at line 875 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

shared_secret_size

uint16_t crypto_parameters_packet_t::shared_secret_size

Shared secret size in bytes (e.g., 32 for X25519)

Definition at line 889 of file packet.h.

Referenced by client_crypto_handshake(), crypto_handshake_set_parameters(), send_crypto_parameters_packet(), and server_crypto_handshake().

signature_size

uint16_t crypto_parameters_packet_t::signature_size

Signature size in bytes (e.g., 64 for Ed25519, 3309 for Dilithium3)

Definition at line 887 of file packet.h.

Referenced by client_crypto_handshake(), crypto_handshake_set_parameters(), send_crypto_parameters_packet(), and server_crypto_handshake().

stream_type

uint32_t stream_header_t::stream_type

Stream type bitmask (STREAM_TYPE_VIDEO | STREAM_TYPE_AUDIO)

Definition at line 568 of file packet.h.

supported_auth_algorithms

uint16_t crypto_capabilities_packet_t::supported_auth_algorithms

Supported authentication algorithms bitmask (AUTH_ALGO_*)

Definition at line 848 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

supported_cipher_algorithms

uint16_t crypto_capabilities_packet_t::supported_cipher_algorithms

Supported cipher algorithms bitmask (CIPHER_ALGO_*)

Definition at line 850 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

supported_kex_algorithms

uint16_t crypto_capabilities_packet_t::supported_kex_algorithms

Supported key exchange algorithms bitmask (KEX_ALGO_*)

Definition at line 846 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

supports_encryption

uint8_t protocol_version_packet_t::supports_encryption

Encryption support flag (1=support encryption, 0=plaintext only)

Definition at line 716 of file packet.h.

Referenced by client_crypto_handshake(), handle_protocol_version_packet(), and server_crypto_handshake().

term_type

char terminal_capabilities_packet_t::term_type[32]

$TERM environment variable value (for debugging)

Definition at line 923 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

timestamp [1/2]

uint32_t stream_header_t::timestamp

Timestamp when frame/audio was captured (milliseconds since epoch)

Definition at line 570 of file packet.h.

timestamp [2/2]

uint32_t image_frame_packet_t::timestamp

Timestamp when frame was captured (milliseconds since epoch)

Definition at line 780 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

total_samples

uint32_t audio_batch_packet_t::total_samples

Total audio samples across all chunks (typically 8192)

Definition at line 800 of file packet.h.

Referenced by acip_send_audio_batch(), audio_parse_batch_header(), and send_audio_batch_packet().

type [1/2]

uint16_t packet_header_t::type

Packet type (packet_type_t enumeration)

Definition at line 494 of file packet.h.

Referenced by packet_queue_enqueue(), packet_queue_try_dequeue(), packet_queue_validate_packet(), packet_send_via_transport(), packet_validate_header(), process_encrypted_packet(), and receive_packet_secure().

type [2/2]

packet_type_t packet_envelope_t::type

Packet type (from packet_types.h)

Definition at line 982 of file packet.h.

Referenced by acip_client_receive_and_dispatch(), acip_server_receive_and_dispatch(), and receive_packet_secure().

utf8_support

uint32_t terminal_capabilities_packet_t::utf8_support

UTF-8 support flag (0=no UTF-8, 1=UTF-8 supported)

Definition at line 929 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().

verification_enabled

uint8_t crypto_parameters_packet_t::verification_enabled

Server verification enabled flag (1=enabled, 0=disabled)

Definition at line 881 of file packet.h.

Referenced by client_crypto_handshake(), and server_crypto_handshake().

was_encrypted

bool packet_envelope_t::was_encrypted

True if packet was encrypted (decrypted before envelope creation)

Definition at line 988 of file packet.h.

width [1/4]

uint32_t size_packet_t::width

Terminal width in characters.

Definition at line 531 of file packet.h.

Referenced by handle_size_packet().

width [2/4]

uint32_t ascii_frame_packet_t::width

Terminal width in characters.

Definition at line 742 of file packet.h.

Referenced by acip_send_ascii_frame(), and send_ascii_frame_packet().

width [3/4]

uint32_t image_frame_packet_t::width

Image width in pixels.

Definition at line 770 of file packet.h.

Referenced by acip_send_image_frame(), and send_image_frame_packet().

width [4/4]

uint16_t terminal_capabilities_packet_t::width

Terminal width in characters.

Definition at line 919 of file packet.h.

Referenced by handle_client_capabilities_packet(), tcp_client_send_terminal_capabilities(), and threaded_send_terminal_size_with_auto_detect().