actions.c File Reference

Action option callbacks for ascii-chat. More...

Go to the source code of this file.

Functions
void	actions_defer (deferred_action_t action, const action_args_t *args)
deferred_action_t	actions_get_deferred (void)
const action_args_t *	actions_get_args (void)
void	action_list_webcams (void)
void	action_list_microphones (void)
void	action_list_speakers (void)
void	action_show_capabilities_immediate (void)
	Execute show capabilities immediately (for early binary-level execution)
void	action_show_capabilities (void)
void	action_check_update_immediate (void)
	Execute update check immediately (for early binary-level execution)
void	action_check_update (void)
void	action_show_version (void)
void	action_help_server (void)
void	action_help_client (void)
void	action_help_mirror (void)
void	action_help_acds (void)
void	action_help_discovery (void)
void	action_create_manpage (const char *output_path)
void	action_create_config (const char *output_path)
void	action_completions (const char *shell_name, const char *output_path)
void	actions_execute_deferred (void)

Detailed Description

Action option callbacks for ascii-chat.

Action options are deferred until after all options are fully parsed and initialized. This ensures that options like –width and –height are properly reflected in action output (e.g., –show-capabilities displays the final terminal dimensions).

Examples: –list-webcams, –list-microphones, –list-speakers, –show-capabilities

Definition in file options/parsing/actions.c.

Function Documentation

action_check_update()

void action_check_update

(

void

)

Definition at line 348 of file options/parsing/actions.c.

                               {
  // Defer execution until after options are fully parsed
  actions_defer(ACTION_CHECK_UPDATE, NULL);
}

References actions_defer().

Referenced by options_registry_add_all_to_builder().

action_check_update_immediate()

void action_check_update_immediate

(

void

)

Execute update check immediately (for early binary-level execution)

Definition at line 330 of file options/parsing/actions.c.

                                         {
  printf("Checking for updates...\n");
  update_check_result_t result;
  asciichat_error_t err = update_check_perform(&result);
  if (err != ASCIICHAT_OK) {
    printf("\nFailed to check for updates.\n\n");
    action_exit(1);
  }
  if (result.update_available) {
    char notification[1024];
    update_check_format_notification(&result, notification, sizeof(notification));
    printf("\n%s\n\n", notification);
  } else {
    printf("\nYou are already on the latest version: %s (%.8s)\n\n", result.current_version, result.current_sha);
  }
  action_exit(0);
}

References update_check_format_notification(), and update_check_perform().

Referenced by options_init().

action_completions()

void action_completions	(	const char *	shell_name,
		const char *	output_path
	)

Definition at line 590 of file options/parsing/actions.c.

                                                                         {
  if (!shell_name || strlen(shell_name) == 0) {
    log_plain_stderr("Error: --completions requires shell name (bash, fish, zsh, powershell)");
    action_exit(ERROR_USAGE);
  }
 
  completion_format_t format = completions_parse_shell_name(shell_name);
  if (format == COMPLETION_FORMAT_UNKNOWN) {
    log_plain_stderr("Error: Unknown shell '%s' (supported: bash, fish, zsh, powershell)", shell_name);
    action_exit(ERROR_USAGE);
  }
 
  FILE *output = stdout;
  bool should_close = false;
 
  // Determine output: use provided path if given and not "-", otherwise stdout
  if (output_path && strlen(output_path) > 0 && strcmp(output_path, "-") != 0) {
    // Check if file already exists and prompt for confirmation
    struct stat st;
    if (stat(output_path, &st) == 0) {
      // File exists - ask user if they want to overwrite
      log_plain("Completions file already exists: %s", output_path);
 
      bool overwrite = platform_prompt_yes_no("Overwrite", false); // Default to No
      if (!overwrite) {
        log_plain("Completions generation cancelled.");
        action_exit(0);
      }
 
      log_plain("Overwriting existing completions file...");
    }
 
    output = platform_fopen(output_path, "w");
    if (!output) {
      log_plain_stderr("Error: Failed to open %s for writing", output_path);
      action_exit(ERROR_FILE_OPERATION);
    }
    should_close = true;
  }
 
  asciichat_error_t result = completions_generate_for_shell(format, output);
 
  if (should_close) {
    fclose(output);
  }
 
  if (result != ASCIICHAT_OK) {
    log_plain_stderr("Error: Failed to generate %s completions", completions_get_shell_name(format));
    action_exit(ERROR_USAGE);
  }
 
  // Silently exit - completions are written (either to file or stdout)
  action_exit(0);
}

References completions_generate_for_shell(), completions_get_shell_name(), completions_parse_shell_name(), platform_fopen(), and platform_prompt_yes_no().

Referenced by options_init().

action_create_config()

void action_create_config

(

const char *

output_path

)

