system.c

Go to the documentation of this file.

 
#ifndef PLATFORM_SYSTEM_C
#define PLATFORM_SYSTEM_C
 
#include <ascii-chat/atomic.h>
#include <stdarg.h>
#include <stdio.h>
#include <errno.h>
#include <ascii-chat/common.h>
#include <ascii-chat/uthash.h> // UBSan-safe uthash wrapper
#include <ascii-chat/log/log.h>
#include <ascii-chat/log/format.h>
#include <ascii-chat/util/string.h>
#include <ascii-chat/util/lifecycle.h>
#include <ascii-chat/platform/filesystem.h>
#include <time.h>
 
// Forward declaration for filesystem functions
extern bool check_binary_in_path_uncached(const char *bin_name);
 
// Platform-specific binary suffix
#ifdef _WIN32
#define BIN_SUFFIX ".exe"
#else
#define BIN_SUFFIX ""
#endif
// PATH_DELIM and PATH_ENV_SEPARATOR are now defined in system.h
 
// ============================================================================
// Maximum Path Length
// ============================================================================
 
#ifdef _WIN32
// Windows extended-length path maximum
// Reference: https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
#define PLATFORM_MAX_PATH_LENGTH 32767
#elif defined(__linux__)
// Linux PATH_MAX (typically 4096)
#ifndef PATH_MAX
#define PLATFORM_MAX_PATH_LENGTH 4096
#else
#define PLATFORM_MAX_PATH_LENGTH PATH_MAX
#endif
#elif defined(__APPLE__)
// macOS PATH_MAX (typically 1024)
#ifndef PATH_MAX
#define PLATFORM_MAX_PATH_LENGTH 1024
#else
#define PLATFORM_MAX_PATH_LENGTH PATH_MAX
#endif
#else
// Fallback for unknown platforms
#define PLATFORM_MAX_PATH_LENGTH 4096
#endif
 
// ============================================================================
// Binary PATH Detection Cache
// ============================================================================
 
typedef struct {
  char *bin_name;
  bool in_path;
  UT_hash_handle hh;
} bin_cache_entry_t;
 
// ============================================================================
// Public API
// ============================================================================
 
int safe_snprintf(char *buffer, size_t buffer_size, const char *format, ...) {
  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;
}
 
int safe_fprintf(FILE *stream, const char *format, ...) {
  if (!stream || !format) {
    return -1;
  }
 
  va_list args;
  va_start(args, format);
  int ret = vfprintf(stream, format, args);
  va_end(args);
 
  return ret;
}
 
int safe_vsnprintf(char *buffer, size_t buffer_size, const char *format, va_list ap) {
  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);
}
 
// ============================================================================
// I/O Functions
// ============================================================================
 
size_t platform_write_all(int fd, const void *buf, size_t count) {
  if (!buf || count == 0) {
    return 0;
  }
 
  size_t written_total = 0;
  int attempts = 0;
  const int MAX_ATTEMPTS = 1000;
 
  while (written_total < count && attempts < MAX_ATTEMPTS) {
    ssize_t result = platform_write(fd, (const char *)buf + written_total, count - written_total);
 
    if (result > 0) {
      written_total += (size_t)result;
      attempts = 0; // Reset attempt counter on successful write
    } else if (result < 0) {
      // Handle EAGAIN (non-blocking would-block) with sleep instead of tight loop
      if (errno == EAGAIN || errno == EWOULDBLOCK) {
        // Sleep 100us before retrying to avoid busy-waiting and spinning CPU
        platform_sleep_us(100);
      } else {
        // Other write errors - log and retry
        log_warn("platform_write_all: write() error on fd=%d (wrote %zu/%zu so far, errno=%d)", fd, written_total,
                 count, errno);
      }
      attempts++;
    } else {
      // result == 0: no bytes written, retry
      attempts++;
    }
  }
 
  if (attempts >= MAX_ATTEMPTS && written_total < count) {
    log_warn("platform_write_all: Hit retry limit on fd=%d: wrote %zu of %zu bytes", fd, written_total, count);
  }
 
  return written_total;
}
#endif // PLATFORM_SYSTEM_C