omnizip 0.4.7-x86_64-linux

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI Table Parser
+      #
+      # Parses MSI database tables from OLE streams. MSI uses a column-major
+      # storage format where each column's data is stored contiguously.
+      #
+      # Key tables for file extraction:
+      # - File: File entries with name, size, component, sequence
+      # - Component: Links files to directories
+      # - Directory: Directory hierarchy
+      # - Media: Cabinet file references
+      class TableParser
+        include Omnizip::Formats::Msi::Constants
+
+        # @return [StringPool] String pool for string lookups
+        attr_reader :string_pool
+
+        # @return [Hash] Parsed tables (table_name => rows)
+        attr_reader :tables
+
+        # @return [Hash] Column definitions (table_name => columns)
+        attr_reader :columns
+
+        # @return [Array<String>] Table names
+        attr_reader :table_names
+
+        # @return [Proc] Stream reader method
+        attr_reader :read_stream
+
+        # Initialize table parser
+        #
+        # @param string_pool [StringPool] String pool for lookups
+        # @param stream_reader [Proc] Method to read streams
+        def initialize(string_pool, stream_reader)
+          @string_pool = string_pool
+          @read_stream = stream_reader
+          @tables = {}
+          @columns = {}
+          @table_names = []
+          load_table_list
+          load_column_defs
+        end
+
+        # Get table rows
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Table rows (each row is a hash of column => value)
+        def table(table_name)
+          return @tables[table_name] if @tables.key?(table_name)
+
+          @tables[table_name] = parse_table(table_name)
+        end
+
+        # Get column definitions for table
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Column definitions
+        def column_defs(table_name)
+          @columns[table_name] || []
+        end
+
+        # Check if table exists
+        #
+        # @param table_name [String] Table name
+        # @return [Boolean]
+        def table_exists?(table_name)
+          @table_names.include?(table_name)
+        end
+
+        private
+
+        # Load list of table names from _Tables stream
+        def load_table_list
+          data = @read_stream.call(TABLES_STREAM)
+          return if data.nil? || data.empty?
+
+          # _Tables format: column-major with one column (Table string index)
+          # First 2 bytes appear to be header (skip)
+          # Then 2-byte string indices for each table name
+          return if data.bytesize < 4
+
+          # Skip first 2 bytes (header), read string indices
+          offset = 2
+          while offset + 2 <= data.bytesize
+            str_idx = data[offset, 2].unpack1("v")
+            name = @string_pool[str_idx]
+            @table_names << name if name
+            offset += 2
+          end
+        end
+
+        # Load column definitions from _Columns stream
+        def load_column_defs
+          data = @read_stream.call(COLUMNS_STREAM)
+          return if data.nil? || data.empty?
+
+          # _Columns format: column-major with 4 columns
+          # Column 1: Table (string index, 2 bytes)
+          # Column 2: Number (signed short, 2 bytes)
+          # Column 3: Name (string index, 2 bytes)
+          # Column 4: Type (unsigned short, 2 bytes)
+
+          # Determine number of rows
+          num_rows = data.bytesize / 8 # 4 columns * 2 bytes each
+
+          # Extract each column (column-major order)
+          col_size = num_rows * 2
+
+          table_col = data[0, col_size].unpack("v*")
+          number_col = data[col_size, col_size].unpack("v*")
+          name_col = data[col_size * 2, col_size].unpack("v*")
+          type_col = data[col_size * 3, col_size].unpack("v*")
+
+          # Build column definitions per table
+          num_rows.times do |i|
+            table_name = @string_pool[table_col[i]]
+            next unless table_name
+
+            col_name = @string_pool[name_col[i]]
+            next unless col_name
+
+            # Number column: signed short with nullable bit
+            raw_num = number_col[i]
+            col_num = raw_num & 0x7FFF
+            is_primary_key = raw_num.anybits?(0x8000)
+
+            # Type column: determine storage width
+            type_val = type_col[i]
+            col_type = parse_column_type(type_val)
+
+            @columns[table_name] ||= []
+            @columns[table_name] << {
+              name: col_name,
+              number: col_num,
+              type: col_type[:type],
+              width: col_type[:width],
+              nullable: col_type[:nullable],
+              primary_key: is_primary_key,
+            }
+          end
+
+          # Sort columns by number for each table
+          @columns.each_value do |cols|
+            cols.sort_by! { |c| c[:number] }
+          end
+        end
+
+        # Parse column type from raw type value
+        #
+        # Type encoding:
+        # - Low byte: length or type code
+        # - High byte: type category with nullable bit
+        #
+        # @param raw [Integer] Raw type value
+        # @return [Hash] Parsed type info
+        def parse_column_type(raw)
+          low_byte = raw & 0xFF
+          high_byte = (raw >> 8) & 0xFF
+          nullable = high_byte.anybits?(0x80)
+          type_id = high_byte & 0x7F
+
+          # Determine type and width based on type_id
+          # Type 1 = int, Type >= 0x10 = string
+          if type_id == 1
+            # Integer type
+            if low_byte == 2
+              { type: :i2, width: 2, nullable: nullable }
+            else
+              { type: :i4, width: 4, nullable: nullable }
+            end
+          elsif type_id == 2
+            # Long integer
+            { type: :i4, width: 4, nullable: nullable }
+          elsif type_id >= 0x10
+            # String type - width is always 2 (string pool index)
+            { type: :string, width: 2, nullable: nullable }
+          else
+            # Default to string
+            { type: :string, width: 2, nullable: nullable }
+          end
+        end
+
+        # Parse a table stream into rows
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Parsed rows
+        def parse_table(table_name)
+          rows = []
+          data = @read_stream.call(table_name)
+          return rows if data.nil? || data.empty?
+
+          column_defs = @columns[table_name]
+          return rows if column_defs.nil? || column_defs.empty?
+
+          # Calculate row count from data size and column widths
+          total_width = column_defs.sum { |c| c[:width] }
+          return rows if total_width.zero?
+
+          num_rows = data.bytesize / total_width
+
+          # Parse column by column (column-major order)
+          offset = 0
+          rows = Array.new(num_rows) { {} }
+
+          column_defs.each do |col|
+            num_rows.times do |row_idx|
+              value = read_column_value(data, offset, col)
+              rows[row_idx][col[:name]] = value
+              offset += col[:width]
+            end
+          end
+
+          rows
+        end
+
+        # Read a single column value from data
+        #
+        # @param data [String] Raw table data
+        # @param offset [Integer] Current offset
+        # @param col [Hash] Column definition
+        # @return [Object] Parsed value
+        def read_column_value(data, offset, col)
+          case col[:type]
+          when :string
+            str_idx = data[offset, 2]&.unpack1("v") || 0
+            @string_pool[str_idx]
+          when :i2
+            val = data[offset, 2]&.unpack1("v") || 0
+            # Handle nullable marker
+            col[:nullable] ? (val & 0x7FFF) : val
+          when :i4
+            val = data[offset, 4]&.unpack1("V") || 0
+            # Handle nullable marker (high bit)
+            col[:nullable] ? (val & 0x7FFFFFFF) : val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/msi.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # MSI (Microsoft Installer) format support
+    #
+    # Provides read access to MSI packages, extracting files from
+    # embedded or external cabinet archives.
+    #
+    # MSI files are OLE compound documents containing:
+    # - Database tables (File, Component, Directory, Media, etc.)
+    # - String pool for interned strings
+    # - Embedded cabinets (in _Streams or direct OLE streams)
+    module Msi
+      autoload :Constants, "omnizip/formats/msi/constants"
+      autoload :Entry, "omnizip/formats/msi/entry"
+      autoload :StringPool, "omnizip/formats/msi/string_pool"
+      autoload :TableParser, "omnizip/formats/msi/table_parser"
+      autoload :DirectoryResolver, "omnizip/formats/msi/directory_resolver"
+      autoload :CabExtractor, "omnizip/formats/msi/cab_extractor"
+      autoload :Reader, "omnizip/formats/msi/reader"
+
+      class << self
+        # Open MSI file and return reader
+        #
+        # @param path [String] Path to MSI file
+        # @yield [Reader] Reader instance
+        # @return [Reader]
+        def open(path)
+          reader = Reader.new(path)
+          reader.open
+          if block_given?
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          else
+            reader
+          end
+        end
+
+        # List files in MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @return [Array<String>] File paths
+        def list(path)
+          open(path) { |r| r.files.map(&:path) }
+        end
+
+        # Extract all files from MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @param output_dir [String] Output directory
+        # @return [Array<String>] Extracted file paths
+        def extract(path, output_dir)
+          open(path) do |reader|
+            reader.extract(output_dir)
+            reader.files.map { |f| File.join(output_dir, f.path) }
+          end
+        end
+
+        # Get information about MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @return [Hash] Package information
+        def info(path)
+          open(path, &:info)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/ole/allocation_table.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE allocation table
+      #
+      # Manages block chains for files stored in OLE containers.
+      # There are two types: Big (BBAT) and Small (SBAT).
+      class AllocationTable
+        include Omnizip::Formats::Ole::Constants
+
+        # @return [Array<Integer>] Table entries
+        attr_reader :entries
+
+        # @return [Object] Parent OLE storage
+        attr_reader :ole
+
+        # @return [IO] Underlying IO
+        attr_reader :io
+
+        # @return [Integer] Block size in bytes
+        attr_reader :block_size
+
+        # Initialize allocation table
+        #
+        # @param ole [Object] Parent OLE storage
+        def initialize(ole)
+          @ole = ole
+          @entries = []
+        end
+
+        # Load allocation table from binary data
+        #
+        # @param data [String] Binary data containing table entries
+        def load(data)
+          @entries = data.unpack("V*")
+        end
+
+        # Get entry at index
+        #
+        # @param idx [Integer] Entry index
+        # @return [Integer] Entry value
+        def [](idx)
+          @entries[idx]
+        end
+
+        # Set entry at index
+        #
+        # @param idx [Integer] Entry index
+        # @param val [Integer] Entry value
+        def []=(idx, val)
+          @entries[idx] = val
+        end
+
+        # Get number of entries
+        #
+        # @return [Integer] Entry count
+        def length
+          @entries.length
+        end
+
+        # Free resources to prevent memory leaks
+        #
+        # Call this when done with the allocation table to release memory.
+        # @return [void]
+        def free
+          @entries = nil
+          @ole = nil
+          @io = nil
+        end
+
+        # Follow chain from starting index
+        #
+        # @param idx [Integer] Starting block index
+        # @return [Array<Integer>] Chain of block indices
+        # @raise [ArgumentError] If chain is broken
+        def chain(idx)
+          result = []
+          visited = Set.new
+
+          until idx >= META_BAT
+            if idx.negative? || idx > length
+              raise ArgumentError, "Broken allocation chain at index #{idx}"
+            end
+
+            if visited.include?(idx)
+              raise ArgumentError, "Circular chain detected at index #{idx}"
+            end
+
+            visited << idx
+            result << idx
+            idx = @entries[idx]
+          end
+
+          result
+        end
+
+        # Convert block chain to byte ranges
+        #
+        # @param blocks [Array<Integer>] Block indices
+        # @param size [Integer, nil] Optional size to truncate to
+        # @return [Array<Array<Integer, Integer>>] Array of [offset, length] pairs
+        def blocks_to_ranges(blocks, size = nil)
+          return [] if blocks.empty?
+
+          # Truncate chain if size specified
+          blocks = blocks[0, (size.to_f / block_size).ceil] if size
+
+          # Convert to ranges
+          ranges = blocks.map { |i| [block_size * i, block_size] }
+
+          # Truncate final range if needed
+          if ranges.last && size
+            ranges.last[1] -= ((ranges.length * block_size) - size)
+          end
+
+          ranges
+        end
+
+        # Get ranges for a chain
+        #
+        # @param chain_or_idx [Array<Integer>, Integer] Block chain or head index
+        # @param size [Integer, nil] Optional size
+        # @return [Array<Array<Integer, Integer>>] Byte ranges
+        def ranges(chain_or_idx, size = nil)
+          blocks = chain_or_idx.is_a?(Array) ? chain_or_idx : chain(chain_or_idx)
+          blocks_to_ranges(blocks, size)
+        end
+
+        # Read data from block chain
+        #
+        # @param chain_or_idx [Array<Integer>, Integer] Block chain or head index
+        # @param size [Integer, nil] Optional size
+        # @return [String] Data from chain
+        def read(chain_or_idx, size = nil)
+          ranges = self.ranges(chain_or_idx, size)
+          data = "".b
+
+          ranges.each do |offset, len|
+            @io.seek(offset)
+            data << @io.read(len).to_s
+          end
+
+          data
+        end
+
+        # Find a free block
+        #
+        # @return [Integer] Free block index
+        def free_block
+          idx = @entries.index(AVAIL)
+          return idx if idx
+
+          @entries << AVAIL
+          @entries.length - 1
+        end
+
+        # Resize a block chain
+        #
+        # @param blocks [Array<Integer>] Current blocks (modified in place)
+        # @param size [Integer] New size in bytes
+        # @return [Array<Integer>] Updated blocks
+        def resize_chain(blocks, size)
+          new_num_blocks = (size / block_size.to_f).ceil
+          old_num_blocks = blocks.length
+
+          if new_num_blocks < old_num_blocks
+            # De-allocate excess blocks
+            (new_num_blocks...old_num_blocks).each do |i|
+              @entries[blocks[i]] = AVAIL
+            end
+            if new_num_blocks.positive?
+              @entries[blocks[new_num_blocks - 1]] =
+                EOC
+            end
+            blocks.slice!(new_num_blocks..-1)
+          elsif new_num_blocks > old_num_blocks
+            # Allocate more blocks
+            last_block = blocks.last
+            (new_num_blocks - old_num_blocks).times do
+              block = free_block
+              @entries[last_block] = block if last_block
+              blocks << block
+              last_block = block
+              @entries[last_block] = EOC
+            end
+          end
+
+          blocks
+        end
+
+        # Truncate table to remove trailing AVAIL entries
+        #
+        # @return [Array<Integer>] Truncated entries
+        def truncate
+          temp = @entries.reverse
+          first_non_avail = temp.find { |b| b != AVAIL }
+          temp = temp[temp.index(first_non_avail)..] if first_non_avail
+          temp.reverse
+        end
+
+        # Truncate entries in place
+        def truncate_entries
+          @entries.replace(truncate)
+        end
+
+        # Pack table to binary data
+        #
+        # @return [String] Binary data
+        def pack
+          table = truncate
+
+          # Pad to block boundary
+          num = @ole.bbat.block_size / 4
+          if (table.length % num) != 0
+            table += [AVAIL] * (num - (table.length % num))
+          end
+
+          table.pack("V*")
+        end
+
+        # Big allocation table (BBAT)
+        #
+        # Manages large blocks (typically 512 bytes) for files >= 4096 bytes.
+        class Big < AllocationTable
+          def initialize(ole)
+            super
+            @block_size = 1 << @ole.header.b_shift
+            @io = @ole.io
+          end
+
+          # Big blocks are -1 based to avoid clashing with header
+          #
+          # @param blocks [Array<Integer>] Block indices
+          # @param size [Integer, nil] Optional size
+          # @return [Array<Array<Integer, Integer>>] Byte ranges
+          def blocks_to_ranges(blocks, size = nil)
+            return [] if blocks.empty?
+
+            blocks = blocks[0, (size.to_f / block_size).ceil] if size
+            ranges = blocks.map { |i| [block_size * (i + 1), block_size] }
+            ranges.last[1] -= ((ranges.length * block_size) - size) if ranges.last && size
+            ranges
+          end
+        end
+
+        # Small allocation table (SBAT)
+        #
+        # Manages small blocks (typically 64 bytes) for files < 4096 bytes.
+        class Small < AllocationTable
+          def initialize(ole)
+            super
+            @block_size = 1 << @ole.header.s_shift
+            @io = @ole.sb_file
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE format constants
+      #
+      # Constants for the OLE compound document format including
+      # magic bytes, special markers, and format-related values.
+      module Constants
+        # OLE magic signature (D0CF11E0A1B11AE1)
+        MAGIC = "\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1".b
+
+        # Header size in bytes
+        HEADER_SIZE = 76
+
+        # Header block size (always 512)
+        HEADER_BLOCK_SIZE = 512
+
+        # Allocation table special markers
+        AVAIL     = 0xffffffff # Free block
+        EOC       = 0xfffffffe # End of chain
+        BAT       = 0xfffffffd # Block stores BAT data
+        META_BAT  = 0xfffffffc # Block stores Meta BAT
+
+        # End of tree marker for dirents
+        EOT = 0xffffffff
+
+        # Default threshold for small block vs big block (4096 bytes)
+        DEFAULT_THRESHOLD = 4096
+
+        # Byte order marker for little-endian
+        BYTE_ORDER_LE = "\xfe\xff".b
+
+        # Default block sizes
+        DEFAULT_BIG_BLOCK_SHIFT   = 9  # 512 bytes
+        DEFAULT_SMALL_BLOCK_SHIFT = 6  # 64 bytes
+
+        # Dirent types
+        DIRENT_TYPES = {
+          0 => :empty,
+          1 => :dir,
+          2 => :file,
+          5 => :root,
+        }.freeze
+
+        # Dirent colors for red-black tree
+        DIRENT_COLORS = {
+          0 => :red,
+          1 => :black,
+        }.freeze
+
+        # Dirent size in bytes
+        DIRENT_SIZE = 128
+
+        # Maximum name length in UTF-16 characters (including null terminator)
+        MAX_NAME_LENGTH = 32
+      end
+    end
+  end
+end