ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
common.h File Reference

Common utilities and helpers for option parsing across all modes. More...

Go to the source code of this file.

Macros

#define OPTIONS_COMMON_H

Functions

const char * find_similar_option (const char *unknown_opt, const struct option *options)
 Find a similar option name for typo suggestions.
const char * format_available_modes (option_mode_bitmask_t mode_bitmask)
 Format all available modes for an option as comma-separated list.
char * validate_required_argument (const char *optarg, char *argbuf, size_t argbuf_size, const char *option_name, asciichat_mode_t mode)
 Validate and retrieve required argument for an option.
bool validate_positive_int_opt (const char *value_str, int *out_value, const char *param_name)
 Validate a positive integer value.
bool validate_port_opt (const char *value_str, uint16_t *out_port)
 Validate port number (1-65535).
bool validate_fps_opt (const char *value_str, int *out_fps)
 Validate FPS value (0 for auto, otherwise 1-144).
bool validate_webcam_index (const char *value_str, unsigned short int *out_index)
 Validate webcam index using the common device index validator.
asciichat_error_t validate_options_and_report (const void *config, const void *opts)
 Validate options and report errors to stderr.
asciichat_error_t detect_default_ssh_key (char *key_path, size_t path_size)
 Detect default SSH key path for the current user.
char * strip_equals_prefix (const char *opt_value, char *buffer, size_t buffer_size)
 Strip equals sign prefix from option argument.
char * get_required_argument (const char *opt_value, char *buffer, size_t buffer_size, const char *option_name, asciichat_mode_t mode)
 Handle required arguments with consistent error messages.
char * read_password_from_stdin (const char *prompt)
 Read password from stdin with prompt.
asciichat_error_t parse_color_mode_option (const char *value_str, options_t *opts)
 Parse –color-mode option and set opts->color_mode.
asciichat_error_t parse_render_mode_option (const char *value_str, options_t *opts)
 Parse –render-mode option and set opts->render_mode.
asciichat_error_t parse_palette_option (const char *value_str, options_t *opts)
 Parse –palette option and set opt_palette_type.
asciichat_error_t parse_palette_chars_option (const char *value_str, options_t *opts)
 Parse –palette-chars option and set opt_palette_custom.
asciichat_error_t parse_width_option (const char *value_str, options_t *opts)
 Parse –width option and set opts->width.
asciichat_error_t parse_height_option (const char *value_str, options_t *opts)
 Parse –height option and set opts->height.
asciichat_error_t parse_webcam_index_option (const char *value_str, options_t *opts)
 Parse –webcam-index option and set opts->webcam_index.
asciichat_error_t parse_snapshot_delay_option (const char *value_str, options_t *opts)
 Parse –snapshot-delay option and set opts->snapshot_delay.
asciichat_error_t parse_log_level_option (const char *value_str, options_t *opts)
 Parse –log-level option and set opt_log_level.
void print_project_links (FILE *desc)
 Update dimensions for full-height mode.

Detailed Description

Common utilities and helpers for option parsing across all modes.

This module provides shared utilities used by the entire options system:

  • Validators for numeric ranges, file existence, formats (IP, port, etc.)
  • String parsing helpers (safe integer conversion, color mode parsing, etc.)
  • Terminal dimension management functions
  • Option lookup and typo suggestion (Levenshtein distance)
  • SSH key detection and defaults

Design Philosophy:

  • Single Responsibility: Each validator handles one specific type of validation
  • Consistent Error Reporting: All validators provide helpful error messages
  • No Side Effects: Validators are pure functions (no global state modification)
  • Reusability: These functions are used by registry, builder, and parsers modules
  • Cross-Cutting Concerns: Handles validation needs for all modes uniformly

Validator Functions:

Return conventions:

  • Numeric validators: Return parsed value on success, INT_MIN/-1 on error
  • Boolean validators: Return true/false with error message on failure
  • String validators: Validate format, write to output buffer

Typical Usage:

// Validate port number
uint16_t port;
if (!validate_port_opt("8080", &port)) {
fprintf(stderr, "Invalid port: 8080\\n");
return false;
}
// Parse color mode from string
if (err != ASCIICHAT_OK) {
fprintf(stderr, "Unknown color mode\\n");
return false;
}
// Find similar option if user misspelled
const char *suggestion = find_similar_option("prot", all_options);
if (suggestion) {
fprintf(stderr, "Did you mean: --%s?\\n", suggestion);
}
unsigned short uint16_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ASCIICHAT_OK
Definition error_codes.h:50
const char * find_similar_option(const char *unknown_opt, const struct option *options)
Find a similar option name for typo suggestions.
bool validate_port_opt(const char *value_str, uint16_t *out_port)
Validate port number (1-65535).
asciichat_error_t parse_color_mode_option(const char *value_str, options_t *opts)
Parse –color-mode option and set opts->color_mode.

Option Parsing Helpers:

Display Option Parsers:

Terminal Functions:

Cryptography Helpers:

See also
options.h - Main Options Module module
registry.h - Central registry of all Options Module
builder.h - Builder API using these validators
validation.h - Additional Validation Helpers functions
Author
Zachary Fogg me@zf.nosp@m.o.gg
Date
January 2026

Definition in file include/ascii-chat/options/common.h.

Macro Definition Documentation

◆ OPTIONS_COMMON_H

#define OPTIONS_COMMON_H

Definition at line 91 of file include/ascii-chat/options/common.h.

Function Documentation

◆ detect_default_ssh_key()

asciichat_error_t detect_default_ssh_key ( char * key_path,
size_t path_size )

Detect default SSH key path for the current user.

