system.c File Reference

🔧 Shared cross-platform system utilities (included by posix/system.c and windows/system.c) More...

Go to the source code of this file.

Data Structures
struct	bin_cache_entry_t
	Binary PATH cache entry structure for binary detection caching. More...

Macros
#define	BIN_SUFFIX   ""
#define	PLATFORM_MAX_PATH_LENGTH   4096

Functions
void	platform_cleanup_binary_path_cache (void)
	Cleanup the binary PATH cache.
bool	platform_is_binary_in_path (const char *bin_name)
bool	platform_get_executable_path (char *exe_path, size_t path_size)
	Get the path to the current executable.
int	safe_snprintf (char *buffer, size_t buffer_size, const char *format,...)
	Safe formatted string printing to buffer.
int	safe_fprintf (FILE *stream, const char *format,...)
	Safe formatted output to file stream.
int	safe_vsnprintf (char *buffer, size_t buffer_size, const char *format, va_list ap)
	Safe formatted string printing with va_list.
void	platform_print_backtrace_symbols (const char *label, char **symbols, int count, int skip_frames, int max_frames, backtrace_frame_filter_t filter)
	Print pre-resolved backtrace symbols with colored terminal output and plain log file output.

Detailed Description

🔧 Shared cross-platform system utilities (included by posix/system.c and windows/system.c)

Definition in file system.c.

Macro Definition Documentation

BIN_SUFFIX

#define BIN_SUFFIX   ""

Definition at line 25 of file system.c.

PLATFORM_MAX_PATH_LENGTH

#define PLATFORM_MAX_PATH_LENGTH   4096

Maximum path length supported by the operating system

Platform-specific values:

• Windows: 32767 characters (extended-length path with \?\ prefix)
• Linux: 4096 bytes (PATH_MAX from limits.h)
• macOS: 1024 bytes (PATH_MAX from sys/syslimits.h)

Note: Windows legacy MAX_PATH (260) is too restrictive for modern use. We use the extended-length limit instead.

Definition at line 64 of file system.c.

Function Documentation

platform_cleanup_binary_path_cache()

void platform_cleanup_binary_path_cache

(

void

)

Cleanup the binary PATH cache.

Definition at line 304 of file system.c.

                                              {
  if (!atomic_load(&g_cache_initialized)) {
    return;
  }
 
  if (g_bin_path_cache) {
    rwlock_wrlock(&g_cache_rwlock);
 
    // Free all cached entries using uthash iteration
    bin_cache_entry_t *entry, *tmp;
    HASH_ITER(hh, g_bin_path_cache, entry, tmp) {
      HASH_DELETE(hh, g_bin_path_cache, entry);
      free_cache_entry(entry);
    }
 
    rwlock_wrunlock(&g_cache_rwlock);
    rwlock_destroy(&g_cache_rwlock);
    g_bin_path_cache = NULL;
  }
 
  atomic_store(&g_cache_initialized, false);
}

Referenced by server_main().

platform_get_executable_path()

bool platform_get_executable_path	(	char *	exe_path,
		size_t	path_size
	)

Get the path to the current executable.

Parameters

exe_path	Buffer to store the executable path
path_size	Size of the buffer

Returns

true on success, false on failure

