omnizip 0.3.2 → 0.3.4

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

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "header"
+require_relative "allocation_table"
+require_relative "dirent"
+require_relative "ranges_io"
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE compound document storage
+      #
+      # Main class for reading and writing OLE compound documents.
+      # Provides access to the hierarchical file structure within the document.
+      class Storage
+        include Constants
+
+        # OLE format error
+        class FormatError < StandardError; end
+
+        # @return [IO] Underlying IO object
+        attr_reader :io
+
+        # @return [Boolean] Whether to close IO on #close
+        attr_reader :close_parent
+
+        # @return [Boolean] Whether opened for writing
+        attr_reader :writeable
+
+        # @return [Header] Parsed header
+        attr_reader :header
+
+        # @return [AllocationTable::Big] Big block allocation table
+        attr_reader :bbat
+
+        # @return [AllocationTable::Small] Small block allocation table
+        attr_reader :sbat
+
+        # @return [RangesIO] Small block file
+        attr_reader :sb_file
+
+        # @return [Dirent] Root entry
+        attr_reader :root
+
+        # @return [Array<Dirent>] All dirents (flat list)
+        attr_reader :dirents
+
+        # Open OLE file
+        #
+        # @param path_or_io [String, IO] File path or IO object
+        # @param mode [String, nil] Open mode
+        # @yield [Storage]
+        # @return [Storage]
+        def self.open(path_or_io, mode = nil)
+          storage = new(path_or_io, mode)
+          if block_given?
+            begin
+              yield storage
+            ensure
+              storage.close
+            end
+          else
+            storage
+          end
+        end
+
+        # Initialize storage
+        #
+        # @param path_or_io [String, IO] File path or IO object
+        # @param mode [String, nil] Open mode
+        def initialize(path_or_io, mode = nil)
+          @close_parent, @io = if path_or_io.is_a?(String)
+                                 mode ||= "rb"
+                                 [true, File.open(path_or_io, mode)]
+                               else
+                                 raise ArgumentError, "Cannot specify mode with IO object" if mode
+
+                                 [false, path_or_io]
+                               end
+
+          # Force binary encoding
+          @io.set_encoding(Encoding::ASCII_8BIT) if @io.respond_to?(:set_encoding)
+
+          # Determine if writable
+          @writeable = determine_writeable(mode)
+
+          @sb_file = nil
+
+          # Load or create
+          if @io.size.positive?
+            load
+          else
+            create_empty
+          end
+        end
+
+        # Load OLE document from IO
+        def load
+          @io.rewind
+          header_block = @io.read(HEADER_BLOCK_SIZE)
+
+          # Parse header
+          @header = Header.parse(header_block)
+
+          # Build BBAT chain from header
+          @bbat = AllocationTable::Big.new(self)
+          bbat_chain = header_block[HEADER_SIZE..].unpack("V*")
+
+          # Add Meta BAT blocks if present
+          mbat_block = @header.mbat_start
+          @header.num_mbat.times do
+            blocks = @bbat.read([mbat_block]).unpack("V*")
+            mbat_block = blocks.pop
+            bbat_chain += blocks
+          end
+
+          # Load BBAT
+          @bbat.load(@bbat.read(bbat_chain[0, @header.num_bat]))
+
+          # Load dirents
+          raw_dirents = @bbat.read(@header.dirent_start)
+          @dirents = []
+          (raw_dirents.bytesize / DIRENT_SIZE).times do |i|
+            dirent_data = raw_dirents.byteslice(i * DIRENT_SIZE, DIRENT_SIZE)
+            @dirents << Dirent.parse(self, dirent_data)
+          end
+
+          # Build tree structure
+          @root = build_tree(@dirents).first
+
+          # Remove empty entries
+          @dirents.reject!(&:empty?)
+
+          # Setup SBAT
+          @sb_file = RangesIOResizeable.new(@bbat, first_block: @root.first_block, size: @root.size)
+          @sbat = AllocationTable::Small.new(self)
+          @sbat.load(@bbat.read(@header.sbat_start))
+        end
+
+        # Build tree from flat dirent list
+        #
+        # @param dirents [Array<Dirent>]
+        # @param idx [Integer]
+        # @return [Array<Dirent>]
+        def build_tree(dirents, idx = 0)
+          return [] if idx == EOT
+
+          dirent = dirents[idx]
+
+          # Build children recursively
+          build_tree(dirents, dirent.child).each { |child| dirent << child }
+
+          # Set index
+          dirent.idx = idx
+
+          # Return list for tree building
+          build_tree(dirents, dirent.prev) + [dirent] + build_tree(dirents, dirent.next)
+        end
+
+        # Close storage
+        def close
+          @sb_file&.close
+          @io.close if @close_parent
+        end
+
+        # Get appropriate BAT for size
+        #
+        # @param size [Integer] File size
+        # @return [AllocationTable]
+        def bat_for_size(size)
+          size >= @header.threshold ? @bbat : @sbat
+        end
+
+        # List entries at path
+        #
+        # @param path [String] Directory path
+        # @return [Array<String>]
+        def list(path = "/")
+          dirent = find_dirent(path)
+          return [] unless dirent
+
+          dirent.children.map(&:name)
+        end
+
+        # Read file content
+        #
+        # @param path [String] File path
+        # @return [String]
+        def read(path)
+          dirent = find_dirent(path)
+          raise Errno::ENOENT, path unless dirent
+          raise Errno::EISDIR, path if dirent.dir?
+
+          dirent.read
+        end
+
+        # Check if entry exists
+        #
+        # @param path [String]
+        # @return [Boolean]
+        def exist?(path)
+          !find_dirent(path).nil?
+        end
+
+        alias exists? :exist?
+
+        # Check if path is a file
+        #
+        # @param path [String]
+        # @return [Boolean]
+        def file?(path)
+          dirent = find_dirent(path)
+          dirent&.file?
+        end
+
+        # Check if path is a directory
+        #
+        # @param path [String]
+        # @return [Boolean]
+        def directory?(path)
+          dirent = find_dirent(path)
+          dirent&.dir?
+        end
+
+        # Get entry info
+        #
+        # @param path [String]
+        # @return [Hash, nil]
+        def info(path)
+          dirent = find_dirent(path)
+          return nil unless dirent
+
+          {
+            name: dirent.name,
+            type: dirent.type,
+            size: dirent.size,
+            create_time: dirent.create_time,
+            modify_time: dirent.modify_time,
+          }
+        end
+
+        # Find dirent by path
+        #
+        # @param path [String]
+        # @return [Dirent, nil]
+        def find_dirent(path)
+          path = path.to_s
+          path = path[1..] if path.start_with?("/")
+
+          return @root if path.empty?
+
+          parts = path.split("/")
+          current = @root
+
+          parts.each do |part|
+            next if part.empty?
+            return nil if current.file?
+
+            current = current / part
+            return nil unless current
+          end
+
+          current
+        end
+
+        # Inspect
+        def inspect
+          "#<#{self.class} io=#{@io.inspect} root=#{@root.inspect}>"
+        end
+
+        private
+
+        # Determine if IO is writable
+        def determine_writeable(mode)
+          return false if mode&.include?("r") && !mode.include?("+")
+
+          if mode
+            mode.include?("w") || mode.include?("a") || mode.include?("+")
+          else
+            begin
+              @io.flush
+              @io.write_nonblock("") if @io.respond_to?(:write_nonblock)
+              true
+            rescue IOError, Errno::EBADF
+              false
+            end
+          end
+        end
+
+        # Create empty OLE document
+        def create_empty
+          @header = Header.create
+          @bbat = AllocationTable::Big.new(self)
+          @root = Dirent.create(self, type: :root, name: "Root Entry")
+          @root.idx = 0
+          @dirents = [@root]
+          @sb_file = RangesIOResizeable.new(@bbat, first_block: EOC)
+          @sbat = AllocationTable::Small.new(self)
+          @io.truncate(0)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/ole/types/variant.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Omnizip
+  module Formats
+    module Ole
+      # OLE type serialization module
+      #
+      # Provides serialization and deserialization for OLE data types
+      # including variant types, strings, timestamps, and GUIDs.
+      module Types
+        # Generic binary data handler
+        class Data < String
+          # Load from binary data
+          def self.load(str)
+            new(str)
+          end
+
+          # Dump to binary data
+          def self.dump(str)
+            str.to_s
+          end
+        end
+
+        # Null-terminated ASCII string (VT_LPSTR)
+        class Lpstr < String
+          # Load from binary data
+          def self.load(str)
+            new(str.to_s.chomp("\x00"))
+          end
+
+          # Dump to binary data
+          def self.dump(str)
+            str.to_s
+          end
+        end
+
+        # Null-terminated UTF-16LE string (VT_LPWSTR)
+        class Lpwstr < String
+          # Load from UTF-16LE binary data
+          def self.load(str)
+            return new("") if str.nil? || str.empty?
+
+            # Decode UTF-16LE to UTF-8, strip null terminator
+            decoded = str.encode(Encoding::UTF_8, Encoding::UTF_16LE)
+            new(decoded.chomp("\x00"))
+          end
+
+          # Dump to UTF-16LE binary data
+          def self.dump(str)
+            return "\x00\x00".b if str.nil? || str.empty?
+
+            # Encode UTF-8 to UTF-16LE and force to binary
+            data = str.encode(Encoding::UTF_16LE).force_encoding(Encoding::ASCII_8BIT)
+            # Add null terminator (single UTF-16 null character = 2 bytes)
+            data + "\x00\x00".b
+          end
+        end
+
+        # Windows FILETIME timestamp (VT_FILETIME)
+        #
+        # Represents time as 100-nanosecond intervals since January 1, 1601.
+        class FileTime
+          # Size in bytes
+          SIZE = 8
+
+          # Windows epoch (January 1, 1601)
+          EPOCH = DateTime.new(1601, 1, 1)
+
+          # @return [DateTime] The timestamp value
+          attr_reader :value
+
+          # Create FileTime from DateTime
+          #
+          # @param value [DateTime, Time, nil]
+          def initialize(value = nil)
+            @value = case value
+                     when DateTime, nil
+                       value
+                     when Time
+                       DateTime.new(value.year, value.month, value.day,
+                                    value.hour, value.min, value.sec)
+                     else
+                       raise ArgumentError, "Invalid time value: #{value.class}"
+                     end
+          end
+
+          # Load from binary data
+          #
+          # @param str [String] 8-byte FILETIME data
+          # @return [FileTime, nil] Parsed timestamp or nil if zero
+          def self.load(str)
+            return nil if str.nil? || str.bytesize < SIZE
+
+            low, high = str.unpack("V2")
+            return nil if low.zero? && high.zero?
+
+            # Convert 100-nanosecond intervals to seconds
+            intervals = (high << 32) | low
+            seconds = intervals / 10_000_000.0
+
+            # Add to epoch
+            begin
+              value = EPOCH + (seconds / 86_400.0)
+              new(value)
+            rescue StandardError
+              nil
+            end
+          end
+
+          # Dump to binary data
+          #
+          # @param time [FileTime, DateTime, Time, nil]
+          # @return [String] 8-byte FILETIME data
+          def self.dump(time)
+            return "\x00".b * SIZE if time.nil?
+
+            case time
+            when FileTime
+              value = time.value
+            when DateTime
+              value = time
+            when Time
+              value = DateTime.new(time.year, time.month, time.day,
+                                   time.hour, time.min, time.sec)
+            else
+              raise ArgumentError, "Invalid time argument: #{time.class}"
+            end
+
+            # Calculate nanoseconds since epoch
+            days = (value - EPOCH).to_f
+            nanoseconds = (days * 86_400_000_000_000).round
+
+            high = nanoseconds >> 32
+            low = nanoseconds & 0xFFFFFFFF
+
+            [low, high].pack("V2")
+          end
+
+          # Convert to Time
+          #
+          # @return [Time]
+          def to_time
+            return nil if @value.nil?
+
+            Time.new(@value.year, @value.month, @value.day,
+                     @value.hour, @value.min, @value.sec)
+          end
+
+          # Convert to string
+          #
+          # @return [String]
+          def to_s
+            @value.to_s
+          end
+
+          # Inspect
+          def inspect
+            "#<#{self.class}: #{@value}>"
+          end
+        end
+
+        # COM CLSID/GUID (VT_CLSID)
+        #
+        # 128-bit globally unique identifier.
+        class Clsid < String
+          # Size in bytes
+          SIZE = 16
+
+          # Pack format for GUID components
+          PACK = "V v v CC C6"
+
+          # Load from binary data
+          #
+          # @param str [String] 16-byte GUID data
+          # @return [Clsid]
+          def self.load(str)
+            new(str.to_s)
+          end
+
+          # Dump to binary data
+          #
+          # @param guid [String, nil] GUID string or binary data
+          # @return [String] 16-byte binary data
+          def self.dump(guid)
+            return "\x00".b * SIZE if guid.nil?
+
+            # If it contains dashes, parse from string format
+            guid.include?("-") ? parse(guid) : guid.to_s
+          end
+
+          # Parse from string format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
+          #
+          # @param str [String] GUID string
+          # @return [Clsid]
+          # @raise [ArgumentError] If format is invalid
+          def self.parse(str)
+            values = str.scan(/[a-f\d]+/i).map(&:hex)
+
+            if values.length == 5
+              # Split 4th and 5th groups into bytes
+              values[3] = sprintf("%04x", values[3]).scan(/../).map(&:hex)
+              values[4] = sprintf("%012x", values[4]).scan(/../).map(&:hex)
+              guid = new(values.flatten.pack(PACK))
+
+              if guid.format.delete("{}").downcase == str.downcase.delete("{}")
+                return guid
+              end
+            end
+
+            raise ArgumentError, "Invalid GUID format: #{str}"
+          end
+
+          # Format to human-readable string
+          #
+          # @return [String] "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
+          def format
+            vals = unpack(PACK)
+            # vals = [uint32, uint16, uint16, uint8, uint8, uint8, uint8, uint8, uint8, uint8, uint8]
+            last_six = vals[5, 6].map { |b| sprintf("%02x", b) }.join
+            sprintf("%08x-%04x-%04x-%02x%02x-%s", vals[0], vals[1], vals[2], vals[3], vals[4], last_six)
+          end
+
+          # Inspect
+          def inspect
+            "#<#{self.class}:{#{format}}>"
+          end
+        end
+
+        # Variant type constants
+        module Variant
+          # Type ID to name mapping
+          NAMES = {
+            0x0000 => "VT_EMPTY",
+            0x0001 => "VT_NULL",
+            0x0002 => "VT_I2",
+            0x0003 => "VT_I4",
+            0x0004 => "VT_R4",
+            0x0005 => "VT_R8",
+            0x0006 => "VT_CY",
+            0x0007 => "VT_DATE",
+            0x0008 => "VT_BSTR",
+            0x0009 => "VT_DISPATCH",
+            0x000a => "VT_ERROR",
+            0x000b => "VT_BOOL",
+            0x000c => "VT_VARIANT",
+            0x000d => "VT_UNKNOWN",
+            0x000e => "VT_DECIMAL",
+            0x0010 => "VT_I1",
+            0x0011 => "VT_UI1",
+            0x0012 => "VT_UI2",
+            0x0013 => "VT_UI4",
+            0x0014 => "VT_I8",
+            0x0015 => "VT_UI8",
+            0x0016 => "VT_INT",
+            0x0017 => "VT_UINT",
+            0x0018 => "VT_VOID",
+            0x0019 => "VT_HRESULT",
+            0x001a => "VT_PTR",
+            0x001b => "VT_SAFEARRAY",
+            0x001c => "VT_CARRAY",
+            0x001d => "VT_USERDEFINED",
+            0x001e => "VT_LPSTR",
+            0x001f => "VT_LPWSTR",
+            0x0040 => "VT_FILETIME",
+            0x0041 => "VT_BLOB",
+            0x0042 => "VT_STREAM",
+            0x0043 => "VT_STORAGE",
+            0x0044 => "VT_STREAMED_OBJECT",
+            0x0045 => "VT_STORED_OBJECT",
+            0x0046 => "VT_BLOB_OBJECT",
+            0x0047 => "VT_CF",
+            0x0048 => "VT_CLSID",
+            0x0fff => "VT_ILLEGALMASKED",
+            0x1000 => "VT_VECTOR",
+            0x2000 => "VT_ARRAY",
+            0x4000 => "VT_BYREF",
+            0x8000 => "VT_RESERVED",
+            0xffff => "VT_ILLEGAL",
+          }.freeze
+
+          # Type name to class mapping
+          CLASS_MAP = {
+            "VT_LPSTR" => Lpstr,
+            "VT_LPWSTR" => Lpwstr,
+            "VT_FILETIME" => FileTime,
+            "VT_CLSID" => Clsid,
+          }.freeze
+
+          # Define type constants
+          NAMES.each do |num, name|
+            const_set name, num
+          end
+
+          # Additional constant
+          VT_TYPEMASK = 0x0fff
+
+          # Load variant value from binary data
+          #
+          # @param type [Integer] Variant type ID
+          # @param str [String] Binary data
+          # @return [Object] Deserialized value
+          def self.load(type, str)
+            type_name = NAMES[type]
+            raise ArgumentError, "Unknown OLE type: 0x#{format('%04x', type)}" unless type_name
+
+            klass = CLASS_MAP[type_name] || Data
+            klass.load(str)
+          end
+
+          # Dump variant value to binary data
+          #
+          # @param type [Integer] Variant type ID
+          # @param value [Object] Value to serialize
+          # @return [String] Binary data
+          def self.dump(type, value)
+            type_name = NAMES[type]
+            raise ArgumentError, "Unknown OLE type: 0x#{format('%04x', type)}" unless type_name
+
+            klass = CLASS_MAP[type_name] || Data
+            klass.dump(value)
+          end
+        end
+      end
+    end
+  end
+end