ocran 1.4.2 → 1.4.4

data/lib/ocran/ed_icon.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require "fiddle/import"
+require "fiddle/types"
+
+module Ocran
+  # Changes the Icon in a PE executable.
+  module EdIcon
+    extend Fiddle::Importer
+    dlload "kernel32.dll"
+
+    include Fiddle::Win32Types
+    typealias "LPVOID", "void*"
+    typealias "LPCWSTR", "char*"
+
+    module Successive
+      include Enumerable
+
+      def each
+        return to_enum(__method__) unless block_given?
+
+        entry = self
+        while true
+          yield(entry)
+          entry = self.class.new(tail)
+        end
+      end
+
+      def tail
+        to_ptr + self.class.size
+      end
+    end
+
+    # Icon file header
+    IconHeader = struct(
+      [
+        "WORD Reserved",
+        "WORD ResourceType",
+        "WORD ImageCount"
+      ]
+    ).include(Successive)
+
+    icon_info = [
+      "BYTE Width",
+      "BYTE Height",
+      "BYTE Colors",
+      "BYTE Reserved",
+      "WORD Planes",
+      "WORD BitsPerPixel",
+      "DWORD ImageSize"
+    ]
+
+    # Icon File directory entry structure
+    IconDirectoryEntry = struct(icon_info + ["DWORD ImageOffset"]).include(Successive)
+
+    # Group Icon Resource directory entry structure
+    IconDirResEntry = struct(icon_info + ["WORD ResourceID"]).include(Successive)
+
+    class IconFile < IconHeader
+      def initialize(icon_filename)
+        @data = File.binread(icon_filename)
+        super(Fiddle::Pointer.to_ptr(@data))
+
+        entries_end = IconHeader.size + self.ImageCount * IconDirectoryEntry.size
+        if entries_end > @data.bytesize
+          raise "Icon file too small for declared ImageCount"
+        end
+
+        entries.each_with_index do |entry, i|
+          if entry.ImageOffset + entry.ImageSize > @data.bytesize
+            raise "Icon entry #{i} exceeds file bounds"
+          end
+        end
+      end
+
+      def entries
+        IconDirectoryEntry.new(self.tail).take(self.ImageCount)
+      end
+    end
+
+    class GroupIcon < IconHeader
+      attr_reader :size
+
+      def initialize(image_count, resource_type)
+        @size = IconHeader.size + image_count * IconDirResEntry.size
+        super(Fiddle.malloc(@size), Fiddle::RUBY_FREE)
+        self.Reserved = 0
+        self.ResourceType = resource_type
+        self.ImageCount = image_count
+      end
+
+      def entries
+        IconDirResEntry.new(self.tail).take(self.ImageCount)
+      end
+    end
+
+    MAKEINTRESOURCE = -> (i) { Fiddle::Pointer.new(i) }
+    RT_ICON = MAKEINTRESOURCE.(3)
+    RT_GROUP_ICON = MAKEINTRESOURCE.(RT_ICON.to_i + 11)
+
+    MAKELANGID = -> (p, s) { s << 10 | p }
+    LANG_NEUTRAL = 0x00
+    SUBLANG_DEFAULT = 0x01
+    LANGID = MAKELANGID.(LANG_NEUTRAL, SUBLANG_DEFAULT)
+
+    extern "DWORD GetLastError()"
+    extern "HANDLE BeginUpdateResourceW(LPCWSTR, BOOL)"
+    extern "BOOL EndUpdateResourceW(HANDLE, BOOL)"
+    extern "BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, LPVOID, DWORD)"
+
+    class << self
+      def update_icon(executable_filename, icon_filename)
+        update_resource(executable_filename) do |handle|
+          icon_file = IconFile.new(icon_filename)
+          icon_entries = icon_file.entries
+
+          # Create the RT_ICON resources
+          icon_entries.each_with_index do |entry, i|
+            if UpdateResourceW(handle, RT_ICON, 101 + i, LANGID, icon_file.to_i + entry.ImageOffset, entry.ImageSize) == 0
+              raise "failed to UpdateResource(#{GetLastError()})"
+            end
+          end
+
+          # Create the RT_GROUP_ICON structure
+          group_icon = GroupIcon.new(icon_file.ImageCount, icon_file.ResourceType)
+          group_icon.entries.zip(icon_entries).each_with_index do |(res, icon), i|
+            res.Width = icon.Width
+            res.Height = icon.Height
+            res.Colors = icon.Colors
+            res.Reserved = icon.Reserved
+            res.Planes = icon.Planes
+            res.BitsPerPixel = icon.BitsPerPixel
+            res.ImageSize = icon.ImageSize
+            res.ResourceID = 101 + i
+          end
+
+          # Save the RT_GROUP_ICON resource
+          if UpdateResourceW(handle, RT_GROUP_ICON, 100, LANGID, group_icon, group_icon.size) == 0
+            raise "Failed to create group icon(#{GetLastError()})"
+          end
+        end
+      end
+
+      def update_resource(executable_filename)
+        handle = BeginUpdateResourceW(executable_filename.encode("UTF-16LE"), 0)
+        if handle == Fiddle::NULL
+          raise "Failed to BeginUpdateResourceW(#{GetLastError()})"
+        end
+
+        yield(handle)
+
+        if EndUpdateResourceW(handle, 0) == 0
+          raise "Failed to EndUpdateResourceW(#{GetLastError()})"
+        end
+      end
+    end
+  end
+end

