omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/iso.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # ISO 9660 CD-ROM filesystem format support
+    #
+    # Reads and writes ISO 9660 images: Primary Volume Descriptor
+    # parsing, directory traversal, file extraction, and image
+    # creation whose directory records point at allocated extents
+    # (verified against 7-Zip). Rock Ridge and Joliet are NOT
+    # implemented — the writer's options stay false rather than
+    # advertising extensions readers would misparse.
+    module Iso
+      # Nested classes - autoloaded
+      autoload :Reader, "omnizip/formats/iso/reader"
+      autoload :Writer, "omnizip/formats/iso/writer"
+      autoload :VolumeDescriptor, "omnizip/formats/iso/volume_descriptor"
+      autoload :VolumeBuilder, "omnizip/formats/iso/volume_builder"
+      autoload :DirectoryRecord, "omnizip/formats/iso/directory_record"
+      autoload :DirectoryBuilder, "omnizip/formats/iso/directory_builder"
+      autoload :PathTable, "omnizip/formats/iso/path_table"
+      autoload :RockRidge, "omnizip/formats/iso/rock_ridge"
+      autoload :Joliet, "omnizip/formats/iso/joliet"
+
+      # ISO 9660 constants
+      SECTOR_SIZE = 2048
+      SYSTEM_AREA_SECTORS = 16
+      VOLUME_DESCRIPTOR_START = SYSTEM_AREA_SECTORS
+
+      # Volume descriptor types
+      VD_BOOT_RECORD = 0
+      VD_PRIMARY = 1
+      VD_SUPPLEMENTARY = 2
+      VD_PARTITION = 3
+      VD_TERMINATOR = 255
+
+      # File flags
+      FLAG_HIDDEN = 0x01
+      FLAG_DIRECTORY = 0x02
+      FLAG_ASSOCIATED = 0x04
+      FLAG_EXTENDED = 0x08
+      FLAG_PERMISSIONS = 0x10
+      FLAG_NOT_FINAL = 0x80
+
+      # Open existing ISO image
+      #
+      # @param path [String] Path to ISO file
+      # @yield [reader] Block for reading archive
+      # @yieldparam reader [Reader] ISO reader
+      # @return [Reader] ISO reader
+      def self.open(path)
+        reader = Reader.new(path)
+        reader.open
+
+        if block_given?
+          begin
+            yield reader
+          ensure
+            reader.close
+          end
+        end
+
+        reader
+      end
+
+      # List contents of ISO image
+      #
+      # @param path [String] Path to ISO file
+      # @return [Array<DirectoryRecord>] Directory entries
+      def self.list(path)
+        entries = nil
+        open(path) { |iso| entries = iso.entries }
+        entries
+      end
+
+      # Extract ISO contents
+      #
+      # @param iso_path [String] Path to ISO file
+      # @param output_dir [String] Output directory
+      def self.extract(iso_path, output_dir)
+        open(iso_path) do |iso|
+          iso.extract_all(output_dir)
+        end
+      end
+
+      # Get ISO volume information
+      #
+      # @param path [String] Path to ISO file
+      # @return [Hash] Volume information
+      def self.info(path)
+        open(path) do |iso|
+          {
+            format: "ISO 9660",
+            volume_id: iso.volume_identifier,
+            system_id: iso.system_identifier,
+            size: iso.volume_size,
+            files: iso.entries.count { |e| !e.directory? },
+            directories: iso.entries.count(&:directory?),
+          }
+        end
+      end
+
+      # Create ISO 9660 image
+      #
+      # @param path [String] Output ISO file path
+      # @param options [Hash] Creation options
+      # @yield [writer] Block for adding files/directories
+      # @yieldparam writer [Writer] ISO writer
+      # @return [String] Path to created ISO
+      #
+      # @example Create ISO image
+      #   Omnizip::Formats::Iso.create('backup.iso') do |iso|
+      #     iso.volume_id = 'BACKUP_2024'
+      #     iso.add_directory('documents/')
+      #   end
+      #
+      # @example With Rock Ridge and Joliet
+      #   Omnizip::Formats::Iso.create('cdrom.iso',
+      #     rock_ridge: true,
+      #     joliet: true
+      #   ) do |iso|
+      #     iso.add_directory('files/')
+      #   end
+      def self.create(path, options = {})
+        writer = Writer.new(path, options)
+
+        yield writer if block_given?
+
+        writer.write
+      end
+    end
+  end
+end

