strings.c File Reference

Session string generation and validation implementation. More...

Go to the source code of this file.

Data Structures
struct	word_cache_entry_t
	Hashtable entry for cached word lookups. More...

Functions
void	acds_strings_destroy (void)
	Cleanup function for session string cache Called by asciichat_shared_destroy() during library cleanup. Safe to call multiple times (idempotent).
asciichat_error_t	acds_string_init (void)
asciichat_error_t	acds_string_generate (char *output, size_t output_size)
bool	is_session_string (const char *str)

Detailed Description

Session string generation and validation implementation.

This module generates memorable session strings in the format: adjective-noun-noun (e.g., "swift-river-mountain")

It maintains cached hashtables of adjectives and nouns for fast O(1) validation, ensuring session strings only contain real words.

Definition in file discovery/strings.c.

Function Documentation

acds_string_generate()

asciichat_error_t acds_string_generate	(	char *	output,
		size_t	output_size
	)

Definition at line 192 of file discovery/strings.c.

                                                                         {
  if (!output || output_size < SESSION_STRING_BUFFER_SIZE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "output buffer must be at least %zu bytes",
                     (size_t)SESSION_STRING_BUFFER_SIZE);
  }
 
  // libsodium is guaranteed to be initialized by acds_string_init() before this is called
  // No need to call sodium_init() again (redundant initialization removed)
 
  // Pick random adjective
  uint32_t adj_idx = randombytes_uniform((uint32_t)adjectives_count);
  const char *adj = adjectives[adj_idx];
 
  // Pick two random nouns
  uint32_t noun1_idx = randombytes_uniform((uint32_t)nouns_count);
  uint32_t noun2_idx = randombytes_uniform((uint32_t)nouns_count);
  const char *noun1 = nouns[noun1_idx];
  const char *noun2 = nouns[noun2_idx];
 
  // Format: adjective-noun-noun
  int written = safe_snprintf(output, output_size, "%s-%s-%s", adj, noun1, noun2);
  if (written < 0 || (size_t)written >= output_size) {
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Session string too long for buffer");
  }
 
  log_dev("Generated session string: %s", output);
  return ASCIICHAT_OK;
}

References adjectives, adjectives_count, nouns, nouns_count, and safe_snprintf().

Referenced by database_session_create(), options_preset_unified(), and server_main().

acds_string_init()

asciichat_error_t acds_string_init

(

void

)

Definition at line 183 of file discovery/strings.c.

                                         {
  // Fast initialization - only init libsodium
  // Hashtable building is deferred until actually needed for validation
  if (sodium_init() < 0) {
    return SET_ERRNO(ERROR_CRYPTO_INIT, "Failed to initialize libsodium");
  }
  return ASCIICHAT_OK;
}

Referenced by acds_main().

acds_strings_destroy()

void acds_strings_destroy

(

void

)

Cleanup function for session string cache Called by asciichat_shared_destroy() during library cleanup. Safe to call multiple times (idempotent).

Definition at line 54 of file discovery/strings.c.

                                {
  if (!g_cache_initialized) {
    return;
  }
 
  // Cleanup adjectives cache
  word_cache_entry_t *adj_entry, *adj_tmp;
  HASH_ITER(hh, g_adjectives_cache, adj_entry, adj_tmp) {
    HASH_DEL(g_adjectives_cache, adj_entry);
    SAFE_FREE(adj_entry->word);
    SAFE_FREE(adj_entry);
  }
  g_adjectives_cache = NULL;
 
  // Cleanup nouns cache
  word_cache_entry_t *noun_entry, *noun_tmp;
  HASH_ITER(hh, g_nouns_cache, noun_entry, noun_tmp) {
    HASH_DEL(g_nouns_cache, noun_entry);
    SAFE_FREE(noun_entry->word);
    SAFE_FREE(noun_entry);
  }
  g_nouns_cache = NULL;
 
  g_cache_initialized = false;
  log_dev("Session string word cache cleaned up");
}