data/lib/ocran/gem_spec_queryable.rb

@@ -131,8 +131,11 @@ module Ocran
 
     def gem_root = Pathname(gem_dir)
 
-    # Find the selected files
-    def gem_root_files = gem_root.find.select(&:file?)
+    # Find the selected files. Default gems (e.g. fiddle, singleton on
+    # Homebrew or distro-packaged Ruby) may have a gemspec without a
+    # materialized gem directory - their files live in Ruby's stdlib and
+    # are packed via the load path instead.
+    def gem_root_files = gem_root.directory? ? gem_root.find.select(&:file?) : []
 
     def script_files
       gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
@@ -154,7 +157,25 @@ module Ocran
         when :spec
           files.map { |file| Pathname(file) }
         when :loaded
-          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
+          # Some distros expose gem files under additional paths via symlinks
+          # (e.g. Fedora symlinks /usr/share/ruby/psych.rb into the psych gem
+          # directory) and $LOADED_FEATURES records the symlink path. Resolve
+          # each feature to its realpath so such files count as gem files and
+          # are packed inside the gem directory. Packing them at the symlink
+          # location instead would break require_relative, which resolves
+          # against the realpath on the build host but not in the packed app.
+          features_from_gems.filter_map do |feature|
+            if feature.subpath?(gem_dir)
+              feature
+            else
+              real = begin
+                feature.realpath
+              rescue SystemCallError
+                next
+              end
+              real if real.subpath?(gem_dir)
+            end
+          end
         when :files
           resource_files
         when :extras

data/lib/ocran/inno_setup_script_builder.rb

@@ -14,7 +14,14 @@ module Ocran
 
     class << self
       def compile(iss_filename, quiet: false)
-        unless Gem.win_platform? || system("where #{quote_and_escape(ISCC_CMD)} >NUL 2>&1")
+        # "where" and ">NUL" only exist on Windows; use "command -v" on POSIX
+        # (e.g. when testing the pipeline with a fake ISCC on Linux/macOS).
+        iscc_found = if Gem.win_platform?
+                       true # ISCC is invoked directly; failure is reported below
+                     else
+                       system("command -v #{quote_and_escape(ISCC_CMD)} > /dev/null 2>&1")
+                     end
+        unless iscc_found
           raise "ISCC command not found. Is the InnoSetup directory in your PATH?"
         end
 
@@ -79,6 +86,13 @@ module Ocran
       @dirs.add?("/", target)
     end
 
+    # Symbolic links cannot be expressed in an Inno Setup script. They only
+    # occur when building from POSIX hosts (e.g. libruby.so links); Windows
+    # installations do not need them, so they are skipped.
+    def symlink(_target, _link_name)
+      nil
+    end
+
     def cp(source, target)
       unless File.exist?(source)
         raise "The file does not exist (#{source})"

data/lib/ocran/launcher_event_recorder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ocran
+  # Records launcher-directed build events (environment exports and the
+  # application exec command) while forwarding them to another launcher
+  # builder. The recorded events can later be replayed into a further
+  # builder — e.g. to produce a wrapper stub executable alongside the
+  # launcher batch file in Inno Setup builds.
+  class LauncherEventRecorder
+    def initialize(launcher)
+      @launcher = launcher
+      @events = []
+    end
+
+    def export(name, value)
+      @events << [:export, name, value]
+      @launcher.export(name, value)
+    end
+
+    def exec(image, script, *argv)
+      @events << [:exec, image, script, *argv]
+      @launcher.exec(image, script, *argv)
+    end
+
+    def replay(builder)
+      @events.each { |event, *args| builder.public_send(event, *args) }
+    end
+  end
+end

data/lib/ocran/option.rb

@@ -37,6 +37,7 @@ module Ocran
         :source_files => [],
         :verbose? => false,
         :warning? => true,
