ocran 1.4.5 → 1.5.0

data/src/path_utils.c

@@ -0,0 +1,144 @@
+/*
+ * Path string helpers shared by the Windows (system_utils.c) and POSIX
+ * (system_utils_posix.c) builds. Pure string manipulation: nothing here
+ * touches the file system.
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef __COSMOPOLITAN__
+#include <cosmo.h>  /* IsWindows() */
+#endif
+#include "error.h"
+#include "system_utils.h"
+
+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;
+    }
+
+#ifdef __COSMOPOLITAN__
+    /* A cosmopolitan stub splits paths at '/' only, but on Windows the
+       path ends up with the Win32 API, which splits at '\' as well: a
+       name like "..\x" would pass below as a single segment and then
+       climb out of the extraction directory. The packer never emits a
+       backslash in a name, so refuse all of them there. */
+    if (IsWindows() && strchr(path, '\\')) {
+        return false;
+    }
+#endif
+
+    /* 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;
+}
+
+// Combines two file path components into a single path, handling path separators.
+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 root = path_root_length(path);
+    size_t i    = strlen(path);
+
+    /* Skip any trailing separators */
+    while (i > root && is_path_separator(path[i - 1])) {
+        i--;
+    }
+
+    /* Skip the last segment's characters */
+    while (i > root && !is_path_separator(path[i - 1])) {
+        i--;
+    }
+
+    /* Skip the separators before it, keeping the root ("/" or "C:\") */
+    while (i > root && is_path_separator(path[i - 1])) {
+        i--;
+    }
+
+    /* i==0 ⇒ empty parent (relative path with a single segment) */
+
+    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;
+}

data/src/script_info.c