Definition at line 393 of file system.c.

                                                                    {
  if (!exe_path || path_size == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: exe_path=%p, path_size=%zu", (void *)exe_path, path_size);
    return false;
  }
 
#ifdef _WIN32
  DWORD len = GetModuleFileNameA(NULL, exe_path, (DWORD)path_size);
  if (len == 0) {
    SET_ERRNO_SYS(ERROR_INVALID_STATE, "GetModuleFileNameA failed: error code %lu", GetLastError());
    return false;
  }
  if (len >= path_size) {
    SET_ERRNO(ERROR_BUFFER_OVERFLOW,
              "Executable path exceeds buffer size (path length >= %zu bytes, buffer size = %zu bytes)", (size_t)len,
              path_size);
    return false;
  }
  return true;
 
#elif defined(__linux__)
  ssize_t len = readlink("/proc/self/exe", exe_path, path_size - 1);
  if (len < 0) {
    SET_ERRNO_SYS(ERROR_INVALID_STATE, "readlink(\"/proc/self/exe\") failed: %s", SAFE_STRERROR(errno));
    return false;
  }
  if ((size_t)len >= path_size - 1) {
    SET_ERRNO(ERROR_BUFFER_OVERFLOW,
              "Executable path exceeds buffer size (path length >= %zu bytes, buffer size = %zu bytes)", (size_t)len,
              path_size);
    return false;
  }
  exe_path[len] = '\0';
  return true;
 
#elif defined(__APPLE__)
  uint32_t bufsize = (uint32_t)path_size;
  int result = _NSGetExecutablePath(exe_path, &bufsize);
  if (result != 0) {
    SET_ERRNO(ERROR_BUFFER_OVERFLOW, "_NSGetExecutablePath failed: path requires %u bytes, buffer size = %zu bytes",
              bufsize, path_size);
    return false;
  }
  return true;
 
#else
  SET_ERRNO(ERROR_GENERAL, "Unsupported platform - cannot get executable path");
  return false;
#endif
}

platform_is_binary_in_path()

bool platform_is_binary_in_path

(

const char *

bin_name

)

Definition at line 331 of file system.c.

                                                      {
  if (!bin_name || bin_name[0] == '\0') {
    return false;
  }
 
  // Initialize cache if needed
  init_cache_once();
  if (!atomic_load(&g_cache_initialized)) {
    // Cache initialization failed, check directly (this should never happen)
    SET_ERRNO(ERROR_INVALID_STATE, "Binary PATH cache not initialized, checking directly (this should never happen)");
    return check_binary_in_path_uncached(bin_name);
  }
 
  // Check cache first
  rwlock_rdlock(&g_cache_rwlock);
  bin_cache_entry_t *entry = NULL;
  HASH_FIND_STR(g_bin_path_cache, bin_name, entry);
  rwlock_rdunlock(&g_cache_rwlock);
 
  if (entry) {
    // Cache hit
    log_dev("Binary '%s' %s in PATH (%s)", bin_name, colored_string(LOG_COLOR_INFO, "found"),
            colored_string(LOG_COLOR_WARN, "cached"));
    return entry->in_path;
  }
 
  // Cache miss - check PATH and cache result
  bool found = check_binary_in_path_uncached(bin_name);
 
  // Create new cache entry
  entry = SAFE_MALLOC(sizeof(bin_cache_entry_t), bin_cache_entry_t *);
  if (!entry) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate cache entry");
    return found; // Return result without caching
  }
 
  entry->bin_name = platform_strdup(bin_name);
  if (!entry->bin_name) {
    SET_ERRNO(ERROR_MEMORY, "Failed to duplicate binary name");
    SAFE_FREE(entry);
    return found;
  }
 
  entry->in_path = found;
 
  // Add to cache using uthash
  rwlock_wrlock(&g_cache_rwlock);
  HASH_ADD_KEYPTR(hh, g_bin_path_cache, entry->bin_name, strlen(entry->bin_name), entry);
  rwlock_wrunlock(&g_cache_rwlock);
 
  log_dev("Binary '%s' %s in PATH", bin_name,
          colored_string(found ? LOG_COLOR_INFO : LOG_COLOR_ERROR, found ? "found" : "NOT found"));
 
  return found;
}

References bin_cache_entry_t::bin_name, colored_string(), bin_cache_entry_t::in_path, and platform_strdup().

platform_print_backtrace_symbols()

void platform_print_backtrace_symbols	(	const char *	label,
		char **	symbols,
		int	count,
		int	skip_frames,
		int	max_frames,
		backtrace_frame_filter_t	filter
	)

Print pre-resolved backtrace symbols with colored terminal output and plain log file output.