Checks if ~/.ssh/id_ed25519 exists and is a regular file. Only supports Ed25519 keys (modern, secure, fast).

Parameters
key_pathBuffer to store detected key path
path_sizeSize of key_path buffer
Returns
ASCIICHAT_OK if found, ERROR_CRYPTO_KEY with helpful message otherwise
Note
Uses expand_path() to resolve tilde (~) in path
Prints message to stderr suggesting key generation if not found

Example:

char key_path[OPTIONS_BUFF_SIZE];
if (detect_default_ssh_key(key_path, sizeof(key_path)) == ASCIICHAT_OK) {
log_debug("Using default SSH key: %s", key_path);
SAFE_SNPRINTF(opt_encrypt_key, OPTIONS_BUFF_SIZE, "%s", key_path);
}
#define SAFE_SNPRINTF(buffer, buffer_size,...)
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
#define OPTIONS_BUFF_SIZE
Buffer size for option string values.
Definition options.h:305
asciichat_error_t detect_default_ssh_key(char *key_path, size_t path_size)
Detect default SSH key path for the current user.

Definition at line 181 of file options/common.c.

181 {
182 // Use expand_path utility to resolve ~/.ssh/id_ed25519
183 char *full_path = expand_path("~/.ssh/id_ed25519");
184 if (!full_path) {
185 return SET_ERRNO(ERROR_CONFIG, "Could not expand SSH key path");
186 }
187
188 // Check if the Ed25519 private key file exists
189 struct stat st;
190 bool found = (stat(full_path, &st) == 0 && S_ISREG(st.st_mode));
191
192 if (found) {
193 SAFE_SNPRINTF(key_path, path_size, "%s", full_path);
194 log_debug("Found default SSH key: %s", full_path);
195 SAFE_FREE(full_path);
196 return ASCIICHAT_OK;
197 }
198
199 log_error("No Ed25519 SSH key found at %s", full_path);
200 SAFE_FREE(full_path);
201 return SET_ERRNO(ERROR_CRYPTO_KEY, "Only Ed25519 keys are supported (modern, secure, fast). Generate a new key with: ssh-keygen -t ed25519");
202}
#define SET_ERRNO(code,...)
#define SAFE_FREE(ptr)
@ ERROR_CRYPTO_KEY
Definition error_codes.h:98
@ ERROR_CONFIG
Definition error_codes.h:56
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
char * expand_path(const char *path)
Expand path with tilde (~) support.
Definition path.c:257

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_CRYPTO_KEY, expand_path(), log_debug, log_error, SAFE_FREE, SAFE_SNPRINTF, and SET_ERRNO.

◆ find_similar_option()

const char * find_similar_option ( const char * unknown_opt,
const struct option * options )

Find a similar option name for typo suggestions.

Uses Levenshtein distance to find the most similar option name from the provided options array. Only suggests options within a reasonable edit distance.

Parameters
unknown_optThe unknown/misspelled option name
optionsArray of valid option structures (must be NULL-terminated)
Returns
Suggested option name, or NULL if no good match found
Note
Uses LEVENSHTEIN_SUGGESTION_THRESHOLD to filter poor matches

Example:

const char *suggestion = find_similar_option("--colr", client_options);
if (suggestion) {
fprintf(stderr, "Did you mean '--%s'?\n", suggestion);
}

References ERROR_INVALID_PARAM.

◆ format_available_modes()

const char * format_available_modes ( option_mode_bitmask_t mode_bitmask)

Format all available modes for an option as comma-separated list.

Converts a mode bitmask to a human-readable comma-separated list of mode names. Used in error messages to show which modes support a given option.

Parameters
mode_bitmaskBitmask of modes (OPTION_MODE_SERVER | OPTION_MODE_CLIENT, etc.)
Returns
Formatted string like "server, client, mirror" or "global options"
Note
Returns pointer to static buffer - not thread-safe

Example:

const char *modes = format_available_modes(bitmask);
// modes == "server, client"
option_mode_bitmask_t
Option mode bitmask.
Definition options.h:933
@ OPTION_MODE_CLIENT
Client mode (bit 1).
Definition options.h:936
@ OPTION_MODE_SERVER
Server mode (bit 0).
Definition options.h:935
const char * format_available_modes(option_mode_bitmask_t mode_bitmask)
Format all available modes for an option as comma-separated list.

Definition at line 118 of file options/common.c.

