protocol.c File Reference

Go to the source code of this file.

Functions
void	session_protocol_init (session_protocol_t *protocol, acip_transport_t *transport, session_protocol_media_t media, acip_client_callbacks_t control)
asciichat_error_t	session_protocol_dispatch (session_protocol_t *protocol, packet_type_t type, const void *payload, size_t length)
void	session_protocol_build_capabilities (unsigned short width, unsigned short height, terminal_capabilities_packet_t *packet)
asciichat_error_t	session_protocol_update_settings (terminal_size_t *advertised, uint64_t *advertised_revision, session_protocol_send_settings_fn send, void *context)

Function Documentation

session_protocol_build_capabilities()

void session_protocol_build_capabilities	(	unsigned short	width,
		unsigned short	height,
		terminal_capabilities_packet_t *	packet )

Definition at line 274 of file common/session/protocol.c.

                                                                                 {
  const options_t *opts = options_get();
  // Log the dimensions being sent to server (helps debug dimension mismatch issues)
  log_debug("Sending terminal size to server: %ux%u (auto_width=%d, auto_height=%d)", width, height, opts->auto_width,
            opts->auto_height);
 
  // Connection and transport availability is checked by threaded_send_packet()
 
  // Build terminal capabilities packet locally
  // Detect terminal capabilities automatically
  terminal_capabilities_t caps = detect_terminal_capabilities(options_terminal_settings());
 
  // Set wants_padding based on snapshot mode and TTY status
  // Disable padding when:
  // - In snapshot mode (one frame and exit)
  // - When stdout is not a TTY (piped/redirected output)
  // Enable padding for interactive terminal sessions
  bool is_snapshot_mode = opts->snapshot_mode;
  bool is_interactive = terminal_is_interactive();
  caps.wants_padding = is_interactive && !is_snapshot_mode;
 
  log_debug("Client capabilities: wants_padding=%d (snapshot=%d, interactive=%d, stdin_tty=%d, stdout_tty=%d)",
            caps.wants_padding, is_snapshot_mode, is_interactive, terminal_is_stdin_tty(), terminal_is_stdout_tty());
 
  // Apply user's color mode override
  caps = apply_color_mode_override(caps, options_terminal_settings());
 
  // TERM_COLOR_AUTO is an option/configuration sentinel, not a wire-level
  // capability.  A remote peer must receive a concrete color level; this can
  // otherwise make the server reject the complete capabilities packet. The
  // browser/native renderer contract supports truecolor as the safe default.
  terminal_color_mode_t normalized_color = acip_render_settings_normalize_color_mode(caps.color_level);
  if (normalized_color != caps.color_level) {
    log_debug("Terminal color detection returned AUTO; advertising truecolor");
    caps.color_level = normalized_color;
    caps.color_count = 16777216;
    caps.capabilities |= TERM_CAP_COLOR_16 | TERM_CAP_COLOR_256 | TERM_CAP_COLOR_TRUE;
  }
 
  // Check if detection was reliable, use fallback only for auto-detection
  if (!caps.detection_reliable && opts->color_mode == COLOR_MODE_AUTO) {
    log_warn("Terminal capability detection not reliable, using fallback");
    SAFE_MEMSET(&caps, sizeof(caps), 0, sizeof(caps));
    caps.color_level = TERM_COLOR_NONE;
    caps.color_count = 2;
    caps.capabilities = 0;
    SAFE_STRNCPY(caps.term_type, "unknown", sizeof(caps.term_type));
    SAFE_STRNCPY(caps.colorterm, "", sizeof(caps.colorterm));
    caps.detection_reliable = 0;
    // Preserve wants_padding even in fallback mode
    caps.wants_padding = is_interactive && !is_snapshot_mode;
  }
 
  // Convert to network packet format with proper byte order
  terminal_capabilities_packet_t net_packet = {0};
  if (opts->matrix_rain)
    caps.capabilities |= TERM_CAP_MATRIX_RAIN;
  else
    caps.capabilities &= ~(uint32_t)TERM_CAP_MATRIX_RAIN;
  net_packet.capabilities = HOST_TO_NET_U32(caps.capabilities);
  net_packet.color_level = HOST_TO_NET_U32(caps.color_level);
  net_packet.color_count = HOST_TO_NET_U32(caps.color_count);
  net_packet.render_mode = HOST_TO_NET_U32(opts->render_mode);
  net_packet.color_filter = (uint8_t)opts->color_filter;
  net_packet.width = HOST_TO_NET_U16(width);
  net_packet.height = HOST_TO_NET_U16(height);
  net_packet.palette_type = HOST_TO_NET_U32(opts->palette_type);
  net_packet.utf8_support = HOST_TO_NET_U32(caps.utf8_support ? 1 : 0);
 
  if (opts->palette_type == PALETTE_CUSTOM && opts->palette_custom_set) {
    const char *palette_custom = opts && opts->palette_custom_set ? opts->palette_custom : "";
    SAFE_STRNCPY(net_packet.palette_custom, palette_custom, sizeof(net_packet.palette_custom));
    net_packet.palette_custom[sizeof(net_packet.palette_custom) - 1] = '\0';
  } else {
    SAFE_MEMSET(net_packet.palette_custom, sizeof(net_packet.palette_custom), 0, sizeof(net_packet.palette_custom));
  }
 
  // Set desired FPS
  int fps = opts->fps;
  if (fps > 0) {
    net_packet.desired_fps = (uint8_t)(fps > 144 ? 144 : fps);
  } else {
    net_packet.desired_fps = caps.desired_fps;
  }
 
  if (net_packet.desired_fps == 0) {
    net_packet.desired_fps = DEFAULT_MAX_FPS;
  }
 
  SAFE_STRNCPY(net_packet.term_type, caps.term_type, sizeof(net_packet.term_type));
  net_packet.term_type[sizeof(net_packet.term_type) - 1] = '\0';
 
  SAFE_STRNCPY(net_packet.colorterm, caps.colorterm, sizeof(net_packet.colorterm));
  net_packet.colorterm[sizeof(net_packet.colorterm) - 1] = '\0';
 
  net_packet.detection_reliable = caps.detection_reliable;
  // Send UTF-8 support flag: true for AUTO (default) and TRUE settings, false for FALSE setting
  net_packet.utf8_support = (opts->force_utf8 != UTF8_SETTING_FALSE) ? 1 : 0;
 
  // Set wants_padding flag (1=padding enabled, 0=no padding for snapshot/piped modes)
  net_packet.wants_padding = caps.wants_padding ? 1 : 0;
 
  // Set codec capabilities (client supports all codecs by default)
  net_packet.codec_capabilities_video = HOST_TO_NET_U32(VIDEO_CODEC_CAP_ALL);
  net_packet.codec_capabilities_audio = HOST_TO_NET_U32(AUDIO_CODEC_CAP_ALL);
 
  *packet = net_packet;
}

