ocran 1.3.18 → 1.4.0

data/src/system_utils.h

@@ -0,0 +1,209 @@
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef _WIN32
+#define PATH_SEPARATOR '\\'
+#else
+#define PATH_SEPARATOR '/'
+#endif
+
+static inline bool is_path_separator(char c) {
+#ifdef _WIN32
+    return c == '\\' || c == '/';
+#else
+    return c == '/';
+#endif
+}
+
+/**
+ * @brief   Check if a path is a “clean” relative path.
+ *
+ * A clean relative path satisfies all of the following:
+ *   - Non-NULL, non-empty (`path != NULL && *path != '\0'`)
+ *   - Does not start with a path separator (`'/'` or `'\'`)
+ *   - On Windows, does not use a drive-letter specifier (e.g. `"C:\"`)
+ *   - Contains no empty segments (no `"//"` or `"\\"`)
+ *   - Contains no `"."` or `".."` segments
+ *
+ * @param   path  A null-terminated string representing the path to validate.
+ * @return  true  if the input meets all clean-relative-path criteria;  
+ *          false otherwise.
+ */
+bool IsCleanRelativePath(const char *path);
+
+/**
+ * JoinPath - Combines two file path components into a single path.
+ *
+ * @param p1 The first path component.
+ * @param p2 The second path component.
+ * @return A pointer to a newly allocated string that represents the combined file path.
+ *         Returns NULL if either input is NULL, empty, or if memory allocation fails.
+ */
+char *JoinPath(const char *p1, const char *p2);
+
+/**
+ * @brief  Returns a newly allocated string containing the parent
+ *         directory for a given path.
+ * @param  path  Input path (must be non-NULL).
+ * @return
+ *   - NULL       if path is NULL or on allocation failure.
+ *   - ""         if path is empty or has no parent segment.
+ *   - otherwise  malloc’d NUL-terminated parent path (caller must free).
+ */
+char *GetParentPath(const char *path);
+
+/**
+ * CreateDirectoriesRecursively - Creates a directory and all its parent directories if they do not exist.
+ *
+ * @param dir The path of the directory to create.
+ * @return true if the directory was successfully created or already exists.
+ *         false if the directory could not be created due to an error.
+ */
+bool CreateDirectoriesRecursively(const char *dir);
+
+/**
+ * DeleteRecursively - Deletes a directory and all its contents recursively.
+ *
+ * @param path The path of the directory to delete.
+ * @return true if the directory and its contents were successfully deleted.
+ *         false if the directory could not be fully deleted due to an error.
+ */
+bool DeleteRecursively(const char *path);
+
+/**
+ * @brief Windows-side replacement for POSIX mkdtemp().
+ *
+ * The string \t tmpl must end with at least six ’X’ characters.
+ * Those X’s are replaced with random portable-filename characters and
+ * the function tries to create the directory.  
+ *
+ * @param tmpl  Writable, NUL-terminated buffer ending in “XXXXXX”.
+ * @return      tmpl on success (now holding the new path), or NULL on error
+ *              with errno set.
+ */
+char *CreateUniqueDirectory(char *tmpl);
+
+/**
+ * GetImagePath - Retrieves the full path of the executable file of the current process.
+ *
+ * @return A pointer to a newly allocated string that represents the full path of the executable.
+ *         Returns NULL if the path could not be retrieved or if memory allocation fails.
+ */
+char *GetImagePath(void);
+
+/**
+ * GetTempDirectoryPath - Retrieves the path of the temporary directory for the current user.
+ *
+ * @return A pointer to a newly allocated string that represents the path of the temporary directory.
+ *         Returns NULL if the path could not be retrieved or if memory allocation fails.
+ */
+char *GetTempDirectoryPath(void);
+
+/**
+ * @brief Writes the contents of a buffer to the specified file path.
+ *        Creates any missing parent directories and overwrites existing files.
+ *
+ * @param path        Output file path (absolute or relative).
+ * @param buffer      Pointer to the data buffer to write.
+ * @param buffer_size Size of the data buffer in bytes.
+ * @return            true if the write succeeded, false otherwise.
+ */
+bool ExportFile(const char *path, const void *buffer, size_t buffer_size);
+
+/**
+ * @brief Opaque handle to a memory-mapped file region.
+ *
+ * The contents of this structure are private; users must
+ * obtain and destroy instances via the API functions below.
+ */
+typedef struct MemoryMap MemoryMap;
+
+/**
+ * @brief Creates a memory map for the entire contents of a file.
+ *
+ * Opens @p path in read-only mode and maps its full length
+ * into memory.  The returned pointer must later be passed to
+ * DestroyMemoryMap() to unmap and free resources.
+ *
+ * @param path        Path to an existing file to map; must not be NULL.
+ * @return            Pointer to a new MemoryMap on success, or NULL on failure.
+ */
+MemoryMap *CreateMemoryMap(const char *path);
+
+/**
+ * @brief Unmaps and destroys a MemoryMap object.
+ *
+ * Releases the mapped view and frees all associated resources.
+ * After this call, @p map is no longer valid.  Passing NULL
+ * will log an error but otherwise do nothing.
+ *
+ * @param map         MemoryMap instance to destroy.
+ */
+void DestroyMemoryMap(MemoryMap *map);
+
+/**
+ * @brief Returns the base address of the mapped view.
+ *
+ * @param map         A valid MemoryMap returned by CreateMemoryMap.
+ *                    Must not be NULL.
+ * @return            Base address of the mapping, or NULL if @p map is NULL.
+ */
+void *GetMemoryMapBase(const MemoryMap *map);
+
+/**
+ * @brief Returns the size of the mapped region in bytes.
+ *
+ * @param map         A valid MemoryMap returned by CreateMemoryMap.
+ *                    Must not be NULL.
+ * @return            Size in bytes of the mapping, or 0 if @p map is NULL.
+ *                    Note: 0 may also be a valid size for an empty file.
+ */
+size_t GetMemoryMapSize(const MemoryMap *map);
+
+/**
+ * @brief Initialize signal and control handling.
+ *
+ * This function sets up console control and POSIX signal handlers so that
+ * the parent process is not prematurely terminated during initialization and
+ * cleanup phases. On Windows, a console control handler is registered to ignore
+ * control events (e.g., Ctrl+C) in the parent process. On POSIX, relevant
+ * signals (SIGINT, SIGTERM, SIGHUP) can be configured to allow cleanup
+ * processing before exit.
+ *
+ * @return
+ *   - true  if initialization succeeded  
+ *   - false if an error occurred (e.g., SetConsoleCtrlHandler failed)
+ */
+bool InitializeSignalHandling(void);
+
+/**
+ * @brief Sets or removes an environment variable.
+ *
+ * Sets the specified environment variable to the given value. If value is NULL,
+ * the variable will be removed from the environment. Returns true on success,
+ * false if the operation fails.
+ *
+ * @param name  Name of the environment variable to set or remove.
+ * @param value Value to assign to the variable, or NULL to remove it.
+ * @return true if the operation succeeded; false otherwise.
+ */
+bool SetEnvVar(const char *name, const char *value);
+
+/**
+ * @brief Launches the specified application with given arguments,
+ *        waits for it to finish, and retrieves its exit code.
+ *
+ * @param app_name
+ *   Path of the executable to run.
+ * @param argv
+ *   NULL-terminated array of argument strings; each element is one argument.
+ * @param exit_code
+ *   Pointer to an int where the child process’s exit code will be stored.
+ * @return
+ *   True if the process was successfully created, waited on, and its exit
+ *   code retrieved; false otherwise.
+ */
+bool CreateAndWaitForProcess(const char *app_name, char *argv[], int *exit_code);

