update_checker.c File Reference

Update checker implementation with GitHub API and cache management. More...

Go to the source code of this file.

Macros
#define	UPDATE_CHECK_CACHE_FILENAME   "last_update_check"
#define	UPDATE_CHECK_CACHE_MAX_AGE_SECONDS   (7 * 24 * 60 * 60)
#define	DNS_TIMEOUT_SECONDS   2
#define	GITHUB_API_HOSTNAME   "api.github.com"
#define	GITHUB_RELEASES_PATH   "/repos/zfogg/ascii-chat/releases/latest"

Functions
asciichat_error_t	update_check_load_cache (update_check_result_t *result)
asciichat_error_t	update_check_save_cache (const update_check_result_t *result)
bool	update_check_is_cache_fresh (const update_check_result_t *result)
asciichat_error_t	update_check_perform (update_check_result_t *result)
install_method_t	update_check_detect_install_method (void)
void	update_check_get_upgrade_suggestion (install_method_t method, const char *latest_version, char *buffer, size_t buffer_size)
void	update_check_format_notification (const update_check_result_t *result, char *buffer, size_t buffer_size)
asciichat_error_t	update_check_startup (update_check_result_t *result)

Detailed Description

Update checker implementation with GitHub API and cache management.

Definition in file update_checker.c.

Macro Definition Documentation

DNS_TIMEOUT_SECONDS

#define DNS_TIMEOUT_SECONDS   2

Definition at line 34 of file update_checker.c.

GITHUB_API_HOSTNAME

#define GITHUB_API_HOSTNAME   "api.github.com"

Definition at line 37 of file update_checker.c.

GITHUB_RELEASES_PATH

#define GITHUB_RELEASES_PATH   "/repos/zfogg/ascii-chat/releases/latest"

Definition at line 38 of file update_checker.c.

UPDATE_CHECK_CACHE_FILENAME

#define UPDATE_CHECK_CACHE_FILENAME   "last_update_check"

Definition at line 28 of file update_checker.c.

UPDATE_CHECK_CACHE_MAX_AGE_SECONDS

#define UPDATE_CHECK_CACHE_MAX_AGE_SECONDS   (7 * 24 * 60 * 60)

Definition at line 31 of file update_checker.c.

Function Documentation

update_check_detect_install_method()

install_method_t update_check_detect_install_method

(

void

)

Definition at line 387 of file update_checker.c.

                                                          {
  if (is_homebrew_install()) {
    return INSTALL_METHOD_HOMEBREW;
  }
 
  if (is_arch_linux()) {
    return INSTALL_METHOD_ARCH_AUR;
  }
 
  // Default to GitHub releases
  return INSTALL_METHOD_GITHUB;
}

Referenced by update_check_format_notification().

update_check_format_notification()

