main.c File Reference

ascii-chat Unified Binary - Mode Dispatcher and Entry Point More...

Go to the source code of this file.

Data Structures
struct	mode_descriptor_t
	Mode descriptor for string conversion. More...

Macros
#define	APP_NAME   "ascii-chat"
#define	VERSION   ASCII_CHAT_VERSION_FULL

Typedefs
typedef int(*	mode_entry_point_t) (void)

Functions
bool	should_exit (void)
void	signal_exit (void)
void	set_interrupt_callback (void(*cb)(void))
void	setup_signal_handlers (void)
int	main (int argc, char *argv[])

Detailed Description

ascii-chat Unified Binary - Mode Dispatcher and Entry Point

This file implements the main entry point for the unified ascii-chat binary, which provides server, client, mirror, and discovery service functionality in a single executable.

The dispatcher now delegates ALL option parsing (including mode detection and binary-level options) to options_init(), then simply dispatches to the appropriate mode-specific entry point based on the detected mode.

Author

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

Date

2025

Version

3.0

Definition in file main.c.

Macro Definition Documentation

APP_NAME

#define APP_NAME   "ascii-chat"

Definition at line 73 of file main.c.

VERSION

#define VERSION   ASCII_CHAT_VERSION_FULL

Definition at line 74 of file main.c.

Typedef Documentation

mode_entry_point_t

typedef int(* mode_entry_point_t) (void)

Definition at line 183 of file main.c.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 281 of file main.c.

                                 {
  // Set global argc/argv for early argv inspection (e.g., in terminal.c)
  g_argc = argc;
  g_argv = argv;
  // Validate basic argument structure
  if (argc < 1 || argv == NULL || argv[0] == NULL) {
    fprintf(stderr, "Error: Invalid argument vector\n");
    return 1;
  }
 
  // VERY FIRST: Scan for --color BEFORE ANY logging initialization
  // This sets global flags that persist through cleanup, enabling --color to force colors
  extern bool g_color_flag_passed;
  extern bool g_color_flag_value;
  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "--color") == 0 || strcmp(argv[i], "--color=true") == 0) {
      g_color_flag_passed = true;
      g_color_flag_value = true;
      break;
    } else if (strcmp(argv[i], "--color=false") == 0) {
      g_color_flag_passed = true;
      g_color_flag_value = false;
      break;
    } else if (strncmp(argv[i], "--color=", 8) == 0) {
      g_color_flag_passed = true;
      // Default to true for any other --color=X value
      g_color_flag_value = true;
      break;
    }
  }
 
  // SECOND: Scan for --grep BEFORE ANY logging initialization
  // This ensures ALL logs (including from shared_init) can be filtered
  // Supports multiple --grep patterns (ORed together)
  for (int i = 1; i < argc - 1; i++) {
    if (strcmp(argv[i], "--grep") == 0) {
      const char *pattern = argv[i + 1];
      asciichat_error_t filter_result = grep_init(pattern);
      if (filter_result != ASCIICHAT_OK) {
        fprintf(stderr,
                "ERROR: Invalid --grep pattern or invalid flags: \"%s\" - use /pattern/flags format (e.g., "
                "\"/query/ig\" or \"/literal/F\")\n",
                pattern);
        return 1;
      }
      i++; // Skip the pattern argument
    }
  }
 
  // Detect terminal capabilities early so colored help output works
  // Logging will be initialized by asciichat_shared_init() before options_init()
  log_redetect_terminal_capabilities();
  terminal_capabilities_t caps = detect_terminal_capabilities();
  caps = apply_color_mode_override(caps);
 
  // Warn if Release build was built from dirty working tree
#if ASCII_CHAT_GIT_IS_DIRTY
  if (strcmp(ASCII_CHAT_BUILD_TYPE, "Release") == 0) {
    fprintf(stderr, "⚠️  WARNING: This Release build was compiled from a dirty git working tree!\n");
    fprintf(stderr, "    Git commit: %s (dirty)\n", ASCII_CHAT_GIT_COMMIT_HASH);
    fprintf(stderr, "    Build date: %s\n", ASCII_CHAT_BUILD_DATE);
    fprintf(stderr, "    For reproducible builds, commit or stash changes before building.\n\n");
  }
