ocran 1.3.18 → 1.4.0

data/src/lzma/LzmaDec.h

@@ -0,0 +1,236 @@
+/* LzmaDec.h -- LZMA Decoder
+2020-03-19 : Igor Pavlov : Public domain */
+
+#ifndef __LZMA_DEC_H
+#define __LZMA_DEC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+/* #define _LZMA_PROB32 */
+/* _LZMA_PROB32 can increase the speed on some CPUs,
+   but memory usage for CLzmaDec::probs will be doubled in that case */
+
+typedef
+#ifdef _LZMA_PROB32
+  UInt32
+#else
+  UInt16
+#endif
+  CLzmaProb;
+
+
+/* ---------- LZMA Properties ---------- */
+
+#define LZMA_PROPS_SIZE 5
+
+typedef struct _CLzmaProps
+{
+  Byte lc;
+  Byte lp;
+  Byte pb;
+  Byte _pad_;
+  UInt32 dicSize;
+} CLzmaProps;
+
+/* LzmaProps_Decode - decodes properties
+Returns:
+  SZ_OK
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+*/
+
+SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
+
+
+/* ---------- LZMA Decoder state ---------- */
+
+/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
+   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
+
+#define LZMA_REQUIRED_INPUT_MAX 20
+
+typedef struct
+{
+  /* Don't change this structure. ASM code can use it. */
+  CLzmaProps prop;
+  CLzmaProb *probs;
+  CLzmaProb *probs_1664;
+  Byte *dic;
+  SizeT dicBufSize;
+  SizeT dicPos;
+  const Byte *buf;
+  UInt32 range;
+  UInt32 code;
+  UInt32 processedPos;
+  UInt32 checkDicSize;
+  UInt32 reps[4];
+  UInt32 state;
+  UInt32 remainLen;
+
+  UInt32 numProbs;
+  unsigned tempBufSize;
+  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
+} CLzmaDec;
+
+#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; }
+
+void LzmaDec_Init(CLzmaDec *p);
+
+/* There are two types of LZMA streams:
+     - Stream with end mark. That end mark adds about 6 bytes to compressed size.
+     - Stream without end mark. You must know exact uncompressed size to decompress such stream. */
+
+typedef enum
+{
+  LZMA_FINISH_ANY,   /* finish at any point */
+  LZMA_FINISH_END    /* block must be finished at the end */
+} ELzmaFinishMode;
+
+/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
+
+   You must use LZMA_FINISH_END, when you know that current output buffer
+   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
+
+   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
+   and output value of destLen will be less than output buffer size limit.
+   You can check status result also.
+
+   You can use multiple checks to test data integrity after full decompression:
+     1) Check Result and "status" variable.
+     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
+     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
+        You must use correct finish mode in that case. */
+
+typedef enum
+{
+  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
+  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
+  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
+  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
+  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
+} ELzmaStatus;
+
+/* ELzmaStatus is used only as output value for function call */
+
+
+/* ---------- Interfaces ---------- */
+
+/* There are 3 levels of interfaces:
+     1) Dictionary Interface
+     2) Buffer Interface
+     3) One Call Interface
+   You can select any of these interfaces, but don't mix functions from different
+   groups for same object. */
+
+
+/* There are two variants to allocate state for Dictionary Interface:
+     1) LzmaDec_Allocate / LzmaDec_Free
+     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
+   You can use variant 2, if you set dictionary buffer manually.
+   For Buffer Interface you must always use variant 1.
+
+LzmaDec_Allocate* can return:
+  SZ_OK
+  SZ_ERROR_MEM         - Memory allocation error
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+*/
+   
+SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);
+
+SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
+void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
+
+/* ---------- Dictionary Interface ---------- */
+
+/* You can use it, if you want to eliminate the overhead for data copying from
+   dictionary to some other external buffer.
+   You must work with CLzmaDec variables directly in this interface.
+
+   STEPS:
+     LzmaDec_Construct()
+     LzmaDec_Allocate()
+     for (each new stream)
+     {
+       LzmaDec_Init()
+       while (it needs more decompression)
+       {
+         LzmaDec_DecodeToDic()
+         use data from CLzmaDec::dic and update CLzmaDec::dicPos
+       }
+     }
+     LzmaDec_Free()
+*/
+
+/* LzmaDec_DecodeToDic
+   
+   The decoding to internal dictionary buffer (CLzmaDec::dic).
+   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
+
+finishMode:
+  It has meaning only if the decoding reaches output limit (dicLimit).
+  LZMA_FINISH_ANY - Decode just dicLimit bytes.
+  LZMA_FINISH_END - Stream must be finished after dicLimit.
+
+Returns:
+  SZ_OK
+    status:
+      LZMA_STATUS_FINISHED_WITH_MARK
+      LZMA_STATUS_NOT_FINISHED
+      LZMA_STATUS_NEEDS_MORE_INPUT
+      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
+  SZ_ERROR_DATA - Data error
+  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
+*/
+
+SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
+
+
+/* ---------- Buffer Interface ---------- */
+
+/* It's zlib-like interface.
+   See LzmaDec_DecodeToDic description for information about STEPS and return results,
+   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
+   to work with CLzmaDec variables manually.
+
+finishMode:
+  It has meaning only if the decoding reaches output limit (*destLen).
+  LZMA_FINISH_ANY - Decode just destLen bytes.
+  LZMA_FINISH_END - Stream must be finished after (*destLen).
+*/
+
+SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
+
+
+/* ---------- One Call Interface ---------- */
+
+/* LzmaDecode
+
+finishMode:
+  It has meaning only if the decoding reaches output limit (*destLen).
+  LZMA_FINISH_ANY - Decode just destLen bytes.
+  LZMA_FINISH_END - Stream must be finished after (*destLen).
+
+Returns:
+  SZ_OK
+    status:
+      LZMA_STATUS_FINISHED_WITH_MARK
+      LZMA_STATUS_NOT_FINISHED
+      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
+  SZ_ERROR_DATA - Data error
+  SZ_ERROR_MEM  - Memory allocation error
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
+  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
+*/
+
+SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
+    ELzmaStatus *status, ISzAllocPtr alloc);
+
+EXTERN_C_END
+
+#endif

