omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/msi/constants.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI-specific constants
+      #
+      # MSI files use OLE compound document format with additional
+      # semantic structures for database tables and embedded cabinets.
+      module Constants
+        # Column type codes used in _Columns table
+        # Format: first char is type, rest is size/category
+
+        # String types: s0-s255
+        # String index into string pool, category indicates max length
+        STRING_TYPE = "s"
+
+        # Integer types
+        INT16_TYPE = "i2" # 2-byte signed integer
+        INT32_TYPE = "i4" # 4-byte signed integer
+
+        # Binary/stream type
+        BINARY_TYPE = "v0" # Binary data stored in separate stream
+
+        # Object type (temporary)
+        OBJECT_TYPE = "O0"
+
+        # Special column category values
+        CATEGORY_TEXT = 0
+        CATEGORY_UPPERCASE = 1
+        CATEGORY_LOWERCASE = 2
+        CATEGORY_PATH = 3
+        CATEGORY_FILENAME = 4
+        CATEGORY_CONDITION = 5
+        CATEGORY_GUID = 6
+        CATEGORY_VERSION = 7
+        CATEGORY_LANGUAGE = 8
+        CATEGORY_BINARY = 9
+        CATEGORY_TEMPLATE = 10
+        CATEGORY_DOUBLE = 11
+        CATEGORY_CABINET = 12
+        CATEGORY_SHORTCUT = 13
+        CATEGORY_DEFAULT = 14
+        CATEGORY_IDENTIFIER = 15
+
+        # Standard MSI table names
+        TABLES_STREAM = "_Tables"
+        COLUMNS_STREAM = "_Columns"
+        STRING_POOL_STREAM = "_StringPool"
+        STRING_DATA_STREAM = "_StringData"
+
+        # Application tables
+        FILE_TABLE = "File"
+        COMPONENT_TABLE = "Component"
+        DIRECTORY_TABLE = "Directory"
+        MEDIA_TABLE = "Media"
+        STREAMS_TABLE = "_Streams"
+
+        # File attributes (File.Attributes column)
+        FILE_ATTR_READONLY = 0x00000001
+        FILE_ATTR_HIDDEN = 0x00000002
+        FILE_ATTR_SYSTEM = 0x00000004
+        FILE_ATTR_VITAL = 0x00000100
+        FILE_ATTR_CHECKSUM = 0x00000400
+        FILE_ATTR_PATCHADDED = 0x00001000
+        FILE_ATTR_NONCOMPRESSED = 0x00002000
+        FILE_ATTR_COMPRESSED = 0x00004000
+
+        # Directory table special values
+        TARGET_DIR = "TARGETDIR"
+        SOURCE_DIR = "SourceDir"
+        PROGRAM_FILES = "ProgramFilesFolder"
+        PROGRAM_FILES_X64 = "ProgramFiles64Folder"
+        WINDOWS_FOLDER = "WindowsFolder"
+        SYSTEM_FOLDER = "SystemFolder"
+        SYSTEM_X64_FOLDER = "System64Folder"
+
+        # Component attributes
+        COMP_ATTR_LOCAL_ONLY = 0x00000000
+        COMP_ATTR_SOURCE_ONLY = 0x00000001
+        COMP_ATTR_OPTIONAL = 0x00000002
+        COMP_ATTR_REGISTRY_KEY_PATH = 0x00000004
+        COMP_ATTR_SHARED_DLL = 0x00000008
+        COMP_ATTR_PERMANENT = 0x00000010
+        COMP_ATTR_ODBC = 0x00000020
+        COMP_ATTR_TRANSITIVE = 0x00000040
+        COMP_ATTR_NEVER_OVERWRITE = 0x00000080
+        COMP_ATTR_64BIT = 0x00000100
+        COMP_ATTR_DISABLE_REGISTRY = 0x00000200
+        COMP_ATTR_UNINSTALL_ON_SUPERSEDE = 0x00000400
+        COMP_ATTR_SHARED = 0x00000800
+
+        # Media table cabinet name prefix
+        # Cabinet names starting with # indicate embedded cabinets
+        EMBEDDED_CAB_PREFIX = "#"
+
+        # Decode MSI stream name from OLE storage
+        #
+        # MSI uses a custom encoding where characters in the range 0x3800-0x4800
+        # are encoded using a MIME-like base64 scheme. Characters 0x4840 and 0x5
+        # are prefix markers that should be skipped.
+        #
+        # Based on ReactOS/Wine's decode_streamname from msi/table.c
+        #
+        # @param encoded_name [String] Encoded stream name (UTF-16LE with special encoding)
+        # @return [String] Decoded stream name
+        def self.decode_stream_name(encoded_name)
+          result = +""
+          i = 0
+
+          while i < encoded_name.length
+            ch = encoded_name[i].ord
+
+            if ch >= 0x3800 && ch < 0x4800
+              # MIME-like encoding: two 6-bit values
+              c = ch - 0x3800
+              result << mime_char(c & 0x3f)
+              result << mime_char((c >> 6) & 0x3f)
+            elsif ch >= 0x4800 && ch < 0x4840
+              # Single character encoding
+              result << mime_char(ch - 0x4800)
+            elsif i.zero? && [0x4840, 0x0005].include?(ch)
+              # Prefix character to skip (0x4840 is always first for tables)
+              # 0x5 is also a prefix seen in some streams
+            else
+              # Regular character (including ASCII)
+              result << encoded_name[i]
+            end
+
+            i += 1
+          end
+
+          result
+        end
+
+        # Helper for MIME-like character encoding
+        #
+        # @param val [Integer] 6-bit value
+        # @return [String] Encoded character
+        def self.mime_char(val)
+          if val < 10
+            ("0".ord + val).chr
+          elsif val < 36
+            ("A".ord + val - 10).chr
+          elsif val < 62
+            ("a".ord + val - 36).chr
+          elsif val == 62
+            "."
+          else
+            "_"
+          end
+        end
+        private_class_method :mime_char
+      end
+    end
+  end
+end