References acip_render_settings_normalize_color_mode(), AUDIO_CODEC_CAP_ALL, options_state::auto_height, options_state::auto_width, terminal_capabilities_packet_t::capabilities, terminal_capabilities_packet_t::codec_capabilities_audio, terminal_capabilities_packet_t::codec_capabilities_video, terminal_capabilities_packet_t::color_count, options_state::color_filter, terminal_capabilities_packet_t::color_filter, terminal_capabilities_packet_t::color_level, options_state::color_mode, COLOR_MODE_AUTO, terminal_capabilities_packet_t::colorterm, DEFAULT_MAX_FPS, terminal_capabilities_packet_t::desired_fps, terminal_capabilities_packet_t::detection_reliable, options_state::force_utf8, options_state::fps, height, terminal_capabilities_packet_t::height, HOST_TO_NET_U16, HOST_TO_NET_U32, log_debug, log_warn, options_state::matrix_rain, options_get(), options_terminal_settings, PALETTE_CUSTOM, options_state::palette_custom, terminal_capabilities_packet_t::palette_custom, options_state::palette_custom_set, options_state::palette_type, terminal_capabilities_packet_t::palette_type, options_state::render_mode, terminal_capabilities_packet_t::render_mode, SAFE_MEMSET, SAFE_STRNCPY, options_state::snapshot_mode, terminal_capabilities_packet_t::term_type, UTF8_SETTING_FALSE, terminal_capabilities_packet_t::utf8_support, VIDEO_CODEC_CAP_ALL, terminal_capabilities_packet_t::wants_padding, terminal_capabilities_packet_t::width, and width.

Referenced by threaded_send_terminal_size_with_auto_detect().

session_protocol_dispatch()

asciichat_error_t session_protocol_dispatch	(	session_protocol_t *	protocol,
		packet_type_t	type,
		const void *	payload,
		size_t	length )