Definition at line 543 of file options/parsing/actions.c.

                                                   {
  // Build the schema first so config_create_default can generate options from it
  const options_config_t *unified_config = options_preset_unified(NULL, NULL);
  if (unified_config) {
    asciichat_error_t schema_build_result = config_schema_build_from_configs(&unified_config, 1);
    if (schema_build_result != ASCIICHAT_OK) {
      // Schema build failed, but continue anyway
      (void)schema_build_result;
    }
    // options_config_destroy(unified_config);
  }
 
  const char *config_path = NULL;
 
  // Determine output path: use provided path, or NULL for stdout
  if (output_path && strlen(output_path) > 0 && strcmp(output_path, "-") != 0) {
    // User provided explicit path - use it as-is
    config_path = output_path;
  } else {
    // No path or "-" means stdout
    config_path = NULL;
  }
 
  // Create config with default options
  asciichat_error_t result = config_create_default(config_path);
  if (result != ASCIICHAT_OK) {
    asciichat_error_context_t err_ctx;
    if (HAS_ERRNO(&err_ctx)) {
      log_plain_stderr("Error creating config: %s", err_ctx.context_message);
    } else {
      log_plain_stderr("Error: Failed to create config file");
    }
    action_exit(ERROR_CONFIG);
  }
 
  if (config_path) {
    log_plain_stderr("Created default config file at: %s", config_path);
  } else {
    log_plain_stderr("Config written to stdout");
  }
  action_exit(0);
}

References config_create_default(), config_schema_build_from_configs(), and options_preset_unified().

Referenced by options_init().

action_create_manpage()

void action_create_manpage

(

const char *

output_path

)

Definition at line 494 of file options/parsing/actions.c.

                                                    {
  // Get binary-level config
  const options_config_t *config = options_preset_unified(NULL, NULL);
 
  if (!config) {
    log_plain_stderr("Error: Failed to get binary options config");
    action_exit(ERROR_FILE_OPERATION);
  }
 
  // Determine output path: use provided path, or NULL for stdout
  const char *path_to_use = NULL;
  if (output_path && strlen(output_path) > 0 && strcmp(output_path, "-") != 0) {
    // User provided explicit path - use it
    path_to_use = output_path;
  } else {
    // No path or "-" means stdout
    path_to_use = NULL;
  }
 
  // Generate merged man page from embedded or filesystem resources
  // Resources are loaded automatically based on build type:
  // - Production (Release): From embedded binary data
  // - Development (Debug): From filesystem files
  asciichat_error_t err =
      options_config_generate_manpage_merged(config, "ascii-chat", NULL, path_to_use, "Video chat in your terminal");
 
  if (err != ASCIICHAT_OK) {
    asciichat_error_context_t err_ctx;
    if (HAS_ERRNO(&err_ctx)) {
      log_plain_stderr("Error: %s", err_ctx.context_message);
    } else {
      log_plain_stderr("Error: Failed to generate man page");
    }
    action_exit(ERROR_FILE_OPERATION);
  }
 
  if (path_to_use) {
    log_plain_stderr("Man page written to: %s", path_to_use);
  } else {
    log_plain_stderr("Man page written to stdout");
  }
 
  action_exit(0);
}

References options_config_generate_manpage_merged(), and options_preset_unified().

Referenced by options_init().

action_help_acds()

void action_help_acds

(

void

)

Definition at line 480 of file options/parsing/actions.c.

                            {
  usage(stdout, MODE_DISCOVERY_SERVICE);
  action_exit(0);
}

References usage().

action_help_client()

void action_help_client

(

void

)

Definition at line 470 of file options/parsing/actions.c.

                              {
  usage(stdout, MODE_CLIENT);
  action_exit(0);
}

References usage().

action_help_discovery()

void action_help_discovery

(

void

)

Definition at line 485 of file options/parsing/actions.c.

                                 {
  usage(stdout, MODE_DISCOVERY);
  action_exit(0);
}

References usage().

action_help_mirror()

void action_help_mirror

(

void

)

Definition at line 475 of file options/parsing/actions.c.

                              {
  usage(stdout, MODE_MIRROR);
  action_exit(0);
}

References usage().

action_help_server()

void action_help_server

(

void

)

Definition at line 465 of file options/parsing/actions.c.

                              {
  usage(stdout, MODE_SERVER);
  action_exit(0);
}

References usage().

action_list_microphones()

void action_list_microphones

(

void

)

Definition at line 148 of file options/parsing/actions.c.

                                   {
  // Defer execution until after options are fully parsed
  actions_defer(ACTION_LIST_MICROPHONES, NULL);
}

References actions_defer().

Referenced by options_init(), and options_registry_add_all_to_builder().

action_list_speakers()

void action_list_speakers

(

void

)

Definition at line 194 of file options/parsing/actions.c.

                                {
  // Defer execution until after options are fully parsed
  actions_defer(ACTION_LIST_SPEAKERS, NULL);
}

