ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
src/client/server.c
Go to the documentation of this file.
2#include <ascii-chat/otel.h>
61
63
64#include "server.h"
65#include "session/protocol.h"
66#include "main.h"
67#include "../main.h" // Global exit API
68#include "crypto.h"
72
73#include <libplatform/compiler.h>
74#include <libplatform/system.h>
75#include <libplatform/terminal.h>
76#include <libplatform/terminal.h>
77#include <libplatform/system.h>
86#include <ascii-chat/util/ip.h>
88#include <ascii-chat/util/url.h> // For WebSocket URL detection
89#include <ascii-chat/common.h>
90#include "display.h"
91#include <options/options.h>
92#include <options/rcu.h> // For RCU-based options access
95#include <ascii-chat/buffer.h>
96
97#include <string.h>
98#include <stdarg.h>
99#include <time.h>
100#include <sys/types.h>
101#include <libplatform/atomic.h>
103#include <ascii-chat/debug/named.h> // For NAMED_REGISTER_ATOMIC macro
104
105#include <ascii-chat/network/platform.h> // Consolidates platform-specific network headers (includes TCP options)
106
107// Debug flags
108#define DEBUG_NETWORK 1
109#define DEBUG_THREADS 1
110#define DEBUG_MEMORY 1
111
112/* ============================================================================
113 * Connection State Management
114 * ============================================================================ */
115
125
126// Publish a remote rejection from the receive worker to the reconnect owner.
133
134/* ============================================================================
135 * Crypto State
136 * ============================================================================ */
137
138/* ============================================================================
139 * Reconnection Logic
140 * ============================================================================ */
141
143#define MAX_RECONNECT_DELAY (5 * 1000 * 1000)
144
145/* ============================================================================
146 * Public Interface Functions
147 * ============================================================================ */
148
160 ASCII_OTEL_SCOPE(SERVER_CONNECTION_INIT);
161 // Initialize mutex for thread-safe packet sending
162 if (mutex_init(&connection->send_mutex, "send") != 0) {
163 log_error("Failed to initialize send mutex");
164 return -1;
165 }
166
167 connection->send_mutex_initialized = true;
168
169 // Initialize connection state
170 atomic_ptr_store(&connection->transport, NULL);
171 atomic_store_bool(&connection->connection_active, false);
172 atomic_store_bool(&connection->connection_lost, false);
173 connection->my_client_id = 0;
174
175 return 0;
176}
177
196 if (!connection)
197 return false;
198 return atomic_load_bool(&connection->connection_active) && atomic_ptr_load(&connection->transport) != NULL;
199}
200
211
213 atomic_ptr_store(&connection->transport, transport);
214 atomic_store_bool(&connection->connection_active, transport != NULL);
215 if (transport)
216 atomic_store_bool(&connection->connection_lost, false);
217}
218
229
241 return connection->server_ip;
242}
243
253void server_connection_set_ip(client_connection_t *connection, const char *ip) {
254 if (ip) {
255 SAFE_STRNCPY(connection->server_ip, ip, sizeof(connection->server_ip));
256 log_debug("Server IP set to: %s", connection->server_ip);
257 } else {
258 connection->server_ip[0] = '\0';
259 log_debug("Server IP cleared");
260 }
261}
262
273 connection->server_port = port;
274 log_debug("Server port set to: %d", connection->server_port);
275}
276
287 return connection->server_port;
288}
289
290/* Called by the owner and its workers, never by a signal handler. The
291 * transport remains allocated until the controlling thread joins all users. */
293 ASCII_OTEL_SCOPE(SERVER_CONNECTION_SHUTDOWN);
294 if (!connection)
295 return;
296 atomic_store_bool(&connection->connection_active, false);
297 atomic_store_bool(&connection->connection_lost, true);
299}
300
310 uint64_t sent = atomic_load_u64(&connection->telemetry_ping_ns);
311 if (sent && sent != UINT64_MAX && atomic_cas_u64(&connection->telemetry_ping_ns, &sent, 0)) {
312 uint64_t now = time_get_ns();
313 stats_duration_record(stats_runtime_scope(), STATS_DURATION_RTT, now >= sent ? now - sent : 0);
314 }
315}
317 ASCII_OTEL_SCOPE(CONNECTION_LOST);
318 if (!atomic_exchange_bool(&connection->connection_lost, true))
319 ascii_otel_metric(ASCII_OTEL_METRIC_DISCONNECT, 1);
320 atomic_store_bool(&connection->connection_active, false);
321
322 // Don't re-enable terminal logging here - let the splash screen handle it
323 // The reconnection splash will capture and display logs properly
325}
326
335 if (!connection)
336 return true;
337 return atomic_load_bool(&connection->connection_lost);
338}
339
340/* ============================================================================
341 * Thread Safety Interface
342 * ============================================================================ */
343
344/* ============================================================================
345 * Thread-Safe Wrapper Functions
346 * ============================================================================ */
347
361asciichat_error_t threaded_send_packet(client_connection_t *connection, packet_type_t type, const void *data, size_t len) {
362 // Check connection status and get transport reference
363 acip_transport_t *transport = server_connection_get_transport(connection);
364 if (!atomic_load_bool(&connection->connection_active) || !transport) {
365 log_debug("[TRANSPORT_LIFECYCLE] threaded_send_packet() check failed: active=%s, transport=%p", atomic_load_bool(&connection->connection_active) ? "true" : "false",
366 (void *)server_connection_get_transport(connection));
367 return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
368 }
369 log_debug_every(LOG_RATE_SLOW, "[TRANSPORT_LIFECYCLE] threaded_send_packet() using transport=%p, is_connected=%s", (void *)transport, acip_transport_is_connected(transport) ? "true" : "false");
370
371 // The ACIP outbound scheduler serializes transport admission and writes.
372 asciichat_error_t result = packet_send_via_transport(transport, type, data, len, 0);
373
374 // Unlock after send completes
375 // If send failed due to network error, signal connection loss
376 if (result != ASCIICHAT_OK) {
377 log_debug("Packet send failed");
379 server_connection_lost(connection);
380 return result;
381 }
382
383 return ASCIICHAT_OK;
384}
385
400asciichat_error_t threaded_send_audio_batch_packet(client_connection_t *connection, const float *samples, int num_samples, int batch_count) {
401 // Check connection status and get transport reference
402 acip_transport_t *transport = server_connection_get_transport(connection);
403 if (!atomic_load_bool(&connection->connection_active) || !transport) {
404 return SET_ERRNO(ERROR_NETWORK, "Connection not active");
405 }
406
407 // The ACIP outbound scheduler serializes transport admission and writes.
408 asciichat_error_t result = acip_send_audio_batch(transport, samples, (uint32_t)num_samples, (uint32_t)batch_count);
409
410 // If send failed due to network error, signal connection loss
411 if (result != ASCIICHAT_OK) {
413 server_connection_lost(connection);
414 return result;
415 }
416
417 return ASCIICHAT_OK;
418}
419
434asciichat_error_t threaded_send_audio_opus(client_connection_t *connection, const uint8_t *opus_data, size_t opus_size, int sample_rate, int frame_duration) {
435 // Check connection status and get transport reference
436 acip_transport_t *transport = server_connection_get_transport(connection);
437 if (!atomic_load_bool(&connection->connection_active) || !transport) {
438 return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
439 }
440
441 // The protocol carries Opus through batches, including a one-frame batch.
442 // Reuse its serializer so the count and frame-size table are always present.
443 if (opus_size > UINT16_MAX)
444 return SET_ERRNO(ERROR_INVALID_PARAM, "Opus frame exceeds its wire size field");
445 uint16_t frame_size = (uint16_t)opus_size;
446 asciichat_error_t result = acip_send_audio_opus_batch(transport, opus_data, opus_size, &frame_size, 1, sample_rate, frame_duration);
447
448 // If send failed due to network error, signal connection loss
449 if (result != ASCIICHAT_OK) {
451 server_connection_lost(connection);
452 return result;
453 }
454
455 return ASCIICHAT_OK;
456}
457
472asciichat_error_t threaded_send_audio_opus_batch(client_connection_t *connection, const uint8_t *opus_data, size_t opus_size, const uint16_t *frame_sizes, int frame_count) {
473 // Check connection status and get transport reference
474 acip_transport_t *transport = server_connection_get_transport(connection);
475 if (!atomic_load_bool(&connection->connection_active) || !transport) {
476 return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
477 }
478
479 // Network I/O happens while holding mutex to prevent concurrent socket writes
480 // Opus uses 20ms frames at 48kHz (960 samples = 20ms)
481 asciichat_error_t result = acip_send_audio_opus_batch(transport, opus_data, opus_size, frame_sizes, frame_count, 48000, 20);
482
483 // If send failed due to network error, signal connection loss
484 if (result != ASCIICHAT_OK) {
486 server_connection_lost(connection);
487 return result;
488 }
489
490 return ASCIICHAT_OK;
491}
492
508 if (!pixel_data) {
509 return SET_ERRNO(ERROR_INVALID_PARAM, "Pixel data is NULL");
510 }
511
512 // Get transport reference - may be NULL if connection was lost
513 acip_transport_t *transport = server_connection_get_transport(connection);
514 if (!transport || !server_connection_is_active(connection)) {
515 return SET_ERRNO(ERROR_NETWORK, "Transport unavailable");
516 }
517
518 // Submit through the connection-owned outbound scheduler.
519 asciichat_error_t result = acip_send_image_frame(transport, pixel_data, width, height, pixel_format);
520
521 // Unlock after send completes
522 // If send failed due to network error, signal connection loss
523 if (result != ASCIICHAT_OK) {
525 server_connection_lost(connection);
526 return result;
527 }
528
529 return ASCIICHAT_OK;
530}
531
546asciichat_error_t threaded_send_image_frame_encoded(client_connection_t *connection, const void *pixel_data, uint32_t width, uint32_t height, video_codec_t codec, bool *encoding_failed) {
547 if (!encoding_failed)
548 return SET_ERRNO(ERROR_INVALID_PARAM, "Missing video encoding status output");
549 *encoding_failed = false;
550 if (!pixel_data || width > UINT16_MAX || height > UINT16_MAX) {
551 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid video frame");
552 }
553 // The capture thread creates the selected encoder only when a frame is ready.
554 if (!connection->video_encoder) {
556 if (!connection->video_encoder) {
557 *encoding_failed = true;
558 return GET_ERRNO();
559 }
560 }
561 h265_encoder_t *encoder = connection->video_encoder;
562#ifndef __EMSCRIPTEN__
563 acip_transport_t *encoder_transport = server_connection_get_transport(connection);
566#endif
567 size_t output_buffer_size = 5 + ((size_t)width * height * 3) + 65536;
568 if (buffer_workspace_reserve(&connection->encoded_video_workspace, NULL, output_buffer_size) != ASCIICHAT_OK)
569 return SET_ERRNO(ERROR_MEMORY, "Failed to allocate video output buffer: %zu bytes", output_buffer_size);
570 uint8_t *output_buffer = connection->encoded_video_workspace.data;
571
572 // h265_encode already writes the five-byte ACIP envelope for either codec.
573 size_t total_size = output_buffer_size;
574 asciichat_error_t encode_result = h265_encode(encoder, (uint16_t)width, (uint16_t)height, (const uint8_t *)pixel_data, output_buffer, &total_size);
575 if (encode_result != ASCIICHAT_OK || total_size == 0) {
576 *encoding_failed = encode_result != ASCIICHAT_OK;
577 return encode_result;
578 }
579
580 // NOW acquire the send mutex just for the actual network transmission
581 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_3] About to acquire g_send_mutex for network send");
582 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_4] ✅ Acquired g_send_mutex, checking transport");
583
584 // Get transport reference - may be NULL if connection was lost
585 acip_transport_t *transport = server_connection_get_transport(connection);
586 if (!transport || !server_connection_is_active(connection)) {
587 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_5] Transport unavailable, releasing mutex");
588 return SET_ERRNO(ERROR_NETWORK, "Transport unavailable");
589 }
590
591 // Submit through the connection-owned outbound scheduler.
592 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_6] Sending packet via transport (%zu bytes)", total_size);
594 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_7] packet_send_via_transport returned: %d", result);
595
596 // Unlock after send completes
597 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_8] ✅ Released g_send_mutex");
598
599 log_debug_every(US_PER_SEC_INT, "[H265_SEND_FRAME_9] Retained video output workspace");
600
601 // If send failed due to network error, signal connection loss
602 if (result != ASCIICHAT_OK) {
604 server_connection_lost(connection);
605 return result;
606 }
607
608 return ASCIICHAT_OK;
609}
610
619 // Use threaded_send_packet which handles encryption, mutex locking, and connection state
620 // Without a probe ID, overlapping pings make subsequent pongs ambiguous.
621 // Keep sending normally, but suppress RTT samples for this connection.
622 client_connection_mark_ping_sent(connection, time_get_ns());
623 asciichat_error_t result = threaded_send_packet(connection, PACKET_TYPE_PING, NULL, 0);
624 if (result != ASCIICHAT_OK)
625 atomic_store_u64(&connection->telemetry_ping_ns, UINT64_MAX);
626 return result;
627}
628
637 // Use threaded_send_packet which handles encryption, mutex locking, and connection state
638 return threaded_send_packet(connection, PACKET_TYPE_PONG, NULL, 0);
639}
640
650 // Connection and transport availability is checked by threaded_send_packet()
651
652 // Build STREAM_START packet locally
653 uint32_t type_data = HOST_TO_NET_U32(stream_type);
654
655 // Use threaded_send_packet() which handles encryption
656 return threaded_send_packet(connection, PACKET_TYPE_STREAM_START, &type_data, sizeof(type_data));
657}
658
675 asciichat_error_t result = threaded_send_packet(connection, PACKET_TYPE_CLIENT_CAPABILITIES, &packet, sizeof(packet));
676 if (result == ASCIICHAT_OK)
677 connection->advertised_dimensions = (terminal_size_t){.cols = width, .rows = height};
678 return result;
679}
680
692asciichat_error_t threaded_send_client_join_packet(client_connection_t *connection, const char *display_name, uint32_t capabilities) {
693 // Connection and transport availability is checked by threaded_send_packet()
694
695 // Build CLIENT_JOIN packet locally
696 client_info_packet_t join_packet;
697 SAFE_MEMSET(&join_packet, sizeof(join_packet), 0, sizeof(join_packet));
698 join_packet.client_id = HOST_TO_NET_U32(0); // Will be assigned by server
699 SAFE_SNPRINTF(join_packet.display_name, MAX_DISPLAY_NAME_LEN, "%s", display_name ? display_name : "Unknown");
700 join_packet.capabilities = HOST_TO_NET_U32(capabilities);
701
702 // Use threaded_send_packet() which handles encryption
703 int send_result = threaded_send_packet(connection, PACKET_TYPE_CLIENT_JOIN, &join_packet, sizeof(join_packet));
704 if (send_result == 0) {
705 bool active = atomic_load_u64(&connection->connection_active);
706 acip_transport_t *transport = server_connection_get_transport(connection);
707 if (active && transport) {
708 log_net_message(transport, LOG_INFO, REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER, __FILE__, __LINE__, __func__, "CLIENT_JOIN sent (display=\"%s\", capabilities=0x%x)", join_packet.display_name,
709 capabilities);
710 }
711 }
712 return send_result;
713}
#define SET_ERRNO(code,...)
#define GET_ERRNO()
bool atomic_cas_u64(atomic_t *a, uint64_t *expected, uint64_t new_value)
Atomically compare-and-swap a uint64_t.
void atomic_store_bool(atomic_t *a, bool value)
Atomically store a boolean value.
void atomic_ptr_store(atomic_ptr_t *a, void *value)
Atomically store a pointer.
bool atomic_load_bool(atomic_t *a)
Atomic pointer wrapper.
void * atomic_ptr_load(atomic_ptr_t *a)
Atomically load a pointer.
void atomic_store_u64(atomic_t *a, uint64_t value)
Atomically store a uint64_t value.
void atomic_store_int(atomic_t *a, int value)
Atomically store an int value.
uint64_t atomic_load_u64(atomic_t *a)
Atomically load a uint64_t value.
bool atomic_exchange_bool(atomic_t *a, bool new_value)
Atomically exchange a boolean and return the old value.
int atomic_load_int(atomic_t *a)
Atomically load an int value.
bool acip_outbound_needs_keyframe(acip_transport_t *transport, uint16_t type, uint32_t id)
asciichat_error_t buffer_workspace_reserve(buffer_workspace_t *workspace, buffer_domain_t *domain, size_t capacity)
Definition buffer.c:353
ascii-chat Client Mode Entry Point Header
Video and audio codec definitions and capability bitmasks.
video_codec_t
Definition codecs.h:28
@ VIDEO_CODEC_H264
H.264 (AVC) video codec.
Definition codecs.h:32
void session_protocol_build_capabilities(unsigned short width, unsigned short height, terminal_capabilities_packet_t *packet)
Shared endpoint normalization for TCP and WebSocket connections.
Named object registry for debugging — log identifiable resource names.
asciichat_error_t h265_encode(h265_encoder_t *encoder, uint16_t width, uint16_t height, const uint8_t *ascii_data, uint8_t *output_buf, size_t *output_size)
Definition encoder.c:316
void h265_encoder_request_keyframe(h265_encoder_t *encoder)
Definition encoder.c:436
struct h265_encoder h265_encoder_t
h265 encoder is intentionally a small, concrete record. Fields such as codec_ctx, codec,...
h265_encoder_t * video_encoder_create(video_codec_t codec_type, uint16_t initial_width, uint16_t initial_height)
Definition encoder.c:90
HEVC/H.265 encoder for ASCII art frames using libx265.
🔄 Network byte order conversion helpers
#define HOST_TO_NET_U32(val)
Definition endian.h:70
unsigned int height
Definition fft.c:24
unsigned int width
Definition fft.c:24
void display_full_reset()
Perform full display reset.
unsigned short uint16_t
unsigned int uint32_t
#define SAFE_STRNCPY(dst, src, size)
#define SAFE_MEMSET(dest, dest_size, ch, count)
#define SAFE_SNPRINTF(buffer, buffer_size,...)
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_NETWORK
Definition error_codes.h:76
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define MAX_DISPLAY_NAME_LEN
Maximum display name length in characters.
#define LOG_RATE_SLOW
Log rate limit: 10 seconds (10,000,000 microseconds).
Definition log_rates.h:39
asciichat_error_t log_net_message(struct acip_transport *transport, log_level_t level, remote_log_direction_t direction, const char *file, int line, const char *func, const char *fmt,...)
Log a message to all destinations (network, file, and terminal).
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
@ REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER
Definition network/log.h:20
#define US_PER_SEC_INT
Definition time.h:177
packet_type_t
Network protocol packet type enumeration.
Definition packet.h:315
@ PACKET_TYPE_PONG
Keepalive pong response.
Definition packet.h:423
@ PACKET_TYPE_STREAM_START
Client requests to start sending video/audio.
Definition packet.h:429
@ PACKET_TYPE_IMAGE_FRAME_H265
H.265-encoded frame from client (HEVC/H.265 codec).
Definition packet.h:401
@ PACKET_TYPE_CLIENT_JOIN
Client announces capability to send media.
Definition packet.h:425
@ PACKET_TYPE_CLIENT_CAPABILITIES
Client reports terminal capabilities.
Definition packet.h:419
@ PACKET_TYPE_IMAGE_FRAME_H264
Definition packet.h:403
@ PACKET_TYPE_PING
Keepalive ping packet.
Definition packet.h:421
struct acip_transport acip_transport_t
Forward declaration of ACIP transport.
Definition host.h:508
⚙️ Common definitions, error codes, macros, and types shared throughout the application
Common declarations and data structures for cryptographic handshake.
ACIP client-side protocol API.
Transport abstraction layer for ACIP protocol.
Network error handling utilities.
🌍 IP Address Parsing and Formatting Utilities
asciichat_error_t acip_send_image_frame(acip_transport_t *transport, const void *pixel_data, uint32_t width, uint32_t height, uint32_t pixel_format)
Send image frame to server (client → server).
bool network_error_is_local_rejection(asciichat_error_t code)
void stats_duration_record(stats_scope_t *scope, stats_duration_id_t id, uint64_t elapsed_ns)
#define log_debug_every(interval_us, fmt,...)
Rate-limited DEBUG logging.
Definition log/log.h:743
Global application exit and signal handling API.
🌐 Core network I/O operations with timeout support
⚙️ Unified options parsing system for ascii-chat with builder pattern and lock-free access
void ascii_otel_metric(ascii_otel_metric_t metric, double value)
Definition otel.c:159
#define ASCII_OTEL_SCOPE(id)
Definition otel.h:77
ASCII Palette Management for Video-to-ASCII Conversion.
stats_scope_t * stats_runtime_scope(void)
Definition runtime.c:78
asciichat_error_t acip_send_audio_opus_batch(acip_transport_t *transport, const void *opus_data, size_t opus_len, const uint16_t *frame_sizes, uint32_t frame_count, uint32_t sample_rate, uint32_t frame_duration)
Send batched Opus-encoded audio frames.
Definition send.c:338
asciichat_error_t acip_send_audio_batch(acip_transport_t *transport, const float *samples, uint32_t num_samples, uint32_t batch_count)
Send audio batch packet.
Definition send.c:286
asciichat_error_t packet_send_via_transport(acip_transport_t *transport, packet_type_t type, const void *payload, size_t payload_len, uint32_t client_id)
Definition send.c:183
ACIP shared/bidirectional packet sending functions.
struct client_connection client_connection_t
ascii-chat Client Display Management Interface
void server_connection_set_transport(client_connection_t *connection, acip_transport_t *transport)
Set ACIP transport instance from connection fallback.
asciichat_error_t threaded_send_image_frame_encoded(client_connection_t *connection, const void *pixel_data, uint32_t width, uint32_t height, video_codec_t codec, bool *encoding_failed)
Send H.265-encoded video frame to server (thread-safe).
void server_connection_shutdown(client_connection_t *connection)
Interrupt connection I/O from normal thread context.
asciichat_error_t threaded_send_packet(client_connection_t *connection, packet_type_t type, const void *data, size_t len)
Thread-safe packet transmission.
asciichat_error_t threaded_send_terminal_size_with_auto_detect(client_connection_t *connection, unsigned short width, unsigned short height)
Thread-safe terminal size packet transmission with auto-detection.
asciichat_error_t threaded_send_audio_batch_packet(client_connection_t *connection, const float *samples, int num_samples, int batch_count)
Thread-safe batched audio packet transmission.
asciichat_error_t threaded_send_stream_start_packet(client_connection_t *connection, uint32_t stream_type)
Thread-safe stream start packet transmission.
void server_connection_set_remote_error(client_connection_t *connection, asciichat_error_t code)
Atomic flag indicating if connection is currently active.
uint32_t server_connection_get_client_id(client_connection_t *connection)
Get client ID assigned by server.
int server_connection_get_port(client_connection_t *connection)
Get the server port.
asciichat_error_t threaded_send_client_join_packet(client_connection_t *connection, const char *display_name, uint32_t capabilities)
Thread-safe client join packet transmission.
bool server_connection_is_active(client_connection_t *connection)
Establish connection to ascii-chat server.
const char * server_connection_get_ip(client_connection_t *connection)
Get resolved server IP address.
void server_connection_lost(client_connection_t *connection)
Signal that connection has been lost.
asciichat_error_t threaded_send_audio_opus_batch(client_connection_t *connection, const uint8_t *opus_data, size_t opus_size, const uint16_t *frame_sizes, int frame_count)
Thread-safe Opus audio batch packet transmission.
asciichat_error_t threaded_send_pong_packet(client_connection_t *connection)
Thread-safe pong packet transmission.
asciichat_error_t threaded_send_audio_opus(client_connection_t *connection, const uint8_t *opus_data, size_t opus_size, int sample_rate, int frame_duration)
Thread-safe Opus audio frame transmission.
asciichat_error_t server_connection_get_remote_error(client_connection_t *connection)
bool server_connection_is_lost(client_connection_t *connection)
Check if connection loss has been detected.
void server_connection_pong_received(client_connection_t *connection)
Signal that connection has been lost.
int server_connection_init(client_connection_t *connection)
Initialize the server connection management subsystem.
void server_connection_set_port(client_connection_t *connection, int port)
Set the server port.
void server_connection_set_ip(client_connection_t *connection, const char *ip)
Set the server IP address.
acip_transport_t * server_connection_get_transport(client_connection_t *connection)
Get ACIP transport instance.
asciichat_error_t threaded_send_image_frame(client_connection_t *connection, const void *pixel_data, uint32_t width, uint32_t height, uint32_t pixel_format)
Thread-safe image frame transmission.
asciichat_error_t threaded_send_ping_packet(client_connection_t *connection)
Thread-safe ping packet transmission.
ascii-chat Client Server Connection Management Interface
void session_connection_interrupt_transport(acip_transport_t *transport)
🔤 String Manipulation and Shell Escaping Utilities
char server_ip[HOSTNAME_BUFFER_SIZE]
buffer_workspace_t encoded_video_workspace
h265_encoder_t *volatile video_encoder
terminal_size_t advertised_dimensions
Client information packet structure.
Definition packet.h:703
char display_name[32]
User display name (null-terminated, max MAX_DISPLAY_NAME_LEN bytes).
Definition packet.h:707
uint32_t client_id
Unique client identifier (1-9, 0 = server).
Definition packet.h:705
uint32_t capabilities
Client capabilities bitmask (CLIENT_CAP_VIDEO | CLIENT_CAP_AUDIO | CLIENT_CAP_COLOR | CLIENT_CAP_STRE...
Definition packet.h:710
Terminal capabilities packet structure (Packet Type 5).
Definition packet.h:1093
⏱️ High-precision timing utilities using sokol_time.h and uthash
#define LOG_INFO
Definition types.h:44
🌐 Production-Grade URL Validation and Parsing