118 {
119 static char buffer[OPTIONS_COMMON_BUFFER_BUFFER_SIZE];
120 buffer[0] = '\0';
121
122 bool first = true;
123
124 // Check if it's a global/binary option
125 if (mode_bitmask & OPTION_MODE_BINARY) {
126 SAFE_SNPRINTF(buffer, sizeof(buffer), "global options");
127 return buffer;
128 }
129
130 // Build comma-separated list of modes (ordered: default, client, server, mirror, discovery-service)
131 if (mode_bitmask & OPTION_MODE_DISCOVERY) {
132 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%sdefault", first ? "" : ", ");
133 first = false;
134 }
135 if (mode_bitmask & OPTION_MODE_CLIENT) {
136 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%sclient", first ? "" : ", ");
137 first = false;
138 }
139 if (mode_bitmask & OPTION_MODE_SERVER) {
140 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%sserver", first ? "" : ", ");
141 first = false;
142 }
143 if (mode_bitmask & OPTION_MODE_MIRROR) {
144 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%smirror", first ? "" : ", ");
145 first = false;
146 }
147 if (mode_bitmask & OPTION_MODE_DISCOVERY_SVC) {
148 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%sdiscovery-service", first ? "" : ", ");
149 first = false;
150 }
151
152 if (mode_bitmask & OPTION_MODE_MCP_SERVER) {
153 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%smcp-server", first ? "" : ", ");
154 first = false;
155 }
156 if (mode_bitmask & OPTION_MODE_API_SERVER) {
157 safe_snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%sapi-server", first ? "" : ", ");
158 }
159
160 // Fallback if no modes matched
161 if (buffer[0] == '\0') {
162 SAFE_SNPRINTF(buffer, sizeof(buffer), "unknown mode");
163 }
164
165 return buffer;
166}
@ OPTION_MODE_BINARY
Binary-level options (parsed before mode detection).
Definition options.h:942
@ OPTION_MODE_API_SERVER
Definition options.h:941
@ OPTION_MODE_DISCOVERY
Discovery mode (bit 4).
Definition options.h:939
@ OPTION_MODE_MIRROR
Mirror mode (bit 2).
Definition options.h:937
@ OPTION_MODE_MCP_SERVER
Definition options.h:940
@ OPTION_MODE_DISCOVERY_SVC
Discovery server mode (bit 3).
Definition options.h:938
#define OPTIONS_COMMON_BUFFER_BUFFER_SIZE

References OPTION_MODE_API_SERVER, OPTION_MODE_BINARY, OPTION_MODE_CLIENT, OPTION_MODE_DISCOVERY, OPTION_MODE_DISCOVERY_SVC, OPTION_MODE_MCP_SERVER, OPTION_MODE_MIRROR, OPTION_MODE_SERVER, OPTIONS_COMMON_BUFFER_BUFFER_SIZE, and SAFE_SNPRINTF.

◆ get_required_argument()

char * get_required_argument ( const char * opt_value,
char * buffer,
size_t buffer_size,
const char * option_name,
asciichat_mode_t mode )

Handle required arguments with consistent error messages.

Validates that an option has a non-empty argument and processes it. Returns NULL on error with appropriate error message printed.

Handles edge cases:

  • NULL or empty opt_value
  • getopt_long bug where option name is returned as argument
  • Arguments with '=' prefix (GNU-style –option=value)
Parameters
opt_valueArgument value from getopt_long
bufferBuffer for storing processed argument
buffer_sizeSize of buffer
option_nameName of the option (for error messages)
modeCurrent mode (client/server/mirror) for error messages
Returns
Pointer to processed argument string in buffer, or NULL on error
Note
Prints "option '--<name>' requires an argument" to stderr on error
Used internally by validate_required_argument()

Example:

char argbuf[OPTIONS_BUFF_SIZE];
char *value = get_required_argument(optarg, argbuf, sizeof(argbuf), "key", MODE_CLIENT);
if (!value) {
return option_error_invalid();
}
SAFE_SNPRINTF(opt_encrypt_key, OPTIONS_BUFF_SIZE, "%s", value);
@ MODE_CLIENT
Client mode - network client options.
Definition options.h:918
char * get_required_argument(const char *opt_value, char *buffer, size_t buffer_size, const char *option_name, asciichat_mode_t mode)
Handle required arguments with consistent error messages.

Definition at line 229 of file options/common.c.

229 {
230 // Check if opt_value is NULL or empty
231 if (!opt_value || strlen(opt_value) == 0) {
232 goto error;
233 }
234
235 // Check if getopt_long returned the option name itself as the argument
236 // This happens when a long option requiring an argument is at the end of argv
237 if (opt_value && option_name && strcmp(opt_value, option_name) == 0) {
238 goto error;
239 }
240
241 // Process the argument normally
242 char *value_str = strip_equals_prefix(opt_value, buffer, buffer_size);
243 if (!value_str) {
244 goto error;
245 }
246
247 return value_str;
248
249error:
250 (void)0;
251 const char *mode_name = (mode == MODE_SERVER ? "server" : (mode == MODE_MIRROR ? "mirror" : "client"));
252 log_error("%s: option '--%s' requires an argument", mode_name, option_name);
253 return NULL; // Signal error to caller
254}
int buffer_size
Size of circular buffer.
Definition grep.c:68
@ MODE_SERVER
Server mode - network server options.
Definition options.h:917
@ MODE_MIRROR
Mirror mode - local webcam viewing (no network).
Definition options.h:919
char * strip_equals_prefix(const char *opt_value, char *buffer, size_t buffer_size)
Strip equals sign prefix from option argument.

References buffer_size, log_error, MODE_MIRROR, MODE_SERVER, and strip_equals_prefix().

Referenced by validate_required_argument().

◆ parse_color_mode_option()

asciichat_error_t parse_color_mode_option ( const char * value_str,
options_t * opts )

Parse –color-mode option and set opts->color_mode.

Validates color mode string and sets opts->color_mode field. Accepts: "auto", "none", "mono", "16", "16color", "256", "256color", "truecolor", "24bit"

Parameters
value_strColor mode string from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM on invalid mode
Note
Prints error message to stderr on failure
Sets opts->color_mode on success

Definition at line 298 of file options/common.c.