+        :wrapper_exe? => true,
       }
     end
 
@@ -90,6 +91,8 @@ Output options:
 --output <file>    Name the exe to generate. Defaults to ./<scriptname>.exe.
 --output-dir <dir> Output all files to a directory with a launch script instead of an exe.
 --output-zip <file> Output a zip archive containing all files and a launch script.
+--no-wrapper-exe   Do not add the wrapper executable to installer, directory or
+                   zip output (a launch script is always included there).
 --macosx-bundle    Build a macOS .app bundle. Use --output to name it (default: <scriptname>.app).
 --bundle-id <id>   Bundle identifier for the macOS app bundle (default: com.example.<appname>).
 --no-lzma          Disable LZMA compression of the executable.
@@ -125,6 +128,8 @@ EOF
         when "--output-zip"
           path = argv.shift
           @options[:output_zip] = Pathname.new(path).expand_path if path
+        when "--no-wrapper-exe"
+          @options[:wrapper_exe?] = false
         when "--macosx-bundle"
           @options[:macosx_bundle?] = true
         when "--bundle-id"
@@ -301,6 +306,8 @@ EOF
 
     def quiet? = @options[__method__]
 
+    def wrapper_exe? = @options[__method__]
+
     def rubyopt = @options[__method__]
 
     def run_script? = @options[__method__]

data/lib/ocran/runner.rb

@@ -94,10 +94,12 @@ module Ocran
       direction = Direction.new(@post_env, @pre_env, @option)
 
       if @option.use_inno_setup?
-        if Gem.win_platform?
+        # Native on Windows; on POSIX allow it when an ISCC command is
+        # available (e.g. via Wine wrapper scripts or in tests).
+        if Gem.win_platform? || system("command -v ISCC > /dev/null 2>&1")
           direction.build_inno_setup_installer
         else
-          raise "Inno Setup is only supported on Windows"
+          raise "Inno Setup is only supported on Windows (no ISCC command found in PATH)"
         end
       elsif @option.macosx_bundle
         direction.build_macosx_bundle(@option.macosx_bundle)

data/lib/ocran/stub_builder.rb

@@ -20,6 +20,7 @@ module Ocran
     AUTO_CLEAN_INST_DIR = 0x04
     CHDIR_BEFORE_SCRIPT = 0x08
     DATA_COMPRESSED     = 0x10
+    RUN_IN_EXE_DIR      = 0x20
 
     WINDOWS = Gem.win_platform?
 
@@ -27,7 +28,6 @@ module Ocran
     STUB_PATH = File.expand_path(WINDOWS ? "stub.exe" : "stub", base_dir)
     STUBW_PATH = WINDOWS ? File.expand_path("stubw.exe", base_dir) : nil
     LZMA_PATH = WINDOWS ? File.expand_path("lzma.exe", base_dir) : nil
-    EDICON_PATH = WINDOWS ? File.expand_path("edicon.exe", base_dir) : nil
 
     def self.find_posix_lzma_cmd
       if system("which lzma > /dev/null 2>&1")
@@ -96,8 +96,16 @@ module Ocran
     # icon_path:
     # Specifies the path to the icon file to be embedded in the stub's resources.
     #
+    # run_in_exe_dir:
+    # When set to true, the stub runs the application directly from its own
+    # directory instead of extracting to a temporary directory. Used for
+    # installer (Inno Setup) wrapper executables where the application files
+    # are installed next to the stub (pre-1.4/OCRA behavior). The directory
+    # is never deleted on exit.
+    #
     def initialize(path, chdir_before: nil, debug_extract: nil, debug_mode: nil,
-                   enable_compression: nil, gui_mode: nil, icon_path: nil)
+                   enable_compression: nil, gui_mode: nil, icon_path: nil,
+                   run_in_exe_dir: nil)
       @dirs = FilePathSet.new
       @files = FilePathSet.new
       @data_size = 0
@@ -122,14 +130,15 @@ module Ocran
 
       # Embed icon resource (Windows only)
       if icon_path && WINDOWS
-        system(EDICON_PATH, stub, icon_path.to_s, exception: true)
+        require_relative "ed_icon"
+        EdIcon.update_icon(stub, icon_path.to_s)
       end
 
       File.open(stub, "ab") do |of|
         @of = of
         @opcode_offset = @of.size
 