data/lib/omnizip/formats/msi/directory_resolver.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI Directory Resolver
+      #
+      # Resolves the full installation path for files by traversing
+      # the Directory table hierarchy. MSI uses a self-referential
+      # structure where each directory entry references its parent.
+      #
+      # Directory table columns:
+      # - Directory: Primary key (directory identifier)
+      # - Directory_Parent: Parent directory reference (nil for root)
+      # - DefaultDir: Directory name format "Source|Target" or "Name"
+      class DirectoryResolver
+        include Omnizip::Formats::Msi::Constants
+
+        # @return [Hash] Directory table data
+        attr_reader :directory_table
+
+        # @return [Hash] Directory cache (key => full path)
+        attr_reader :path_cache
+
+        # @return [Hash] Directory info (key => {parent, name, default_dir})
+        attr_reader :directories
+
+        # Initialize resolver with directory table
+        #
+        # @param directory_table [Array<Hash>] Parsed Directory table rows
+        def initialize(directory_table)
+          @directory_table = directory_table || []
+          @path_cache = {}
+          @directories = {}
+          build_directory_map
+        end
+
+        # Resolve full path for a directory key
+        #
+        # @param directory_key [String] Directory identifier
+        # @return [String] Full path (empty string if not found)
+        def resolve_path(directory_key)
+          return "" if directory_key.nil? || directory_key.empty?
+
+          # Check cache
+          return @path_cache[directory_key] if @path_cache.key?(directory_key)
+
+          # Resolve path
+          path = build_path(directory_key, Set.new)
+          @path_cache[directory_key] = path
+          path
+        end
+
+        # Get the source directory name for a directory key
+        #
+        # @param directory_key [String] Directory identifier
+        # @return [String, nil] Source directory name
+        def source_name(directory_key)
+          dir_info = @directories[directory_key]
+          return nil unless dir_info
+
+          parse_default_dir(dir_info[:default_dir])[:source]
+        end
+
+        # Get the target directory name for a directory key
+        #
+        # @param directory_key [String] Directory identifier
+        # @return [String, nil] Target directory name
+        def target_name(directory_key)
+          dir_info = @directories[directory_key]
+          return nil unless dir_info
+
+          parse_default_dir(dir_info[:default_dir])[:target]
+        end
+
+        private
+
+        # Build directory map from table
+        def build_directory_map
+          @directory_table.each do |row|
+            key = row["Directory"]
+            next unless key
+
+            @directories[key] = {
+              key: key,
+              parent: row["Directory_Parent"],
+              default_dir: row["DefaultDir"],
+              name: parse_default_dir(row["DefaultDir"])[:target],
+            }
+          end
+        end
+
+        # Build full path for directory, recursively walking parent chain
+        #
+        # @param key [String] Current directory key
+        # @param visited [Set] Set of visited keys (cycle detection)
+        # @return [String] Full path
+        def build_path(key, visited)
+          return "" if key.nil? || key.empty?
+
+          # Check for circular reference
+          return "" if visited.include?(key)
+
+          dir_info = @directories[key]
+          return "" unless dir_info
+
+          visited.add(key)
+
+          # Get directory name
+          name_info = parse_default_dir(dir_info[:default_dir])
+          name = name_info[:target] || name_info[:source] || ""
+
+          # Handle root directories
+          parent_key = dir_info[:parent]
+          if parent_key.nil? || parent_key.empty? || parent_key == key
+            # This is a root directory
+            return normalize_root_name(name)
+          end
+
+          # Build parent path recursively
+          parent_path = build_path(parent_key, visited)
+
+          # Combine paths
+          if parent_path.empty?
+            normalize_root_name(name)
+          else
+            File.join(parent_path, name)
+          end
+        end
+
+        # Parse DefaultDir format
+        #
+        # Format: "Source|Target" or "Name"
+        # The source name is used during installation from source media.
+        # The target name is used for the installed directory name.
+        #
+        # @param default_dir [String] DefaultDir value
+        # @return [Hash] {source:, target:}
+        def parse_default_dir(default_dir)
+          if default_dir.nil? || default_dir.empty?
+            return { source: "",
+                     target: "" }
+          end
+
+          # Check for source|target format
+          if default_dir.include?("|")
+            parts = default_dir.split("|", 2)
+            {
+              source: parts[0] || "",
+              target: parts[1] || parts[0] || "",
+            }
+          else
+            # Single name - use for both source and target
+            {
+              source: default_dir,
+              target: default_dir,
+            }
+          end
+        end
+
+        # Normalize root directory name
+        #
+        # Maps special MSI directory properties to standard names.
+        #
+        # @param name [String] Directory name
+        # @return [String] Normalized name
+        def normalize_root_name(name)
+          case name
+          when TARGET_DIR, SOURCE_DIR
+            "SourceDir"
+          when PROGRAM_FILES
+            "Program Files"
+          when PROGRAM_FILES_X64
+            "Program Files (x86)"
+          when WINDOWS_FOLDER
+            "Windows"
+          when SYSTEM_FOLDER, SYSTEM_X64_FOLDER
+            "System"
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/msi/entry.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI File Entry
+      #
+      # Represents a single file within an MSI package.
+      # File information is assembled from File, Component, and Directory tables.
+      class Entry
+        include Omnizip::Entry
+        include Omnizip::Formats::Msi::Constants
+
+        def entry_name = path
+        def entry_directory? = false
+        def entry_size = size
+        def entry_mtime = nil
+
+        # @return [String] Full installation path
+        attr_accessor :path
+
+        # @return [String] File key (primary key from File table)
+        attr_accessor :file_key
+
+        # @return [String] Component key
+        attr_accessor :component
+
+        # @return [String] Filename from File table (may be "short|long" format)
+        attr_accessor :filename
+
+        # @return [String] Long filename (extracted from filename)
+        attr_accessor :long_name
+
+        # @return [String] Short filename (8.3 format)
+        attr_accessor :short_name
+
+        # @return [Integer] File size in bytes
+        attr_accessor :size
+
+        # @return [Integer] Sequence number (maps to Media table)
+        attr_accessor :sequence
+
+        # @return [String] File version
+        attr_accessor :version
+
+        # @return [String] File language
+        attr_accessor :language
+
+        # @return [Integer] File attributes
+        attr_accessor :attributes
+
+        # @return [Time, nil] Creation time (from CAB)
+        attr_accessor :creation_time
+
+        # @return [Time, nil] Last write time (from CAB)
+        attr_accessor :last_write_time
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean]
+        def directory?
+          false
+        end
+
+        # Check if entry is a file
+        #
+        # @return [Boolean]
+        def file?
+          true
+        end
+
+        # Check if file is compressed
+        #
+        # @return [Boolean]
+        def compressed?
+          @attributes&.anybits?(FILE_ATTR_COMPRESSED)
+        end
+
+        # Check if file is vital (must be present for installation)
+        #
+        # @return [Boolean]
+        def vital?
+          @attributes&.anybits?(FILE_ATTR_VITAL)
+        end
+
+        # Get file attributes as string
+        #
+        # @return [String] Attributes string (e.g., "Archive")
+        def attributes_string
+          attrs = []
+          attrs << "Archive"
+          attrs << "ReadOnly" if @attributes&.anybits?(FILE_ATTR_READONLY)
+          attrs << "Hidden" if @attributes&.anybits?(FILE_ATTR_HIDDEN)
+          attrs << "System" if @attributes&.anybits?(FILE_ATTR_SYSTEM)
+          attrs.join(", ")
+        end
+
+        # Parse filename field
+        #
+        # MSI File.Filename can be:
+        # - "short|long" - both short and long names
+        # - "name" - just the name
+        #
+        # @param filename [String] Raw filename from File table
+        def parse_filename(filename)
+          @filename = filename
+
+          if filename&.include?("|")
+            parts = filename.split("|", 2)
+            @short_name = parts[0]
+            @long_name = parts[1]
+          else
+            @long_name = filename
+            @short_name = nil
+          end
+        end
+
+        # Get display filename (prefers long name)
+        #
+        # @return [String]
+        def display_name
+          @long_name || @short_name || @filename || ""
+        end
+
+        # Get path for display (Windows-style backslashes)
+        #
+        # @return [String]
+        def windows_path
+          @path&.gsub("/", "\\")
+        end
+      end
+    end
+  end
+end