🔧 Core utilities: memory management, safe macros, and cross-platform helpers More...

Functions
bool	shutdown_is_requested (void)

	__attribute__ ((constructor))
	Register fork handlers for common module.

asciichat_error_t	asciichat_shared_init (const char *log_file, bool is_client)

void	asciichat_shared_destroy (void)
	Clean up all shared library subsystems.

Variables
ASCIICHAT_API int	g_argc = 0

ASCIICHAT_API char **	g_argv = NULL

ASCIICHAT_API bool	g_color_flag_passed = false

ASCIICHAT_API bool	g_color_flag_value = false

Detailed Description

🔧 Core utilities: memory management, safe macros, and cross-platform helpers

Definition in file common.c.

Function Documentation

◆ attribute()

__attribute__ ( (constructor) )

Register fork handlers for common module.

Definition at line 104 of file common.c.

                                                                             {
  pthread_atfork(NULL, NULL, asciichat_common_atfork_child);
}

◆ asciichat_shared_destroy()

void asciichat_shared_destroy ( void )

Clean up all shared library subsystems.

Performs comprehensive cleanup of all subsystems initialized by asciichat_shared_init(). All cleanup functions are idempotent (safe to call multiple times), so this can be called explicitly and also via atexit() without issues.

Cleanup order is carefully chosen to be the reverse of initialization, ensuring dependencies are respected (e.g., timer cleanup before memory reporting, memory reporting before errno cleanup).

Note: This function is safe to call even if init failed or wasn't called.; All subsystem cleanup functions must remain idempotent.

Definition at line 164 of file common.c.

                                    {
  // Guard against double cleanup (can be called explicitly + via atexit)
  static bool shutdown_done = false;
  if (shutdown_done) {
    return;
  }
  shutdown_done = true;
 
  // Cleanup in reverse order of initialization (LIFO)
  // This ensures dependencies are properly handled
 
  // 0. Stop background threads first (before any cleanup that might use them)
  // Terminal resize detection thread (Windows only, checks if active)
  extern void terminal_stop_resize_detection(void);
  terminal_stop_resize_detection();
 
#ifndef NDEBUG
  // Lock debug thread - must join before any lock cleanup
  extern void lock_debug_cleanup_thread(void);
  lock_debug_cleanup_thread();
 
  // Lock debug system - set initialized=false so mutex_lock uses mutex_lock_impl directly
  // This must happen after thread cleanup but before any subsystem that uses mutex_lock
  extern void lock_debug_destroy(void);
  lock_debug_destroy();
#endif
 
  // 1. Webcam - cleanup resources
  webcam_destroy();
 
  // 2. SIMD caches - cleanup CPU-specific caches
  simd_caches_destroy_all();
 
  // 3. Discovery service strings cache - cleanup session string cache
  acds_strings_destroy();
 
  // 4. Logging - in correct order (end first, then begin)
  log_shutdown_end();
  log_shutdown_begin();
 
  // 5. Known hosts - cleanup authentication state
  known_hosts_destroy();
 
  // 6. Options state - cleanup RCU-based options
  options_state_destroy();
 
  // 7. Buffer pool - cleanup global buffer pool
  buffer_pool_cleanup_global();
 
  // 8. Platform cleanup - restores terminal, cleans up platform resources
  // (includes symbol cache cleanup on Windows)
  platform_destroy();
 
  // 9. Keyboard - restore terminal settings (redundant with platform_destroy but safe)
  extern void keyboard_destroy(void);
  keyboard_destroy();
 
  // 10. Timer system - cleanup timers (may still log!)
  timer_system_destroy();
 
  // 11. Error context cleanup
  asciichat_errno_destroy();
 
  // 12. Logging cleanup - free log format buffers before memory report
  log_destroy();
 
  // 13. Memory stats (debug builds only) - runs with colors still available
  //     Note: PCRE2 singletons are ignored in the report (expected system allocations)
  //     Note: debug_memory_report() is also called manually during shutdown in server_main()
  //     The function is safe to call multiple times with polling-based locking
#if defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
  print_mimalloc_stats();
#endif
 
#if defined(DEBUG_MEMORY) && !defined(NDEBUG)
  debug_memory_report();
#endif
 
  // 14. Color cleanup - free compiled ANSI strings (AFTER memory report)
  log_cleanup_colors();
  colorscheme_destroy();
 
  // 15. PCRE2 - cleanup all regex singletons together
  asciichat_pcre2_cleanup_all();
}

References acds_strings_destroy(), asciichat_errno_destroy(), asciichat_pcre2_cleanup_all(), buffer_pool_cleanup_global(), colorscheme_destroy(), known_hosts_destroy(), lock_debug_cleanup_thread(), lock_debug_destroy(), log_cleanup_colors(), log_destroy(), log_shutdown_begin(), log_shutdown_end(), options_state_destroy(), platform_destroy(), simd_caches_destroy_all(), timer_system_destroy(), and webcam_destroy().

Referenced by client_main(), and main().

◆ asciichat_shared_init()

asciichat_error_t asciichat_shared_init	(	const char *	log_file,
		bool	is_client
	)

Definition at line 109 of file common.c.

                                                                              {
  // Initialize shared subsystems BEFORE options_init()
  // This allows options_init() to use properly configured logging with colors
  //
  // NOTE: This function is called BEFORE options_init(), so we can't use GET_OPTION()
  // Palette config and quiet mode will be applied after options_init() is called
 
  // Only register initialization tracking once
  if (!g_shared_initialized) {
    // 1. TIMER SYSTEM - Initialize first so timing is available for everything else
    if (!timer_system_init()) {
      FATAL(ERROR_PLATFORM_INIT, "Failed to initialize timer system");
    }
 
    // 2. LOGGING - Initialize with provided log file
    // Force stderr for client-like modes when stdout is piped to keep stdout clean
    bool force_stderr = is_client && terminal_is_piped_output();
    // Use LOG_DEBUG by default; will be reconfigured after options_init()
    log_init(log_file, LOG_DEBUG, force_stderr, false /* don't use_mmap */);
 
    // 3. PLATFORM - Initialize platform-specific functionality (Winsock, etc)
    if (platform_init() != ASCIICHAT_OK) {
      FATAL(ERROR_PLATFORM_INIT, "Failed to initialize platform");
    }
 
    // 4. BUFFER POOL - Initialize global shared buffer pool
    buffer_pool_init_global();
 
    // Mark that we've initialized (prevents re-registration of subsystems)
    g_shared_initialized = true;
  }
 
  // NOTE: This library function does NOT register atexit() handlers.
  // Library code should not own the process lifecycle. The application
  // is responsible for calling atexit(asciichat_shared_destroy) if it
  // wants automatic cleanup on normal exit.
 
  return ASCIICHAT_OK;
}

References buffer_pool_init_global(), log_init(), platform_init(), terminal_is_piped_output(), and timer_system_init().

Referenced by main().

◆ shutdown_is_requested()

bool shutdown_is_requested ( void )

Definition at line 65 of file common.c.

                                 {
  shutdown_check_fn callback = atomic_load(&g_shutdown_callback);
  if (callback == NULL) {
    return false; // No callback registered, assume not shutting down
  }
  return callback();
}