This is a cross-platform function that formats backtrace symbols with:

• Semantic coloring: grey numbers, blue functions, red unknowns, magenta addresses
• Two output streams: colored to stderr (terminal), plain to log file

Parameters

label	Header label (e.g., "Backtrace")
symbols	Array of pre-resolved symbol strings
count	Number of symbols in the array
skip_frames	Number of frames to skip from the start
max_frames	Maximum frames to print (0 = unlimited)
filter	Optional filter callback to skip specific frames (NULL = no filtering)

Definition at line 535 of file system.c.

                                                                       {
  if (!symbols || count <= 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: symbols=%p, count=%d", symbols, count);
    return;
  }
 
  // Calculate frame limits
  int start = skip_frames;
  int end = count;
  if (max_frames > 0 && (start + max_frames) < end) {
    end = start + max_frames;
  }
 
  // Build backtrace in two versions: colored for terminal, plain for log file
  char colored_buffer[16384] = {0};
  char plain_buffer[16384] = {0};
  int colored_offset = 0;
  int plain_offset = 0;
 
  // Format log header using logging system's template
  char log_header_buf[512] = {0};
  time_t now = time(NULL);
  struct tm *tm_info = localtime(&now);
  char timestamp[32];
  strftime(timestamp, sizeof(timestamp), "%H:%M:%S", tm_info);
 
  thread_id_t tid = asciichat_thread_self();
  uint64_t tid_val = (uintptr_t)tid;
 
  // Get current time in nanoseconds for template formatting
  uint64_t time_ns = platform_get_monotonic_time_us() * 1000ULL;
 
  // Try to format header using the logging system's template with color
  log_template_t *format = log_get_template();
  if (format) {
    // Color the label with WARN color for terminal output
    const char *colored_label_ptr = colored_string(LOG_COLOR_WARN, label);
    char colored_label_buf[256];
    strncpy(colored_label_buf, colored_label_ptr, sizeof(colored_label_buf) - 1);
    colored_label_buf[sizeof(colored_label_buf) - 1] = '\0';
 
    int len = log_template_apply(format, log_header_buf, sizeof(log_header_buf), LOG_WARN, timestamp, __FILE__,
                                 __LINE__, __func__, tid_val, colored_label_buf, true, time_ns);
    if (len > 0) {
      // Successfully formatted with logging template
      colored_offset += safe_snprintf(colored_buffer + colored_offset, sizeof(colored_buffer) - (size_t)colored_offset,
                                      "%s\n", log_header_buf);
    } else {
      // Fallback: manual formatting if template fails
      safe_snprintf(log_header_buf, sizeof(log_header_buf), "[%s] [WARN] [tid:%llu] %s: %s", timestamp, tid_val,
                    __func__, label);
      const char *colored_header_ptr = colored_string(LOG_COLOR_WARN, log_header_buf);
      char colored_header_buf[512];
      strncpy(colored_header_buf, colored_header_ptr, sizeof(colored_header_buf) - 1);
      colored_header_buf[sizeof(colored_header_buf) - 1] = '\0';
      colored_offset += safe_snprintf(colored_buffer + colored_offset, sizeof(colored_buffer) - (size_t)colored_offset,
                                      "%s\n", colored_header_buf);
    }
  } else {
    // Fallback: manual formatting if no template available
    safe_snprintf(log_header_buf, sizeof(log_header_buf), "[%s] [WARN] [tid:%llu] %s: %s", timestamp, tid_val, __func__,
                  label);
    const char *colored_header_ptr = colored_string(LOG_COLOR_WARN, log_header_buf);
    char colored_header_buf[512];
    strncpy(colored_header_buf, colored_header_ptr, sizeof(colored_header_buf) - 1);
    colored_header_buf[sizeof(colored_header_buf) - 1] = '\0';
    colored_offset += safe_snprintf(colored_buffer + colored_offset, sizeof(colored_buffer) - (size_t)colored_offset,
                                    "%s\n", colored_header_buf);
  }
 
  // Add plain label header for log file
  plain_offset +=
      safe_snprintf(plain_buffer + plain_offset, sizeof(plain_buffer) - (size_t)plain_offset, "%s\n", label);
 
  // Build backtrace frames with colored output for terminal, plain for log
  int frame_num = 0;
  for (int i = start; i < end && colored_offset < (int)sizeof(colored_buffer) - 512; i++) {
    const char *symbol = symbols[i] ? symbols[i] : "???";
 
    // Skip frame if filter says to
    if (filter && filter(symbol)) {
      continue;
    }
 
    // Build frame number string
    char frame_num_str[16];
    safe_snprintf(frame_num_str, sizeof(frame_num_str), "%d", frame_num);
 
    // Get colored frame number - copy to temp buffer to avoid rotating buffer issues
    const char *colored_num_ptr = colored_string(LOG_COLOR_GREY, frame_num_str);
    char colored_num_buf[256];
    strncpy(colored_num_buf, colored_num_ptr, sizeof(colored_num_buf) - 1);
    colored_num_buf[sizeof(colored_num_buf) - 1] = '\0';
 
    // Parse symbol to extract parts for selective coloring
    // Format: "[binary_name] function_name() (file:line)"
    char colored_symbol[2048] = {0};
    const char *s = symbol;
    int colored_sym_offset = 0;
 
    // Color binary name between brackets
    if (*s == '[') {
      colored_sym_offset +=
          safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, "[");
      s++;
      // Find closing bracket
      const char *bracket_end = strchr(s, ']');
      if (bracket_end) {
        int bin_len = bracket_end - s;
        char bin_name[512];
        strncpy(bin_name, s, bin_len);
        bin_name[bin_len] = '\0';
        const char *colored_bin_ptr = colored_string(LOG_COLOR_DEBUG, bin_name);
        char colored_bin_buf[512];
        strncpy(colored_bin_buf, colored_bin_ptr, sizeof(colored_bin_buf) - 1);
        colored_bin_buf[sizeof(colored_bin_buf) - 1] = '\0';
        colored_sym_offset += safe_snprintf(colored_symbol + colored_sym_offset,
                                            sizeof(colored_symbol) - colored_sym_offset, "%s", colored_bin_buf);
        colored_sym_offset +=
            safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, "] ");
        s = bracket_end + 1;
      }
    }
 
    // Skip leading spaces after bracket
    while (*s && *s == ' ')
      s++;
 
    // Parse: could be "function() (file:line)" or "file:line (unresolved)"
    const char *paren_start = strchr(s, '(');
 
    // Detect format: if there's a colon before the first paren, it's "file:line (description)"
    const char *colon_pos = strchr(s, ':');
    if (colon_pos && paren_start && colon_pos < paren_start) {
      // Format: "file:line (unresolved function)" - rearrange to "(unresolved) (file:line)"
      // Extract file:line part (trim trailing spaces)
      int file_len = paren_start - s;
      while (file_len > 0 && s[file_len - 1] == ' ')
        file_len--;
      char file_part[512];
      strncpy(file_part, s, file_len);
      file_part[file_len] = '\0';
 
      // Extract description content (without parens)
      const char *paren_end = strchr(paren_start, ')');
      int desc_content_len = paren_end - paren_start - 1; // -1 to skip opening paren
      char desc_content[512];
      strncpy(desc_content, paren_start + 1, desc_content_len); // +1 to skip opening paren
      desc_content[desc_content_len] = '\0';
 
      const char *colored_desc_ptr = colored_string(LOG_COLOR_ERROR, desc_content);
      char colored_desc_buf[512];
      strncpy(colored_desc_buf, colored_desc_ptr, sizeof(colored_desc_buf) - 1);
      colored_desc_buf[sizeof(colored_desc_buf) - 1] = '\0';
      colored_sym_offset += safe_snprintf(colored_symbol + colored_sym_offset,
                                          sizeof(colored_symbol) - colored_sym_offset, "(%s)", colored_desc_buf);
 
      // Now color file:line in parens
      // Skip leading spaces in file_part
      const char *file_start = file_part;
      while (*file_start && *file_start == ' ')
        file_start++;
 
      char *file_colon = strchr(file_start, ':');
      if (file_colon) {
        int filename_len = file_colon - file_start;
        char filename[512];
        strncpy(filename, file_start, filename_len);
        filename[filename_len] = '\0';
 
        const char *colored_file_ptr = colored_string(LOG_COLOR_DEBUG, filename);
        char colored_file_buf[512];
        strncpy(colored_file_buf, colored_file_ptr, sizeof(colored_file_buf) - 1);
        colored_file_buf[sizeof(colored_file_buf) - 1] = '\0';
 
        const char *line_num = file_colon + 1;
        const char *colored_line_ptr = colored_string(LOG_COLOR_GREY, line_num);
        char colored_line_buf[512];
        strncpy(colored_line_buf, colored_line_ptr, sizeof(colored_line_buf) - 1);
        colored_line_buf[sizeof(colored_line_buf) - 1] = '\0';
 
        colored_sym_offset +=
            safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, " (%s:%s)",
                          colored_file_buf, colored_line_buf);
      }
    } else if (paren_start) {
      // Format: "function() (file:line)"
      int func_len = paren_start - s;
      char func_name[512];
      strncpy(func_name, s, func_len);
      func_name[func_len] = '\0';
 
      const char *colored_func_ptr = colored_string(LOG_COLOR_DEV, func_name);
      char colored_func_buf[512];
      strncpy(colored_func_buf, colored_func_ptr, sizeof(colored_func_buf) - 1);
      colored_func_buf[sizeof(colored_func_buf) - 1] = '\0';
      colored_sym_offset += safe_snprintf(colored_symbol + colored_sym_offset,
                                          sizeof(colored_symbol) - colored_sym_offset, "%s()", colored_func_buf);
 
      // Find file:line in second set of parens
      s = paren_start + 1;
      while (*s && *s != '(')
        s++;
 
      if (*s == '(') {
        const char *file_paren_end = strchr(s, ')');
        if (file_paren_end) {
          colored_sym_offset +=
              safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, " (");
          int file_len = file_paren_end - s - 1;
          char file_part[512];
          strncpy(file_part, s + 1, file_len);
          file_part[file_len] = '\0';
 
          // Skip leading spaces in file_part
          const char *file_start = file_part;
          while (*file_start && *file_start == ' ')
            file_start++;
 
          char *colon_pos = strchr(file_start, ':');
          if (colon_pos) {
            int filename_len = colon_pos - file_start;
            char filename[512];
            strncpy(filename, file_start, filename_len);
            filename[filename_len] = '\0';
 
            const char *colored_file_ptr = colored_string(LOG_COLOR_DEBUG, filename);
            char colored_file_buf[512];
            strncpy(colored_file_buf, colored_file_ptr, sizeof(colored_file_buf) - 1);
            colored_file_buf[sizeof(colored_file_buf) - 1] = '\0';
 
            const char *line_num = colon_pos + 1;
            const char *colored_line_ptr = colored_string(LOG_COLOR_GREY, line_num);
            char colored_line_buf[512];
            strncpy(colored_line_buf, colored_line_ptr, sizeof(colored_line_buf) - 1);
            colored_line_buf[sizeof(colored_line_buf) - 1] = '\0';
 
            colored_sym_offset +=
                safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, "%s:%s",
                              colored_file_buf, colored_line_buf);
          }
          colored_sym_offset +=
              safe_snprintf(colored_symbol + colored_sym_offset, sizeof(colored_symbol) - colored_sym_offset, ")");
        }
      }
    } else {
      // No parens, likely a hex address - color with FATAL
      const char *colored_addr_ptr = colored_string(LOG_COLOR_FATAL, s);
      char colored_addr_buf[512];
      strncpy(colored_addr_buf, colored_addr_ptr, sizeof(colored_addr_buf) - 1);
      colored_addr_buf[sizeof(colored_addr_buf) - 1] = '\0';
      colored_sym_offset += safe_snprintf(colored_symbol + colored_sym_offset,
                                          sizeof(colored_symbol) - colored_sym_offset, "%s", colored_addr_buf);
    }
 
    // Format colored buffer: "  [colored_num] colored_symbol\n"
    colored_offset += safe_snprintf(colored_buffer + colored_offset, sizeof(colored_buffer) - (size_t)colored_offset,
                                    "  [%s] %s\n", colored_num_buf, colored_symbol);
 
    // Format plain buffer: "  [num] symbol\n"
    plain_offset += safe_snprintf(plain_buffer + plain_offset, sizeof(plain_buffer) - (size_t)plain_offset,
                                  "  [%d] %s\n", frame_num, symbol);
    frame_num++;
  }
 
  // TODO: Investigate why log_warn() can't be used here. Currently we bypass the logging
  // system to preserve ANSI color codes, but this means we lose the normal log formatting
  // (timestamps, log level, etc). Ideally log_warn() should accept a flag to preserve codes.
  fprintf(stderr, "%s", colored_buffer);
 
  // Write plain version to log file only (skip stderr since we already printed colored version)
  log_file_msg("%s", plain_buffer);
}