References word_cache_entry_t::word.

Referenced by asciichat_shared_destroy().

is_session_string()

bool is_session_string

(

const char *

str

)

Definition at line 221 of file discovery/strings.c.

                                        {
  if (!str || str[0] == '\0') {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string is NULL or empty");
    return false;
  }
 
  size_t len = strlen(str);
 
  // Check length bounds
  if (len < 5 || len > 47) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string length %zu outside valid range 5-47", len);
    return false;
  }
 
  // Session strings must be ASCII-only (homograph attack prevention)
  if (!utf8_is_ascii_only(str)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string contains non-ASCII characters");
    return false;
  }
 
  // Get compiled regex (lazy initialization)
  pcre2_code *regex = session_format_regex_get();
  if (!regex) {
    SET_ERRNO(ERROR_INTERNAL, "Session string PCRE2 regex failed to initialize");
    return false;
  }
 
  // Validate format using PCRE2 regex
  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
  if (!match_data) {
    log_error("Failed to allocate match data for session string regex");
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate match data");
    return false;
  }
 
  int match_result = pcre2_jit_match(regex, (PCRE2_SPTR8)str, len, 0, 0, match_data, NULL);
 
  pcre2_match_data_free(match_data);
 
  if (match_result < 0) {
    // Format validation failed
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string format does not match pattern");
    return false;
  }
 
  // Extract the three words by finding hyphens
  // Format is guaranteed to be: word-word-word where each word is 2-12 lowercase letters
  const char *hyphen1 = strchr(str, '-');
  if (!hyphen1) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string missing first hyphen");
    return false;
  }
 
  const char *hyphen2 = strchr(hyphen1 + 1, '-');
  if (!hyphen2) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string missing second hyphen");
    return false;
  }
 
  // Extract three words
  size_t adj_len = hyphen1 - str;
  size_t noun1_len = hyphen2 - hyphen1 - 1;
  size_t noun2_len = len - (hyphen2 - str) - 1;
 
  if (adj_len >= 32 || noun1_len >= 32 || noun2_len >= 32) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string word length out of bounds");
    return false;
  }
 
  char adj[32], noun1[32], noun2[32];
  memcpy(adj, str, adj_len);
  adj[adj_len] = '\0';
  memcpy(noun1, hyphen1 + 1, noun1_len);
  noun1[noun1_len] = '\0';
  memcpy(noun2, hyphen2 + 1, noun2_len);
  noun2[noun2_len] = '\0';
 
  // Lazy initialization: build validation caches on first use
  // Note: build_validation_caches() handles synchronization internally
  if (!g_cache_initialized) {
    asciichat_error_t cache_err = build_validation_caches();
    if (cache_err != ASCIICHAT_OK) {
      log_warn("Failed to initialize session string cache; accepting format-valid string");
      log_dev("Valid session string format (cache unavailable): %s", str);
      return true; // Format is valid, cache is unavailable, accept anyway
    }
  }
 
  // Validate first word is an adjective
  word_cache_entry_t *adj_entry = NULL;
  HASH_FIND_STR(g_adjectives_cache, adj, adj_entry);
  if (!adj_entry) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string first word '%s' is not a valid adjective", adj);
    return false;
  }
 
  // Validate second and third words are nouns
  word_cache_entry_t *noun_entry1 = NULL;
  HASH_FIND_STR(g_nouns_cache, noun1, noun_entry1);
  if (!noun_entry1) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string second word '%s' is not a valid noun", noun1);
    return false;
  }
 
  word_cache_entry_t *noun_entry2 = NULL;
  HASH_FIND_STR(g_nouns_cache, noun2, noun_entry2);
  if (!noun_entry2) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Session string third word '%s' is not a valid noun", noun2);
    return false;
  }
 
  log_dev("Valid session string: %s", str);
  return true;
}

References utf8_is_ascii_only().

Referenced by database_session_create(), discover_session_parallel(), and parse_client_address().