omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR archive repair functionality
+      # Attempts to repair corrupted archives using recovery records
+      class ArchiveRepairer
+        attr_reader :verifier, :recovery_record, :parity_handler
+
+        # Repair result
+        class RepairResult
+          attr_accessor :success, :repaired_files, :unrepaired_files,
+                        :repaired_blocks, :errors, :output_path
+
+          def initialize
+            @success = false
+            @repaired_files = []
+            @unrepaired_files = []
+            @repaired_blocks = []
+            @errors = []
+            @output_path = nil
+          end
+
+          # Check if repair was successful
+          #
+          # @return [Boolean] true if all files repaired
+          def success?
+            @success && @unrepaired_files.empty?
+          end
+
+          # Get repair summary
+          #
+          # @return [String] Repair summary
+          def summary
+            if success?
+              "Repair successful: #{@repaired_files.size} files, " \
+                "#{@repaired_blocks.size} blocks"
+            elsif @repaired_files.any?
+              "Partial repair: #{@repaired_files.size} files OK, " \
+                "#{@unrepaired_files.size} failed"
+            else
+              "Repair failed: #{@errors.join(', ')}"
+            end
+          end
+        end
+
+        # Initialize repairer
+        def initialize
+          @verifier = nil
+          @recovery_record = nil
+          @parity_handler = nil
+        end
+
+        # Repair corrupted archive
+        #
+        # @param input_path [String] Path to corrupted archive
+        # @param output_path [String] Path for repaired archive
+        # @param options [Hash] Repair options
+        # @option options [Boolean] :use_external_rev Use external .rev files
+        # @option options [Boolean] :verify_repaired Verify after repair
+        # @option options [Boolean] :verbose Enable verbose output
+        # @return [RepairResult] Repair results
+        def repair(input_path, output_path, options = {})
+          result = RepairResult.new
+          result.output_path = output_path
+
+          begin
+            # Verify archive first
+            @verifier = ArchiveVerifier.new(input_path)
+            verification = @verifier.verify(
+              use_recovery: true,
+              verbose: options[:verbose],
+            )
+
+            unless verification.recovery_available
+              result.errors << "No recovery records available"
+              return result
+            end
+
+            unless verification.can_repair?
+              result.errors << "Corruption not recoverable"
+              return result
+            end
+
+            # Perform repair
+            @recovery_record = @verifier.recovery_record
+            @parity_handler = @verifier.parity_handler
+
+            perform_repair(input_path, output_path, verification, result,
+                           options)
+
+            # Verify repaired archive
+            if options[:verify_repaired] && result.success
+              verify_repaired_archive(output_path, result)
+            end
+          rescue StandardError => e
+            result.success = false
+            result.errors << "Repair error: #{e.message}"
+          end
+
+          result
+        end
+
+        # Attempt quick repair (in-place)
+        #
+        # @param archive_path [String] Path to archive
+        # @param options [Hash] Repair options
+        # @return [RepairResult] Repair results
+        def quick_repair(archive_path, options = {})
+          # Create temporary output
+          temp_output = "#{archive_path}.repaired"
+
+          result = repair(archive_path, temp_output, options)
+
+          if result.success?
+            # Replace original with repaired
+            FileUtils.mv(temp_output, archive_path, force: true)
+            result.output_path = archive_path
+          else
+            # Clean up temp file
+            FileUtils.rm_f(temp_output)
+          end
+
+          result
+        end
+
+        private
+
+        # Perform the actual repair
+        #
+        # @param input_path [String] Input archive path
+        # @param output_path [String] Output archive path
+        # @param verification [VerificationResult] Verification results
+        # @param result [RepairResult] Repair result to update
+        # @param options [Hash] Repair options
+        def perform_repair(input_path, output_path, verification, result,
+                           options)
+          # Copy archive to output first
+          FileUtils.cp(input_path, output_path)
+
+          # Repair corrupted blocks
+          verification.corrupt_blocks.each do |block_index|
+            if repair_block(output_path, block_index, options)
+              result.repaired_blocks << block_index
+            else
+              result.errors << "Failed to repair block #{block_index}"
+            end
+          end
+
+          # Track repaired files
+          verification.corrupted_files.each do |filename|
+            if verify_file_in_archive(output_path, filename)
+              result.repaired_files << filename
+            else
+              result.unrepaired_files << filename
+            end
+          end
+
+          result.success = result.unrepaired_files.empty?
+        end
+
+        # Repair single block in archive
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block to repair
+        # @param options [Hash] Repair options
+        # @return [Boolean] true if repaired
+        def repair_block(archive_path, block_index, options)
+          return false unless @parity_handler.can_recover?(block_index)
+
+          # Recover the block
+          recovered_data = @parity_handler.recover_block(archive_path,
+                                                         block_index)
+          return false unless recovered_data
+
+          # Write recovered data to archive
+          write_block_to_archive(archive_path, block_index, recovered_data)
+
+          puts "Repaired block #{block_index}" if options[:verbose]
+          true
+        rescue StandardError => e
+          if options[:verbose]
+            puts "Failed to repair block #{block_index}: #{e.message}"
+          end
+          false
+        end
+
+        # Write block data to archive
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block index
+        # @param data [String] Block data
+        def write_block_to_archive(archive_path, block_index, data)
+          block_size = @recovery_record.block_size
+          offset = block_index * block_size
+
+          File.open(archive_path, "r+b") do |io|
+            io.seek(offset)
+            io.write(data)
+          end
+        end
+
+        # Verify file in archive
+        #
+        # @param archive_path [String] Path to archive
+        # @param filename [String] File name to verify
+        # @return [Boolean] true if file is valid
+        def verify_file_in_archive(archive_path, filename)
+          reader = Reader.new(archive_path)
+          reader.open
+
+          entry = reader.entries.find { |e| e.name == filename }
+          return false unless entry
+
+          # Verify entry (simplified - would check CRC in full implementation)
+          true
+        rescue StandardError
+          false
+        end
+
+        # Verify repaired archive
+        #
+        # @param archive_path [String] Path to repaired archive
+        # @param result [RepairResult] Repair result to update
+        def verify_repaired_archive(archive_path, result)
+          verifier = ArchiveVerifier.new(archive_path)
+          verification = verifier.verify(use_recovery: false)
+
+          return if verification.valid?
+
+          result.success = false
+          result.errors << "Repaired archive still has errors"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR archive verification
+      # Verifies archive integrity using CRCs and recovery records
+      class ArchiveVerifier
+        attr_reader :archive_path, :recovery_record, :parity_handler
+
+        # Verification result
+        class VerificationResult
+          attr_accessor :valid, :files_total, :files_ok, :files_corrupted,
+                        :corrupted_files, :recoverable, :corrupt_blocks,
+                        :recovery_available, :errors
+
+          def initialize
+            @valid = true
+            @files_total = 0
+            @files_ok = 0
+            @files_corrupted = 0
+            @corrupted_files = []
+            @recoverable = false
+            @corrupt_blocks = []
+            @recovery_available = false
+            @errors = []
+          end
+
+          # Check if archive is valid
+          #
+          # @return [Boolean] true if valid
+          def valid?
+            @valid && @files_corrupted.zero?
+          end
+
+          # Check if corruption can be repaired
+          #
+          # @return [Boolean] true if repairable
+          def can_repair?
+            @recovery_available && @recoverable
+          end
+
+          # Get summary string
+          #
+          # @return [String] Verification summary
+          def summary
+            if valid?
+              "Archive OK: #{@files_total} files verified"
+            else
+              msg = "Archive corrupted: #{@files_corrupted}/#{@files_total} files damaged"
+              msg += " (repairable)" if can_repair?
+              msg
+            end
+          end
+        end
+
+        # Initialize verifier
+        #
+        # @param archive_path [String] Path to RAR archive
+        def initialize(archive_path)
+          @archive_path = archive_path
+          @recovery_record = nil
+          @parity_handler = nil
+        end
+
+        # Verify archive integrity
+        #
+        # @param use_recovery [Boolean] Use recovery records for verification
+        # @param verbose [Boolean] Enable verbose output
+        # @return [VerificationResult] Verification results
+        def verify(use_recovery: true, verbose: false)
+          result = VerificationResult.new
+
+          begin
+            # Open and parse archive
+            reader = Reader.new(@archive_path)
+            reader.open
+
+            result.files_total = reader.entries.size
+
+            # Detect recovery records
+            detect_recovery_records(reader, result) if use_recovery
+
+            # Verify each file
+            reader.entries.each do |entry|
+              file_valid = verify_entry(entry, verbose)
+
+              if file_valid
+                result.files_ok += 1
+              else
+                result.files_corrupted += 1
+                result.corrupted_files << entry.name
+                result.valid = false
+              end
+            end
+
+            # Check if corruption is recoverable
+            if result.files_corrupted.positive? && result.recovery_available
+              result.recoverable = check_recoverability(result.corrupt_blocks)
+            end
+          rescue StandardError => e
+            result.valid = false
+            result.errors << "Verification failed: #{e.message}"
+          end
+
+          result
+        end
+
+        # Verify single file entry
+        #
+        # @param entry [Models::RarEntry] Entry to verify
+        # @param verbose [Boolean] Print verbose output
+        # @return [Boolean] true if valid
+        def verify_entry(entry, verbose = false)
+          return true if entry.directory?
+
+          # For now, we rely on the decompressor to verify
+          # In a full implementation, we would check CRC32
+          valid = verify_entry_crc(entry)
+
+          puts "#{entry.name}: #{valid ? 'OK' : 'FAILED'}" if verbose
+
+          valid
+        rescue StandardError => e
+          puts "#{entry.name}: ERROR (#{e.message})" if verbose
+          false
+        end
+
+        # Quick test of archive
+        #
+        # @return [Boolean] true if archive can be opened
+        def quick_test
+          Reader.new(@archive_path).open
+          true
+        rescue StandardError
+          false
+        end
+
+        private
+
+        # Detect recovery records in archive
+        #
+        # @param reader [Reader] Archive reader
+        # @param result [VerificationResult] Result object to update
+        def detect_recovery_records(reader, result)
+          version = reader.header&.version || 4
+
+          @recovery_record = RecoveryRecord.new(version)
+
+          # Check for integrated recovery records
+          File.open(@archive_path, "rb") do |io|
+            @recovery_record.parse_from_archive(io, reader.archive_info.flags)
+          end
+
+          # Check for external .rev files
+          rev_files = @recovery_record.detect_external_files(@archive_path)
+          @recovery_record.load_external_files(rev_files) if rev_files.any?
+
+          result.recovery_available = @recovery_record.available?
+
+          # Initialize parity handler if recovery available
+          return unless result.recovery_available
+
+          @parity_handler = ParityHandler.new(@recovery_record)
+          @parity_handler.load_parity_data(@recovery_record.external_files)
+        end
+
+        # Verify entry CRC
+        #
+        # @param entry [Models::RarEntry] Entry to verify
+        # @return [Boolean] true if CRC matches
+        def verify_entry_crc(_entry)
+          # This is a placeholder - actual CRC verification would require
+          # extracting and checking the file
+          # For now, assume OK unless we have specific corruption data
+          true
+        end
+
+        # Check if corruption is recoverable
+        #
+        # @param corrupt_blocks [Array<Integer>] Corrupted block indices
+        # @return [Boolean] true if recoverable
+        def check_recoverability(corrupt_blocks)
+          return false unless @parity_handler
+
+          # Check if all corrupted blocks can be recovered
+          corrupt_blocks.all? { |idx| @parity_handler.can_recover?(idx) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR block parser
+      # Parses different block types in RAR archives
+      class BlockParser
+        include Omnizip::Formats::Rar::Constants
+
+        attr_reader :version
+
+        # Initialize block parser
+        #
+        # @param version [Integer] RAR version (4 or 5)
+        def initialize(version)
+          @version = version
+        end
+
+        # Parse file block and create entry
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_file_block(io)
+          if @version == 5
+            parse_rar5_file_block(io)
+          else
+            parse_rar4_file_block(io)
+          end
+        end
+
+        # Skip to next block
+        #
+        # @param io [IO] Input stream
+        # @param block_size [Integer] Block size to skip
+        def skip_block(io, block_size)
+          io.read(block_size) if block_size.positive?
+        end
+
+        private
+
+        # Parse RAR4 file block
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_rar4_file_block(io)
+          entry = Models::RarEntry.new
+          block_start = io.pos
+
+          # Read block header
+          read_uint16(io)
+          head_type = io.read(1)&.ord
+          return nil unless head_type == BLOCK_FILE
+
+          head_flags = read_uint16(io)
+          head_size = read_uint16(io)
+
+          # Read file header data
+          pack_size = read_uint32(io)
+          unpack_size = read_uint32(io)
+          host_os = io.read(1)&.ord
+          file_crc = read_uint32(io)
+          file_time = read_uint32(io)
+          unpack_ver = io.read(1)&.ord
+          method = io.read(1)&.ord
+          name_size = read_uint16(io)
+          attr = read_uint32(io)
+
+          # Read extended sizes if large file
+          if head_flags.anybits?(FILE_LARGE)
+            high_pack_size = read_uint32(io)
+            high_unpack_size = read_uint32(io)
+            pack_size |= (high_pack_size << 32)
+            unpack_size |= (high_unpack_size << 32)
+          end
+
+          # Sanity bounds: corrupt headers must not drive huge reads.
+          # head_size can never exceed the bytes left from the block
+          # start, and the name must fit inside the header.
+          if head_size > io.size - block_start ||
+              name_size + 32 > head_size
+            return nil
+          end
+
+          # Read file name
+          name_bytes = io.read(name_size)
+          entry.name = decode_filename(name_bytes, head_flags)
+          # RAR4 archives store DOS-style backslash separators;
+          # normalize to forward slashes like unrar on Unix. Scrub
+          # first: unicode-flagged names may carry bytes that are not
+          # valid UTF-8, and String#tr raises on them under any
+          # locale.
+          entry.name = entry.name.scrub.tr("\\", "/")
+
+          # Set entry properties
+          entry.size = unpack_size
+          entry.compressed_size = pack_size
+          entry.crc = file_crc
+          entry.host_os = host_os
+          entry.method = method
+          entry.version = unpack_ver
+          entry.flags = head_flags
+          entry.attributes = attr
+          entry.mtime = dos_time_to_time(file_time)
+
+          # Set flags. RAR4 directory entries carry the full
+          # dictionary mask 0xE0 in HEAD_FLAGS (a directory has no
+          # dictionary); the exact match avoids misreading a large
+          # dictionary size on files as the marker.
+          entry.is_dir = head_flags.allbits?(FILE_DIRECTORY)
+          # WinRAR writes directory names with a trailing backslash;
+          # normalize it away for host paths.
+          entry.name = entry.name.chomp("\\") if entry.is_dir
+          entry.encrypted = head_flags.anybits?(FILE_ENCRYPTED)
+          entry.split_before = head_flags.anybits?(FILE_SPLIT_BEFORE)
+          entry.split_after = head_flags.anybits?(FILE_SPLIT_AFTER)
+
+          # Skip remaining header data and file data. HEAD_SIZE
+          # counts the whole block including the 2-byte HEAD_CRC;
+          # consumed so far: 2 (CRC) + 30 (fixed fields) + name, plus
+          # 8 more when high-size words were present. Leftover bytes
+          # cover salt/extra time fields without interpreting them.
+          remaining = head_size - (name_size + 32)
+          remaining -= 8 if head_flags.anybits?(FILE_LARGE)
+          io.read(remaining) if remaining.positive?
+          # Record where the packed data starts so extraction can seek
+          # straight to it instead of re-parsing the archive
+          entry.data_offset = io.pos
+          # Seek past the data: never allocate the packed bytes just
+          # to skip them. A corrupt pack_size (bigger than the file)
+          # would overflow the seek offset on Linux — clamp to EOF so
+          # the entry still lists.
+          skip_past(io, pack_size)
+
+          entry
+        end
+
+        # Parse RAR5 file block
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_rar5_file_block(io)
+          entry = Models::RarEntry.new
+
+          # Read block header
+          read_uint32(io)
+          read_vint(io)
+          header_type = read_vint(io)
+          return nil unless header_type == RAR5_HEADER_FILE
+
+          header_flags = read_vint(io)
+
+          # Optional ExtraAreaSize / DataSize precede the file fields
+          extra_size = header_flags.anybits?(RAR5_FLAG_EXTRA_AREA) ? read_vint(io) : 0
+          data_size = header_flags.anybits?(RAR5_FLAG_DATA_AREA) ? read_vint(io) : 0
+
+          # Sanity bounds: corrupt headers must not drive huge reads
+          remaining_bytes = io.size - io.pos
+          return nil if extra_size > remaining_bytes || data_size > remaining_bytes
+
+          # Read file header
+          file_flags = read_vint(io)
+          unpack_size = read_vint(io)
+          attr = read_vint(io)
+
+          # Read modification time if present
+          mtime = nil
+          mtime = read_uint32(io) if file_flags.anybits?(0x02)
+
+          # Read CRC if present
+          crc = nil
+          crc = read_uint32(io) if file_flags.anybits?(0x04)
+
+          # Read compression info
+          read_vint(io)
+          host_os = read_vint(io)
+          name_length = read_vint(io)
+
+          # Read file name
+          name_bytes = io.read(name_length)
+          entry.name = name_bytes.to_s.scrub.force_encoding("UTF-8")
+
+          # Set entry properties
+          entry.size = unpack_size
+          entry.compressed_size = data_size
+          entry.crc = crc
+          entry.host_os = host_os
+          entry.flags = file_flags
+          entry.attributes = attr
+          entry.mtime = Time.at(mtime) if mtime
+          entry.is_dir = file_flags.anybits?(RAR5_FLAG_IS_DIR)
+          entry.version = 5
+
+          # Skip extra area, then compressed data; record the data
+          # start for direct-seek extraction. The data is seeked past,
+          # never read: corrupt sizes must not drive huge allocations.
+          io.read(extra_size) if extra_size.positive?
+          entry.data_offset = io.pos
+          skip_past(io, data_size)
+
+          entry
+        end
+
+        # Skip forward without allocating: clamp corrupt sizes to EOF
+        # so an overflowing seek (EINVAL on Linux) cannot abort the
+        # block walk
+        def skip_past(io, bytes)
+          return if bytes <= 0
+
+          remaining = io.size - io.pos
+          io.seek([bytes, remaining].min, ::IO::SEEK_CUR)
+        end
+
+        # Decode filename from bytes
+        #
+        # @param bytes [String] Raw filename bytes
+        # @param flags [Integer] Block flags
+        # @return [String] Decoded filename
+        def decode_filename(bytes, flags)
+          if flags.nobits?(FILE_UNICODE)
+            # ASCII filename
+            bytes.force_encoding("ASCII-8BIT")
+          else
+            # Unicode filename
+            bytes.force_encoding("UTF-8")
+          end
+        end
+
+        # Convert DOS time to Ruby Time
+        #
+        # @param dos_time [Integer] DOS time value
+        # @return [Time] Ruby time object
+        def dos_time_to_time(dos_time)
+          sec = (dos_time & 0x1F) * 2
+          min = (dos_time >> 5) & 0x3F
+          hour = (dos_time >> 11) & 0x1F
+          day = (dos_time >> 16) & 0x1F
+          month = (dos_time >> 21) & 0x0F
+          year = ((dos_time >> 25) & 0x7F) + 1980
+
+          Time.new(year, month, day, hour, min, sec)
+        rescue ArgumentError
+          Time.now
+        end
+
+        # Read 16-bit unsigned integer (little-endian)
+        def read_uint16(io)
+          bytes = io.read(2)
+          return 0 unless bytes&.size == 2
+
+          bytes.unpack1("v")
+        end
+
+        # Read 32-bit unsigned integer (little-endian)
+        def read_uint32(io)
+          bytes = io.read(4)
+          return 0 unless bytes&.size == 4
+
+          bytes.unpack1("V")
+        end
+
+        # Read variable-length integer (RAR5)
+        def read_vint(io)
+          result = 0
+          shift = 0
+
+          loop do
+            byte = io.read(1)&.ord
+            return result unless byte
+
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          result
+        end
+      end
+    end
+  end
+end