References asciichat_thread_self(), colored_string(), log_file_msg(), log_get_template(), log_template_apply(), platform_get_monotonic_time_us(), and safe_snprintf().

Referenced by asciichat_fatal_with_context(), and asciichat_print_error_context().

safe_fprintf()

int safe_fprintf	(	FILE *	stream,
		const char *	format,
			...
	)

Safe formatted output to file stream.

Parameters

stream	Output file stream
format	Printf-style format string

Returns

Number of characters written, or -1 on error

Safely formats and prints output to a file stream. Returns the number of characters written, or -1 on error.

Definition at line 480 of file system.c.

                                                        {
  if (!stream || !format) {
    return -1;
  }
 
  va_list args;
  va_start(args, format);
  int ret = vfprintf(stream, format, args);
  va_end(args);
 
  return ret;
}

References args.

Referenced by add_known_host(), asciichat_fatal_with_context(), asciichat_print_error_context(), log_init(), log_labeled(), log_msg(), log_plain_msg(), and webcam_print_init_error_help().

safe_snprintf()

int safe_snprintf	(	char *	buffer,
		size_t	buffer_size,
		const char *	format,
			...
	)

Safe formatted string printing to buffer.

Parameters

buffer	Output buffer
buffer_size	Size of output buffer
format	Printf-style format string

