env.c

Go to the documentation of this file.

 
#include <ascii-chat/util/env.h>
#include <ascii-chat/common.h>
#include <ascii-chat/log/log.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static const char *find_unescaped_semicolon(const char *str) {
  if (!str) {
    return NULL;
  }
 
  const char *p = str;
  while (*p) {
    if (*p == '\\' && *(p + 1)) {
      // Skip escaped character (\\  or \;)
      p += 2;
      continue;
    }
    if (*p == ';') {
      return p;
    }
    p++;
  }
  return NULL;
}
 
static void unescape_response(char *str) {
  if (!str) {
    return;
  }
 
  char *read = str;
  char *write = str;
 
  while (*read) {
    if (*read == '\\' && *(read + 1)) {
      // Escaped character: \; → ; or \\ → \.
      read++; // Skip backslash
      *write++ = *read++;
    } else {
      *write++ = *read++;
    }
  }
  *write = '\0';
}
 
bool env_pop_prompt_response(char *response_out, size_t response_size) {
  if (!response_out || response_size < 2) {
    return false;
  }
 
  const char *env_value = SAFE_GETENV("ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
  if (!env_value || env_value[0] == '\0') {
    return false;
  }
 
  // Validate: no leading semicolon (unless escaped)
  if (env_value[0] == ';') {
    log_warn("Invalid ASCII_CHAT_QUESTION_PROMPT_RESPONSE format: leading semicolon");
    return false;
  }
 
  // Find the first unescaped semicolon
  const char *semicolon = find_unescaped_semicolon(env_value);
 
  if (semicolon == NULL) {
    // No semicolon - this is the last (or only) response
    size_t len = strlen(env_value);
    if (len == 0) {
      return false;
    }
 
    // Validate: ensure it's not empty
    if (len >= response_size) {
      log_warn("Response too long: %zu bytes (max: %zu)", len, response_size - 1);
      return false;
    }
 
    // Copy the response
    SAFE_STRNCPY(response_out, env_value, response_size);
 
    // Unescape the response (\; → ; and \\ → \‍)
    unescape_response(response_out);
 
    // Clear the environment variable
    platform_unsetenv("ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
 
    log_dev("Popped last response from stack: '%s' (cleared env)", response_out);
    return true;
  }
 
  // Calculate response length
  size_t response_len = (size_t)(semicolon - env_value);
 
  // Validate: no empty segment
  if (response_len == 0) {
    log_warn("Invalid ASCII_CHAT_QUESTION_PROMPT_RESPONSE format: empty segment");
    return false;
  }
 
  if (response_len >= response_size) {
    log_warn("Response too long: %zu bytes (max: %zu)", response_len, response_size - 1);
    return false;
  }
 
  // Copy the first response
  memcpy(response_out, env_value, response_len);
  response_out[response_len] = '\0';
 
  // Unescape the response (\; → ; and \\ → \‍)
  unescape_response(response_out);
 
  // Calculate remaining stack (skip the semicolon)
  const char *remaining = semicolon + 1;
 
  // Validate: if remaining is empty or only semicolons, clear the env
  bool remaining_valid = false;
  for (const char *p = remaining; *p; p++) {
    if (*p != ';') {
      remaining_valid = true;
      break;
    }
  }
 
  // Update environment variable with remaining responses
  if (remaining_valid && remaining[0] != '\0') {
    char new_env[1024];
    int written = snprintf(new_env, sizeof(new_env), "ASCII_CHAT_QUESTION_PROMPT_RESPONSE=%s", remaining);
    if (written < 0 || (size_t)written >= sizeof(new_env)) {
      log_warn("Failed to format new environment variable");
      return false;
    }
 
    if (platform_setenv("ASCII_CHAT_QUESTION_PROMPT_RESPONSE", remaining) != 0) {
      log_warn("Failed to update ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
      return false;
    }
 
    log_debug("Popped response from stack: '%s' (remaining: '%s')", response_out, remaining);
  } else {
    // No valid remaining responses - clear the env
    platform_unsetenv("ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
 
    log_debug("Popped response from stack: '%s' (cleared env)", response_out);
  }
 
  return true;
}
 
bool env_has_prompt_response(void) {
  const char *env_value = SAFE_GETENV("ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
  if (!env_value || env_value[0] == '\0' || env_value[0] == ';') {
    return false;
  }
 
  // Check if it's all semicolons
  for (const char *p = env_value; *p; p++) {
    if (*p != ';') {
      return true;
    }
  }
 
  return false;
}
 
bool env_validate_prompt_response_format(void) {
  const char *env_value = SAFE_GETENV("ASCII_CHAT_QUESTION_PROMPT_RESPONSE");
  if (!env_value) {
    return true; // Not set is valid (no automated responses)
  }
 
  if (env_value[0] == '\0') {
    return true; // Empty is valid (no automated responses)
  }
 
  // Invalid: leading semicolon (unless escaped)
  if (env_value[0] == ';') {
    return false;
  }
 
  // Check for consecutive unescaped semicolons or empty segments
  const char *p = env_value;
  bool last_was_semicolon = false;
 
  while (*p) {
    if (*p == '\\' && *(p + 1)) {
      // Skip escaped character
      last_was_semicolon = false;
      p += 2;
      continue;
    }
    if (*p == ';') {
      if (last_was_semicolon) {
        return false; // Consecutive unescaped semicolons (empty segment)
      }
      last_was_semicolon = true;
    } else {
      last_was_semicolon = false;
    }
    p++;
  }
 
  // Trailing semicolon is allowed
  return true;
}