#endif
 
  // Load color scheme early (from config files and CLI) before logging initialization
  // This allows logging to use the correct colors from the start
  options_colorscheme_init_early(argc, argv);
 
  // Parse --color-scheme from argv early to set logging colors for help output
  const char *colorscheme_name = "pastel"; // default
  for (int i = 1; i < argc - 1; i++) {
    if (strcmp(argv[i], "--color-scheme") == 0) {
      colorscheme_name = argv[i + 1];
      break;
    }
  }
 
  // Load and apply colorscheme to logging BEFORE options_init() so help gets colors
  color_scheme_t scheme;
  if (colorscheme_load_builtin(colorscheme_name, &scheme) == ASCIICHAT_OK) {
    log_set_color_scheme(&scheme);
  } else {
    // Fall back to default pastel if scheme not found
    if (colorscheme_load_builtin("pastel", &scheme) == ASCIICHAT_OK) {
      log_set_color_scheme(&scheme);
    }
  }
 
  // Initialize logging colors so they're ready for help output
  log_init_colors();
 
  // EARLY PARSE: Find the mode position (first positional argument)
  // Binary-level options must appear BEFORE the mode
  int mode_position = -1;
  for (int i = 1; i < argc; i++) {
    if (argv[i][0] != '-') {
      // Found a positional argument - this is the mode or session string
      mode_position = i;
      break;
    }
 
    // Skip option and its argument if needed
    // Check if this is an option that takes a required argument
    const char *arg = argv[i];
    const char *opt_name = arg;
    if (arg[0] == '-') {
      opt_name = arg + (arg[1] == '-' ? 2 : 1);
    }
 
    // Handle --option=value format
    if (strchr(opt_name, '=')) {
      continue; // Value is part of this arg, no need to skip next
    }
 
    // Options that take required arguments
    if (strcmp(arg, "--log-file") == 0 || strcmp(arg, "-L") == 0 || strcmp(arg, "--log-level") == 0 ||
        strcmp(arg, "--config") == 0 || strcmp(arg, "--color-scheme") == 0 || strcmp(arg, "--log-template") == 0) {
      if (i + 1 < argc) {
        i++; // Skip the argument value
      }
    }
  }
 
  // EARLY PARSE: Determine mode from argv to know if this is client-like mode
  // The first positional argument (after options) is the mode: client, server, mirror, discovery, acds
  bool is_client_like_mode = false;
  if (mode_position > 0) {
    const char *first_arg = argv[mode_position];
    if (strcmp(first_arg, "client") == 0 || strcmp(first_arg, "mirror") == 0 || strcmp(first_arg, "discovery") == 0) {
      is_client_like_mode = true;
    }
  }
 
  // EARLY PARSE: Extract log file from argv (--log-file or -L)
  // Must appear BEFORE the mode
  const char *log_file = "ascii-chat.log"; // default
  int max_search = (mode_position > 0) ? mode_position : argc;
  for (int i = 1; i < max_search - 1; i++) {
    if ((strcmp(argv[i], "--log-file") == 0 || strcmp(argv[i], "-L") == 0)) {
      log_file = argv[i + 1];
      break;
    }
  }
 
  // EARLY PARSE: Check for --json (JSON logging format)
  // If JSON format is enabled, we'll use the JSON filename during early init
  // --json MUST appear BEFORE the mode
  bool early_json_format = false;
  if (mode_position > 0) {
    for (int i = 1; i < mode_position; i++) {
      if (strcmp(argv[i], "--json") == 0) {
        early_json_format = true;
        break;
      }
    }
  } else {
    // If no mode found, search entire argv
    for (int i = 1; i < argc; i++) {
      if (strcmp(argv[i], "--json") == 0) {
        early_json_format = true;
        break;
      }
    }
  }
 
  // EARLY PARSE: Extract log template from argv (--log-template)
  // Note: This is for format templates, different from --log-format which is the output format
  // Binary-level options must appear BEFORE the mode
  const char *early_log_template = NULL;
  bool early_log_template_console_only = false;
  for (int i = 1; i < max_search - 1; i++) {
    if (strcmp(argv[i], "--log-template") == 0) {
      early_log_template = argv[i + 1];
      break;
    }
  }
  for (int i = 1; i < max_search; i++) {
    if (strcmp(argv[i], "--log-format-console-only") == 0) {
      early_log_template_console_only = true;
      break;
    }
  }
 
  // Initialize shared subsystems BEFORE options_init()
  // This ensures options parsing can use properly configured logging with colors
  // If JSON format is requested, don't write text logs to file
  // All logs will be JSON formatted later once options_init() runs
  const char *early_log_file = early_json_format ? NULL : log_file;
  asciichat_error_t init_result = asciichat_shared_init(early_log_file, is_client_like_mode);
  if (init_result != ASCIICHAT_OK) {
    return init_result;
  }
 
  // Route logs to stderr if stdout is piped (MUST happen early, before options_init logs)
  // This keeps stdout clean for data output (e.g., --snapshot mode piped to file)
  if (terminal_should_force_stderr()) {
    log_set_force_stderr(true);
  }
 
  // Register cleanup of shared subsystems to run on normal exit
  // Library code doesn't call atexit() - the application is responsible
  (void)atexit(asciichat_shared_destroy);
 
  // SECRET: Check for --backtrace (debug builds only) BEFORE options_init()
  // Prints a backtrace and exits immediately - useful for debugging hangs