Returns

Number of characters written, or -1 on error

Safely formats a string into a buffer with bounds checking. Uses platform_snprintf for cross-platform implementation. Returns the number of characters written (not including null terminator). Returns -1 if buffer is too small.

Definition at line 456 of file system.c.

                                                                             {
  if (!buffer || !format || buffer_size == 0) {
    return -1;
  }
 
  va_list args;
  va_start(args, format);
 
  /* Delegate to platform_snprintf for actual formatting */
  int ret = platform_vsnprintf(buffer, buffer_size, format, args);
 
  va_end(args);
  return ret;
}

References args, buffer_size, and platform_vsnprintf().

Referenced by acds_client_connect(), acds_identity_default_path(), acds_identity_fingerprint(), acds_main(), acds_string_generate(), add_client(), add_webrtc_client(), asciichat_instr_log_line(), asciichat_instr_log_pc(), build_github_gpg_url(), build_github_ssh_url(), build_gitlab_gpg_url(), build_gitlab_ssh_url(), capture_init(), check_gpg_key_expiry(), check_known_host(), check_known_host_no_identity(), colored_string(), colorize_log_message(), colorscheme_compile_scheme(), colorscheme_export_scheme(), config_load_and_apply(), create_client_render_threads(), crypto_get_rekey_status(), crypto_handshake_client_key_exchange(), crypto_handshake_server_auth_challenge(), crypto_handshake_server_start(), discovery_keys_fetch_github(), discovery_keys_fetch_gitlab(), discovery_keys_get_cache_path(), discovery_keys_save_cached(), display_mitm_warning(), expand_path(), find_similar_option_with_mode(), format_available_modes(), format_bytes_pretty(), format_duration_ns(), format_gpg_key_display(), format_mode_names(), format_option_default_value_str(), format_public_key(), format_uptime_hms(), get_current_time_formatted(), get_discovery_database_dir(), get_known_hosts_path(), get_log_dir(), get_manpage_template(), gpg_agent_sign(), gpg_get_public_key(), gpg_sign_detached_ed25519(), gpg_sign_with_key(), gpg_verify_detached_ed25519(), gpg_verify_signature(), gpg_verify_signature_with_binary(), https_get(), ice_format_candidate(), image_print_color(), log_mmap_write(), log_recolor_plain_entry(), log_template_apply(), manpage_content_generate_environment(), manpage_content_generate_environment_with_manual(), manpage_content_generate_examples(), manpage_content_generate_options(), manpage_content_generate_positional(), manpage_content_generate_usage(), manpage_fmt_write_title(), manpage_merger_generate_synopsis(), manpage_merger_generate_usage(), nat_upnp_get_address(), options_config_calculate_max_col_width(), options_config_print_options_sections_with_width(), options_config_print_usage(), options_format_default_value(), options_init(), options_preset_unified(), options_print_help_for_mode(), parallel_connect(), parse_client_address(), parse_color_filter(), parse_color_mode(), parse_gpg_key(), parse_gpg_key_binary(), parse_gpg_keys_from_response(), parse_log_level(), parse_palette_chars(), parse_palette_type(), parse_port_option(), parse_private_key(), parse_render_mode(), parse_server_bind_address(), parse_ssh_private_key(), path_validate_user_path(), platform_print_backtrace_symbols(), prompt_unknown_host(), prompt_unknown_host_no_identity(), pubkey_to_hex(), query_init(), remove_known_host(), rgb_to_truecolor_ansi(), sdp_generate_answer(), sdp_generate_offer(), server_main(), session_capture_create(), session_network_capture_create(), stats_logger_thread(), test_get_binary_path(), turn_generate_credentials(), and yt_dlp_extract_stream_url().

