omnizip 0.3.2 → 0.3.4

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

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE header parser
+      #
+      # Parses the 512-byte header block from OLE compound documents.
+      # The first 76 bytes contain the header structure, followed by
+      # up to 109 BAT block indices.
+      class Header
+        include Constants
+
+        # Pack format for header structure
+        PACK = "a8 a16 v2 a2 v2 a6 V3 a4 V5"
+
+        # @return [String] 8-byte OLE magic signature
+        attr_accessor :magic
+
+        # @return [String] 16-byte CLSID (usually zeros)
+        attr_accessor :clsid
+
+        # @return [Integer] Minor version (usually 59)
+        attr_accessor :minor_ver
+
+        # @return [Integer] Major version (3 or 4)
+        attr_accessor :major_ver
+
+        # @return [String] 2-byte byte order marker
+        attr_accessor :byte_order
+
+        # @return [Integer] Big block shift (9 = 512 bytes)
+        attr_accessor :b_shift
+
+        # @return [Integer] Small block shift (6 = 64 bytes)
+        attr_accessor :s_shift
+
+        # @return [String] 6-byte reserved field
+        attr_accessor :reserved
+
+        # @return [Integer] Number of SECTs in directory (0 for v3)
+        attr_accessor :csectdir
+
+        # @return [Integer] Number of BAT blocks
+        attr_accessor :num_bat
+
+        # @return [Integer] First block of directory entries
+        attr_accessor :dirent_start
+
+        # @return [String] 4-byte transaction signature
+        attr_accessor :transacting_signature
+
+        # @return [Integer] Small block threshold (4096)
+        attr_accessor :threshold
+
+        # @return [Integer] First block of SBAT
+        attr_accessor :sbat_start
+
+        # @return [Integer] Number of SBAT blocks
+        attr_accessor :num_sbat
+
+        # @return [Integer] First block of Meta BAT
+        attr_accessor :mbat_start
+
+        # @return [Integer] Number of Meta BAT blocks
+        attr_accessor :num_mbat
+
+        # Parse header from binary data
+        #
+        # @param data [String] 512-byte header block
+        # @return [Header] Parsed header object
+        # @raise [ArgumentError] If data is invalid
+        def self.parse(data)
+          raise ArgumentError, "Header data too short" if data.nil? || data.bytesize < HEADER_SIZE
+
+          header = new
+          header.unpack(data)
+          header.validate!
+          header
+        end
+
+        # Create default header for new documents
+        #
+        # @return [Header] New header with default values
+        def self.create
+          header = new
+          header.apply_defaults
+          header
+        end
+
+        # Initialize header
+        def initialize
+          apply_defaults
+        end
+
+        # Apply default values
+        def apply_defaults
+          @magic = MAGIC.dup
+          @clsid = "\x00".b * 16
+          @minor_ver = 59
+          @major_ver = 3
+          @byte_order = BYTE_ORDER_LE.dup
+          @b_shift = DEFAULT_BIG_BLOCK_SHIFT
+          @s_shift = DEFAULT_SMALL_BLOCK_SHIFT
+          @reserved = "\x00".b * 6
+          @csectdir = 0
+          @num_bat = 1
+          @dirent_start = EOC
+          @transacting_signature = "\x00".b * 4
+          @threshold = DEFAULT_THRESHOLD
+          @sbat_start = EOC
+          @num_sbat = 0
+          @mbat_start = EOC
+          @num_mbat = 0
+        end
+
+        # Get big block size
+        #
+        # @return [Integer] Block size in bytes
+        def big_block_size
+          1 << @b_shift
+        end
+
+        # Get small block size
+        #
+        # @return [Integer] Block size in bytes
+        def small_block_size
+          1 << @s_shift
+        end
+
+        # Unpack header from binary data
+        #
+        # @param data [String] Binary data
+        def unpack(data)
+          values = data[0, HEADER_SIZE].unpack(PACK)
+          @magic = values[0]
+          @clsid = values[1]
+          @minor_ver = values[2]
+          @major_ver = values[3]
+          @byte_order = values[4]
+          @b_shift = values[5]
+          @s_shift = values[6]
+          @reserved = values[7]
+          @csectdir = values[8]
+          @num_bat = values[9]
+          @dirent_start = values[10]
+          @transacting_signature = values[11]
+          @threshold = values[12]
+          @sbat_start = values[13]
+          @num_sbat = values[14]
+          @mbat_start = values[15]
+          @num_mbat = values[16]
+        end
+
+        # Pack header to binary data
+        #
+        # @return [String] 76-byte header binary data
+        def pack
+          [
+            @magic, @clsid, @minor_ver, @major_ver, @byte_order,
+            @b_shift, @s_shift, @reserved, @csectdir, @num_bat,
+            @dirent_start, @transacting_signature, @threshold,
+            @sbat_start, @num_sbat, @mbat_start, @num_mbat
+          ].pack(PACK)
+        end
+
+        # Validate header structure
+        #
+        # @raise [ArgumentError] If header is invalid
+        def validate!
+          unless @magic == MAGIC
+            raise ArgumentError, "Invalid OLE magic signature"
+          end
+
+          if @num_bat.zero?
+            raise ArgumentError, "Invalid OLE: no BAT blocks"
+          end
+
+          if @s_shift > @b_shift || @b_shift <= 6 || @b_shift >= 31
+            raise ArgumentError, "Invalid block shift values"
+          end
+
+          unless @byte_order == BYTE_ORDER_LE
+            raise ArgumentError, "Only little-endian OLE files are supported"
+          end
+
+          if @threshold != DEFAULT_THRESHOLD
+            # Warning, not error
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Ole
+      # Virtual IO for non-contiguous byte ranges
+      #
+      # Provides a contiguous IO interface over scattered byte ranges
+      # in an underlying IO object.
+      class RangesIO
+        # @return [IO] Underlying IO object
+        attr_reader :io
+
+        # @return [Array<Array<Integer, Integer>>] Byte ranges [[offset, length], ...]
+        attr_reader :ranges
+
+        # @return [Integer] Total size in bytes
+        attr_reader :size
+
+        # @return [Integer] Current position
+        attr_reader :pos
+
+        # Initialize RangesIO
+        #
+        # @param io [IO] Underlying IO object
+        # @param ranges [Array<Array<Integer, Integer>>] Byte ranges
+        def initialize(io, ranges = [])
+          @io = io
+          @pos = 0
+          @active = 0
+          self.ranges = ranges
+        end
+
+        # Open with block support
+        #
+        # @yield [RangesIO]
+        def self.open(io, ranges = [])
+          ranges_io = new(io, ranges)
+          if block_given?
+            begin
+              yield ranges_io
+            ensure
+              ranges_io.close
+            end
+          else
+            ranges_io
+          end
+        end
+
+        # Set ranges
+        #
+        # @param ranges [Array<Range, Array>] Byte ranges
+        def ranges=(ranges)
+          # Convert Range objects to arrays
+          @ranges = ranges.map do |r|
+            r.is_a?(Range) ? [r.begin, r.end - r.begin] : r
+          end
+
+          # Calculate cumulative offsets
+          @size = 0
+          @offsets = []
+          @ranges.map(&:last).each do |len|
+            @offsets << @size
+            @size += len
+          end
+
+          # Reset position
+          @active = 0
+          @pos = 0
+        end
+
+        # Set position
+        #
+        # @param new_pos [Integer]
+        # @param whence [Integer] IO::SEEK_SET, IO::SEEK_CUR, or IO::SEEK_END
+        def pos=(new_pos, whence = ::IO::SEEK_SET)
+          case whence
+          when ::IO::SEEK_SET
+            # use new_pos as is
+          when ::IO::SEEK_CUR
+            new_pos = @pos + new_pos
+          when ::IO::SEEK_END
+            new_pos = @size + new_pos
+          else
+            raise Errno::EINVAL
+          end
+
+          raise Errno::EINVAL unless (0..@size).cover?(new_pos)
+
+          @pos = new_pos
+
+          # Binary search for active range
+          low = 0
+          high = @offsets.length
+          while low < high
+            mid = (low + high) / 2
+            if @pos < @offsets[mid]
+              high = mid
+            else
+              low = mid + 1
+            end
+          end
+
+          @active = low - 1
+        end
+
+        alias seek :pos=
+        alias tell :pos
+
+        # Rewind to beginning
+        def rewind
+          seek(0)
+        end
+
+        # Check if at end
+        #
+        # @return [Boolean]
+        def eof?
+          @pos == @size
+        end
+
+        # Read data
+        #
+        # @param limit [Integer, nil] Maximum bytes to read
+        # @return [String]
+        def read(limit = nil)
+          data = "".b
+          return data if eof?
+
+          limit ||= @size
+          return data if limit <= 0
+
+          range_pos, range_len = @ranges[@active]
+          diff = @pos - @offsets[@active]
+          range_pos += diff
+          range_len -= diff
+
+          loop do
+            @io.seek(range_pos)
+
+            if limit < range_len
+              chunk = @io.read(limit).to_s
+              @pos += chunk.length
+              data << chunk
+              break
+            end
+
+            chunk = @io.read(range_len).to_s
+            @pos += chunk.length
+            data << chunk
+
+            break if chunk.length != range_len
+
+            limit -= range_len
+            break if @active >= @ranges.length - 1
+
+            @active += 1
+            range_pos, range_len = @ranges[@active]
+          end
+
+          data
+        end
+
+        # Write data
+        #
+        # @param data [String] Data to write
+        # @return [Integer] Bytes written
+        def write(data)
+          data = data.dup.force_encoding(Encoding::ASCII_8BIT) if data.respond_to?(:encoding)
+          return 0 if data.empty?
+
+          # Grow if needed
+          if data.length > @size - @pos
+            truncate(@pos + data.length)
+          end
+
+          range_pos, range_len = @ranges[@active]
+          diff = @pos - @offsets[@active]
+          range_pos += diff
+          range_len -= diff
+
+          written = 0
+
+          loop do
+            @io.seek(range_pos)
+
+            if written + range_len > data.length
+              chunk = data[written..]
+              @io.write(chunk)
+              @pos += chunk.length
+              break
+            end
+
+            @io.write(data[written, range_len])
+            @pos += range_len
+            written += range_len
+
+            break if @active >= @ranges.length - 1
+
+            @active += 1
+            range_pos, range_len = @ranges[@active]
+          end
+
+          data.length
+        end
+
+        alias << :write
+
+        # Truncate (not supported by default)
+        #
+        # @param _size [Integer] New size
+        def truncate(_size)
+          raise NotImplementedError, "truncate not supported"
+        end
+
+        # Close (no-op by default)
+        def close
+          # No-op
+        end
+
+        # Inspect
+        def inspect
+          "#<#{self.class} io=#{@io.inspect}, size=#{@size}, pos=#{@pos}>"
+        end
+      end
+
+      # Resizeable RangesIO backed by AllocationTable
+      class RangesIOResizeable < RangesIO
+        # @return [AllocationTable] Backing allocation table
+        attr_reader :bat
+
+        # @return [Integer] First block index
+        attr_accessor :first_block
+
+        # Initialize resizeable RangesIO
+        #
+        # @param bat [AllocationTable] Allocation table
+        # @param first_block [Integer] First block index
+        # @param size [Integer, nil] Optional size
+        def initialize(bat, first_block:, size: nil)
+          @bat = bat
+          @first_block = first_block
+          @blocks = first_block == Constants::EOC ? [] : bat.chain(first_block)
+
+          super(bat.io, bat.ranges(@blocks, size))
+        end
+
+        # Truncate to new size
+        #
+        # @param new_size [Integer] New size in bytes
+        def truncate(new_size)
+          @bat.resize_chain(@blocks, new_size)
+          @pos = new_size if @pos > new_size
+          self.ranges = @bat.ranges(@blocks, new_size)
+          @first_block = @blocks.empty? ? Constants::EOC : @blocks.first
+
+          # Grow underlying IO if needed
+          max_pos = @ranges.map { |pos, len| pos + len }.max || 0
+          @io.truncate(max_pos) if max_pos > @io.size
+        end
+      end
+    end
+  end
+end