#ifndef NDEBUG
  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "--backtrace") == 0) {
      log_info("=== Backtrace at startup ===");
      platform_print_backtrace(0);
      log_info("=== End Backtrace ===");
      asciichat_shared_destroy();
      return 0;
    }
  }
#endif
 
  // NOW parse all options - can use logging with colors!
  asciichat_error_t options_result = options_init(argc, argv);
  if (options_result != ASCIICHAT_OK) {
    asciichat_error_context_t error_ctx;
    if (HAS_ERRNO(&error_ctx)) {
      fprintf(stderr, "Error: %s\n", error_ctx.context_message);
    } else {
      fprintf(stderr, "Error: Failed to initialize options\n");
    }
    (void)fflush(stderr);
 
    // Clean up options state before exiting
    options_state_destroy();
    options_cleanup_schema();
 
    exit(options_result);
  }
 
  // Get parsed options
  const options_t *opts = options_get();
  if (!opts) {
    fprintf(stderr, "Error: Options not initialized\n");
    return 1;
  }
 
  // Determine final log file path (use mode-specific default from options if available)
  // Determine output format early to decide on filename and logging strategy
  bool use_json_logging = GET_OPTION(json);
 
  // Determine the log filename
  // Check if user explicitly passed --log-file (not just the mode-specific default from options_init)
  bool user_specified_log_file = false;
  for (int i = 1; i < argc - 1; i++) {
    if (strcmp(argv[i], "--log-file") == 0 || strcmp(argv[i], "-L") == 0) {
      user_specified_log_file = true;
      break;
    }
  }
 
  const char *final_log_file = opts->log_file;
  char json_filename_buf[256];
 
  if (use_json_logging) {
    // When JSON logging is enabled, determine JSON output filename
    if (user_specified_log_file) {
      // User explicitly specified a log file - use it exactly for JSON output
      SAFE_STRNCPY(json_filename_buf, final_log_file, sizeof(json_filename_buf) - 1);
    } else {
      // Using default: replace .log with .json in the mode-specific default
      // e.g., server.log -> server.json, mirror.log -> mirror.json, etc.
      size_t len = strlen(final_log_file);
      if (len > 4 && strcmp(&final_log_file[len - 4], ".log") == 0) {
        // File ends with .log - replace with .json
        SAFE_STRNCPY(json_filename_buf, final_log_file, sizeof(json_filename_buf) - 1);
        // Replace .log with .json
        strcpy(&json_filename_buf[len - 4], ".json");
      } else {
        // File doesn't end with .log - just append .json
        SAFE_STRNCPY(json_filename_buf, final_log_file, sizeof(json_filename_buf) - 1);
        strncat(json_filename_buf, ".json", sizeof(json_filename_buf) - strlen(json_filename_buf) - 1);
      }
    }
    final_log_file = json_filename_buf;
    // For JSON mode: Initialize logging without file (text will be disabled)
    // We'll set up JSON output separately below
    log_init(NULL, GET_OPTION(log_level), false, false);
  } else {
    // Text logging mode: use the file from options (which is mode-specific default or user-specified)
    log_init(final_log_file, GET_OPTION(log_level), false, false);
  }
 
  // Apply custom log template if specified (use early parsed value if available, otherwise use options)
  const char *final_format = early_log_template ? early_log_template : GET_OPTION(log_template);
  bool final_format_console_only =
      early_log_template ? early_log_template_console_only : GET_OPTION(log_format_console_only);
  if (final_format && final_format[0] != '\0') {
    asciichat_error_t fmt_result = log_set_format(final_format, final_format_console_only);
    if (fmt_result != ASCIICHAT_OK) {
      log_error("Failed to apply custom log format");
    }
  }
 
  // Configure JSON output if requested
  if (use_json_logging) {
    // Open the JSON file for output
    int json_fd = platform_open(final_log_file, O_CREAT | O_RDWR | O_TRUNC, FILE_PERM_PRIVATE);
    if (json_fd >= 0) {
      log_set_json_output(json_fd);
    } else {
      // Failed to open JSON file - report error and exit
      SET_ERRNO(ERROR_CONFIG, "Failed to open JSON output file: %s", final_log_file);
      return ERROR_CONFIG;
    }
  }
 
  // Initialize colors now that logging is fully initialized
  // This must happen after log_init() since log_init_colors() checks if g_log.initialized
  log_init_colors();
 
  // Apply quiet mode - disables terminal output
  // Status screen mode only disables terminal output if terminal is interactive
  // In non-interactive mode (piped output), logs go to stdout/stderr normally
  if (GET_OPTION(quiet) ||
      (opts->detected_mode == MODE_SERVER && GET_OPTION(status_screen) && terminal_is_interactive())) {
    log_set_terminal_output(false);
  }
 
  // Initialize palette based on command line options
  const char *custom_chars = opts && opts->palette_custom_set ? opts->palette_custom : NULL;
  if (apply_palette_config(GET_OPTION(palette_type), custom_chars) != 0) {
    FATAL(ERROR_CONFIG, "Failed to apply palette configuration");
  }
 
  // Set quiet mode for memory debugging
