ocran 1.3.18 → 1.4.0

data/src/inst_dir.c

@@ -0,0 +1,334 @@
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32
+#include <unistd.h>
+#include <errno.h>
+#endif
+#include "error.h"
+#include "system_utils.h"
+#include "inst_dir.h"
+
+// Static variable to hold the installation directory path.
+static char *InstDir = NULL;
+
+/**
+ * @brief Checks whether the installation directory is configured.
+ *
+ * @return true if InstDir is non-NULL and not empty; false otherwise.
+ */
+static inline bool IsInstDirSet(void)
+{
+    return InstDir != NULL && InstDir[0] != '\0';
+}
+
+// Creates an installation directory with a unique name in the specified target directory.
+static char *create_uniq_dir(const char *target_dir)
+{
+    char *base_path = JoinPath(target_dir, "ocran" "XXXXXX");
+    if (!base_path) {
+        APP_ERROR("Failed to construct a base path");
+        return NULL;
+    }
+    return CreateUniqueDirectory(base_path);
+}
+
+// Creates a debug installation directory next to the executable.
+static char *create_debug_extract_inst_dir(void)
+{
+    char *image_path = GetImagePath();
+    if (!image_path) {
+        APP_ERROR("Failed to get executable name");
+        return NULL;
+    }
+
+    char *image_dir = GetParentPath(image_path);
+    free(image_path);
+    if (!image_dir) {
+        APP_ERROR("Failed to obtain the directory path of the executable file");
+        return NULL;
+    }
+
+    char *inst_dir = create_uniq_dir(image_dir);
+    
+    if (!inst_dir) {
+        APP_ERROR("Failed to create installation directory in '%s'", image_dir);
+        free(image_dir);
+        return NULL;
+    }
+
+    free(image_dir);
+    return inst_dir;
+}
+
+// Creates a temporary installation directory in the system's temp directory.
+static char *create_temporary_inst_dir(void)
+{
+    char *temp_dir = GetTempDirectoryPath();
+    if (!temp_dir) {
+        APP_ERROR("Failed to obtain the temporary directory path");
+        return NULL;
+    }
+
+    char *inst_dir = create_uniq_dir(temp_dir);
+    if (!inst_dir) {
+        APP_ERROR("Failed to create installation directory in '%s'", temp_dir);
+        free(temp_dir);
+        return NULL;
+    }
+
+    free(temp_dir);
+    return inst_dir;
+}
+
+const char *CreateInstDir(bool is_extract_to_exe_dir)
+{
+    if (InstDir != NULL) {
+        APP_ERROR("Installation directory has already been set");
+        return NULL;
+    }
+
+    char *inst_dir = NULL;
+
+    if (is_extract_to_exe_dir) {
+        inst_dir = create_debug_extract_inst_dir();
+    } else {
+        inst_dir = create_temporary_inst_dir();
+    }
+    if (!inst_dir) {
+        return NULL;
+    }
+
+    InstDir = inst_dir;
+    return inst_dir;
+}
+
+// Frees the allocated memory for the installation directory path.
+void FreeInstDir(void)
+{
+    free(InstDir);
+    InstDir = NULL;
+}
+
+// Returns the path to the installation directory.
+const char *GetInstDir()
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    return InstDir;
+}
+
+// Concatenates the installation directory path with a relative path.
+char *ExpandInstDirPath(const char *rel_path)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    if (!rel_path || !*rel_path) {
+        APP_ERROR("relative path is NULL or empty");
+        return NULL;
+    }
+
+    if (!IsCleanRelativePath(rel_path)) {
+        APP_ERROR("invalid relative path '%s'", rel_path);
+        return NULL;
+    }
+
+    char *full_path = JoinPath(InstDir, rel_path);
+    if (!full_path) {
+        APP_ERROR("Failed to build full path");
+    }
+    return full_path;
+}
+
+// Deletes the installation directory and all its contents.
+bool DeleteInstDir(void)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    return DeleteRecursively(InstDir);
+}
+
+// Replaces placeholders in a string with the installation directory path.
+char *ReplaceInstDirPlaceholder(const char *tmpl)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return NULL;
+    }
+
+    const char *replacement = InstDir;
+    size_t replacement_len = strlen(replacement);
+    size_t c = 0;
+
+    for (const char *p = tmpl; *p; p++) { if (*p == PLACEHOLDER) c++; }
+    size_t replaced_len = strlen(tmpl) - c + replacement_len * c + 1;
+    char *replaced = calloc(replaced_len, sizeof(*replaced));
+    if (!replaced) {
+        APP_ERROR("Memory allocation failed for placeholder replacement");
+        return NULL;
+    }
+
+    char *out = replaced;
+    for (const char *in = tmpl; *in; in++) {
+        if (*in == PLACEHOLDER) {
+            memcpy(out, replacement, replacement_len);
+            out += replacement_len;
+        } else {
+            *out = *in;
+            out++;
+        }
+    }
+    *out = '\0';
+
+    return replaced;
+}
+
+bool CreateDirectoryUnderInstDir(const char *rel_path)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    if (!rel_path) {
+        APP_ERROR("relative path is NULL");
+        return false;
+    }
+
+    /* Treat empty string as a no-op and return success */
+    if (rel_path[0] == '\0') {
+        return true;
+    }
+
+    char *dir = ExpandInstDirPath(rel_path);
+    if (!dir) {
+        APP_ERROR("Failed to build full path");
+        return false;
+    }
+
+    bool result = CreateDirectoriesRecursively(dir);
+    if (!result) {
+        APP_ERROR(
+            "Failed to create directory under installation directory: '%s'",
+            dir
+        );
+    }
+
+    free(dir);
+    return result;
+}
+
+bool ExportFileToInstDir(const char *rel_path, const void *buf, size_t len)
+{
+    bool  result = false;
+    char *path   = NULL;
+
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        goto cleanup;
+    }
+
+    if (rel_path == NULL || *rel_path == '\0') {
+        APP_ERROR("Relative path is null or empty");
+        goto cleanup;
+    }
+
+    DEBUG("ExportFileToInstDir: rel_path=\"%s\", len=%zu", rel_path, len);
+
+    if (len > 0 && buf == NULL) {
+        APP_ERROR("Buffer pointer is NULL for non-zero length");
+        goto cleanup;
+    }
+
+    path = ExpandInstDirPath(rel_path);
+    if (!path) {
+        goto cleanup;
+    }
+
+    if (!ExportFile(path, buf, len)) {
+        APP_ERROR("Failed to export file: %s", path);
+        goto cleanup;
+    }
+
+    result = true;
+
+cleanup:
+    if (path) {
+        free(path);
+    }
+    return result;
+}
+
+#ifndef _WIN32
+bool CreateSymlinkUnderInstDir(const char *rel_link_path, const char *target)
+{
+    if (!IsInstDirSet()) {
+        APP_ERROR("Installation directory has not been set");
+        return false;
+    }
+
+    if (!rel_link_path || !*rel_link_path) {
+        APP_ERROR("rel_link_path is NULL or empty");
+        return false;
+    }
+
+    if (!target || !*target) {
+        APP_ERROR("target is NULL or empty");
+        return false;
+    }
+
+    char *link_path = ExpandInstDirPath(rel_link_path);
+    if (!link_path) {
+        return false;
+    }
+
+    bool result = false;
+    char *parent = GetParentPath(link_path);
+    if (parent && *parent && !CreateDirectoriesRecursively(parent)) {
+        APP_ERROR("Failed to create parent directory for symlink '%s'", link_path);
+        goto cleanup;
+    }
+
+    if (symlink(target, link_path) < 0) {
+        APP_ERROR("Failed to create symlink '%s' -> '%s': %s", link_path, target, strerror(errno));
+        goto cleanup;
+    }
+
+    DEBUG("CreateSymlinkUnderInstDir: '%s' -> '%s'", link_path, target);
+    result = true;
+
+cleanup:
+    if (parent) {
+        free(parent);
+    }
+    free(link_path);
+    return result;
+}
+#endif /* _WIN32 */
+
+bool SetEnvWithInstDir(const char *name, const char *value)
+{
+    char *replaced_value = ReplaceInstDirPlaceholder(value);
+    if (!replaced_value) {
+        APP_ERROR("Failed to replace the value placeholder");
+        return false;
+    }
+
+    DEBUG("SetEnv(%s, %s)", name, replaced_value);
+
+    bool result = SetEnvVar(name, replaced_value);
+    if (!result) {
+        APP_ERROR("Failed to set environment variable: %s", name);
+    }
+
+    free(replaced_value);
+    return result;
+}

