omnizip 0.3.1

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

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "header"
+require_relative "block_parser"
+require_relative "decompressor"
+require_relative "volume_manager"
+require_relative "recovery_record"
+require_relative "models/rar_entry"
+require_relative "models/rar_archive"
+require_relative "compression/dispatcher"
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR archive reader
+      # Provides read-only access to RAR archives (single and multi-volume)
+      class Reader
+        include Constants
+
+        attr_reader :file_path, :header, :entries, :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
+        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
+          self
+        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)
+          entry = @entries.find { |e| e.name == entry_name }
+          raise "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)
+          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 RAR archive structure
+        #
+        # @param io [IO] Input stream
+        def parse_archive(io)
+          # Read and validate header
+          @header = Header.read(io)
+          raise "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 using decompressor
+          parse_entries_with_decompressor
+        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
+
+          # Check if we have the compression method
+          return false unless entry.respond_to?(:method) && entry.method
+
+          # All RAR4 methods are supported by our Dispatcher
+          true
+        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)
+          # Read compressed data from archive
+          compressed_data = read_compressed_data(entry)
+
+          # Decompress using Dispatcher
+          File.open(output_path, "wb") do |output|
+            # For now, assume METHOD_STORE (0x30)
+            # Real implementation would get method from entry
+            method = entry.respond_to?(:method) ? entry.method : 0x30
+
+            Compression::Dispatcher.decompress(method, compressed_data, output)
+          end
+        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)
+          require "stringio"
+
+          # Find the entry's data offset in the archive
+          File.open(@file_path, "rb") do |io|
+            # Skip signature and headers
+            Header.read(io)
+
+            # Parse file blocks to find our entry
+            parser = BlockParser.new(@header.version)
+
+            loop do
+              block_start = io.pos
+              break if io.eof?
+
+              # Peek at block type
+              crc_bytes = io.read(2)
+              break unless crc_bytes
+
+              type_byte = io.read(1)
+              break unless type_byte
+
+              head_type = type_byte.ord
+
+              # If end block, stop
+              break if head_type == BLOCK_ENDARC
+
+              # Reset to block start
+              io.seek(block_start)
+
+              # If not a file block, read and skip it
+              unless head_type == BLOCK_FILE
+                # Read header
+                io.read(2) # CRC
+                io.read(1) # TYPE
+                io.read(2)&.unpack1("v") || 0
+                size = io.read(2)&.unpack1("v") || 0
+
+                # Skip rest of block (size includes TYPE+FLAGS+SIZE = 5 bytes)
+                remaining = size - 5
+                io.read(remaining) if remaining.positive?
+                next
+              end
+
+              # Parse this file block
+              test_entry = parser.parse_file_block(io)
+
+              # Check if this is our entry
+              if test_entry && test_entry.name == entry.name
+                # BlockParser positions us right after the compressed data
+                # So we need to back up and read it
+                data_end = io.pos
+                data_start = data_end - entry.compressed_size
+
+                io.seek(data_start)
+                compressed = io.read(entry.compressed_size)
+
+                return StringIO.new(compressed)
+              end
+            end
+          end
+
+          # If we didn't find it, return empty
+          StringIO.new("")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR recovery record handling
+      # Parses and manages recovery records for error correction
+      class RecoveryRecord
+        attr_reader :version, :type, :protection_percent, :block_size,
+                    :recovery_blocks, :protected_size, :recovery_size,
+                    :reed_solomon_params, :external_files
+
+        # Recovery record types
+        TYPE_INTEGRATED = :integrated  # Inside archive
+        TYPE_EXTERNAL = :external      # Separate .rev files
+
+        # Initialize recovery record
+        #
+        # @param version [Integer] RAR version (4 or 5)
+        def initialize(version)
+          @version = version
+          @type = TYPE_INTEGRATED
+          @protection_percent = 0
+          @block_size = 0
+          @recovery_blocks = 0
+          @protected_size = 0
+          @recovery_size = 0
+          @reed_solomon_params = {}
+          @external_files = []
+        end
+
+        # Check if recovery records are available
+        #
+        # @return [Boolean] true if recovery available
+        def available?
+          @recovery_blocks.positive? || @external_files.any?
+        end
+
+        # Check if using external .rev files
+        #
+        # @return [Boolean] true if external recovery
+        def external?
+          @type == TYPE_EXTERNAL
+        end
+
+        # Parse recovery record from archive
+        #
+        # @param io [IO] Input stream
+        # @param flags [Integer] Archive flags
+        # @return [Boolean] true if recovery record found
+        def parse_from_archive(io, flags)
+          return false unless recovery_flag_set?(flags)
+
+          if @version == 5
+            parse_rar5_recovery(io)
+          else
+            parse_rar4_recovery(io)
+          end
+        end
+
+        # Detect external .rev files
+        #
+        # @param archive_path [String] Path to main archive
+        # @return [Array<String>] Paths to .rev files
+        def detect_external_files(archive_path)
+          dir = File.dirname(archive_path)
+          basename = File.basename(archive_path, ".*")
+
+          # Check for RAR5 naming (.part01.rar.rev)
+          if archive_path.match?(/\.part\d+\.rar$/i)
+            detect_rar5_rev_files(dir, archive_path)
+          else
+            # RAR4 naming (.r00.rev, .r01.rev)
+            detect_rar4_rev_files(dir, basename)
+          end
+        end
+
+        # Load external recovery files
+        #
+        # @param rev_files [Array<String>] Paths to .rev files
+        def load_external_files(rev_files)
+          @external_files = rev_files.select { |f| File.exist?(f) }
+          @type = TYPE_EXTERNAL if @external_files.any?
+        end
+
+        # Get total recovery data size
+        #
+        # @return [Integer] Total recovery bytes
+        def total_recovery_size
+          if external?
+            @external_files.sum { |f| File.size(f) }
+          else
+            @recovery_size
+          end
+        end
+
+        # Calculate protection level
+        #
+        # @return [Float] Protection percentage
+        def protection_level
+          return 0.0 if @protected_size.zero?
+
+          (@recovery_size.to_f / @protected_size * 100).round(2)
+        end
+
+        private
+
+        # Check if recovery flag is set in archive flags
+        #
+        # @param flags [Integer] Archive flags
+        # @return [Boolean] true if recovery flag set
+        def recovery_flag_set?(flags)
+          flags.anybits?(Constants::ARCHIVE_RECOVERY)
+        end
+
+        # Parse RAR5 recovery record
+        #
+        # @param io [IO] Input stream
+        # @return [Boolean] true if parsed successfully
+        def parse_rar5_recovery(io)
+          # RAR5 recovery record structure
+          # Read block header
+          block_type = read_vint(io)
+          return false unless block_type == Constants::RAR5_HEADER_SERVICE
+
+          block_flags = read_vint(io)
+          _extra_size = read_vint(io) if block_flags.anybits?(0x0001)
+
+          # Read recovery parameters
+          @block_size = read_vint(io)
+          @recovery_blocks = read_vint(io)
+          @protected_size = read_vint(io)
+
+          # Reed-Solomon parameters for RAR5
+          @reed_solomon_params[:data_blocks] = read_vint(io)
+          @reed_solomon_params[:parity_blocks] = read_vint(io)
+
+          @recovery_size = @block_size * @recovery_blocks
+          @protection_percent = protection_level.to_i
+
+          true
+        rescue StandardError
+          false
+        end
+
+        # Parse RAR4 recovery record
+        #
+        # @param io [IO] Input stream
+        # @return [Boolean] true if parsed successfully
+        def parse_rar4_recovery(io)
+          # RAR4 old recovery record structure
+          # Skip to recovery block
+          block_type = io.read(1)&.unpack1("C")
+          return false unless block_type == Constants::BLOCK_OLD_RECOVERY
+
+          # Read block header
+          _block_flags = io.read(2)&.unpack1("v")
+          io.read(2)&.unpack1("v")
+
+          # Read recovery data size
+          @recovery_size = io.read(4)&.unpack1("V") || 0
+          @protected_size = io.read(4)&.unpack1("V") || 0
+          @recovery_blocks = io.read(2)&.unpack1("v") || 0
+
+          if @recovery_blocks.positive?
+            @block_size = @recovery_size / @recovery_blocks
+          end
+          @protection_percent = protection_level.to_i
+
+          true
+        rescue StandardError
+          false
+        end
+
+        # Detect RAR5 external .rev files
+        #
+        # @param dir [String] Directory path
+        # @param archive_path [String] Archive path
+        # @return [Array<String>] .rev file paths
+        def detect_rar5_rev_files(_dir, archive_path)
+          rev_files = []
+
+          # Check for .partNN.rar.rev files
+          if archive_path =~ /^(.+)(\.part\d+\.rar)$/i
+            base_name = Regexp.last_match(1)
+            Regexp.last_match(2)
+
+            (1..999).each do |i|
+              rev_path = format("%s.part%02d.rar.rev", base_name, i)
+              break unless File.exist?(rev_path)
+
+              rev_files << rev_path
+            end
+          end
+
+          rev_files
+        end
+
+        # Detect RAR4 external .rev files
+        #
+        # @param dir [String] Directory path
+        # @param basename [String] Archive base name
+        # @return [Array<String>] .rev file paths
+        def detect_rar4_rev_files(dir, basename)
+          rev_files = []
+
+          # Check for archive.rev
+          main_rev = File.join(dir, "#{basename}.rev")
+          rev_files << main_rev if File.exist?(main_rev)
+
+          # Check for .rNN.rev files
+          (0..99).each do |i|
+            rev_path = File.join(dir, format("%s.r%02d.rev", basename, i))
+            break unless File.exist?(rev_path)
+
+            rev_files << rev_path
+          end
+
+          rev_files
+        end
+
+        # Read variable-length integer (RAR5)
+        #
+        # @param io [IO] Input stream
+        # @return [Integer] Decoded integer
+        def read_vint(io)
+          result = 0
+          shift = 0
+
+          loop do
+            byte = io.read(1)&.unpack1("C")
+            raise "Unexpected EOF" unless byte
+
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          result
+        end
+      end
+    end
+  end
+end