#if defined(DEBUG_MEMORY) && !defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
  debug_memory_set_quiet_mode(GET_OPTION(quiet));
#endif
 
  // Truncate log if it's already too large
  log_truncate_if_large();
 
  // Handle --help and --version (these are detected and flagged by options_init)
  // Terminal capabilities already initialized before options_init() at startup
  if (opts->help) {
    print_usage(opts->detected_mode);
    fflush(NULL);
    _Exit(0);
  }
 
  if (opts->version) {
    log_set_terminal_output(true);
    action_show_version();
    // action_show_version() calls _Exit(), so we don't reach here
  }
 
  // For server mode with status screen: disable terminal output only if interactive
  // In non-interactive mode (piped output), logs go to stdout/stderr normally
  // The status screen (when shown) will capture and display logs in its buffer instead
  if (opts->detected_mode == MODE_SERVER && opts->status_screen && terminal_is_interactive()) {
    log_set_terminal_output(false);
  }
 
  log_dev("Logging initialized to %s", final_log_file);
 
  // Note: We do NOT auto-disable colors when stdout appears to be piped, because:
  // 1. Tools like ripgrep can display ANSI colors when piped
  // 2. Sandboxed/containerized environments may report false positives for isatty()
  // 3. Users can explicitly disable colors with --color=false if needed
  // Color behavior is now fully controlled by --color and --color-mode options.
 
#ifndef NDEBUG
  // Initialize lock debugging system after logging is fully set up
  log_debug("Initializing lock debug system...");
  int lock_debug_result = lock_debug_init();
  if (lock_debug_result != 0) {
    LOG_ERRNO_IF_SET("Lock debug system initialization failed");
    FATAL(ERROR_PLATFORM_INIT, "Lock debug system initialization failed");
  }
  log_debug("Lock debug system initialized successfully");
 
  // Start lock debug thread in all modes (not just server)
  if (lock_debug_start_thread() != 0) {
    LOG_ERRNO_IF_SET("Lock debug thread startup failed");
    FATAL(ERROR_THREAD, "Lock debug thread startup failed");
  }
  log_debug("Lock debug thread started");
 
#ifndef _WIN32
  // Register SIGUSR1 to trigger lock state printing in all modes
  platform_signal(SIGUSR1, common_handle_sigusr1);