References actions_defer().

Referenced by options_init(), and options_registry_add_all_to_builder().

action_list_webcams()

void action_list_webcams

(

void

)

Definition at line 108 of file options/parsing/actions.c.

                               {
  // Defer execution until after options are fully parsed
  actions_defer(ACTION_LIST_WEBCAMS, NULL);
}

References actions_defer().

Referenced by options_init(), and options_registry_add_all_to_builder().

action_show_capabilities()

void action_show_capabilities

(

void

)

Definition at line 317 of file options/parsing/actions.c.

                                    {
  // Defer execution until after options are fully parsed and dimensions updated
  // This ensures --width and --height flags are properly reflected in the output
  actions_defer(ACTION_SHOW_CAPABILITIES, NULL);
}

References actions_defer().

Referenced by options_registry_add_all_to_builder().

action_show_capabilities_immediate()

void action_show_capabilities_immediate

(

void

)

Execute show capabilities immediately (for early binary-level execution)

Definition at line 247 of file options/parsing/actions.c.

                                              {
  terminal_capabilities_t caps = detect_terminal_capabilities();
 
  // Determine if we should use colored output
  bool use_colors = terminal_should_color_output(STDOUT_FILENO);
 
  // Override color level if colors should not be shown
  if (!use_colors) {
    caps.color_level = TERM_COLOR_NONE;
    caps.color_count = 0;
    caps.capabilities &= ~((uint32_t)(TERM_CAP_COLOR_TRUE | TERM_CAP_COLOR_256 | TERM_CAP_COLOR_16));
  }
 
  // Use detected terminal size (immediate execution doesn't have parsed options yet)
  terminal_size_t size;
  terminal_get_size(&size);
  unsigned short width = size.cols;
  unsigned short height = size.rows;
 
  log_color_t label_color = use_colors ? LOG_COLOR_GREY : LOG_COLOR_GREY;
  log_color_t string_color = use_colors ? LOG_COLOR_DEBUG : LOG_COLOR_GREY;
  log_color_t good_color = use_colors ? LOG_COLOR_INFO : LOG_COLOR_GREY;
  log_color_t bad_color = use_colors ? LOG_COLOR_ERROR : LOG_COLOR_GREY;
  log_color_t number_color = use_colors ? LOG_COLOR_FATAL : LOG_COLOR_GREY;
 
  printf("%s\n", colored_string(LOG_COLOR_WARN, "Terminal Capabilities:"));
 
  char size_buf[64];
  snprintf(size_buf, sizeof(size_buf), "%ux%u", width, height);
  printf("  %s: %s\n", colored_string(label_color, "Terminal Size"), colored_string(number_color, size_buf));
 
  const char *color_level_name = terminal_color_level_name(caps.color_level);
  log_color_t color_level_color = (caps.color_level == TERM_COLOR_NONE) ? bad_color : string_color;
  printf("  %s: %s\n", colored_string(label_color, "Color Level"),
         colored_string(color_level_color, (char *)color_level_name));
 
  char colors_buf[64];
  snprintf(colors_buf, sizeof(colors_buf), "%u", caps.color_count);
  printf("  %s: %s\n", colored_string(label_color, "Max Colors"), colored_string(number_color, colors_buf));
 
  log_color_t utf8_color = caps.utf8_support ? good_color : bad_color;
  printf("  %s: %s\n", colored_string(label_color, "UTF-8 Support"),
         colored_string(utf8_color, (char *)(caps.utf8_support ? "Yes" : "No")));
 
  const char *render_mode_str = "unknown";
  if (caps.render_mode == RENDER_MODE_FOREGROUND) {
    render_mode_str = "foreground";
  } else if (caps.render_mode == RENDER_MODE_BACKGROUND) {
    render_mode_str = "background";
  } else if (caps.render_mode == RENDER_MODE_HALF_BLOCK) {
    render_mode_str = "half-block";
  }
  printf("  %s: %s\n", colored_string(label_color, "Render Mode"),
         colored_string(string_color, (char *)render_mode_str));
  printf("  %s: %s\n", colored_string(label_color, "TERM"), colored_string(string_color, (char *)caps.term_type));
  printf("  %s: %s\n", colored_string(label_color, "COLORTERM"),
         colored_string(string_color, (char *)(strlen(caps.colorterm) ? caps.colorterm : "(not set)")));
 
  log_color_t reliable_color = caps.detection_reliable ? good_color : bad_color;
  printf("  %s: %s\n", colored_string(label_color, "Detection Reliable"),
         colored_string(reliable_color, (char *)(caps.detection_reliable ? "Yes" : "No")));
 
  char bitmask_buf[64];
  snprintf(bitmask_buf, sizeof(bitmask_buf), "0x%08x", caps.capabilities);
  printf("  %s: %s\n", colored_string(label_color, "Capabilities Bitmask"), colored_string(number_color, bitmask_buf));
 
  fflush(stdout);
  action_exit(0);
}