Definition at line 210 of file common/session/protocol.c.

                                                           {
  if (!protocol || (!payload && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid participant protocol packet");
  protocol->callback_result = ASCIICHAT_OK;
  if (type == PACKET_TYPE_ACIP_SETTINGS_ACK) {
    acip_settings_header_t header;
    const char *json;
    size_t json_length;
    asciichat_error_t result = acip_settings_decode(payload, length, &header, &json, &json_length);
    if (result != ASCIICHAT_OK)
      return result;
    if ((header.request && header.request < protocol->settings_request) ||
        header.revision < protocol->settings_revision)
      return ASCIICHAT_OK;
    options_t *current = SAFE_MALLOC(sizeof(*current), options_t *),
              *candidate = SAFE_MALLOC(sizeof(*candidate), options_t *);
    acip_render_settings_options(&protocol->effective_render_settings, current);
    result = options_prepare_json(current, json, json_length, candidate, true);
    if (result == ASCIICHAT_OK)
      result = acip_render_settings_prepare(&protocol->effective_render_settings, candidate);
    SAFE_FREE(current);
    SAFE_FREE(candidate);
    if (result != ASCIICHAT_OK)
      return result;
    protocol->effective_render_settings.revision = header.revision;
    if (header.request)
      protocol->settings_request = header.request;
    protocol->settings_revision = header.revision;
    protocol->settings_status = header.status;
    if (header.status)
      log_warn("Remote rendering update rejected (request=%u, status=%u)", header.request, header.status);
    else
      log_info("Remote rendering update accepted (request=%u, revision=%u)", header.request, header.revision);
    return ASCIICHAT_OK;
  }
  acip_client_callbacks_t media = {.on_ascii_frame = receive_frame,
                                   .on_audio_batch = receive_samples,
                                   .on_audio_opus_batch = receive_opus_batch,
                                   .on_server_state = receive_state,
                                   .on_error = receive_error,
                                   .app_ctx = protocol};
  bool audio = type == PACKET_TYPE_AUDIO_BATCH || type == PACKET_TYPE_AUDIO_OPUS_BATCH;
  bool common =
      audio || type == PACKET_TYPE_ASCII_FRAME || type == PACKET_TYPE_SERVER_STATE || type == PACKET_TYPE_ERROR_MESSAGE;
  asciichat_error_t result;
  if (type == PACKET_TYPE_PING && !protocol->control.on_ping)
    result = acip_send_pong(protocol->transport);
  else
    result =
        acip_handle_client_packet(protocol->transport, type, payload, length, common ? &media : &protocol->control);
  if (result == ASCIICHAT_OK)
    result = protocol->callback_result;
  if (result == ASCIICHAT_OK) {
    protocol->packets_received++;
    if (audio) {
      protocol->audio_packets_received++;
      if (protocol->media.on_audio_packet)
        protocol->media.on_audio_packet(length, protocol->media.context);
    }
  }
  return result;
}

References acip_handle_client_packet(), acip_render_settings_options(), acip_render_settings_prepare(), acip_send_pong(), acip_settings_decode(), ASCIICHAT_OK, session_protocol_t::audio_packets_received, session_protocol_t::callback_result, session_protocol_media_t::context, session_protocol_t::control, session_protocol_t::effective_render_settings, ERROR_INVALID_PARAM, log_info, log_warn, session_protocol_t::media, session_protocol_media_t::on_audio_packet, acip_client_callbacks_t::on_ping, options_prepare_json(), PACKET_TYPE_ACIP_SETTINGS_ACK, PACKET_TYPE_ASCII_FRAME, PACKET_TYPE_AUDIO_BATCH, PACKET_TYPE_AUDIO_OPUS_BATCH, PACKET_TYPE_ERROR_MESSAGE, PACKET_TYPE_PING, PACKET_TYPE_SERVER_STATE, session_protocol_t::packets_received, acip_render_settings_t::revision, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, session_protocol_t::settings_request, session_protocol_t::settings_revision, session_protocol_t::settings_status, and session_protocol_t::transport.

session_protocol_init()

void session_protocol_init	(	session_protocol_t *	protocol,
		acip_transport_t *	transport,
		session_protocol_media_t	media,
		acip_client_callbacks_t	control )

Definition at line 204 of file common/session/protocol.c.

                                                            {
  *protocol = (session_protocol_t){.transport = transport, .media = media, .control = control};
  protocol->effective_render_settings.caps.utf8_support = GET_OPTION(force_utf8) != UTF8_SETTING_FALSE;
}

References acip_render_settings_t::caps, session_protocol_t::effective_render_settings, GET_OPTION, and UTF8_SETTING_FALSE.

Referenced by client_protocol_start().

session_protocol_update_settings()

asciichat_error_t session_protocol_update_settings	(	terminal_size_t *	advertised,
		uint64_t *	advertised_revision,
		session_protocol_send_settings_fn	send,
		void *	context )

Definition at line 384 of file common/session/protocol.c.

                                                                                                          {
  if (!advertised || !advertised_revision || !send)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Settings update requires state and a send callback");
  if (advertised->cols > 0 && advertised->rows > 0 && *advertised_revision == options_revision())
    return ASCIICHAT_OK;
  SAFE_MALLOC_DEFER_FREE(snapshot, sizeof(options_snapshot_t), options_snapshot_t *);
  asciichat_error_t result = options_read_snapshot(snapshot);
  if (result != ASCIICHAT_OK) {
    return result;
  }
  terminal_size_t size = {.cols = snapshot->values.width, .rows = snapshot->values.height};
  if (size.cols <= 0 || size.rows <= 0) {
    return ASCIICHAT_OK;
  }
  if (snapshot->values.color_mode == TERM_COLOR_AUTO) {
    terminal_capabilities_t caps = detect_terminal_capabilities(options_terminal_settings());
    snapshot->values.color_mode = caps.detection_reliable ? caps.color_level : TERM_COLOR_NONE;
  }
  result = send(&snapshot->values, (uint32_t)snapshot->revision, context);
  if (result == ASCIICHAT_OK) {
    *advertised = size;
    *advertised_revision = snapshot->revision;
  }
 
  return result;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, options_read_snapshot(), options_revision(), options_terminal_settings, SAFE_MALLOC_DEFER_FREE, and SET_ERRNO.