298 {
299 if (!value_str || !opts) {
300 return ERROR_INVALID_PARAM;
301 }
302
303 if (strcmp(value_str, OPT_VALUE_AUTO) == 0 || strcmp(value_str, "a") == 0) {
305 } else if (strcmp(value_str, OPT_COLOR_MODE_NONE) == 0 || strcmp(value_str, OPT_COLOR_MODE_MONO) == 0) {
307 } else if (strcmp(value_str, OPT_COLOR_MODE_16) == 0 || strcmp(value_str, "16color") == 0 || strcmp(value_str, "ansi") == 0) {
309 } else if (strcmp(value_str, OPT_COLOR_MODE_256) == 0 || strcmp(value_str, "256color") == 0) {
311 } else if (strcmp(value_str, OPT_COLOR_MODE_TRUECOLOR) == 0 || strcmp(value_str, "24bit") == 0 || strcmp(value_str, "tc") == 0 || strcmp(value_str, "rgb") == 0 ||
312 strcmp(value_str, OPT_VALUE_TRUE) == 0) {
314 } else {
315 log_error("Invalid color mode '%s'. Valid modes: auto, none, 16, 256, truecolor", value_str);
316 return ERROR_INVALID_PARAM;
317 }
318
319 return ASCIICHAT_OK;
320}
#define OPT_COLOR_MODE_256
Definition enums.h:101
#define OPT_VALUE_TRUE
Definition enums.h:78
#define OPT_COLOR_MODE_NONE
Definition enums.h:98
#define OPT_VALUE_AUTO
Definition enums.h:77
#define OPT_COLOR_MODE_TRUECOLOR
Definition enums.h:102
#define OPT_COLOR_MODE_MONO
Definition enums.h:99
#define OPT_COLOR_MODE_16
Definition enums.h:100
@ ERROR_INVALID_PARAM
#define COLOR_MODE_16_COLOR
16-color mode (full name)
Definition options.h:226
#define COLOR_MODE_256_COLOR
256-color mode (full name)
Definition options.h:228
#define COLOR_MODE_TRUECOLOR
24-bit truecolor mode
Definition options.h:229
#define COLOR_MODE_AUTO
Backward compatibility aliases for color mode enum values.
Definition options.h:223
#define COLOR_MODE_NONE
Monochrome mode.
Definition options.h:224
terminal_color_mode_t color_mode
Color mode (auto/none/16/256/truecolor).
Definition options.h:1084

References ASCIICHAT_OK, options_state::color_mode, COLOR_MODE_16_COLOR, COLOR_MODE_256_COLOR, COLOR_MODE_AUTO, COLOR_MODE_NONE, COLOR_MODE_TRUECOLOR, ERROR_INVALID_PARAM, log_error, OPT_COLOR_MODE_16, OPT_COLOR_MODE_256, OPT_COLOR_MODE_MONO, OPT_COLOR_MODE_NONE, OPT_COLOR_MODE_TRUECOLOR, OPT_VALUE_AUTO, and OPT_VALUE_TRUE.

◆ parse_height_option()

asciichat_error_t parse_height_option ( const char * value_str,
options_t * opts )

Parse –height option and set opts->height.

Validates height value and sets opts->height and opts->auto_height fields.

Parameters
value_strHeight value from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if invalid
Note
Prints error message to stderr on failure
Sets opts->height and opts->auto_height = false on success

Definition at line 401 of file options/common.c.

401 {
402 if (!opts) {
403 return ERROR_INVALID_PARAM;
404 }
405
406 int32_t height_val;
407 if (!flags_parse_int32(value_str, &height_val) || height_val <= 0) {
408 log_error("Invalid height value '%s'. Height must be a positive integer.", value_str ? value_str : "(null)");
409 return ERROR_INVALID_PARAM;
410 }
411
412 opts->height = height_val;
413 opts->auto_height = false;
414
415 return ASCIICHAT_OK;
416}
int height
Terminal height in characters (int for OPTION_TYPE_INT compat).
Definition options.h:992
bool auto_height
Auto-detect height from terminal.
Definition options.h:994

References ASCIICHAT_OK, options_state::auto_height, ERROR_INVALID_PARAM, options_state::height, and log_error.

◆ parse_log_level_option()

asciichat_error_t parse_log_level_option ( const char * value_str,
options_t * opts )

Parse –log-level option and set opt_log_level.

Validates log level string and sets global opt_log_level variable. Accepts: "dev", "debug", "info", "warn", "error", "fatal" (case-insensitive)

Parameters
value_strLog level string from command line
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if invalid
Note
Prints error message to stderr on failure
Sets opt_log_level global variable on success
Uses validate_opt_log_level() from validation.h

Definition at line 451 of file options/common.c.

451 {
452 if (!opts) {
453 return ERROR_INVALID_PARAM;
454 }
455
456 char error_msg[BUFFER_SIZE_SMALL];
457 int log_level = validate_opt_log_level(value_str, error_msg, sizeof(error_msg));
458
459 if (log_level == -1) {
460 log_error("%s", error_msg);
461 return ERROR_INVALID_PARAM;
462 }
463
464 opts->log_level = (log_level_t)log_level;
465
466 return ASCIICHAT_OK;
467}
#define BUFFER_SIZE_SMALL
Small buffer size (256 bytes).
log_level_t
Logging levels enumeration.
Definition types.h:33
int validate_opt_log_level(const char *value_str, char *error_msg, size_t error_msg_size)
Validate log level string.
Definition validation.c:239
log_level_t log_level
Log level threshold.
Definition options.h:1160

References ASCIICHAT_OK, BUFFER_SIZE_SMALL, ERROR_INVALID_PARAM, log_error, options_state::log_level, and validate_opt_log_level().

◆ parse_palette_chars_option()

asciichat_error_t parse_palette_chars_option ( const char * value_str,
options_t * opts )

Parse –palette-chars option and set opt_palette_custom.

Validates custom palette characters and sets global opt_palette_custom, opt_palette_custom_set, and opt_palette_type variables.