@@ -183,6 +183,11 @@ bool RunScript(char *argv[], bool is_chdir_to_script_dir,
     char **merged_argv = NULL;
     char *script_dir = NULL;
 
+    if (!script_info) {
+        APP_ERROR("Failed to copy the script info");
+        goto cleanup;
+    }
+
     app_name = ExpandInstDirPath(script_info[0]);
     if (!app_name) {
         APP_ERROR("Failed to expand application name to installation directory");

data/src/stub.c

@@ -18,11 +18,48 @@
 #include "script_info.h"
 #include "unpack.h"
 
+/* Operation modes from the header of the packed data; 0 until read. */
+static OperationModes OpModes = 0;
+
+/*
+   Deletes the extraction directory when AUTO_CLEAN_INST_DIR is set. Runs
+   once, through RunCleanupRoutine(): at the end of main(), or on Windows
+   from the console control handler when the console window is closed or
+   the system shuts down - possibly on another thread, at any point of
+   main().
+*/
+static void delete_extraction_dir(void)
+{
+    /* Never delete in RUN_IN_EXE_DIR mode: the "installation directory"
+       is the real application directory, not a temporary extraction dir. */
+    if (!IsAutoCleanInstDir(OpModes) || IsRunInExeDir(OpModes)) {
+        return;
+    }
+
+    const char *dir = GetInstDir();
+    if (!dir) {
+        return;
+    }
+
+    DEBUG("Deleting extraction directory: %s", dir);
+    if (!DeleteInstDir()) {
+        DEBUG("Failed to delete extraction directory");
+    }
+}
+
+
+/* Whether an environment variable asks for something: set, and neither
+   empty nor "0". OCRAN_DEBUG=0 used to switch debug output on. */
+static bool IsEnvFlagSet(const char *name)
+{
+    const char *value = getenv(name);
+    return value != NULL && value[0] != '\0' && strcmp(value, "0") != 0;
+}
+
 int main(int argc, char *argv[])
 {
     int status = EXIT_CODE_FAILURE;
     UnpackContext *unpack_ctx = NULL;
-    OperationModes op_modes = 0;
     const char *extract_dir = NULL;
     char *image_path = NULL;
     char *exe_dir = NULL;
@@ -34,6 +71,7 @@ int main(int argc, char *argv[])
        Child processes (e.g., Ruby) handle their own signals independently,
        ensuring the parent can finalize cleanup without premature termination.
     */
+    SetCleanupRoutine(delete_extraction_dir);
     if (!InitializeSignalHandling()) {
         FATAL("Failed to initialize system controls");
         goto cleanup;
@@ -54,17 +92,18 @@ int main(int argc, char *argv[])
     }
 
     /* Read header of packed data */
-    op_modes = GetOperationModes(unpack_ctx);
+    OpModes = GetOperationModes(unpack_ctx);
 
-    /* Enable debug mode when the flag is set or OCRAN_DEBUG env var is set */
-    if (IsDebugMode(op_modes) || getenv("OCRAN_DEBUG")) {
+    /* Enable debug mode when the flag is set or OCRAN_DEBUG is set to
+       anything but "0" or the empty string. */
+    if (IsDebugMode(OpModes) || IsEnvFlagSet("OCRAN_DEBUG")) {
         EnableDebugMode();
         DEBUG("Ocran stub running in debug mode");
     }
 
     /* Create extraction directory, or run in place next to the executable
        (installer/wrapper mode, see RUN_IN_EXE_DIR) */
-    if (IsRunInExeDir(op_modes)) {
+    if (IsRunInExeDir(OpModes)) {
         extract_dir = SetInstDirToExeDir();
         if (!extract_dir) {
             FATAL("Failed to resolve the executable directory");
@@ -72,7 +111,7 @@ int main(int argc, char *argv[])
         }
         DEBUG("Running in executable directory: %s", extract_dir);
     } else {
-        extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
+        extract_dir = CreateInstDir(IsExtractToExeDir(OpModes));
         if (!extract_dir) {
             FATAL("Failed to create extraction directory");
             goto cleanup;
@@ -103,7 +142,7 @@ int main(int argc, char *argv[])
 
     /* Resolve the executable's directory when the script should start
        with its working directory next to the .exe (--chdir-exe-dir). */
-    if (IsChdirToExeDir(op_modes)) {
+    if (IsChdirToExeDir(OpModes)) {
         exe_dir = GetParentPath(image_path);
         if (!exe_dir) {
             FATAL("Failed to resolve the executable directory");
@@ -135,10 +174,33 @@ int main(int argc, char *argv[])
        and then overwrites it with the external script’s return code.
     */
     DEBUG("Run application script");
-    if (!RunScript(argv, IsChdirBeforeScript(op_modes), exe_dir, &status)) {
+    if (!RunScript(argv, IsChdirBeforeScript(OpModes), exe_dir, &status)) {
         FATAL("Failed to run script");
         goto cleanup;
     }
+#ifdef _WIN32
+    /*
+       The loader failed before the interpreter ran a single line, so
+       nothing else would say why the application did nothing. Reported
+       here rather than in system_utils.c: FATAL is a message box in the
+       windowed stub only, and this file is compiled for each variant.
+    */
+    switch ((unsigned long)status) {
+    case 0xC0000135UL: /* STATUS_DLL_NOT_FOUND */
+        FATAL("The Ruby interpreter could not start: a DLL it needs was not "
+              "found (0x%08lX). An mswin Ruby also needs the Visual C++ "
+              "runtime (vcruntime140.dll).", (unsigned long)status);
+        break;
+    case 0xC0000138UL: /* STATUS_ORDINAL_NOT_FOUND */
+    case 0xC0000139UL: /* STATUS_ENTRYPOINT_NOT_FOUND */
+    case 0xC0000142UL: /* STATUS_DLL_INIT_FAILED */
+    case 0xC000007BUL: /* STATUS_INVALID_IMAGE_FORMAT */
+        FATAL("The Ruby interpreter could not start: a DLL it loads is "
+              "incompatible or failed to initialize (0x%08lX)",
+              (unsigned long)status);
+        break;
+    }
+#endif
     /*
        If the script executes successfully, its return code is stored in status.
     */
@@ -164,21 +226,17 @@ cleanup:
 
     FreeScriptInfo();
 
-    /*
-       If AUTO_CLEAN_INST_DIR is set, delete the extraction directory.
-    */
-    /* Never delete in RUN_IN_EXE_DIR mode: the "installation directory"
-       is the real application directory, not a temporary extraction dir. */
-    if (IsAutoCleanInstDir(op_modes) && !IsRunInExeDir(op_modes)) {
-        DEBUG("Deleting extraction directory: %s", extract_dir);
-        if (!DeleteInstDir()) {
-            DEBUG("Failed to delete extraction directory");
-        }
-    }
+    /* Delete the extraction directory (see delete_extraction_dir), unless
+       the console control handler has done so already. */
+    RunCleanupRoutine();
 
     FreeInstDir();
     extract_dir = NULL;
 
+    /* A child killed by a signal kills the stub the same way, now that the
+       extraction directory is gone. Returns if the signal did not. */
+    ReraiseChildSignal();
+
 #ifdef __COSMOPOLITAN__
     /* On Windows, Cosmopolitan Libc's exit path encodes the full wait
        status into the process exit code (code << 8) so that cosmo

data/src/stub.rc

@@ -1,3 +1,3 @@
 #include <winresrc.h>
 CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "stub.manifest"
-101 ICON vit-ruby.ico
+101 ICON "vit-ruby.ico"