void update_check_format_notification	(	const update_check_result_t *	result,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 429 of file update_checker.c.

                                                                                                             {
  if (!result || !buffer || buffer_size == 0) {
    return;
  }
 
  // Get upgrade suggestion
  install_method_t method = update_check_detect_install_method();
  char suggestion[512];
  update_check_get_upgrade_suggestion(method, result->latest_version, suggestion, sizeof(suggestion));
 
  // Format: "Update available: v0.8.1 (f8dc35e1) → v0.9.0 (a1b2c3d4). Run: brew upgrade ascii-chat"
  snprintf(buffer, buffer_size, "Update available: %s (%.8s) → %s (%.8s). %s%s", result->current_version,
           result->current_sha, result->latest_version, result->latest_sha,
           (method == INSTALL_METHOD_GITHUB || method == INSTALL_METHOD_UNKNOWN) ? "Download: " : "Run: ", suggestion);
}

References buffer_size, update_check_detect_install_method(), and update_check_get_upgrade_suggestion().

Referenced by action_check_update_immediate(), and main().

update_check_get_upgrade_suggestion()

void update_check_get_upgrade_suggestion	(	install_method_t	method,
		const char *	latest_version,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 400 of file update_checker.c.

                                                             {
  if (!buffer || buffer_size == 0) {
    return;
  }
 
  switch (method) {
  case INSTALL_METHOD_HOMEBREW:
    snprintf(buffer, buffer_size, "brew upgrade ascii-chat");
    break;
 
  case INSTALL_METHOD_ARCH_AUR:
    // Check if paru is available, otherwise suggest yay
    if (system("command -v paru >/dev/null 2>&1") == 0) {
      snprintf(buffer, buffer_size, "paru -S ascii-chat");
    } else {
      snprintf(buffer, buffer_size, "yay -S ascii-chat");
    }
    break;
 
  case INSTALL_METHOD_GITHUB:
  case INSTALL_METHOD_UNKNOWN:
  default:
    snprintf(buffer, buffer_size, "https://github.com/zfogg/ascii-chat/releases/tag/%s",
             latest_version ? latest_version : "latest");
    break;
  }
}

References buffer_size.

Referenced by update_check_format_notification().

update_check_is_cache_fresh()

bool update_check_is_cache_fresh

(

const update_check_result_t *

result

)

Definition at line 172 of file update_checker.c.

                                                                      {
  if (!result || result->last_check_time == 0) {
    return false;
  }
 
  time_t now = time(NULL);
  time_t age = now - result->last_check_time;
 
  return (age < UPDATE_CHECK_CACHE_MAX_AGE_SECONDS);
}

References UPDATE_CHECK_CACHE_MAX_AGE_SECONDS.

Referenced by update_check_startup().

update_check_load_cache()

asciichat_error_t update_check_load_cache

(

update_check_result_t *

result

)

Definition at line 61 of file update_checker.c.

                                                                         {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  memset(result, 0, sizeof(*result));
 
  char *cache_path = get_cache_file_path();
  if (!cache_path) {
    return SET_ERRNO(ERROR_FILE_OPERATION, "Could not determine cache file path");
  }
 
  FILE *f = platform_fopen(cache_path, "r");
  if (!f) {
    const char *error_msg = file_read_error_message(cache_path);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "%s", error_msg);
  }
 
  // Read line 1: timestamp
  char line[512];
  if (!fgets(line, sizeof(line), f)) {
    fclose(f);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "Failed to read timestamp from cache");
  }
  result->last_check_time = (time_t)atoll(line);
 
  // Read line 2: latest version (may be empty if check failed)
  if (fgets(line, sizeof(line), f)) {
    // Remove newline
    size_t len = strlen(line);
    if (len > 0 && line[len - 1] == '\n') {
      line[len - 1] = '\0';
    }
    SAFE_STRNCPY(result->latest_version, line, sizeof(result->latest_version));
  }
 
  // Read line 3: latest SHA (may be empty if check failed)
  if (fgets(line, sizeof(line), f)) {
    // Remove newline
    size_t len = strlen(line);
    if (len > 0 && line[len - 1] == '\n') {
      line[len - 1] = '\0';
    }
    SAFE_STRNCPY(result->latest_sha, line, sizeof(result->latest_sha));
  }
 
  fclose(f);
 
  // Fill in current version/SHA
  SAFE_STRNCPY(result->current_version, ASCII_CHAT_VERSION_STRING, sizeof(result->current_version));
  SAFE_STRNCPY(result->current_sha, ASCII_CHAT_GIT_COMMIT_HASH, sizeof(result->current_sha));
 
  // Determine if update is available using version comparison (if we have cached data)
  if (result->latest_version[0] != '\0') {
    semantic_version_t current_ver = version_parse(result->current_version);
    semantic_version_t latest_ver = version_parse(result->latest_version);
 
    if (current_ver.valid && latest_ver.valid) {
      int cmp = version_compare(latest_ver, current_ver);
      result->update_available = (cmp > 0); // Update available if latest > current
      result->check_succeeded = true;
    } else {
      // Cache contains invalid version data - delete it
      log_warn("Update cache contains invalid version data (current:%s, latest:%s) - deleting corrupted cache",
               result->current_version, result->latest_version);
      if (remove(cache_path) != 0) {
        log_warn("Failed to delete corrupted cache file: %s", cache_path);
      }
      SAFE_FREE(cache_path);
      return SET_ERRNO(ERROR_FORMAT, "Corrupted cache file deleted");
    }
  }
 
  SAFE_FREE(cache_path);
  return ASCIICHAT_OK;
}

References file_read_error_message(), platform_fopen(), version_compare(), and version_parse().

Referenced by update_check_startup().

update_check_perform()

asciichat_error_t update_check_perform

(

update_check_result_t *

result

)

