omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/rar/rar_format_base.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+module Omnizip
+  module Formats
+    module Rar
+      # Base class for RAR format implementations
+      #
+      # This class provides common functionality for RAR v3 and RAR v5 formats,
+      # following the Strategy pattern where each version has its own
+      # implementation strategy.
+      #
+      # @abstract Subclass and override {#read_archive}, {#write_archive},
+      #   {#compress}, and {#decompress} to implement a RAR version strategy.
+      class RarFormatBase
+        attr_reader :spec, :version
+
+        # Initialize a RAR format handler
+        #
+        # @param spec_name [String] The format specification name
+        #   (e.g., "rar3", "rar5")
+        def initialize(spec_name)
+          @spec = FormatSpecLoader.load(spec_name)
+          @version = @spec.version
+        end
+
+        # Read a RAR archive
+        #
+        # @param io [IO] The input stream
+        # @return [Array<Entry>] The archive entries
+        # @raise [NotImplementedError] Must be implemented by subclasses
+        def read_archive(io)
+          raise NotImplementedError,
+                "#{self.class} must implement #read_archive"
+        end
+
+        # Write a RAR archive
+        #
+        # @param io [IO] The output stream
+        # @param entries [Array<Entry>] The entries to write
+        # @return [void]
+        # @raise [NotImplementedError] Must be implemented by subclasses
+        def write_archive(io, entries)
+          raise NotImplementedError,
+                "#{self.class} must implement #write_archive"
+        end
+
+        # Compress data
+        #
+        # @param data [String] The data to compress
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Compression options
+        # @return [String] The compressed data
+        # @raise [NotImplementedError] Must be implemented by subclasses
+        def compress(data, method: :normal, **options)
+          raise NotImplementedError,
+                "#{self.class} must implement #compress"
+        end
+
+        # Decompress data
+        #
+        # @param data [String] The compressed data
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Decompression options
+        # @return [String] The decompressed data
+        # @raise [NotImplementedError] Must be implemented by subclasses
+        def decompress(data, method: :normal, **options)
+          raise NotImplementedError,
+                "#{self.class} must implement #decompress"
+        end
+
+        # Verify magic bytes match this format
+        #
+        # @param io [IO] The input stream
+        # @return [Boolean] True if magic bytes match
+        def verify_magic_bytes(io)
+          magic = spec.magic_bytes.pack("C*")
+          bytes = io.read(magic.bytesize)
+          io.rewind
+          bytes == magic
+        end
+
+        # Get compression method code from symbol
+        #
+        # @param method [Symbol] The method name (e.g., :normal, :best)
+        # @return [Integer] The method code
+        # @raise [FormatError] If method is not supported
+        def compression_method_code(method)
+          code = spec.format.compression_methods[method]
+          return code if code
+
+          raise FormatError,
+                "Unsupported compression method: #{method}"
+        end
+
+        # Get compression method symbol from code
+        #
+        # @param code [Integer] The method code
+        # @return [Symbol] The method name
+        # @raise [FormatError] If code is not recognized
+        def compression_method_name(code)
+          methods = spec.format.compression_methods
+          name = methods.key(code)
+          return name if name
+
+          # Handle unknown method codes gracefully
+          # RAR can have version-specific or PPMd methods not in standard list
+          case code
+          when 0x00..0x2F then :store      # Very old or stored
+          when 0x30 then :store
+          when 0x31 then :fastest
+          when 0x32 then :fast
+          when 0x33 then :normal
+          when 0x34 then :good
+          when 0x35 then :best
+          when 0x36..0x40 then :normal     # Extended range
+          when 0x80..0xFF then :ppmd       # PPMd or version-specific
+          else :unknown
+          end
+        end
+
+        # Get block type code from symbol
+        #
+        # @param type [Symbol] The block type name
+        # @return [Integer] The block type code
+        # @raise [FormatError] If type is not supported
+        def block_type_code(type)
+          code = spec.format.block_types[type]
+          return code if code
+
+          raise FormatError, "Unknown block type: #{type}"
+        end
+
+        # Get block type symbol from code
+        #
+        # @param code [Integer] The block type code
+        # @return [Symbol] The block type name
+        # @raise [FormatError] If code is not recognized
+        def block_type_name(code)
+          types = spec.format.block_types
+          name = types.key(code)
+          return name if name
+
+          raise FormatError, "Unknown block type code: #{code}"
+        end
+
+        # Check if format supports a feature
+        #
+        # @param feature [Symbol] The feature name
+        # @return [Boolean] True if supported
+        def supports_feature?(feature)
+          features = spec.format.features || {}
+          compression_features = spec.format.compression_features || {}
+          advanced_features = spec.format.advanced_features || {}
+
+          features[feature] ||
+            compression_features[feature] ||
+            advanced_features[feature] ||
+            false
+        end
+
+        # Get encryption algorithm
+        #
+        # @return [String, nil] The encryption algorithm or nil
+        def encryption_algorithm
+          return nil unless spec.format.encryption&.supported
+
+          algorithms = spec.format.encryption.algorithms
+          algorithms&.first
+        end
+
+        # Get dictionary size for compression level
+        #
+        # @param level [Symbol] The compression level
+        # @return [Integer] The dictionary size code
+        def dictionary_size_code(level)
+          spec.format.dictionary_sizes[level] ||
+            spec.format.dictionary_sizes[:auto]
+        end
+
+        protected
+
+        # Read a vint (variable-length integer) from stream
+        #
+        # Used in RAR 5 format for variable-length encoding
+        #
+        # @param io [IO] The input stream
+        # @return [Integer] The decoded integer
+        def read_vint(io)
+          result = 0
+          shift = 0
+
+          loop do
+            byte = io.read(1)&.unpack1("C")
+            raise FormatError, "Unexpected EOF" unless byte
+
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          result
+        end
+
+        # Write a vint (variable-length integer) to stream
+        #
+        # @param io [IO] The output stream
+        # @param value [Integer] The value to encode
+        # @return [void]
+        def write_vint(io, value)
+          loop do
+            byte = value & 0x7F
+            value >>= 7
+
+            byte |= 0x80 if value.positive?
+            io.write([byte].pack("C"))
+
+            break if value.zero?
+          end
+        end
+
+        # Calculate CRC32 checksum
+        #
+        # @param data [String] The data to checksum
+        # @return [Integer] The CRC32 value
+        def calculate_crc32(data)
+          require "zlib"
+          Zlib.crc32(data)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/reader.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "stringio"
+require "zlib"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR archive reader
+      # Provides read-only access to RAR archives (single and multi-volume)
+      class Reader
+        include Omnizip::Formats::Rar::Constants
+
+        attr_reader :file_path, :header, :archive_info,
+                    :volume_manager
+
+        # Initialize reader with file path
+        #
+        # @param file_path [String] Path to RAR file
+        def initialize(file_path)
+          @file_path = file_path
+          @header = nil
+          @entries = []
+          @archive_info = Models::RarArchive.new(file_path)
+          @volume_manager = VolumeManager.new(file_path)
+          @use_native = true # Prefer native decompression
+          @opened = false
+        end
+
+        # Open and parse RAR archive
+        #
+        # @raise [RuntimeError] if file cannot be opened or parsed
+        def open
+          File.open(@file_path, "rb") do |io|
+            parse_archive(io)
+          end
+          @opened = true
+          self
+        end
+
+        # All entries, parsing on first use — a Reader is always
+        # usable; #open remains for eager loading
+        #
+        # @return [Array<Models::RarEntry>] File entries
+        def entries
+          ensure_open
+          @entries
+        end
+
+        # List all files in archive
+        #
+        # @return [Array<Models::RarEntry>] File entries
+        def list_files
+          entries
+        end
+
+        # Extract file to output path
+        #
+        # @param entry_name [String] File name to extract
+        # @param output_path [String] Destination path
+        # @param password [String, nil] Optional password
+        # @raise [RuntimeError] if entry not found or extraction fails
+        def extract_entry(entry_name, output_path, password: nil)
+          ensure_open
+          entry = @entries.find { |e| e.name == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+          # Create directory if needed
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          # Extract file
+          if entry.directory?
+            FileUtils.mkdir_p(output_path)
+          else
+            # Try native decompression first, fall back to external
+            if @use_native && native_decompression_available?(entry)
+              extract_entry_native(entry, output_path)
+            else
+              extract_entry_external(entry_name, output_path, password)
+            end
+
+            # Set timestamp if available
+            File.utime(entry.mtime, entry.mtime, output_path) if entry.mtime
+          end
+        end
+
+        # Extract all files to directory
+        #
+        # @param output_dir [String] Destination directory
+        # @param password [String, nil] Optional password
+        # @raise [RuntimeError] on extraction error
+        def extract_all(output_dir, password: nil)
+          ensure_open
+          FileUtils.mkdir_p(output_dir)
+
+          # Use decompressor to extract all
+          base_path = @volume_manager.first_volume&.path || @file_path
+          Decompressor.extract(base_path, output_dir, password: password)
+
+          # Set timestamps for extracted files
+          @entries.each do |entry|
+            next unless entry.mtime
+
+            output_path = File.join(output_dir, entry.name)
+            next unless File.exist?(output_path)
+
+            File.utime(entry.mtime, entry.mtime, output_path)
+          end
+        end
+
+        # Check if archive is valid RAR format
+        #
+        # @return [Boolean] true if valid
+        def valid?
+          !@header.nil? && @header.valid?
+        end
+
+        # Get volumes in multi-volume archive
+        #
+        # @return [Array<String>] Volume paths
+        def volumes
+          @volume_manager.volume_paths
+        end
+
+        # Get total number of volumes
+        #
+        # @return [Integer] Number of volumes
+        def total_volumes
+          @volume_manager.volume_count
+        end
+
+        # Check if multi-volume archive
+        #
+        # @return [Boolean] true if multi-volume
+        def multi_volume?
+          @volume_manager.multi_volume? || @header&.is_multi_volume
+        end
+
+        private
+
+        # Parse the archive once, on demand
+        def ensure_open
+          open unless @opened
+        end
+
+        # Parse RAR archive structure
+        #
+        # @param io [IO] Input stream
+        def parse_archive(io)
+          # Read and validate header
+          @header = Header.read(io)
+          raise Omnizip::InvalidArchiveError, "Invalid RAR archive" unless @header.valid?
+
+          # Update archive info
+          @archive_info.version = @header.version
+          @archive_info.flags = @header.flags
+          @archive_info.is_multi_volume = @header.is_multi_volume
+          @archive_info.volumes = @volume_manager.volumes
+
+          # Detect recovery records
+          detect_recovery_records
+
+          # Parse entries natively first (full metadata: sizes,
+          # directory flags); fall back to the external decompressor
+          # when native parsing yields nothing (e.g. encrypted
+          # headers).
+          parse_entries_from_header
+          parse_entries_with_decompressor if @entries.empty?
+        end
+
+        # Detect recovery records in archive
+        def detect_recovery_records
+          recovery = RecoveryRecord.new(@header.version)
+
+          # Check for integrated recovery
+          File.open(@file_path, "rb") do |io|
+            recovery.parse_from_archive(io, @header.flags)
+          end
+
+          # Check for external .rev files
+          rev_files = recovery.detect_external_files(@file_path)
+          recovery.load_external_files(rev_files) if rev_files.any?
+
+          # Update archive info
+          @archive_info.has_recovery = recovery.available?
+          @archive_info.recovery_percent = recovery.protection_percent
+          @archive_info.recovery_files = recovery.external_files
+        end
+
+        # Parse entries using decompressor
+        #
+        # This uses the external decompressor to list archive contents
+        # Falls back to native parser if decompressor fails or unavailable
+        def parse_entries_with_decompressor
+          unless Decompressor.available?
+            # If decompressor not available, create minimal entries from header
+            parse_entries_from_header
+            return
+          end
+
+          # Try to list archive contents with external tool
+          begin
+            entry_info = Decompressor.list(@file_path)
+            entry_info.each do |info|
+              entry = Models::RarEntry.new
+              entry.name = info[:name]
+              entry.size = info[:size]
+              entry.compressed_size = info[:compressed_size]
+              entry.is_dir = info[:is_dir]
+              entry.mtime = info[:mtime]
+              entry.version = @header.version
+
+              @entries << entry
+              @archive_info.total_size += entry.size
+              @archive_info.compressed_size += entry.compressed_size
+            end
+
+            @archive_info.entries = @entries
+          rescue StandardError => e
+            # Fall back to native parser if external decompressor fails
+            warn "External decompressor failed: #{e.message}"
+            warn "Falling back to native block parser"
+            parse_entries_from_header
+          end
+        end
+
+        # Parse entries from header (fallback when decompressor unavailable)
+        #
+        # This provides basic information but cannot extract files
+        def parse_entries_from_header
+          # Reset to after header
+          File.open(@file_path, "rb") do |io|
+            Header.read(io) # Skip header
+
+            # Try to parse file blocks
+            parser = BlockParser.new(@header.version)
+
+            loop do
+              pos = io.pos
+              break if io.eof?
+
+              begin
+                entry = parser.parse_file_block(io)
+                break unless entry
+
+                @entries << entry
+                @archive_info.total_size += entry.size
+                @archive_info.compressed_size += entry.compressed_size
+              rescue StandardError => e
+                warn "Failed to parse block at #{pos}: #{e.message}"
+                break
+              end
+            end
+          end
+
+          @archive_info.entries = @entries
+        end
+
+        # Check if native decompression is available for entry
+        #
+        # @param entry [Models::RarEntry] File entry
+        # @return [Boolean] true if native decompression supported
+        def native_decompression_available?(entry)
+          # Native decompression only for RAR4 for now
+          return false unless @header.version == 4
+
+          !entry.nil? && !entry.method.nil?
+        end
+
+        # Extract entry using native decompression
+        #
+        # @param entry [Models::RarEntry] File entry
+        # @param output_path [String] Destination path
+        def extract_entry_native(entry, output_path)
+          compressed_data = read_compressed_data(entry)
+          method = entry.method || 0x30
+
+          output = StringIO.new(+"")
+          Compression::Dispatcher.decompress(method, compressed_data, output)
+
+          # The native LZ/PPMd decoders understand Omnizip's own
+          # encoder output, not official RAR streams — without this
+          # check, real WinRAR archives would silently extract as
+          # garbage. The header CRC is authoritative: on mismatch,
+          # fall back to unrar.
+          data = output.string
+          if entry.crc && Zlib.crc32(data) != entry.crc
+            raise Compression::Dispatcher::DecompressionError,
+                  "CRC mismatch for #{entry.name}"
+          end
+
+          File.binwrite(output_path, data)
+        rescue StandardError => e
+          # Fall back to external decompressor on error
+          warn "Native decompression failed for #{entry.name}: #{e.message}"
+          warn "Falling back to external decompressor"
+          extract_entry_external(entry.name, output_path, nil)
+        end
+
+        # Extract entry using external decompressor
+        #
+        # @param entry_name [String] Entry name
+        # @param output_path [String] Destination path
+        # @param password [String, nil] Optional password
+        def extract_entry_external(entry_name, output_path, password)
+          base_path = @volume_manager.first_volume&.path || @file_path
+          Decompressor.extract_entry(base_path, entry_name,
+                                     output_path, password: password)
+        end
+
+        # Read compressed data for entry
+        #
+        # @param entry [Models::RarEntry] File entry
+        # @return [StringIO] Compressed data stream
+        def read_compressed_data(entry)
+          # The parser records each entry's data offset, so native
+          # extraction is a single seek + read
+          if entry.data_offset && entry.compressed_size
+            File.open(@file_path, "rb") do |io|
+              io.seek(entry.data_offset)
+              return StringIO.new(io.read(entry.compressed_size) || "")
+            end
+          end
+
+          # Fallback for entries parsed without offsets (e.g. by older
+          # parsers): walk the blocks to locate the entry
+          File.open(@file_path, "rb") do |io|
+            Header.read(io)
+
+            parser = BlockParser.new(@header.version)
+
+            loop do
+              block_start = io.pos
+              break if io.eof?
+
+              crc_bytes = io.read(2)
+              break unless crc_bytes
+
+              type_byte = io.read(1)
+              break unless type_byte
+
+              head_type = type_byte.ord
+
+              break if head_type == BLOCK_ENDARC
+
+              io.seek(block_start)
+
+              unless head_type == BLOCK_FILE
+                io.read(2) # CRC
+                io.read(1) # TYPE
+                io.read(2) # FLAGS
+                size = io.read(2)&.unpack1("v") || 0
+
+                # 7 bytes consumed (CRC/TYPE/FLAGS/SIZE); skip the rest
+                remaining = size - 7
+                io.read(remaining) if remaining.positive?
+                next
+              end
+
+              test_entry = parser.parse_file_block(io)
+
+              if test_entry && test_entry.name == entry.name
+                data_start = io.pos - entry.compressed_size
+
+                io.seek(data_start)
+                return StringIO.new(io.read(entry.compressed_size) || "")
+              end
+            end
+          end
+
+          StringIO.new("")
+        end
+      end
+    end
+  end
+end