References colored_string(), detect_terminal_capabilities(), terminal_get_size(), and terminal_should_color_output().

Referenced by options_init().

action_show_version()

void action_show_version

(

void

)

Definition at line 447 of file options/parsing/actions.c.

                               {
  bool use_colors = terminal_should_color_output(STDOUT_FILENO);
  if (use_colors) {
    printf("%s %s (%s, %s)\n", colored_string(LOG_COLOR_WARN, "ascii-chat"),
           colored_string(LOG_COLOR_INFO, (char *)ASCII_CHAT_VERSION_FULL),
           colored_string(LOG_COLOR_DEBUG, (char *)ASCII_CHAT_BUILD_TYPE),
           colored_string(LOG_COLOR_GREY, (char *)ASCII_CHAT_BUILD_DATE));
  } else {
    printf("ascii-chat %s (%s, %s)\n", ASCII_CHAT_VERSION_FULL, ASCII_CHAT_BUILD_TYPE, ASCII_CHAT_BUILD_DATE);
  }
 
  action_exit(0);
}

References colored_string(), and terminal_should_color_output().

Referenced by main().

actions_defer()

void actions_defer	(	deferred_action_t	action,
		const action_args_t *	args
	)

Definition at line 76 of file options/parsing/actions.c.

                                                                        {
  // Only remember the first action found
  if (g_deferred_action_state.has_action) {
    return; // Action already deferred, ignore subsequent actions
  }
 
  g_deferred_action_state.action = action;
  g_deferred_action_state.has_action = true;
 
  // Copy arguments if provided
  if (args) {
    memcpy(&g_deferred_action_state.args, args, sizeof(action_args_t));
  } else {
    memset(&g_deferred_action_state.args, 0, sizeof(action_args_t));
  }
}

References action, and args.

Referenced by action_check_update(), action_list_microphones(), action_list_speakers(), action_list_webcams(), and action_show_capabilities().

actions_execute_deferred()

void actions_execute_deferred

(

void

)

Definition at line 681 of file options/parsing/actions.c.

                                    {
  deferred_action_t action = actions_get_deferred();
 
  switch (action) {
  case ACTION_NONE:
    // No action to execute
    break;
 
  case ACTION_LIST_WEBCAMS:
    execute_list_webcams();
    break;
 
  case ACTION_LIST_MICROPHONES:
    execute_list_microphones();
    break;
 
  case ACTION_LIST_SPEAKERS:
    execute_list_speakers();
    break;
 
  case ACTION_SHOW_CAPABILITIES:
    execute_show_capabilities();
    break;
 
  case ACTION_CHECK_UPDATE:
    execute_check_update();
    break;
 
  default:
    log_warn("Unknown deferred action: %d", action);
    break;
  }
}

References action, and actions_get_deferred().

Referenced by options_init().

actions_get_args()

const action_args_t * actions_get_args

(

void

)

Definition at line 97 of file options/parsing/actions.c.

                                            {
  if (!g_deferred_action_state.has_action) {
    return NULL;
  }
  return &g_deferred_action_state.args;
}

actions_get_deferred()

deferred_action_t actions_get_deferred

(

void

)

Definition at line 93 of file options/parsing/actions.c.

                                             {
  return g_deferred_action_state.action;
}

Referenced by actions_execute_deferred().

Variable Documentation

action

deferred_action_t action

Definition at line 67 of file options/parsing/actions.c.

Referenced by actions_defer(), and actions_execute_deferred().

args

action_args_t args

Definition at line 68 of file options/parsing/actions.c.

Referenced by __isoc23_fscanf(), __isoc23_fwscanf(), __isoc23_scanf(), __isoc23_sscanf(), __isoc23_swscanf(), __isoc23_vfscanf(), __isoc23_vfwscanf(), __isoc23_vscanf(), __isoc23_vsscanf(), __isoc23_vswscanf(), __isoc23_vwscanf(), __isoc23_wscanf(), actions_defer(), asciichat_fatal_with_context(), asciichat_set_errno_with_message(), asciichat_set_errno_with_system_error_and_message(), disconnect_client_for_bad_data(), format_message(), log_file_msg(), log_labeled(), log_mmap_write(), log_msg(), log_net_message(), log_network_message(), log_plain_msg(), log_plain_stderr_msg(), log_plain_stderr_nonewline_msg(), log_terminal_msg(), main(), options_builder_add_example(), options_builder_add_example_utility(), platform_asprintf(), platform_open(), safe_fprintf(), and safe_snprintf().

has_action

bool has_action

Definition at line 69 of file options/parsing/actions.c.

Referenced by options_init().