Parameters
value_strCustom palette characters from command line
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if too long
Note
Prints error message to stderr on failure
Sets opt_palette_custom, opt_palette_custom_set, and opt_palette_type on success
Maximum length is 255 characters (sizeof(opt_palette_custom) - 1)

Definition at line 366 of file options/common.c.

366 {
367 if (!value_str || !opts) {
368 return ERROR_INVALID_PARAM;
369 }
370
371 if (strlen(value_str) >= sizeof(opts->palette_custom)) {
372 log_error("Invalid palette-chars: too long (%zu chars, max %zu)", strlen(value_str), sizeof(opts->palette_custom) - 1);
373 return ERROR_INVALID_PARAM;
374 }
375
376 SAFE_STRNCPY(opts->palette_custom, value_str, sizeof(opts->palette_custom));
377 opts->palette_custom[sizeof(opts->palette_custom) - 1] = '\0';
378 opts->palette_custom_set = true;
380
381 return ASCIICHAT_OK;
382}
#define SAFE_STRNCPY(dst, src, size)
@ PALETTE_CUSTOM
User-defined via –palette-chars.
Definition palette.h:110
char palette_custom[256]
Custom palette characters.
Definition options.h:1221
bool palette_custom_set
True if custom palette was set.
Definition options.h:1222
palette_type_t palette_type
Selected palette type.
Definition options.h:1220

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_error, PALETTE_CUSTOM, options_state::palette_custom, options_state::palette_custom_set, options_state::palette_type, and SAFE_STRNCPY.

◆ parse_palette_option()

asciichat_error_t parse_palette_option ( const char * value_str,
options_t * opts )

Parse –palette option and set opt_palette_type.

Validates palette type string and sets global opt_palette_type variable. Accepts: "standard", "blocks", "digital", "minimal", "cool", "custom"

Parameters
value_strPalette type string from command line
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM on invalid palette
Note
Prints error message to stderr on failure
Sets opt_palette_type global variable on success

Definition at line 341 of file options/common.c.

341 {
342 if (!value_str || !opts) {
343 return ERROR_INVALID_PARAM;
344 }
345
346 if (strcmp(value_str, OPT_PALETTE_STANDARD) == 0) {
348 } else if (strcmp(value_str, OPT_PALETTE_BLOCKS) == 0) {
350 } else if (strcmp(value_str, OPT_PALETTE_DIGITAL) == 0) {
352 } else if (strcmp(value_str, OPT_PALETTE_MINIMAL) == 0) {
354 } else if (strcmp(value_str, OPT_PALETTE_COOL) == 0) {
356 } else if (strcmp(value_str, OPT_PALETTE_CUSTOM) == 0) {
358 } else {
359 log_error("Invalid palette '%s'. Valid palettes: standard, blocks, digital, minimal, cool, custom", value_str);
360 return ERROR_INVALID_PARAM;
361 }
362
363 return ASCIICHAT_OK;
364}
#define OPT_PALETTE_CUSTOM
Definition enums.h:125
#define OPT_PALETTE_COOL
Definition enums.h:124
#define OPT_PALETTE_MINIMAL
Definition enums.h:123
#define OPT_PALETTE_BLOCKS
Definition enums.h:121
#define OPT_PALETTE_STANDARD
Definition enums.h:120
#define OPT_PALETTE_DIGITAL
Definition enums.h:122
@ PALETTE_BLOCKS
Unicode block characters: " ░░▒▒▓▓██".
Definition palette.h:102
@ PALETTE_COOL
Ascending blocks: " ▁▂▃▄▅▆▇█".
Definition palette.h:108
@ PALETTE_STANDARD
Standard ASCII palette: " ...',;:clodxkO0KXNWM".
Definition palette.h:100
@ PALETTE_DIGITAL
Digital/glitch aesthetic: " -=≡≣▰▱◼".
Definition palette.h:104
@ PALETTE_MINIMAL
Simple ASCII: " .-+*#".
Definition palette.h:106

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_error, OPT_PALETTE_BLOCKS, OPT_PALETTE_COOL, OPT_PALETTE_CUSTOM, OPT_PALETTE_DIGITAL, OPT_PALETTE_MINIMAL, OPT_PALETTE_STANDARD, PALETTE_BLOCKS, PALETTE_COOL, PALETTE_CUSTOM, PALETTE_DIGITAL, PALETTE_MINIMAL, PALETTE_STANDARD, and options_state::palette_type.

◆ parse_render_mode_option()

asciichat_error_t parse_render_mode_option ( const char * value_str,
options_t * opts )

Parse –render-mode option and set opts->render_mode.

Validates render mode string and sets opts->render_mode field. Accepts: "foreground", "fg", "background", "bg", "half-block", "halfblock"

Parameters
value_strRender mode string from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM on invalid mode
Note
Prints error message to stderr on failure
Sets opts->render_mode on success

Definition at line 322 of file options/common.c.