safe_vsnprintf()

int safe_vsnprintf	(	char *	buffer,
		size_t	buffer_size,
		const char *	format,
		va_list	ap
	)

Safe formatted string printing with va_list.

Parameters

buffer	Output buffer (can be NULL if buffer_size is 0 for size calculation)
buffer_size	Size of output buffer
format	Printf-style format string
ap	Variable argument list

Returns

Number of characters written, or -1 on error

Safely formats a string into a buffer with bounds checking using va_list. Uses platform_vsnprintf for cross-platform implementation. Returns the number of characters written (not including null terminator). Special case: NULL buffer with size 0 returns required buffer size for size calculation. Returns -1 if buffer is too small, format is invalid, or buffer is NULL with size > 0.

Definition at line 507 of file system.c.

                                                                                     {
  if (!format) {
    return -1;
  }
 
  // Allow NULL buffer with size 0 for size calculation (standard vsnprintf behavior)
  if (!buffer && buffer_size > 0) {
    return -1; // Non-NULL buffer required when buffer_size > 0
  }
 
  /* Delegate to platform_vsnprintf for actual formatting */
  return platform_vsnprintf(buffer, buffer_size, format, ap);
}

References buffer_size, and platform_vsnprintf().

Referenced by disconnect_client_for_bad_data(), format_message(), log_file_msg(), log_mmap_write(), log_msg(), log_plain_msg(), and str_printf().