data/src/inst_dir.h

@@ -0,0 +1,157 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+/**
+ * @brief Creates an installation directory with a unique name.
+ *
+ * Attempts to create a directory within the specified target directory. This
+ * directory is assigned a unique name based on the "ocran" prefix to avoid
+ * conflicts. The function manages the lifetime of the created directory path's
+ * memory, which should not be freed by the caller.
+ * If directory cleanup is needed, call FreeInstDir().
+ *
+ * @param is_extract_to_exe_dir
+ *   If true, the extraction directory will be created in the same folder as
+ *   the executable; if false, it will be created in the system’s temporary
+ *   directory.
+ * @return
+ *   A pointer to the created directory path if successful, NULL if an error
+ *   occurred. The returned path should not be freed by the caller.
+ */
+const char *CreateInstDir(bool is_extract_to_exe_dir);
+
+/**
+ * @brief Free the allocated installation directory path
+ *        and reset the internal pointer to NULL.
+ *
+ * Frees memory previously allocated for the installation directory path
+ * and clears the stored pointer so that GetInstDir() returns NULL until
+ * a new directory is set.
+ */
+void FreeInstDir(void);
+
+/**
+ * @brief Get the current installation directory path.
+ *
+ * @return
+ *   A pointer to the installation directory path if set, or NULL if the
+ *   directory has not been initialized or has been freed.
+ */
+const char *GetInstDir(void);
+
+/**
+ * @brief Concatenates the installation directory path with a given
+ *        relative path.
+ *
+ * This function guarantees that the resulting path will not escape the
+ * installation directory. It will fail and return NULL if any of the following
+ * conditions are met:
+ *   - the installation directory (InstDir) is not set or is empty
+ *   - rel_path is NULL or empty
+ *   - rel_path contains prohibited path elements such as "." or "..", including
+ *     patterns like "/./" or "/../"
+ *
+ * @param rel_path
+ *   A relative path to be combined with the installation directory path.
+ *   Must not be absolute, must not be empty, and must not contain any "." or
+ *   ".." segments (e.g., "/./", "/../", "./", "../").
+ *
+ * @return
+ *   A newly allocated string representing the full path on success; NULL on
+ *   error (and an appropriate error message is logged).
+ */
+char *ExpandInstDirPath(const char *rel_path);
+
+/**
+ * @brief Deletes the installation directory and its contents.
+ *
+ * @return true if the directory and its contents were deleted successfully,
+ *         false otherwise.
+ */
+bool DeleteInstDir(void);
+
+// Placeholder character used in paths.
+#define PLACEHOLDER '|'
+
+/**
+ * @brief Replace placeholders in a template string
+ *        with the installation directory path.
+ *
+ * @param tmpl
+ *   The template string containing placeholder characters defined by the
+ *   PLACEHOLDER macro, which will be replaced by the installation directory
+ *   path.
+ * @return
+ *   A newly allocated string with all PLACEHOLDER occurrences replaced by the
+ *   installation directory path. Returns NULL on failure.
+ */
+char *ReplaceInstDirPlaceholder(const char *tmpl);
+
+/**
+ * @brief Recursively create a directory under the installation directory.
+ *
+ * This function ensures that a directory exists at the specified relative
+ * path under the installation directory. An empty rel_path is treated as
+ * already existing (returns true). If rel_path is NULL, ExpandInstDirPath
+ * fails, or directory creation fails, the function returns false and logs
+ * an error.
+ *
+ * @param rel_path
+ *   A relative path to a directory under the installation directory.
+ *   NULL is invalid (returns false). An empty string is treated as
+ *   already existing (returns true).
+ *
+ * @return
+ *   true if the directory already exists or was created successfully;
+ *   false on error (and an error is logged).
+ */
+bool CreateDirectoryUnderInstDir(const char *rel_path);
+
+/**
+ * @brief Atomically write a file under the installation dir.
+ *
+ * This function writes the given buffer as a file at the specified
+ * relative path under the installation directory. It validates rel_path
+ * and buf, expands the full path, creates any missing parent directories,
+ * and writes the data atomically. If len is zero, an empty file is
+ * created.
+ *
+ * @param rel_path
+ *   A relative file path under the installation directory. NULL or empty
+ *   string is invalid (returns false).
+ * @param buf
+ *   Pointer to the data to write. Must be non-NULL if len > 0.
+ * @param len
+ *   Number of bytes to write. Zero creates an empty file. Values above
+ *   MAXDWORD cause an error.
+ *
+ * @return
+ *   true on success; false on failure (error logged via APP_ERROR/DEBUG).
+ */
+bool ExportFileToInstDir(const char *rel_path, const void *buf, size_t len);
+
+/**
+ * @brief  Expands any installation-directory placeholder found in 'value' and
+ *         sets the environment variable.
+ *
+ * @param  name   Environment variable name to set (must not be NULL).
+ * @param  value  Value string that may include a placeholder for the
+ *                installation directory.
+ *
+ * @return true on success; false on failure.
+ */
+bool SetEnvWithInstDir(const char *name, const char *value);
+
+/**
+ * @brief Create a symlink under the installation directory (POSIX only).
+ *
+ * Creates a symbolic link at rel_link_path that points to target.
+ * Both paths are relative to the installation directory.
+ * The target is treated as a bare filename within the same directory.
+ *
+ * @param rel_link_path  Relative path for the new symlink (e.g. "bin/libruby.so").
+ * @param target         Symlink target filename (e.g. "libruby.so.3.2.0").
+ *
+ * @return true on success; false on failure.
+ */
+bool CreateSymlinkUnderInstDir(const char *rel_link_path, const char *target);