322 {
323 if (!value_str || !opts) {
324 return ERROR_INVALID_PARAM;
325 }
326
327 if (strcmp(value_str, OPT_RENDER_MODE_FOREGROUND) == 0 || strcmp(value_str, OPT_RENDER_MODE_FG) == 0) {
328 opts->render_mode = RENDER_MODE_FOREGROUND;
329 } else if (strcmp(value_str, OPT_RENDER_MODE_BACKGROUND) == 0 || strcmp(value_str, OPT_RENDER_MODE_BG) == 0) {
330 opts->render_mode = RENDER_MODE_BACKGROUND;
331 } else if (strcmp(value_str, OPT_RENDER_MODE_HALF_BLOCK) == 0 || strcmp(value_str, "halfblock") == 0) {
332 opts->render_mode = RENDER_MODE_HALF_BLOCK;
333 } else {
334 log_error("Invalid render mode '%s'. Valid modes: foreground, background, half-block", value_str);
335 return ERROR_INVALID_PARAM;
336 }
337
338 return ASCIICHAT_OK;
339}
#define OPT_RENDER_MODE_BG
Definition enums.h:131
#define OPT_RENDER_MODE_FOREGROUND
Definition enums.h:128
#define OPT_RENDER_MODE_HALF_BLOCK
Definition enums.h:132
#define OPT_RENDER_MODE_FG
Definition enums.h:129
#define OPT_RENDER_MODE_BACKGROUND
Definition enums.h:130
terminal_render_mode_t render_mode
Render mode (foreground/background/half-block).
Definition options.h:1087

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_error, OPT_RENDER_MODE_BACKGROUND, OPT_RENDER_MODE_BG, OPT_RENDER_MODE_FG, OPT_RENDER_MODE_FOREGROUND, OPT_RENDER_MODE_HALF_BLOCK, and options_state::render_mode.

◆ parse_snapshot_delay_option()

asciichat_error_t parse_snapshot_delay_option ( const char * value_str,
options_t * opts )

Parse –snapshot-delay option and set opts->snapshot_delay.

Validates snapshot delay (non-negative float) and sets opts->snapshot_delay field.

Parameters
value_strSnapshot delay in seconds from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if invalid
Note
Prints error message to stderr on failure
Sets opts->snapshot_delay on success

Definition at line 434 of file options/common.c.

434 {
435 if (!value_str || !opts) {
436 return ERROR_INVALID_PARAM;
437 }
438
439 char *endptr;
440 float delay = strtof(value_str, &endptr);
441 if (endptr == value_str || *endptr != '\0' || delay < 0.0f) {
442 log_error("Invalid snapshot delay '%s'. Must be a non-negative number.", value_str);
443 return ERROR_INVALID_PARAM;
444 }
445
446 opts->snapshot_delay = delay;
447
448 return ASCIICHAT_OK;
449}
double snapshot_delay
Snapshot delay in seconds.
Definition options.h:1143

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_error, and options_state::snapshot_delay.

◆ parse_webcam_index_option()

asciichat_error_t parse_webcam_index_option ( const char * value_str,
options_t * opts )

Parse –webcam-index option and set opts->webcam_index.

Validates webcam index and sets opts->webcam_index field.

Parameters
value_strWebcam index from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if invalid
Note
Prints error message to stderr on failure
Sets opts->webcam_index on success

Definition at line 418 of file options/common.c.

418 {
419 if (!opts) {
420 return ERROR_INVALID_PARAM;
421 }
422
423 int32_t index_val;
424 if (!flags_parse_int32(value_str, &index_val) || index_val < 0 || index_val > USHRT_MAX) {
425 log_error("Invalid webcam index '%s'. Webcam index must be a non-negative integer.", value_str ? value_str : "(null)");
426 return ERROR_INVALID_PARAM;
427 }
428
429 opts->webcam_index = (unsigned short int)index_val;
430
431 return ASCIICHAT_OK;
432}
int webcam_index
Webcam device index (0 = first).
Definition options.h:1062

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_error, and options_state::webcam_index.

◆ parse_width_option()

asciichat_error_t parse_width_option ( const char * value_str,
options_t * opts )

Parse –width option and set opts->width.

Validates width value and sets opts->width and opts->auto_width fields.

Parameters
value_strWidth value from command line
optsOptions struct to update
Returns
ASCIICHAT_OK on success, ERROR_INVALID_PARAM if invalid
Note
Prints error message to stderr on failure
Sets opts->width and opts->auto_width = false on success

Definition at line 384 of file options/common.c.

384 {
385 if (!opts) {
386 return ERROR_INVALID_PARAM;
387 }
388
389 int32_t width_val;
390 if (!flags_parse_int32(value_str, &width_val) || width_val <= 0) {
391 log_error("Invalid width value '%s'. Width must be a positive integer.", value_str ? value_str : "(null)");
392 return ERROR_INVALID_PARAM;
393 }
394
395 opts->width = width_val;
396 opts->auto_width = false;
397
398 return ASCIICHAT_OK;
399}
int width
Terminal width in characters (int for OPTION_TYPE_INT compat).
Definition options.h:991
bool auto_width
Auto-detect width from terminal.
Definition options.h:993

References ASCIICHAT_OK, options_state::auto_width, ERROR_INVALID_PARAM, log_error, and options_state::width.

◆ print_project_links()

void print_project_links ( FILE * desc)

Update dimensions for full-height mode.

Sets opt_height to terminal height when auto-detected. Used during initialization to maximize vertical space usage.

Behavior:

  • Both auto: Set both width and height to terminal size
  • Only height auto: Set height to terminal height
  • Only width auto: Set width to terminal width
  • Neither auto: No change
Note
Does not use log_debug because logging may not be initialized yet
Fails silently if terminal size detection fails (keeps defaults)

Example:

// During options_init():
}
void update_dimensions_for_full_height(options_t *opts)
Update dimensions to use full terminal height while maintaining aspect ratio.
bool auto_height
bool auto_width

Update dimensions to current terminal size

Updates opt_width and opt_height to current terminal size for auto-detected dimensions. Used after logging is initialized (can use log_debug).

Behavior:

  • auto_width: Set width to terminal width
  • auto_height: Set height to terminal height
  • Neither: No change
Note
Logs debug messages about dimension updates
Logs debug message if terminal size detection fails

Example:

// After logging initialization:
log_info("Terminal dimensions: %dx%d", opt_width, opt_height);
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
void update_dimensions_to_terminal_size(options_t *opts)
Update dimensions to match current terminal size.

Print project links with link emoji and colored styling

Parameters
descOutput file stream (typically stdout)

Definition at line 621 of file options/common.c.

621 {
622 if (!desc) {
623 return;
624 }
625
626 (void)fprintf(desc, "🔗 %s\n", colored_string(LOG_COLOR_GREY, "https://ascii-chat.com"));
627 (void)fprintf(desc, "🔗 %s\n", colored_string(LOG_COLOR_GREY, "https://github.com/zfogg/ascii-chat"));
628}
@ LOG_COLOR_GREY
Definition log/log.h:153
const char * colored_string(log_color_t color, const char *text)
Build a colored string for terminal output.

References colored_string(), and LOG_COLOR_GREY.

◆ read_password_from_stdin()

char * read_password_from_stdin ( const char * prompt)

Read password from stdin with prompt.

Parameters
promptPrompt message to display to user
Returns
Allocated password string (caller must free), or NULL on error

Prompts user for password input using prompt_password_simple() from util/password.h. Returns dynamically allocated string that must be freed by caller.

Note
Returns NULL if password input fails or if not running in a TTY.
Caller must use SAFE_FREE() to deallocate returned string.

Definition at line 257 of file options/common.c.

257 {
258 char *password_buf = SAFE_MALLOC(PASSWORD_MAX_LEN, char *);
259 if (!password_buf) {
260 return NULL;
261 }
262
263 if (prompt_password_simple(prompt, password_buf, PASSWORD_MAX_LEN) != 0) {
264 SAFE_FREE(password_buf);
265 return NULL;
266 }
267
268 return password_buf; // Caller must free
269}
#define SAFE_MALLOC(size, cast)
#define PASSWORD_MAX_LEN
Buffer size for password input.
Definition password.h:31
int prompt_password_simple(const char *prompt, char *password, size_t max_len)
Prompt the user for a password with simple formatting.
Definition password.c:31

References PASSWORD_MAX_LEN, prompt_password_simple(), SAFE_FREE, and SAFE_MALLOC.

◆ strip_equals_prefix()

char * strip_equals_prefix ( const char * opt_value,
char * buffer,
size_t buffer_size )

Strip equals sign prefix from option argument.

Internal helper that handles GNU-style long options with = syntax (–option=value). Copies argument to buffer and returns pointer past the '=' if present.

Parameters
opt_valueRaw option value from getopt_long
bufferBuffer to store processed value
buffer_sizeSize of buffer
Returns
Pointer to value in buffer (past '=' if present), or NULL if empty
Note
Returns NULL for empty strings after stripping '='
Buffer is always null-terminated via SAFE_SNPRINTF

Example:

char argbuf[OPTIONS_BUFF_SIZE];
char *value = strip_equals_prefix("=1234", argbuf, sizeof(argbuf));
// value points to "1234" in argbuf

Definition at line 209 of file options/common.c.

209 {
210 if (!opt_value)
211 return NULL;
212
213 SAFE_SNPRINTF(buffer, buffer_size, "%s", opt_value);
214 char *value_str = buffer;
215 if (value_str[0] == '=') {
216 value_str++; // Skip the equals sign
217 }
218
219 // Return NULL for empty strings (treat as missing argument)
220 if (strlen(value_str) == 0) {
221 return NULL;
222 }
223
224 return value_str;
225}

References buffer_size, and SAFE_SNPRINTF.

Referenced by get_required_argument().

◆ validate_fps_opt()

bool validate_fps_opt ( const char * value_str,
int * out_fps )

Validate FPS value (0 for auto, otherwise 1-144).

Internal option parsing helper that validates FPS is in reasonable range. Range chosen to support 1 FPS (slideshows) to 144 FPS (high refresh monitors).

Parameters
value_strString to validate
out_fpsOutput parameter for validated FPS
Returns
true if valid, false otherwise

Example:

int fps;
if (!validate_fps_opt(optarg, &fps)) {
return option_error_invalid();
}
opt_fps = fps;
bool validate_fps_opt(const char *value_str, int *out_fps)
Validate FPS value (0 for auto, otherwise 1-144).

Definition at line 48 of file options/common.c.

48 {
49 int32_t fps = 0;
50 if (!out_fps || !flags_parse_int32(value_str, &fps) || fps <= 0)
51 return false;
52 *out_fps = fps;
53 return true;
54}

◆ validate_options_and_report()

asciichat_error_t validate_options_and_report ( const void * config,
const void * opts )

Validate options and report errors to stderr.

Calls options_config_validate() and handles error message display and cleanup. Validates all option dependencies, conflicts, and custom validators.

Parameters
configOptions configuration (opaque pointer, defined in builder.h)
optsOptions struct to validate
Returns
ASCIICHAT_OK if valid, error code otherwise
Note
Prints error message to stderr if validation fails
Frees error message internally

Example:

if (result != ASCIICHAT_OK) {
return result;
}
void options_config_destroy(options_config_t *config)
Free options config.
asciichat_error_t validate_options_and_report(const void *config, const void *opts)
Validate options and report errors to stderr.

Definition at line 592 of file options/common.c.