data/src/system_utils_posix.c

@@ -0,0 +1,500 @@
+#ifdef __APPLE__
+#include <mach-o/dyld.h>
+#endif
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "error.h"
+#include "system_utils.h"
+
+/* Opaque handle for memory-mapped files */
+struct MemoryMap {
+    int fd;
+    void *base;
+    size_t size;
+};
+
+/* ===== Cross-platform path utilities (from system_utils.c) ===== */
+
+bool IsCleanRelativePath(const char *path)
+{
+    if (!path || !*path) {
+        return false;
+    }
+
+#ifdef _WIN32
+    /* Forbid Windows drive specification (e.g. "C:\") */
+    if (((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z'))
+        && path[1] == ':'
+        && is_path_separator(path[2])) {
+        return false;
+    }
+#endif
+
+    /* Forbid absolute path (leading '/' or '\') */
+    if (is_path_separator(*path)) {
+        return false;
+    }
+
+    /* Validate each path segment */
+    const char *p = path;
+    while (*p) {
+        const char *start = p;
+
+        /* Advance until next separator or end-of-string */
+        while (*p && !is_path_separator(*p)) {
+            p++;
+        }
+
+        size_t len = p - start;
+
+        /* Reject empty, "." or ".." segments */
+        if (len == 0
+            || (len == 1 && start[0] == '.')
+            || (len == 2 && start[0] == '.' && start[1] == '.')) {
+            return false;
+        }
+
+        /* Skip over the separator */
+        if (*p) {
+            p++;
+        }
+    }
+
+    return true;
+}
+
+char *JoinPath(const char *p1, const char *p2)
+{
+    if (p1 == NULL || *p1 == '\0') {
+        APP_ERROR("p1 is null or empty");
+        return NULL;
+    }
+
+    if (p2 == NULL || *p2 == '\0') {
+        APP_ERROR("p2 is null or empty");
+        return NULL;
+    }
+
+    size_t p1_len = strlen(p1);
+    if (is_path_separator(p1[p1_len - 1])) { p1_len--; }
+
+    size_t p2_len = strlen(p2);
+    const char *p2_start = p2;
+    if (is_path_separator(*p2_start)) { p2_start++; p2_len--; }
+
+    size_t joined_len = p1_len + 1 + p2_len;
+    char *joined_path = calloc(1, joined_len + 1);
+    if (!joined_path) {
+        APP_ERROR("Failed to allocate buffer for join path");
+        return NULL;
+    }
+    memcpy(joined_path, p1, p1_len);
+    joined_path[p1_len] = PATH_SEPARATOR;
+    memcpy(joined_path + p1_len + 1, p2_start, p2_len);
+    joined_path[joined_len] = '\0';
+
+    return joined_path;
+}
+
+char *GetParentPath(const char *path)
+{
+    if (!path) {
+        APP_ERROR("path is NULL");
+        return NULL;
+    }
+
+    size_t len = strlen(path);
+    size_t i   = len;
+
+    /* Skip any trailing separators */
+    while (i > 0 && is_path_separator(path[i])) {
+        i--;
+    }
+
+    /* Skip the last segment's characters */
+    while (i > 0 && !is_path_separator(path[i])) {
+        i--;
+    }
+
+    /* i==0 ⇒ empty parent */
+
+    char *out = malloc(i + 1);
+    if (!out) {
+        APP_ERROR("Memory allocation failed for parent path");
+        return NULL;
+    }
+    memcpy(out, path, i);
+    out[i] = '\0';
+    return out;
+}
+
+/* ===== Memory-mapped file I/O ===== */
+
+MemoryMap *CreateMemoryMap(const char *path) {
+    if (!path) {
+        FATAL("CreateMemoryMap: path is NULL");
+        return NULL;
+    }
+
+    MemoryMap *map = malloc(sizeof(MemoryMap));
+    if (!map) {
+        FATAL("CreateMemoryMap: malloc failed");
+        return NULL;
+    }
+
+    int fd = open(path, O_RDONLY);
+    if (fd < 0) {
+        FATAL("CreateMemoryMap: open(\"%s\") failed: %s", path, strerror(errno));
+        free(map);
+        return NULL;
+    }
+
+    struct stat st;
+    if (fstat(fd, &st) < 0) {
+        FATAL("CreateMemoryMap: fstat failed: %s", strerror(errno));
+        close(fd);
+        free(map);
+        return NULL;
+    }
+
+    size_t size = (size_t)st.st_size;
+    void *base = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (base == MAP_FAILED) {
+        FATAL("CreateMemoryMap: mmap failed: %s", strerror(errno));
+        close(fd);
+        free(map);
+        return NULL;
+    }
+
+    map->fd = fd;
+    map->base = base;
+    map->size = size;
+    return map;
+}
+
+void DestroyMemoryMap(MemoryMap *map) {
+    if (!map) {
+        FATAL("DestroyMemoryMap: map is NULL");
+        return;
+    }
+
+    if (map->base && map->size > 0) {
+        munmap(map->base, map->size);
+    }
+    if (map->fd >= 0) {
+        close(map->fd);
+    }
+    free(map);
+}
+
+void *GetMemoryMapBase(const MemoryMap *map) {
+    return map ? map->base : NULL;
+}
+
+size_t GetMemoryMapSize(const MemoryMap *map) {
+    return map ? map->size : 0;
+}
+
+/* ===== File and directory operations ===== */
+
+bool CreateDirectoriesRecursively(const char *dir) {
+    if (!dir || !*dir) {
+        return false;
+    }
+
+    /* Check if directory already exists */
+    struct stat st;
+    if (stat(dir, &st) == 0) {
+        if (S_ISDIR(st.st_mode)) {
+            return true;
+        }
+        FATAL("CreateDirectoriesRecursively: \"%s\" exists but is not a directory", dir);
+        return false;
+    }
+
+    /* Create parent directory recursively */
+    char *parent = GetParentPath(dir);
+    if (parent && *parent) {
+        if (!CreateDirectoriesRecursively(parent)) {
+            free(parent);
+            return false;
+        }
+        free(parent);
+    }
+
+    /* Create this directory */
+    if (mkdir(dir, 0755) < 0) {
+        if (errno == EEXIST) {
+            return true;  /* Race condition: created by another thread */
+        }
+        FATAL("CreateDirectoriesRecursively: mkdir(\"%s\") failed: %s", dir, strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool DeleteRecursively(const char *path) {
+    if (!path || !*path) {
+        return false;
+    }
+
+    struct stat st;
+    if (lstat(path, &st) < 0) {
+        FATAL("DeleteRecursively: stat(\"%s\") failed: %s", path, strerror(errno));
+        return false;
+    }
+
+    if (!S_ISDIR(st.st_mode)) {
+        /* It's a file, just delete it */
+        if (unlink(path) < 0) {
+            FATAL("DeleteRecursively: unlink(\"%s\") failed: %s", path, strerror(errno));
+            return false;
+        }
+        return true;
+    }
+
+    /* It's a directory, delete contents recursively */
+    DIR *dir = opendir(path);
+    if (!dir) {
+        FATAL("DeleteRecursively: opendir(\"%s\") failed: %s", path, strerror(errno));
+        return false;
+    }
+
+    bool success = true;
+    struct dirent *entry;
+    while ((entry = readdir(dir)) != NULL) {
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+            continue;
+        }
+
+        char *child_path = JoinPath(path, entry->d_name);
+        if (!child_path) {
+            success = false;
+            break;
+        }
+
+        if (!DeleteRecursively(child_path)) {
+            free(child_path);
+            success = false;
+            break;
+        }
+        free(child_path);
+    }
+
+    closedir(dir);
+
+    if (success) {
+        if (rmdir(path) < 0) {
+            FATAL("DeleteRecursively: rmdir(\"%s\") failed: %s", path, strerror(errno));
+            return false;
+        }
+    }
+
+    return success;
+}
+
+char *CreateUniqueDirectory(char *tmpl) {
+    if (!tmpl) {
+        return NULL;
+    }
+
+    char *result = mkdtemp(tmpl);
+    if (!result) {
+        FATAL("CreateUniqueDirectory: mkdtemp failed: %s", strerror(errno));
+        return NULL;
+    }
+
+    return result;
+}
+
+bool ExportFile(const char *path, const void *buffer, size_t buffer_size) {
+    if (!path || !buffer) {
+        FATAL("ExportFile: path or buffer is NULL");
+        return false;
+    }
+
+    /* Create parent directories if needed */
+    char *parent = GetParentPath(path);
+    if (parent && *parent) {
+        if (!CreateDirectoriesRecursively(parent)) {
+            free(parent);
+            return false;
+        }
+        free(parent);
+    }
+
+    /* Create/overwrite the file */
+    int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0777);
+    if (fd < 0) {
+        FATAL("ExportFile: open(\"%s\") failed: %s", path, strerror(errno));
+        return false;
+    }
+
+    size_t written = 0;
+    while (written < buffer_size) {
+        ssize_t n = write(fd, (const char *)buffer + written, buffer_size - written);
+        if (n < 0) {
+            FATAL("ExportFile: write(\"%s\") failed: %s", path, strerror(errno));
+            close(fd);
+            return false;
+        }
+        written += n;
+    }
+
+    close(fd);
+    return true;
+}
+
+/* ===== Path utilities ===== */
+
+char *GetImagePath(void) {
+    static char path_buffer[4096];
+#ifdef __APPLE__
+    uint32_t size = sizeof(path_buffer);
+    if (_NSGetExecutablePath(path_buffer, &size) != 0) {
+        FATAL("GetImagePath: _NSGetExecutablePath failed");
+        return NULL;
+    }
+#elif defined(__linux__)
+    /* On Linux, the running executable can be found via /proc/self/exe */
+    ssize_t len = readlink("/proc/self/exe", path_buffer, sizeof(path_buffer) - 1);
+
+    if (len < 0) {
+        FATAL("GetImagePath: readlink(\"/proc/self/exe\") failed: %s", strerror(errno));
+        return NULL;
+    }
+    path_buffer[len] = '\0';
+#else
+#error "GetImagePath not implemented for this platform"
+#endif
+
+    char *result = malloc(strlen(path_buffer) + 1);
+    if (!result) {
+        FATAL("GetImagePath: malloc failed");
+        return NULL;
+    }
+
+    strcpy(result, path_buffer);
+    return result;
+}
+
+char *GetTempDirectoryPath(void) {
+    const char *tmpdir = getenv("TMPDIR");
+    if (!tmpdir || !*tmpdir) {
+        tmpdir = "/tmp";
+    }
+
+    size_t len = strlen(tmpdir);
+    char *result = malloc(len + 1);
+    if (!result) {
+        FATAL("GetTempDirectoryPath: malloc failed");
+        return NULL;
+    }
+
+    strcpy(result, tmpdir);
+    return result;
+}
+
+/* ===== Process and signal handling ===== */
+
+bool InitializeSignalHandling(void) {
+    /* On POSIX systems, the parent process ignores SIGINT and SIGTERM during
+       initialization and cleanup. The child process will reset these to
+       SIG_DFL before execv-ing the target application. */
+
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = SIG_IGN;
+
+    if (sigaction(SIGINT, &sa, NULL) < 0) {
+        FATAL("InitializeSignalHandling: sigaction(SIGINT) failed: %s", strerror(errno));
+        return false;
+    }
+
+    if (sigaction(SIGTERM, &sa, NULL) < 0) {
+        FATAL("InitializeSignalHandling: sigaction(SIGTERM) failed: %s", strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool SetEnvVar(const char *name, const char *value) {
+    if (!name) {
+        FATAL("SetEnvVar: name is NULL");
+        return false;
+    }
+
+    if (value == NULL) {
+        /* Remove the variable */
+        if (unsetenv(name) < 0) {
+            FATAL("SetEnvVar: unsetenv(\"%s\") failed: %s", name, strerror(errno));
+            return false;
+        }
+    } else {
+        if (setenv(name, value, 1) < 0) {
+            FATAL("SetEnvVar: setenv(\"%s\", ...) failed: %s", name, strerror(errno));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool CreateAndWaitForProcess(const char *app_name, char *argv[], int *exit_code) {
+    if (!app_name || !argv || !exit_code) {
+        FATAL("CreateAndWaitForProcess: app_name, argv, or exit_code is NULL");
+        return false;
+    }
+
+    pid_t pid = fork();
+    if (pid < 0) {
+        FATAL("CreateAndWaitForProcess: fork() failed: %s", strerror(errno));
+        return false;
+    }
+
+    if (pid == 0) {
+        /* Child process */
+
+        /* Reset signal handlers to default before exec */
+        signal(SIGINT, SIG_DFL);
+        signal(SIGTERM, SIG_DFL);
+
+        /* Execute the target application */
+        execv(app_name, argv);
+
+        /* If we get here, execv failed */
+        FATAL("CreateAndWaitForProcess: execv(\"%s\") failed: %s", app_name, strerror(errno));
+        exit(127);
+    }
+
+    /* Parent process */
+
+    int wstatus;
+    if (waitpid(pid, &wstatus, 0) < 0) {
+        FATAL("CreateAndWaitForProcess: waitpid failed: %s", strerror(errno));
+        return false;
+    }
+
+    if (WIFEXITED(wstatus)) {
+        *exit_code = WEXITSTATUS(wstatus);
+    } else if (WIFSIGNALED(wstatus)) {
+        *exit_code = 128 + WTERMSIG(wstatus);
+    } else {
+        *exit_code = 1;
+    }
+
+    return true;
+}