data/lib/omnizip/formats/lzip.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    #
+    # LZIP (.lz) compression format
+    #
+    # Lzip is a file compression format that uses LZMA compression with a
+    # simple container format. It was created as an alternative to the
+    # legacy .lzma format with better integrity checking.
+    #
+    # This is DIFFERENT from both XZ and .lzma (LZMA_Alone) formats:
+    # - XZ (.xz): Container format with stream header/footer/index, LZMA2 compression
+    # - LZIP (.lz): Standalone format with "LZIP" magic and CRC32 footer, LZMA1 compression
+    # - LZMA_Alone (.lzma): Legacy standalone format with properties byte, LZMA1 compression
+    #
+    # Format structure:
+    # - Header (6 bytes):
+    #   - Magic bytes: "LZIP" (0x4C 0x5A 0x49 0x50)
+    #   - Version (1 byte): 0 or 1
+    #   - Dictionary size (1 byte): encoded format
+    # - LZMA1 compressed stream (with fixed LC=3, LP=0, PB=2)
+    # - Footer:
+    #   - Version 0 (12 bytes): CRC32 (4) + Uncompressed size (8)
+    #   - Version 1 (20 bytes): CRC32 (4) + Uncompressed size (8) + Member size (8)
+    #
+    # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/lzip_decoder.c
+    #
+    module Lzip
+      # Lzip magic bytes: "LZIP" in ASCII
+      # Reference: lzip_decoder.c:106
+      MAGIC = [0x4C, 0x5A, 0x49, 0x50].pack("C*")
+
+      # Fixed LC/LP/PB values for lzip format
+      # Reference: lzip_decoder.c:23-26
+      LZIP_LC = 3
+      LZIP_LP = 0
+      LZIP_PB = 2
+
+      # Minimum and maximum dictionary sizes (in bytes)
+      # Reference: lzip_decoder.c:197-198
+      MIN_DICT_SIZE = 4096 # 4 KiB
+      MAX_DICT_SIZE = (512 << 20) # 512 MiB
+
+      class << self
+        # Compress a file with LZIP
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output LZIP file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :level Compression level (0-9, default: 6)
+        # @option options [Integer] :dict_size Dictionary size (default: auto from level)
+        # @option options [Integer] :version LZIP version (0 or 1, default: 1)
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            compress_stream(
+              StringIO.new(input_data),
+              output,
+              options,
+            )
+          end
+        end
+
+        # Decompress LZIP data
+        #
+        # @param input [String, IO] Input data, file path, or IO object
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options
+        # @option options [Boolean] :ignore_check If true, skip CRC32 verification (default: false)
+        # @option options [Boolean] :concatenated If true, decode concatenated .lz members (default: false)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, options = {})
+          data = Omnizip::IO::Source.for(input).read
+
+          # Decode using LzipDecoder
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(
+            StringIO.new(data),
+            options,
+          )
+          result = decoder.decode_stream
+
+          if output
+            Omnizip::IO::Sink.for(output).write(result)
+          else
+            result
+          end
+        end
+
+        # Decode LZIP data (alias for decompress with no output)
+        #
+        # @param input [String, IO] Input LZIP data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Compress data stream with LZIP
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, output_io, options = {})
+          input = input_io.read
+
+          # Version-1 member: magic + version + dict-size byte, LZMA1
+          # body (EOPM-terminated), 20-byte trailer (CRC32 + data
+          # size + member size). The dictionary byte uses lzip's
+          # 5-bit exponent / 3-bit fraction encoding; 4 MiB is the
+          # typical default.
+          output_io.write(MAGIC)
+          output_io.write([1].pack("C"))
+          output_io.write([22].pack("C")) # 2^22 = 4 MiB, no fraction
+
+          dict_size = options.fetch(:dict_size, 8 * 1024 * 1024)
+          body = Algorithms::LZMA::Lzma1Encoder
+            .new(dict_size: dict_size).encode(input)
+
+          member_size = 6 + body.bytesize + 20
+          output_io.write(body)
+          output_io.write([Checksums::Crc32.calculate(input)].pack("V"))
+          output_io.write([input.bytesize].pack("Q<"))
+          output_io.write([member_size].pack("Q<"))
+        end
+
+        # Decompress LZIP stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Options
+        # @return [Hash] Metadata (version, dict_size, member_size)
+        def decompress_stream(input_io, output_io, options = {})
+          output_io.set_encoding(Encoding::BINARY)
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(input_io,
+                                                               options)
+          result = decoder.decode_stream
+
+          output_io.write(result)
+
+          # Return metadata
+          {
+            version: decoder.version,
+            dict_size: decoder.dict_size,
+            member_size: decoder.member_size,
+          }
+        end
+
+        # Detect if data is LZIP format
+        #
+        # @param data [String] Data to check
+        # @return [Boolean] true if data has LZIP magic bytes
+        def lzip_file?(data)
+          data.start_with?(MAGIC)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/lzma_alone.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    #
+    # LZMA_Alone (.lzma) compression format
+    #
+    # This is the legacy LZMA_Alone format used by LZMA Utils 4.32.x.
+    # It is DIFFERENT from both XZ and LZIP formats:
+    # - XZ (.xz): Container format with stream header/footer/index, LZMA2 compression
+    # - LZIP (.lz): Standalone format with "LZIP" magic and CRC32 footer, LZMA1 compression
+    # - LZMA_Alone (.lzma): Legacy standalone format with properties byte, LZMA1 compression
+    #
+    # Format structure:
+    # - Properties (1 byte): encodes lc, lp, pb values
+    # - Dictionary size (4 bytes, little-endian)
+    # - Uncompressed size (8 bytes, little-endian, UINT64_MAX = unknown)
+    # - LZMA1 compressed stream (no footer, no CRC32)
+    #
+    # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/alone_decoder.c
+    #
+    module LzmaAlone
+      # Maximum valid uncompressed size (256 GiB)
+      # From alone_decoder.c:118
+      MAX_UNCOMPRESSED_SIZE = (1 << 38)
+
+      # Property byte validation limits
+      # From lzma_decoder.c:1218
+      MAX_PROPERTY_BYTE = (((4 * 5) + 4) * 9) + 8 # = 233
+
+      # Value indicating unknown uncompressed size
+      UINT64_MAX = (1 << 64) - 1
+
+      class << self
+        # Compress a file with LZMA_Alone format
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output LZMA_Alone file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :lc Literal context bits (0-8, default: 3)
+        # @option options [Integer] :lp Literal position bits (0-4, default: 0)
+        # @option options [Integer] :pb Position bits (0-4, default: 2)
+        # @option options [Integer] :dict_size Dictionary size (default: 8MB)
+        # @option options [Integer] :uncompressed_size Explicit uncompressed size (default: unknown)
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            compress_stream(
+              StringIO.new(input_data),
+              output,
+              options,
+            )
+          end
+        end
+
+        # Decompress LZMA_Alone data
+        #
+        # @param input [String, IO] Input data, file path, or IO object
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options
+        # @option options [Boolean] :picky If true, reject files unlikely to be .lzma (default: false)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, options = {})
+          data = Omnizip::IO::Source.for(input).read
+
+          # Decode using LzmaAloneDecoder
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(
+            StringIO.new(data),
+            options,
+          )
+          result = decoder.decode_stream
+
+          if output
+            Omnizip::IO::Sink.for(output).write(result)
+          else
+            result
+          end
+        end
+
+        # Decode LZMA_Alone data (alias for decompress with no output)
+        #
+        # @param input [String, IO] Input LZMA_Alone data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Compress data stream with LZMA_Alone format
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, output_io, options = {})
+          input_data = input_io.read
+
+          # Get encoding parameters
+          lc = options[:lc] || 3
+          lp = options[:lp] || 0
+          pb = options[:pb] || 2
+          dict_size = options[:dict_size] || (8 * 1024 * 1024)
+          uncompressed_size = options[:uncompressed_size] || input_data.bytesize
+
+          # Encode properties byte
+          prop_byte = (((pb * 5) + lp) * 9) + lc
+
+          # Write header
+          output_io.write([prop_byte].pack("C"))
+          output_io.write([dict_size].pack("V"))
+          output_io.write([uncompressed_size].pack("Q<"))
+
+          # Raw LZMA1 body. The header carries the uncompressed size,
+          # but the EOPM is still emitted: the format permits it with
+          # a known size and it lets size-agnostic decoders stop too.
+          body = Algorithms::LZMA::Lzma1Encoder
+            .new(dict_size: dict_size, lc: lc, lp: lp, pb: pb)
+            .encode(input_data)
+          output_io.write(body)
+        end
+
+        # Decompress LZMA_Alone stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Options
+        # @return [Hash] Metadata (lc, lp, pb, dict_size, uncompressed_size)
+        def decompress_stream(input_io, output_io, options = {})
+          output_io.set_encoding(Encoding::BINARY)
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(input_io,
+                                                                    options)
+          result = decoder.decode_stream
+
+          output_io.write(result)
+
+          # Return metadata
+          {
+            lc: decoder.lc,
+            lp: decoder.lp,
+            pb: decoder.pb,
+            dict_size: decoder.dict_size,
+            uncompressed_size: decoder.uncompressed_size,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI CAB Extractor
+      #
+      # Handles extraction of files from embedded or external cabinet files.
+      # MSI packages can have cabinets embedded in the _Streams table or
+      # as separate .cab files alongside the MSI.
+      class CabExtractor
+        include Omnizip::Formats::Msi::Constants
+
+        # @return [Ole::Storage] OLE storage
+        attr_reader :ole
+
+        # @return [Array<Hash>] Media table data
+        attr_reader :media_table
+
+        # @return [String] Path to MSI file (for external CAB resolution)
+        attr_reader :msi_path
+
+        # @return [Proc] Stream reader method
+        attr_reader :read_stream
+
+        # Initialize CAB extractor
+        #
+        # @param ole [Ole::Storage] OLE storage object
+        # @param media_table [Array<Hash>] Parsed Media table rows
+        # @param msi_path [String] Path to MSI file
+        # @param stream_reader [Proc] Method to read streams
+        def initialize(ole, media_table, msi_path, stream_reader)
+          @ole = ole
+          @media_table = media_table || []
+          @msi_path = msi_path
+          @read_stream = stream_reader
+        end
+
+        # Extract all cabinets to temporary files
+        #
+        # @return [Hash] Map of cabinet name => temp file path
+        def extract_cabinets
+          cabinets = {}
+
+          @media_table.each do |media|
+            cab_name = media["Cabinet"]
+            next if cab_name.nil? || cab_name.empty?
+
+            cab_data = get_cabinet_data(cab_name)
+            next if cab_data.nil? || cab_data.empty?
+
+            # Write to temp file
+            temp_file = Tempfile.create(["msi_cab_", ".cab"])
+            temp_file.binmode
+            temp_file.write(cab_data)
+            temp_file.flush
+            temp_file.close
+
+            cabinets[media["DiskId"]] = {
+              path: temp_file.path,
+              name: cab_name,
+              last_sequence: media["LastSequence"],
+              temp_file: temp_file,
+            }
+          end
+
+          cabinets
+        end
+
+        # Get cabinet data for a media entry
+        #
+        # @param cabinet_name [String] Cabinet name from Media table
+        # @return [String, nil] Cabinet binary data or nil
+        def get_cabinet_data(cabinet_name)
+          return nil if cabinet_name.nil? || cabinet_name.empty?
+
+          if cabinet_name.start_with?(EMBEDDED_CAB_PREFIX)
+            # Embedded cabinet
+            extract_embedded_cabinet(cabinet_name[1..])
+          else
+            # External cabinet file
+            read_external_cabinet(cabinet_name)
+          end
+        end
+
+        # Find the cabinet containing a file by sequence number
+        #
+        # @param sequence [Integer] File sequence number
+        # @param cabinets [Hash] Cabinet info from extract_cabinets
+        # @return [Hash, nil] Cabinet info or nil
+        def find_cabinet_for_sequence(sequence, cabinets)
+          # Sort by LastSequence and find the cabinet where sequence <= LastSequence
+          sorted = cabinets.values.sort_by { |c| c[:last_sequence] }
+          sorted.find { |c| sequence <= c[:last_sequence] }
+        end
+
+        private
+
+        # Extract embedded cabinet data
+        #
+        # Embedded cabinets can be in:
+        # 1. _Streams table (most common)
+        # 2. Direct OLE stream (rare)
+        #
+        # @param stream_name [String] Stream name (without # prefix)
+        # @return [String, nil] Cabinet data or nil
+        def extract_embedded_cabinet(stream_name)
+          return nil if stream_name.nil? || stream_name.empty?
+
+          # Try to read from OLE directly using various name encodings
+          candidates = build_stream_name_candidates(stream_name)
+
+          candidates.each do |name|
+            data = @read_stream.call(name)
+            return data if data && !data.empty? && valid_cab?(data)
+          end
+
+          # Also try without # prefix but with standard prefixes
+          data = @read_stream.call(stream_name)
+          return data if data && !data.empty? && valid_cab?(data)
+
+          nil
+        end
+
+        # Build possible encoded stream name candidates
+        #
+        # @param name [String] Base stream name
+        # @return [Array<String>] Possible stream names
+        def build_stream_name_candidates(name)
+          candidates = []
+
+          # Try direct name
+          candidates << name
+
+          # Try with MSI stream name encoding prefix
+          # Use binary encoding for the prefix byte
+          utf16le = name.encode("UTF-16LE")
+          candidates << ("\x01".b << utf16le.dup.force_encoding("BINARY"))
+          candidates << ("\x05".b << utf16le.dup.force_encoding("BINARY"))
+
+          # Try without any prefix (plain ASCII)
+          candidates << name
+
+          candidates.uniq
+        end
+
+        # Check if data is a valid cabinet file
+        #
+        # @param data [String] Binary data
+        # @return [Boolean] true if valid CAB signature
+        def valid_cab?(data)
+          return false if data.nil? || data.bytesize < 4
+
+          # Check for MSCF signature
+          data[0, 4] == "MSCF"
+        end
+
+        # Read external cabinet file
+        #
+        # External cabinets are located in the same directory as the MSI.
+        #
+        # @param cabinet_name [String] Cabinet filename
+        # @return [String, nil] Cabinet data or nil
+        def read_external_cabinet(cabinet_name)
+          return nil if @msi_path.nil?
+
+          cab_path = File.join(File.dirname(@msi_path), cabinet_name)
+
+          begin
+            File.binread(cab_path) if File.exist?(cab_path)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end