Definition at line 268 of file update_checker.c.

                                                                      {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  memset(result, 0, sizeof(*result));
 
  // Fill in current version and SHA
  SAFE_STRNCPY(result->current_version, ASCII_CHAT_VERSION_STRING, sizeof(result->current_version));
  SAFE_STRNCPY(result->current_sha, ASCII_CHAT_GIT_COMMIT_HASH, sizeof(result->current_sha));
  result->last_check_time = time(NULL);
 
  // Test DNS connectivity first
  if (!dns_test_connectivity(GITHUB_API_HOSTNAME)) {
    log_warn("No internet connectivity detected, skipping update check");
    // Don't update cache - we'll retry when online
    return SET_ERRNO(ERROR_NETWORK, "DNS connectivity test failed");
  }
 
  // Fetch latest release from GitHub API
  log_info("Checking for updates from GitHub releases...");
  char *response = https_get(GITHUB_API_HOSTNAME, GITHUB_RELEASES_PATH);
  if (!response) {
    log_warn("Failed to fetch GitHub releases API (timeout or network error)");
    // Mark as checked even though it failed (prevents repeated offline attempts)
    result->check_succeeded = false;
    update_check_save_cache(result);
    return SET_ERRNO(ERROR_NETWORK, "Failed to fetch GitHub releases");
  }
 
  // Parse JSON response
  char latest_tag[64] = {0};
  char latest_sha[41] = {0};
  char release_url[512] = {0};
 
  if (!parse_github_release_json(response, latest_tag, sizeof(latest_tag), latest_sha, sizeof(latest_sha), release_url,
                                 sizeof(release_url))) {
    log_error("Failed to parse GitHub API response");
    SAFE_FREE(response);
    result->check_succeeded = false;
    update_check_save_cache(result);
    return SET_ERRNO(ERROR_FORMAT, "Failed to parse GitHub API JSON");
  }
 
  SAFE_FREE(response);
 
  // Fill in result
  SAFE_STRNCPY(result->latest_version, latest_tag, sizeof(result->latest_version));
  SAFE_STRNCPY(result->latest_sha, latest_sha, sizeof(result->latest_sha));
  SAFE_STRNCPY(result->release_url, release_url, sizeof(result->release_url));
  result->check_succeeded = true;
 
  // Compare versions semantically
  semantic_version_t current_ver = version_parse(result->current_version);
  semantic_version_t latest_ver = version_parse(result->latest_version);
 
  if (!current_ver.valid || !latest_ver.valid) {
    log_warn("Failed to parse version strings for comparison (current: %s, latest: %s)", result->current_version,
             result->latest_version);
    result->update_available = false;
  } else {
    int cmp = version_compare(latest_ver, current_ver);
    result->update_available = (cmp > 0); // Update available if latest > current
  }
 
  if (result->update_available) {
    log_info("Update available: %s (%.*s) → %s (%.*s)", result->current_version, 8, result->current_sha,
             result->latest_version, 8, result->latest_sha);
  } else {
    log_info("Already on latest version: %s (%.*s)", result->current_version, 8, result->current_sha);
  }
 
  // Save to cache
  update_check_save_cache(result);
 
  return ASCIICHAT_OK;
}

References dns_test_connectivity(), GITHUB_API_HOSTNAME, GITHUB_RELEASES_PATH, https_get(), update_check_save_cache(), version_compare(), and version_parse().

Referenced by action_check_update_immediate(), and update_check_startup().

update_check_save_cache()

asciichat_error_t update_check_save_cache

(

const update_check_result_t *

result

)

Definition at line 140 of file update_checker.c.

                                                                               {
  if (!result) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL result pointer");
  }
 
  char *cache_path = get_cache_file_path();
  if (!cache_path) {
    return SET_ERRNO(ERROR_FILE_OPERATION, "Could not determine cache file path");
  }
 
  FILE *f = platform_fopen(cache_path, "w");
  if (!f) {
    const char *error_msg = file_write_error_message(cache_path);
    SAFE_FREE(cache_path);
    return SET_ERRNO(ERROR_FILE_OPERATION, "%s", error_msg);
  }
 
  // Write timestamp
  fprintf(f, "%lld\n", (long long)result->last_check_time);
 
  // Write version (may be empty if check failed)
  fprintf(f, "%s\n", result->latest_version);
 
  // Write SHA (may be empty if check failed)
  fprintf(f, "%s\n", result->latest_sha);
 
  fclose(f);
  SAFE_FREE(cache_path);
 
  return ASCIICHAT_OK;
}

References file_write_error_message(), and platform_fopen().

Referenced by update_check_perform().

update_check_startup()

asciichat_error_t update_check_startup

(

update_check_result_t *

result

)

Definition at line 445 of file update_checker.c.

                                                                      {
  update_check_result_t local_result;
  update_check_result_t *target = result ? result : &local_result;
 
  // Try to load from cache first
  asciichat_error_t cache_err = update_check_load_cache(target);
  if (cache_err == ASCIICHAT_OK && update_check_is_cache_fresh(target)) {
    // Cache is fresh, use it
    log_debug("Using cached update check result (age: %.1f days)",
              (time(NULL) - target->last_check_time) / (double)SEC_PER_DAY);
    return ASCIICHAT_OK;
  }
 
  // Cache is stale or missing, perform fresh check
  log_debug("Performing automatic update check (cache %s)", cache_err == ASCIICHAT_OK ? "stale" : "missing");
  asciichat_error_t check_err = update_check_perform(target);
  if (check_err != ASCIICHAT_OK) {
    // Check failed, but don't fail startup
    log_debug("Automatic update check failed (continuing startup)");
    return check_err;
  }
 
  return ASCIICHAT_OK;
}

References update_check_is_cache_fresh(), update_check_load_cache(), and update_check_perform().

Referenced by main().