-        write_header(debug_mode, debug_extract, chdir_before, enable_compression)
+        write_header(debug_mode, debug_extract, chdir_before, enable_compression, run_in_exe_dir)
 
         b = proc {
           yield(self)
@@ -213,14 +222,20 @@ module Ocran
     end
     private :compress
 
-    def write_header(debug_mode, debug_extract, chdir_before, compressed)
+    def write_header(debug_mode, debug_extract, chdir_before, compressed, run_in_exe_dir = nil)
       next_to_exe, delete_after = debug_extract, !debug_extract
+      if run_in_exe_dir
+        # Wrapper mode: run in place next to the executable — never extract,
+        # and (critically) never delete the application directory on exit.
+        next_to_exe, delete_after = false, false
+      end
       @of << [0 |
                 (debug_mode ? DEBUG_MODE : 0) |
                 (next_to_exe ? EXTRACT_TO_EXE_DIR : 0) |
                 (delete_after ? AUTO_CLEAN_INST_DIR : 0) |
                 (chdir_before ? CHDIR_BEFORE_SCRIPT : 0) |
-                (compressed ? DATA_COMPRESSED : 0)
+                (compressed ? DATA_COMPRESSED : 0) |
+                (run_in_exe_dir ? RUN_IN_EXE_DIR : 0)
       ].pack("C")
     end
     private :write_header

data/lib/ocran/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ocran
-  VERSION = "1.4.2"
+  VERSION = "1.4.4"
 end

data/src/Makefile

@@ -21,7 +21,7 @@ else
   STUB_CFLAGS     := $(CFLAGS) -D_CONSOLE
   STUBW_CFLAGS    := $(CFLAGS)
   SYSTEM_UTILS_SRC := system_utils.c
-  PROG_NAMES      := stub stubw edicon
+  PROG_NAMES      := stub stubw
   RESOURCE_OBJ    := stub.res
 endif
 
@@ -62,13 +62,11 @@ ifeq ($(IS_POSIX),)
 stubw$(EXEEXT): $(COMMON_OBJS) $(WINDOW_OBJS)
 	$(CC) $(LDFLAGS) $(GUI_LDFLAGS) $^ $(LDLIBS) -o $@
 
-edicon$(EXEEXT): edicon.o
-	$(CC) $(LDFLAGS) $^ -o $@
 endif
 
 clean:
 	rm -f $(BINARIES) $(COMMON_OBJS) $(CONSOLE_OBJS) $(WINDOW_OBJS) \
-	      edicon.o $(RESOURCE_OBJ)
+	      $(RESOURCE_OBJ)
 
 install: $(BINARIES)
 	mkdir -p $(BINDIR)

data/src/inst_dir.c

@@ -98,8 +98,50 @@ const char *CreateInstDir(bool is_extract_to_exe_dir)
         return NULL;
     }
 
-    InstDir = inst_dir;
-    return inst_dir;
+    /* Normalize 8.3 short names (e.g. a TEMP under C:\Users\RUNNER~1) so all
+       paths derived from the extraction dir use one consistent spelling. */
+    char *long_dir = ToLongPath(inst_dir);
+    free(inst_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
+}
+
+// Sets the installation directory to the executable's own directory
+// (installer/wrapper mode, RUN_IN_EXE_DIR). No directory is created and
+// the directory must never be deleted by the stub.
+const char *SetInstDirToExeDir(void)
+{
+    if (InstDir != NULL) {
+        APP_ERROR("Installation directory has already been set");
+        return NULL;
+    }
+
+    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;
+    }
+
+    /* Normalize 8.3 short names for a consistent spelling (see CreateInstDir) */
+    char *long_dir = ToLongPath(image_dir);
+    free(image_dir);
+    if (!long_dir) {
+        return NULL;
+    }
+
+    InstDir = long_dir;
+    return InstDir;
 }
 
 // Frees the allocated memory for the installation directory path.

data/src/inst_dir.h

@@ -20,6 +20,20 @@
  */
 const char *CreateInstDir(bool is_extract_to_exe_dir);
 
+/**
+ * @brief Sets the installation directory to the executable's own directory.
+ *
+ * Unlike CreateInstDir, no new directory is created: the stub runs the
+ * application directly from the directory the executable resides in
+ * (installer/wrapper mode, RUN_IN_EXE_DIR). The directory must never be
+ * deleted by the stub.
+ *
+ * @return
+ *   A pointer to the directory path if successful, NULL if an error
+ *   occurred. The returned path should not be freed by the caller.
+ */
+const char *SetInstDirToExeDir(void);
+
 /**
  * @brief Free the allocated installation directory path
  *        and reset the internal pointer to NULL.

data/src/stub.c

@@ -57,15 +57,24 @@ int main(int argc, char *argv[])
         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;
+    /* Create extraction directory, or run in place next to the executable
+       (installer/wrapper mode, see RUN_IN_EXE_DIR) */
+    if (IsRunInExeDir(op_modes)) {
+        extract_dir = SetInstDirToExeDir();
+        if (!extract_dir) {
+            FATAL("Failed to resolve the executable directory");
+            goto cleanup;
+        }
+        DEBUG("Running in executable directory: %s", extract_dir);
+    } else {
+        extract_dir = CreateInstDir(IsExtractToExeDir(op_modes));
+        if (!extract_dir) {
+            FATAL("Failed to create extraction directory");
+            goto cleanup;
+        }
+        DEBUG("Created extraction directory: %s", extract_dir);
     }
 