#endif
#endif
 
  if (opts->fps > 0) {
    if (opts->fps < 1 || opts->fps > 144) {
      log_warn("FPS value %d out of range (1-144), using default", opts->fps);
    } else {
      log_debug("FPS set from command line: %d", opts->fps);
    }
  }
 
  // Automatic update check at startup (once per week maximum)
  if (!GET_OPTION(no_check_update)) {
    update_check_result_t update_result;
    asciichat_error_t update_err = update_check_startup(&update_result);
    if (update_err == ASCIICHAT_OK && update_result.update_available) {
      char notification[1024];
      update_check_format_notification(&update_result, notification, sizeof(notification));
      log_info("%s", notification);
 
      // Set update notification for splash/status screens
      splash_set_update_notification(notification);
    }
  }
 
  // Set up global signal handlers BEFORE mode dispatch
  // All modes use the same centralized exit mechanism
  setup_signal_handlers();
 
  // Register SIGUSR1 for lock debugging in debug builds (uses shared handler)
#ifndef NDEBUG
#ifndef _WIN32
  platform_signal(SIGUSR1, common_handle_sigusr1);
#endif
#endif
 
  // Find and dispatch to mode entry point
  const mode_descriptor_t *mode = find_mode(opts->detected_mode);
  if (!mode) {
    fprintf(stderr, "Error: Mode not found for detected_mode=%d\n", opts->detected_mode);
    return 1;
  }
 
  // Call the mode-specific entry point
  // Mode entry points use options_get() to access parsed options
  int exit_code = mode->entry_point();
 
  if (exit_code == ERROR_USAGE) {
    exit(ERROR_USAGE);
  }
 
  return exit_code;
}

References action_show_version(), apply_palette_config(), asciichat_shared_destroy(), asciichat_shared_init(), colorscheme_load_builtin(), detect_terminal_capabilities(), mode_descriptor_t::entry_point, g_argc, g_argv, g_color_flag_passed, g_color_flag_value, grep_init(), lock_debug_init(), lock_debug_start_thread(), log_init(), log_init_colors(), log_redetect_terminal_capabilities(), log_set_color_scheme(), log_set_force_stderr(), log_set_format(), log_set_json_output(), log_set_terminal_output(), log_truncate_if_large(), options_cleanup_schema(), options_colorscheme_init_early(), options_get(), options_init(), options_state_destroy(), platform_open(), platform_print_backtrace(), setup_signal_handlers(), splash_set_update_notification(), terminal_is_interactive(), terminal_should_force_stderr(), update_check_format_notification(), and update_check_startup().

set_interrupt_callback()

void set_interrupt_callback

(

void(*)(void)

cb

)

Register a mode-specific interrupt callback

Called by mode-specific code to register a callback that will be invoked when signal_exit() is called. Used to shut down network sockets so threads blocked in recv() unblock quickly instead of waiting for timeouts.

The callback is called synchronously from signal_exit(), so it must be async-signal-safe (only atomics, socket_shutdown(), no malloc/etc).

Only one callback can be registered at a time. Setting a new callback replaces the previous one.

Parameters

cb	Function to call on exit signal, or NULL to unregister

Definition at line 102 of file main.c.

                                              {
  g_interrupt_callback = cb;
}

Referenced by client_main(), and discovery_main().

setup_signal_handlers()

void setup_signal_handlers

(

void

)

Set up global signal handlers Called once at startup before mode dispatch

Definition at line 167 of file main.c.

                                 {
  platform_set_console_ctrl_handler(console_ctrl_handler);
 
#ifndef _WIN32
  platform_signal_handler_t handlers[] = {
      {SIGTERM, handle_sigterm},
      {SIGPIPE, SIG_IGN},
  };
  platform_register_signal_handlers(handlers, 2);
#endif
}

Referenced by main().

should_exit()

bool should_exit

(

void

)

Check if the application should exit

Called by mode main loops to detect shutdown requests from signals or errors.

Returns

true if shutdown has been requested, false otherwise

Definition at line 90 of file main.c.

                       {
  return atomic_load(&g_app_should_exit);
}

Referenced by connection_attempt_tcp(), connection_attempt_websocket(), display_full_reset(), server_connection_establish(), session_client_like_run(), and session_render_loop().

signal_exit()

void signal_exit

(

void

)

Signal that the application should exit

Sets the global exit flag and calls the registered interrupt callback if set. Safe to call from signal handlers (uses only atomics and function pointers). Called by signal handlers (SIGTERM, Ctrl+C) and normal code (errors, timeouts).

Definition at line 94 of file main.c.

                       {
  atomic_store(&g_app_should_exit, true);
  void (*cb)(void) = g_interrupt_callback;
  if (cb) {
    cb();
  }
}