data/src/lzma/Precomp.h

@@ -0,0 +1,10 @@
+/* Precomp.h -- StdAfx
+2013-11-12 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_PRECOMP_H
+#define __7Z_PRECOMP_H
+
+#include "Compiler.h"
+/* #include "7zTypes.h" */
+
+#endif

data/src/script_info.c

@@ -0,0 +1,246 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include "error.h"
+#include "system_utils.h"
+#include "inst_dir.h"
+#include "script_info.h"
+
+/**
+ * Splits the NULL-delimited strings in buffer and stores pointers in array.
+ *
+ * @param buffer      Pointer to data containing NULL-delimited strings.
+ *                    The buffer must be terminated by a double NULL character.
+ * @param array       Array to receive string pointers. If NULL, only counting
+ *                    is performed.
+ * @return            Number of strings in buffer (excluding the NULL
+ *                    terminator).
+ */
+static size_t split_strings_to_array(const char *buffer, char **array)
+{
+    size_t count = 0;
+
+    for (const char *p = buffer; *p; p++) {
+        if (array) {
+            array[count] = (char *)p;
+        }
+        count++;
+
+        while (*p) p++;
+    }
+
+    if (array) {
+        array[count] = NULL;
+    }
+    return count;
+}
+
+static char **info_to_argv(const char *info, size_t info_size)
+{
+    size_t argc = split_strings_to_array(info, NULL);
+    size_t argv_size = (argc + 1) * sizeof(char *);
+    void *base = malloc(argv_size + info_size);
+    if (!base) {
+        APP_ERROR("Memory allocation failed for argv");
+        return NULL;
+    }
+    char **argv = (char **)base;
+    char  *args = (char *) base + argv_size;
+    memcpy(args, info, info_size);
+    split_strings_to_array(args, argv);
+    return argv;
+}
+
+static char **ScriptInfo = NULL;
+
+static inline bool IsScriptInfoSet(void) {
+    return ScriptInfo != NULL;
+}
+
+char **GetScriptInfo(void)
+{
+    if (!IsScriptInfoSet()) {
+        return NULL;
+    }
+
+    size_t stored = 0;
+    for (char **p = ScriptInfo; *p; p++) stored++;
+    if (stored == 0) {
+        APP_ERROR("ScriptInfo is empty");
+        return NULL;
+    }
+    char *last = ScriptInfo[stored - 1];
+
+    char *end = last + strlen(last) + 1 + 1;  // double-NULL terminated
+    size_t infov_size = end - (char *)ScriptInfo;
+    char **argv = malloc(infov_size);
+    if (!argv) {
+        APP_ERROR("Memory allocation failed for GetScriptInfo");
+        return NULL;
+    }
+    memcpy(argv, ScriptInfo, infov_size);
+    return argv;
+}
+
+bool SetScriptInfo(const char *info, size_t info_size)
+{
+    if (IsScriptInfoSet()) {
+        APP_ERROR("Script info is already set");
+        return false;
+    }
+
+    if (!info) {
+        APP_ERROR("info is NULL");
+        return false;
+    }
+
+    if (info_size < 2
+        || info[info_size - 1] != '\0'
+        || info[info_size - 2] != '\0') {
+        APP_ERROR("Script info not double-NULL terminated");
+        return false;
+    }
+
+    const char *argv0 = info;
+    if (*argv0 == '\0') {
+        APP_ERROR("Application name is empty");
+        return false;
+    }
+
+    if (!IsCleanRelativePath(argv0)) {
+        APP_ERROR("Application name contains prohibited relative path elements");
+        return false;
+    }
+
+    const char *argv1 = argv0 + strlen(info) + 1;
+    if (*argv1 == '\0') {
+        APP_ERROR("Script name is empty");
+        return false;
+    }
+
+    if (!IsCleanRelativePath(argv1)) {
+        APP_ERROR("Script name contains prohibited relative path elements");
+        return false;
+    }
+
+    char **argv = info_to_argv(info, info_size);
+    if (!argv) {
+        APP_ERROR("Failed to convert script info to argv");
+        return false;
+    }
+
+    ScriptInfo = argv;
+    return true;
+}
+
+void FreeScriptInfo(void)
+{
+    if (ScriptInfo) {
+        free(ScriptInfo);
+        ScriptInfo = NULL;
+    }
+}
+
+static char **shallow_merge_argv(char *argv1[], char *argv2[])
+{
+    size_t c1 = 0;
+    for (char **p = argv1; *p; p++) c1++;
+
+    size_t c2 = 0;
+    for (char **p = argv2; *p; p++) c2++;
+
+    size_t outc = c1 + c2;
+    char **outv = calloc(outc + 1, sizeof(*outv));
+    if (!outv) {
+        APP_ERROR("Memory allocation failed for merged argv");
+        return NULL;
+    }
+
+    memcpy(outv,      argv1, sizeof(*outv) * c1);
+    memcpy(outv + c1, argv2, sizeof(*outv) * c2);
+    outv[outc] = NULL;
+    return outv;
+}
+
+bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code)
+{
+    if (!IsScriptInfoSet()) {
+        APP_ERROR("Script info is not initialized");
+        return false;
+    }
+
+    if (!argv || !*argv) {
+        APP_ERROR("argv is NULL or empty");
+        return false;
+    }
+
+    bool result = false;
+    char **script_info = GetScriptInfo();
+    char *app_name = NULL;
+    char *script_name = NULL;
+    char **merged_argv = NULL;
+    char *script_dir = NULL;
+
+    app_name = ExpandInstDirPath(script_info[0]);
+    if (!app_name) {
+        APP_ERROR("Failed to expand application name to installation directory");
+        goto cleanup;
+    }
+
+    script_name = ExpandInstDirPath(script_info[1]);
+    if (!script_name) {
+        APP_ERROR("Failed to expand script name to installation directory");
+        goto cleanup;
+    }
+
+    script_info[1] = script_name;
+
+    merged_argv = shallow_merge_argv(script_info, argv + 1);
+    if (!merged_argv) {
+        APP_ERROR("Failed to merge script arguments with extra arguments");
+        goto cleanup;
+    }
+
+    if (is_chdir_to_script_dir) {
+        script_dir = GetParentPath(script_name);
+        if (!script_dir) {
+            APP_ERROR("Failed to build path for script directory");
+            goto cleanup;
+        }
+
+        DEBUG(
+            "Changing working directory to script directory '%s'",
+            script_dir
+        );
+
+        char *ruby_optv[5] = { script_info[0], "-C", script_dir, "--", NULL };
+        char **new_argv = shallow_merge_argv(ruby_optv, merged_argv + 1);
+        if (!new_argv) {
+            APP_ERROR("Failed to merge script arguments with extra arguments");
+            goto cleanup;
+        }
+        free(merged_argv);
+        merged_argv = new_argv;
+    }
+
+    result = CreateAndWaitForProcess(app_name, merged_argv, exit_code);
+
+cleanup:
+    if (script_info) {
+        free(script_info);
+    }
+    if (app_name) {
+        free(app_name);
+    }
+    if (script_name) {
+        free(script_name);
+    }
+    if (merged_argv) {
+        free(merged_argv);
+    }
+    if (script_dir) {
+        free(script_dir);
+    }
+    return result;
+}