-    DEBUG("Created extraction directory: %s", extract_dir);
-
     /* Unpacking process */
     if (!ProcessImage(unpack_ctx)) {
         FATAL("Failed to unpack image due to invalid or corrupted data");
@@ -120,7 +129,9 @@ cleanup:
     /*
        If AUTO_CLEAN_INST_DIR is set, delete the extraction directory.
     */
-    if (IsAutoCleanInstDir(op_modes)) {
+    /* 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");

data/src/system_utils.c

@@ -96,6 +96,32 @@ char *JoinPath(const char *p1, const char *p2)
     return joined_path;
 }
 
+char *ToLongPath(const char *path)
+{
+    if (!path) {
+        return NULL;
+    }
+
+    DWORD required = GetLongPathName(path, NULL, 0);
+    if (required == 0) {
+        return _strdup(path); /* e.g. path does not exist - keep as is */
+    }
+
+    char *buf = malloc(required);
+    if (!buf) {
+        APP_ERROR("Memory allocation failed for long path");
+        return NULL;
+    }
+
+    DWORD written = GetLongPathName(path, buf, required);
+    if (written == 0 || written >= required) {
+        free(buf);
+        return _strdup(path);
+    }
+
+    return buf;
+}
+
 char *GetParentPath(const char *path)
 {
     if (!path) {

data/src/system_utils.h

@@ -102,6 +102,20 @@ char *GetImagePath(void);
  */
 char *GetTempDirectoryPath(void);
 
+/**
+ * @brief Normalizes a path to its long form.
+ *
+ * On Windows, converts 8.3 short names (e.g. "C:\\Users\\RUNNER~1") to the
+ * full long path via GetLongPathName. Two spellings of the same directory
+ * would otherwise defeat Ruby's $LOADED_FEATURES deduplication, causing
+ * files to be loaded twice ("already initialized constant" warnings).
+ * On POSIX this simply returns a copy of the given path.
+ *
+ * @return A newly allocated string (caller frees), or NULL on allocation
+ *         failure. Falls back to a copy of the input if conversion fails.
+ */
+char *ToLongPath(const char *path);
+
 /**
  * @brief Writes the contents of a buffer to the specified file path.
  *        Creates any missing parent directories and overwrites existing files.

data/src/system_utils_posix.c

@@ -498,3 +498,9 @@ bool CreateAndWaitForProcess(const char *app_name, char *argv[], int *exit_code)
 
     return true;
 }
+
+/* POSIX has no short-path aliases - return a plain copy. */
+char *ToLongPath(const char *path)
+{
+    return path ? strdup(path) : NULL;
+}

data/src/unpack.c

@@ -536,6 +536,10 @@ bool IsDataCompressed(OperationModes modes) {
     return IsMode(modes, DATA_COMPRESSED);
 }
 
+bool IsRunInExeDir(OperationModes modes) {
+    return IsMode(modes, RUN_IN_EXE_DIR);
+}
+
 bool ProcessImage(const UnpackContext *context)
 {
     if (!context) {

data/src/unpack.h

@@ -66,6 +66,14 @@ typedef enum {
      * required before using the data.
      */
     DATA_COMPRESSED     = 0x10,
+
+    /**
+     * Runs the application directly from the executable's own directory
+     * instead of creating an extraction directory. Used by installer builds
+     * (e.g. Inno Setup) where the application files are installed next to
+     * the stub executable. Restores the pre-1.4 (OCRA) wrapper behavior.
+     */
+    RUN_IN_EXE_DIR      = 0x20,
 } OperationModes;
 
 bool IsDebugMode(OperationModes modes);
@@ -73,6 +81,7 @@ bool IsExtractToExeDir(OperationModes modes);
 bool IsAutoCleanInstDir(OperationModes modes);
 bool IsChdirBeforeScript(OperationModes modes);
 bool IsDataCompressed(OperationModes modes);
+bool IsRunInExeDir(OperationModes modes);
 
 typedef struct UnpackContext UnpackContext;