592 {
593 if (!opts) {
594 return SET_ERRNO(ERROR_INVALID_PARAM, "Options are NULL");
595 }
596
597 const options_t *options = (const options_t *)opts;
598 if (options->webrtc_relay_only && options->detected_mode == MODE_CLIENT) {
599 return SET_ERRNO(ERROR_INVALID_PARAM, "Relay only requires discovery mode; connect using a session name");
600 }
601 if (options->webrtc_relay_only && options->detected_mode == MODE_SERVER && !options->discovery) {
602 return SET_ERRNO(ERROR_INVALID_PARAM, "Server relay only requires --discovery");
603 }
604 if (options->webrtc_relay_only && (options->no_webrtc || options->webrtc_disable_turn)) {
605 return SET_ERRNO(ERROR_INVALID_PARAM, "--webrtc-relay-only conflicts with --no-webrtc or --webrtc-disable-turn");
606 }
607 if ((options->turn_username[0] != '\0') != (options->turn_credential[0] != '\0')) {
608 return SET_ERRNO(ERROR_INVALID_PARAM, "Provide both --turn-username and --turn-credential, or leave both blank");
609 }
610 if (strlen(options->turn_username) > 127 || strlen(options->turn_credential) > 127) {
611 return SET_ERRNO(ERROR_INVALID_PARAM, "TURN username and credential must each fit 127 bytes");
612 }
613 (void)config;
614 return options_validate_libflags((options_t *)options);
615}
struct options_state options_t
Immutable, RCU-published snapshot of the application's runtime configuration.
asciichat_error_t options_validate_libflags(options_t *options)
Definition options.c:1617
bool discovery
Enable discovery session registration (default: false).
Definition options.h:1027
bool webrtc_relay_only
–webrtc-relay-only: Require TURN relay candidates
Definition options.h:1202
asciichat_mode_t detected_mode
Mode detected from command-line arguments.
Definition options.h:978
bool no_webrtc
–no-webrtc: Disable WebRTC, use Direct TCP only
Definition options.h:1199
bool webrtc_disable_turn
–webrtc-disable-turn: Disable Stage 3 (TURN), use STUN only
Definition options.h:1203
char turn_credential[256]
ACDS: Credential/password for TURN authentication.
Definition options.h:1214
char turn_username[256]
ACDS: Username for TURN authentication.
Definition options.h:1213

References options_state::detected_mode, options_state::discovery, ERROR_INVALID_PARAM, MODE_CLIENT, MODE_SERVER, options_state::no_webrtc, options_validate_libflags(), SET_ERRNO, options_state::turn_credential, options_state::turn_username, options_state::webrtc_disable_turn, and options_state::webrtc_relay_only.

◆ validate_port_opt()

bool validate_port_opt ( const char * value_str,
uint16_t * out_port )

Validate port number (1-65535).

Internal option parsing helper that validates a port number is in valid range. Uses parse_port() for robust validation.

Parameters
value_strString to validate
out_portOutput parameter for validated port
Returns
true if valid, false otherwise

Example:

uint16_t port;
if (!validate_port_opt(optarg, &port)) {
return option_error_invalid();
}
opt_port = port;

Definition at line 42 of file options/common.c.

42 {
43 if (!out_port || !value_str)
44 return false;
45 return flags_parse_port(value_str, out_port);
46}

◆ validate_positive_int_opt()

bool validate_positive_int_opt ( const char * value_str,
int * out_value,
const char * param_name )

Validate a positive integer value.

Internal option parsing helper that validates a string represents a positive integer (> 0). Prints error message on failure.

Parameters
value_strString to validate
out_valueOutput parameter for validated integer
param_nameParameter name for error messages
Returns
true if valid, false otherwise

Example:

int fps;
if (!validate_positive_int_opt(optarg, &fps, "FPS")) {
return option_error_invalid();
}
bool validate_positive_int_opt(const char *value_str, int *out_value, const char *param_name)
Validate a positive integer value.

◆ validate_required_argument()

char * validate_required_argument ( const char * optarg,
char * argbuf,
size_t argbuf_size,
const char * option_name,
asciichat_mode_t mode )

Validate and retrieve required argument for an option.

Wrapper around get_required_argument() that also sets error code on failure. Used for options that must have an argument.

Parameters
optargArgument value from getopt_long
argbufBuffer for storing processed argument
argbuf_sizeSize of argbuf
option_nameName of the option (for error messages)
modeCurrent mode (client/server/mirror) for error messages
Returns
Pointer to processed argument string in argbuf, or NULL on error
Note
On error, prints message to stderr and calls option_error_invalid()

Example:

char argbuf[OPTIONS_BUFF_SIZE];
char *value = validate_required_argument(optarg, argbuf, sizeof(argbuf), "port", MODE_CLIENT);
if (!value) {
return option_error_invalid();
}
char * validate_required_argument(const char *optarg, char *argbuf, size_t argbuf_size, const char *option_name, asciichat_mode_t mode)
Validate and retrieve required argument for an option.

Definition at line 172 of file options/common.c.

172 {
173 char *value = get_required_argument(optarg, argbuf, argbuf_size, option_name, mode);
174 if (!value) {
175 (void)option_error_invalid();
176 }
177 return value;
178}

References get_required_argument().

◆ validate_webcam_index()

bool validate_webcam_index ( const char * value_str,
unsigned short int * out_index )

Validate webcam index using the common device index validator.

Validates webcam index is a non-negative integer. Unlike audio device indices, webcam indices do not support -1 (default).

Parameters
value_strString to validate
out_indexOutput parameter for validated index
Returns
true if valid, false otherwise

Example:

unsigned short int webcam_idx;
if (!validate_webcam_index(optarg, &webcam_idx)) {
return option_error_invalid();
}
opt_webcam_index = webcam_idx;
bool validate_webcam_index(const char *value_str, unsigned short int *out_index)
Validate webcam index using the common device index validator.

References buffer_size.