omnizip 0.3.2 → 0.3.4

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "constants"
+
+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 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
+
+        # 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 { |i| @entries[blocks[i]] = AVAIL }
+            @entries[blocks[new_num_blocks - 1]] = EOC if new_num_blocks.positive?
+            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
+
+        # 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

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

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "types/variant"
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE directory entry (dirent)
+      #
+      # Represents a file or directory entry in an OLE compound document.
+      # Each dirent is 128 bytes and contains metadata about the entry.
+      class Dirent
+        include Constants
+
+        # Pack format for dirent structure
+        PACK = "a64 v C C V3 a16 V a8 a8 V2 a4"
+
+        # @return [String] 64-byte UTF-16LE name
+        attr_accessor :name_utf16
+
+        # @return [Integer] Name length in bytes
+        attr_accessor :name_len
+
+        # @return [Integer] Entry type (0=empty, 1=dir, 2=file, 5=root)
+        attr_accessor :type_id
+
+        # @return [Integer] Red-black tree color
+        attr_accessor :colour
+
+        # @return [Integer] Previous sibling index
+        attr_accessor :prev
+
+        # @return [Integer] Next sibling index
+        attr_accessor :next
+
+        # @return [Integer] First child index
+        attr_accessor :child
+
+        # @return [String] 16-byte CLSID
+        attr_accessor :clsid
+
+        # @return [Integer] Flags (for directories)
+        attr_accessor :flags
+
+        # @return [String] 8-byte creation time
+        attr_accessor :create_time_str
+
+        # @return [String] 8-byte modification time
+        attr_accessor :modify_time_str
+
+        # @return [Integer] First block of data
+        attr_accessor :first_block
+
+        # @return [Integer] Size in bytes
+        attr_accessor :size
+
+        # @return [String] 4-byte reserved
+        attr_accessor :reserved
+
+        # @return [Object] Parent OLE storage
+        attr_reader :ole
+
+        # @return [Symbol] Entry type (:empty, :dir, :file, :root)
+        attr_reader :type
+
+        # @return [String] Decoded entry name
+        attr_reader :name
+
+        # @return [Time, nil] Creation time
+        attr_reader :create_time
+
+        # @return [Time, nil] Modification time
+        attr_reader :modify_time
+
+        # @return [Array<Dirent>] Child entries (for directories)
+        attr_reader :parent
+
+        # @return [Integer, nil] Index in dirent array (used during loading)
+        attr_accessor :idx
+
+        # Parse dirent from binary data
+        #
+        # @param ole [Object] Parent OLE storage
+        # @param data [String] 128-byte dirent data
+        # @return [Dirent] Parsed dirent
+        def self.parse(ole, data)
+          dirent = new(ole)
+          dirent.unpack(data)
+          dirent
+        end
+
+        # Create new dirent with specified type and name
+        #
+        # @param ole [Object] Parent OLE storage
+        # @param type [Symbol] Entry type (:file, :dir, :root)
+        # @param name [String] Entry name
+        # @return [Dirent] New dirent
+        def self.create(ole, type:, name:)
+          dirent = new(ole)
+          dirent.type = type
+          dirent.name = name
+          dirent
+        end
+
+        # Initialize dirent
+        #
+        # @param ole [Object] Parent OLE storage
+        def initialize(ole)
+          @ole = ole
+          @children = []
+          @name_lookup = {}
+          @parent = nil
+          @idx = nil
+          apply_defaults
+        end
+
+        # Apply default values
+        def apply_defaults
+          @name_utf16 = "\x00".b * 64
+          @name_len = 2
+          @type_id = 0
+          @colour = 1 # black
+          @prev = EOT
+          @next = EOT
+          @child = EOT
+          @clsid = "\x00".b * 16
+          @flags = 0
+          @create_time_str = "\x00".b * 8
+          @modify_time_str = "\x00".b * 8
+          @first_block = EOC
+          @size = 0
+          @reserved = "\x00".b * 4
+          @type = :empty
+          @name = ""
+        end
+
+        # Set entry type
+        #
+        # @param value [Symbol] Type (:empty, :dir, :file, :root)
+        def type=(value)
+          @type = value
+          @type_id = DIRENT_TYPES.invert[value] || 0
+
+          if file?
+            @children = nil
+            @name_lookup = nil
+          else
+            @children ||= []
+            @name_lookup ||= {}
+          end
+        end
+
+        # Set entry name
+        #
+        # @param value [String] Entry name
+        def name=(value)
+          if @parent
+            map = @parent.instance_variable_get(:@name_lookup)
+            map&.delete(@name)
+            map&.store(value, self)
+          end
+          @name = value
+        end
+
+        # Check if entry is a file
+        #
+        # @return [Boolean]
+        def file?
+          @type == :file
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean]
+        def dir?
+          !file?
+        end
+
+        # Check if entry is root
+        #
+        # @return [Boolean]
+        def root?
+          @type == :root
+        end
+
+        # Check if entry is empty
+        #
+        # @return [Boolean]
+        def empty?
+          @type == :empty
+        end
+
+        # Unpack dirent from binary data
+        #
+        # @param data [String] 128-byte dirent data
+        def unpack(data)
+          values = data.unpack(PACK)
+          @name_utf16 = values[0]
+          @name_len = values[1]
+          @type_id = values[2]
+          @colour = values[3]
+          @prev = values[4]
+          @next = values[5]
+          @child = values[6]
+          @clsid = values[7]
+          @flags = values[8]
+          @create_time_str = values[9]
+          @modify_time_str = values[10]
+          @first_block = values[11]
+          @size = values[12]
+          @reserved = values[13]
+
+          # Decode name from UTF-16LE
+          name_data = @name_utf16[0...@name_len]
+          @name = begin
+            Types::Variant.load(Types::Variant::VT_LPWSTR, name_data)
+          rescue StandardError
+            ""
+          end
+
+          # Decode type
+          @type = DIRENT_TYPES[@type_id] || :empty
+
+          # Decode timestamps for files
+          if file?
+            @create_time = begin
+              Types::Variant.load(Types::Variant::VT_FILETIME, @create_time_str)
+            rescue StandardError
+              nil
+            end
+            @modify_time = begin
+              Types::Variant.load(Types::Variant::VT_FILETIME, @modify_time_str)
+            rescue StandardError
+              nil
+            end
+            @children = nil
+            @name_lookup = nil
+          else
+            @create_time = nil
+            @modify_time = nil
+            @children = []
+            @name_lookup = {}
+          end
+        end
+
+        # Pack dirent to binary data
+        #
+        # @return [String] 128-byte binary data
+        def pack
+          # Encode name to UTF-16LE
+          name_data = Types::Variant.dump(Types::Variant::VT_LPWSTR, @name)
+          name_data = name_data[0, 62] if name_data.length > 62
+          name_data += "\x00\x00".b
+          @name_len = name_data.length
+          @name_utf16 = name_data + ("\x00".b * (64 - name_data.length))
+
+          # Set type_id from type
+          @type_id = DIRENT_TYPES.invert[@type] || 0
+
+          # For directories, first_block should be EOT
+          if dir? && !root?
+            @first_block = EOT
+          end
+
+          # Encode timestamps for files
+          if file?
+            @create_time_str = Types::Variant.dump(Types::Variant::VT_FILETIME, @create_time) if @create_time
+            @modify_time_str = Types::Variant.dump(Types::Variant::VT_FILETIME, @modify_time) if @modify_time
+          else
+            @create_time_str = "\x00".b * 8
+            @modify_time_str = "\x00".b * 8
+          end
+
+          [
+            @name_utf16, @name_len, @type_id, @colour,
+            @prev, @next, @child, @clsid, @flags,
+            @create_time_str, @modify_time_str,
+            @first_block, @size, @reserved
+          ].pack(PACK)
+        end
+
+        # Read file content
+        #
+        # @return [String] File content
+        # @raise [Errno::EISDIR] If entry is a directory
+        def read
+          raise Errno::EISDIR unless file?
+
+          bat = @ole.bat_for_size(@size)
+          bat.read(@first_block, @size)
+        end
+
+        # Lookup child by name
+        #
+        # @param name [String] Child name
+        # @return [Dirent, nil] Child dirent
+        def /(name)
+          @name_lookup&.[](name)
+        end
+        alias [] :/
+
+        # Add child entry
+        #
+        # @param child [Dirent] Child to add
+        def <<(child)
+          child.parent = self
+          @name_lookup[child.name] = child if @name_lookup
+          @children << child
+        end
+
+        # Set parent entry
+        #
+        # @param parent [Dirent, nil] Parent dirent
+        def parent=(parent)
+          @parent = parent
+        end
+
+        # Get all children
+        #
+        # @return [Array<Dirent>]
+        def children
+          @children || []
+        end
+
+        # Iterate over children
+        #
+        # @yield [Dirent]
+        def each_child(&block)
+          @children&.each(&block)
+        end
+
+        # Flatten tree to array for serialization
+        #
+        # @param dirents [Array<Dirent>] Output array
+        # @return [Array<Dirent>]
+        def flatten(dirents = [])
+          @idx = dirents.length
+          dirents << self
+
+          if file?
+            self.prev = EOT
+            self.next = EOT
+            self.child = EOT
+          else
+            children.each { |child| child.flatten(dirents) }
+            self.child = self.class.flatten_helper(children)
+          end
+
+          dirents
+        end
+
+        # Helper to create balanced tree structure
+        #
+        # @param children [Array<Dirent>]
+        # @return [Integer] Index of root of subtree
+        def self.flatten_helper(children)
+          return EOT if children.empty?
+
+          i = children.length / 2
+          this = children[i]
+          this.prev = flatten_helper(children[0...i])
+          this.next = flatten_helper(children[(i + 1)..])
+          this.idx
+        end
+
+        # Inspect dirent
+        #
+        # @return [String]
+        def inspect
+          str = "#<Ole::Dirent:#{@name.inspect}"
+          if file?
+            str << " size=#{@size}"
+          end
+          "#{str}>"
+        end
+      end
+    end
+  end
+end