lib/network/client.h

Go to the documentation of this file.

 
#pragma once
 
// C11 stdatomic.h conflicts with MSVC's C++ <atomic> header on Windows.
#if defined(__cplusplus) && defined(_WIN32)
#include <atomic>
using std::atomic_bool;
using std::atomic_int;
using std::atomic_uint;
#else
#include <stdatomic.h>
#endif
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
 
#include "network/network.h"
#include "network/packet.h"
#include "network/packet_queue.h"
#include "network/logging.h"
#include "network/acip/transport.h"  // For acip_transport_t
#include "crypto/handshake/common.h" // For crypto_handshake_context_t (complete type needed for field)
#include "ringbuffer.h"
#include "video/video_frame.h"
#include "platform/terminal.h"
#include "video/palette.h"
#include "util/uthash.h"
 
typedef struct client_info {
  socket_t socket;
  acip_transport_t *transport;       // ACIP transport for protocol-agnostic packet sending
  asciichat_thread_t receive_thread; // Thread for receiving client data
  atomic_uint client_id;             // Thread-safe client ID
  char display_name[MAX_DISPLAY_NAME_LEN];
  char client_ip[INET_ADDRSTRLEN];
  int port;
 
  // Media capabilities
  bool can_send_video;
  bool can_send_audio;
  bool wants_stretch;           // Client wants stretched output (ignore aspect ratio)
  atomic_bool is_sending_video; // Thread-safe video stream state
  atomic_bool is_sending_audio; // Thread-safe audio stream state
 
  // Opus codec for audio compression/decompression
  void *opus_decoder; // opus_codec_t* - Opus decoder for this client's audio
 
  // Terminal capabilities (for rendering appropriate ASCII frames)
  terminal_capabilities_t terminal_caps;
  bool has_terminal_caps; // Whether we've received terminal capabilities from this client
 
  // Per-client palette cache
  char client_palette_chars[256];     // Client's palette characters
  size_t client_palette_len;          // Length of client's palette
  char client_luminance_palette[256]; // Client's luminance-to-character mapping
  palette_type_t client_palette_type; // Client's palette type
  bool client_palette_initialized;    // Whether client's palette is set up
 
  // Stream dimensions
  atomic_ushort width, height;
 
  // Statistics
  atomic_bool active;
  atomic_bool shutting_down;                 // Set when client is being removed
  atomic_bool protocol_disconnect_requested; // Set when protocol violation requires disconnect
  time_t connected_at;
  uint64_t frames_sent;
  uint64_t frames_received;        // Track incoming frames from this client
  uint32_t frames_received_logged; // Track for periodic logging (thread-safe via client_state_mutex)
 
  // Buffers for incoming media (individual per client)
  video_frame_buffer_t *incoming_video_buffer; // Modern double-buffered video frame
  audio_ring_buffer_t *incoming_audio_buffer;  // Buffer for this client's audio
 
  // Professional double-buffer system for outgoing frames
  video_frame_buffer_t *outgoing_video_buffer; // Double buffer for ASCII frames to send
 
  // Packet queue for audio only (video uses double buffer now)
  packet_queue_t *audio_queue; // Queue for audio packets to send to this client
 
  // Dedicated send thread for this client
  asciichat_thread_t send_thread;
  atomic_bool send_thread_running;
 
  // Per-client grid tracking for CLEAR_CONSOLE logic
  atomic_int last_rendered_grid_sources; // Render thread: source count in buffered frame
  atomic_int last_sent_grid_sources;     // Send thread: source count in last sent frame
 
  // Pre-allocated buffers to avoid malloc/free in send thread (prevents buffer pool contention)
  void *send_buffer;
  size_t send_buffer_size;
  void *crypto_plaintext_buffer; // For encryption plaintext (frame + header)
  size_t crypto_plaintext_size;
  void *crypto_ciphertext_buffer; // For encryption ciphertext (encrypted result)
  size_t crypto_ciphertext_size;
 
  // Per-client rendering threads
  asciichat_thread_t video_render_thread;
  asciichat_thread_t audio_render_thread;
  atomic_bool video_render_thread_running;
  atomic_bool audio_render_thread_running;
 
  // Per-client processing state
  struct timespec last_video_render_time;
  struct timespec last_audio_render_time;
 
  // Per-client synchronization
  mutex_t client_state_mutex;
  mutex_t send_mutex; // Protects socket writes (prevents concurrent send race)
 
  // Per-client crypto context for secure communication
  crypto_handshake_context_t crypto_handshake_ctx;
  bool crypto_initialized;
 
  // Pending packet storage for --no-encrypt mode
  // When client uses --no-encrypt, the first packet (e.g., CLIENT_JOIN) arrives
  // during crypto handshake attempt. We store it here so the caller can process it.
  packet_type_t pending_packet_type;
  void *pending_packet_payload;
  size_t pending_packet_length;
 
  // uthash handle for hash table operations
  UT_hash_handle hh;
} client_info_t;