data/src/script_info.h

@@ -0,0 +1,7 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+char **GetScriptInfo(void);
+bool SetScriptInfo(const char *info, size_t info_size);
+void FreeScriptInfo(void);
+bool RunScript(char *argv[], bool is_chdir_to_script_dir, int *exit_code);

data/src/stub.c

@@ -0,0 +1,133 @@
+/*
+  Single Executable Bundle Stub
+  This stub reads itself for embedded instructions to create directory
+  and files in a temporary directory, launching a program.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include "error.h"
+#include "system_utils.h"
+#include "inst_dir.h"
+#include "script_info.h"
+#include "unpack.h"
+
+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;
+
+    /*
+       Initialize signal and control handling so the parent process remains
+       active during startup and cleanup. This setup prevents interruption
+       of critical tasks (such as file extraction) by control events.
+       Child processes (e.g., Ruby) handle their own signals independently,
+       ensuring the parent can finalize cleanup without premature termination.
+    */
+    if (!InitializeSignalHandling()) {
+        FATAL("Failed to initialize system controls");
+        goto cleanup;
+    }
+
+    /* Find name of image */
+    image_path = GetImagePath();
+    if (!image_path) {
+        FATAL("Failed to get executable name");
+        goto cleanup;
+    }
+
+    /* Open and map the image (executable) into memory */
+    unpack_ctx = OpenPackFile(image_path);
+    if (!unpack_ctx) {
+        FATAL("Failed to map the executable file");
+        goto cleanup;
+    }
+
+    /* Read header of packed data */
+    op_modes = 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")) {
+        EnableDebugMode();
+        DEBUG("Ocran stub running in debug mode");
+    }
+
+    /* Create extraction directory */
+    extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
+    if (!extract_dir) {
+        FATAL("Failed to create extraction directory");
+        goto cleanup;
+    }
+
+    DEBUG("Created extraction directory: %s", extract_dir);
+
+    /* Unpacking process */
+    if (!ProcessImage(unpack_ctx)) {
+        FATAL("Failed to unpack image due to invalid or corrupted data");
+        goto cleanup;
+    }
+
+    // Memory map no longer needed after unpacking; free its resources.
+    ClosePackFile(unpack_ctx);
+
+    // Prevent accidental use of the freed map.
+    unpack_ctx = NULL;
+
+    /* Launching the script, provided there are no errors in file extraction from the image */
+    DEBUG("*** Starting application script in %s", extract_dir);
+
+    DEBUG("Set the 'OCRAN_EXECUTABLE' environment variable to %s", image_path);
+    if (!SetEnvVar("OCRAN_EXECUTABLE", image_path)) {
+        FATAL("The script cannot be launched due to a configuration error");
+        goto cleanup;
+    }
+
+    /*
+       RunScript uses the current value of status as its initial value
+       and then overwrites it with the external script’s return code.
+    */
+    DEBUG("Run application script");
+    if (!RunScript(argv, IsChdirBeforeScript(op_modes), &status)) {
+        FATAL("Failed to run script");
+        goto cleanup;
+    }
+    /*
+       If the script executes successfully, its return code is stored in status.
+    */
+
+cleanup:
+    /*
+       Suppress GUI error dialogs during cleanup to avoid blocking the user.
+       Cleanup failures are non-critical and logged as DEBUG only.
+    */
+
+    if (image_path) {
+        free(image_path);
+    }
+
+    if (unpack_ctx) {
+        ClosePackFile(unpack_ctx);
+        unpack_ctx = NULL;
+    }
+
+    FreeScriptInfo();
+
+    /*
+       If AUTO_CLEAN_INST_DIR is set, delete the extraction directory.
+    */
+    if (IsAutoCleanInstDir(op_modes)) {
+        DEBUG("Deleting extraction directory: %s", extract_dir);
+        if (!DeleteInstDir()) {
+            DEBUG("Failed to delete extraction directory");
+        }
+    }
+
+    FreeInstDir();
+    extract_dir = NULL;
+    return status;
+}

data/src/stub.manifest

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker"/>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!--The ID below indicates application support for Windows Vista -->
+      <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+      <!--The ID below indicates application support for Windows 7 -->
+      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+      <!--The ID below indicates application support for Windows 8 -->
+      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+      <!--The ID below indicates application support for Windows 8.1 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+      <!--The ID below indicates application support for Windows 10 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+    </application>
+  </compatibility>
+  <application>
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>

data/src/stub.rc

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