omnizip 0.3.1

data/lib/omnizip/formats/lzip.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../algorithms/lzma"
+require_relative "../format_registry"
+
+module Omnizip
+  module Formats
+    #
+    # LZIP (.lz) compression format
+    #
+    # Lzip is a file compression format that uses LZMA compression with a
+    # simple container format. It was created as an alternative to the
+    # legacy .lzma format with better integrity checking.
+    #
+    # This is DIFFERENT from both XZ and .lzma (LZMA_Alone) formats:
+    # - XZ (.xz): Container format with stream header/footer/index, LZMA2 compression
+    # - LZIP (.lz): Standalone format with "LZIP" magic and CRC32 footer, LZMA1 compression
+    # - LZMA_Alone (.lzma): Legacy standalone format with properties byte, LZMA1 compression
+    #
+    # Format structure:
+    # - Header (6 bytes):
+    #   - Magic bytes: "LZIP" (0x4C 0x5A 0x49 0x50)
+    #   - Version (1 byte): 0 or 1
+    #   - Dictionary size (1 byte): encoded format
+    # - LZMA1 compressed stream (with fixed LC=3, LP=0, PB=2)
+    # - Footer:
+    #   - Version 0 (12 bytes): CRC32 (4) + Uncompressed size (8)
+    #   - Version 1 (20 bytes): CRC32 (4) + Uncompressed size (8) + Member size (8)
+    #
+    # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/lzip_decoder.c
+    #
+    module Lzip
+      # Lzip magic bytes: "LZIP" in ASCII
+      # Reference: lzip_decoder.c:106
+      MAGIC = [0x4C, 0x5A, 0x49, 0x50].pack("C*")
+
+      # Fixed LC/LP/PB values for lzip format
+      # Reference: lzip_decoder.c:23-26
+      LZIP_LC = 3
+      LZIP_LP = 0
+      LZIP_PB = 2
+
+      # Minimum and maximum dictionary sizes (in bytes)
+      # Reference: lzip_decoder.c:197-198
+      MIN_DICT_SIZE = 4096 # 4 KiB
+      MAX_DICT_SIZE = (512 << 20) # 512 MiB
+
+      class << self
+        # Compress a file with LZIP
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output LZIP file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :level Compression level (0-9, default: 6)
+        # @option options [Integer] :dict_size Dictionary size (default: auto from level)
+        # @option options [Integer] :version LZIP version (0 or 1, default: 1)
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            compress_stream(
+              StringIO.new(input_data),
+              output,
+              options,
+            )
+          end
+        end
+
+        # Decompress LZIP data
+        #
+        # @param input [String, IO] Input data, file path, or IO object
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options
+        # @option options [Boolean] :ignore_check If true, skip CRC32 verification (default: false)
+        # @option options [Boolean] :concatenated If true, decode concatenated .lz members (default: false)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, options = {})
+          # Handle raw data string vs file path vs IO object
+          data = if input.respond_to?(:read)
+                   # Already an IO object
+                   input.read
+                 elsif input.is_a?(String)
+                   # Could be file path or raw data
+                   if !input.include?("\0") && File.exist?(input)
+                     File.binread(input)
+                   else
+                     input.b
+                   end
+                 else
+                   raise ArgumentError,
+                         "Input must be a String or IO object"
+                 end
+
+          # Decode using LzipDecoder
+          require_relative "../algorithms/lzma/lzip_decoder"
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(
+            StringIO.new(data),
+            options,
+          )
+          result = decoder.decode_stream
+
+          if output
+            if output.respond_to?(:write)
+              output.write(result)
+            else
+              File.binwrite(output, result)
+            end
+          else
+            result
+          end
+        end
+
+        # Decode LZIP data (alias for decompress with no output)
+        #
+        # @param input [String, IO] Input LZIP data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Compress data stream with LZIP
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, _output_io, _options = {})
+          input_io.read
+
+          # TODO: Implement LZIP encoder
+          raise NotImplementedError,
+                "LZIP encoding not yet implemented. Use decompression only."
+        end
+
+        # Decompress LZIP stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Options
+        # @return [Hash] Metadata (version, dict_size, member_size)
+        def decompress_stream(input_io, output_io, options = {})
+          require_relative "../algorithms/lzma/lzip_decoder"
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(input_io, options)
+          result = decoder.decode_stream
+
+          output_io.write(result)
+
+          # Return metadata
+          {
+            version: decoder.instance_variable_get(:@version),
+            dict_size: decoder.instance_variable_get(:@dict_size),
+            member_size: decoder.instance_variable_get(:@member_size),
+          }
+        end
+
+        # Register LZIP format when loaded
+        def register!
+          FormatRegistry.register(".lz", Omnizip::Formats::Lzip)
+          FormatRegistry.register(".lzip", Omnizip::Formats::Lzip)
+        end
+
+        # Detect if data is LZIP format
+        #
+        # @param data [String] Data to check
+        # @return [Boolean] true if data has LZIP magic bytes
+        def lzip_file?(data)
+          data.start_with?(MAGIC)
+        end
+      end
+    end
+  end
+end
+
+# Auto-register on load
+Omnizip::Formats::Lzip.register!

data/lib/omnizip/formats/lzma_alone.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../algorithms/lzma"
+require_relative "../format_registry"
+
+module Omnizip
+  module Formats
+    #
+    # LZMA_Alone (.lzma) compression format
+    #
+    # This is the legacy LZMA_Alone format used by LZMA Utils 4.32.x.
+    # It is DIFFERENT from both XZ and LZIP formats:
+    # - XZ (.xz): Container format with stream header/footer/index, LZMA2 compression
+    # - LZIP (.lz): Standalone format with "LZIP" magic and CRC32 footer, LZMA1 compression
+    # - LZMA_Alone (.lzma): Legacy standalone format with properties byte, LZMA1 compression
+    #
+    # Format structure:
+    # - Properties (1 byte): encodes lc, lp, pb values
+    # - Dictionary size (4 bytes, little-endian)
+    # - Uncompressed size (8 bytes, little-endian, UINT64_MAX = unknown)
+    # - LZMA1 compressed stream (no footer, no CRC32)
+    #
+    # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/alone_decoder.c
+    #
+    module LzmaAlone
+      # Maximum valid uncompressed size (256 GiB)
+      # From alone_decoder.c:118
+      MAX_UNCOMPRESSED_SIZE = (1 << 38)
+
+      # Property byte validation limits
+      # From lzma_decoder.c:1218
+      MAX_PROPERTY_BYTE = (((4 * 5) + 4) * 9) + 8 # = 233
+
+      # Value indicating unknown uncompressed size
+      UINT64_MAX = (1 << 64) - 1
+
+      class << self
+        # Compress a file with LZMA_Alone format
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output LZMA_Alone file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :lc Literal context bits (0-8, default: 3)
+        # @option options [Integer] :lp Literal position bits (0-4, default: 0)
+        # @option options [Integer] :pb Position bits (0-4, default: 2)
+        # @option options [Integer] :dict_size Dictionary size (default: 8MB)
+        # @option options [Integer] :uncompressed_size Explicit uncompressed size (default: unknown)
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            compress_stream(
+              StringIO.new(input_data),
+              output,
+              options,
+            )
+          end
+        end
+
+        # Decompress LZMA_Alone data
+        #
+        # @param input [String, IO] Input data, file path, or IO object
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options
+        # @option options [Boolean] :picky If true, reject files unlikely to be .lzma (default: false)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, options = {})
+          # Handle raw data string vs file path
+          data = if input.respond_to?(:read)
+                   input.read
+                 elsif input.is_a?(String)
+                   if !input.include?("\0") && File.exist?(input)
+                     File.binread(input)
+                   else
+                     input.b
+                   end
+                 else
+                   raise ArgumentError,
+                         "Input must be a String or IO object"
+                 end
+
+          # Decode using LzmaAloneDecoder
+          require_relative "../algorithms/lzma/lzma_alone_decoder"
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(
+            StringIO.new(data),
+            options,
+          )
+          result = decoder.decode_stream
+
+          if output
+            if output.respond_to?(:write)
+              output.write(result)
+            else
+              File.binwrite(output, result)
+            end
+          else
+            result
+          end
+        end
+
+        # Decode LZMA_Alone data (alias for decompress with no output)
+        #
+        # @param input [String, IO] Input LZMA_Alone data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Compress data stream with LZMA_Alone format
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, output_io, options = {})
+          input_data = input_io.read
+
+          # Get encoding parameters
+          lc = options[:lc] || 3
+          lp = options[:lp] || 0
+          pb = options[:pb] || 2
+          dict_size = options[:dict_size] || (8 * 1024 * 1024)
+          uncompressed_size = options[:uncompressed_size] || input_data.bytesize
+
+          # Encode properties byte
+          prop_byte = (((pb * 5) + lp) * 9) + lc
+
+          # Write header
+          output_io.write([prop_byte].pack("C"))
+          output_io.write([dict_size].pack("V"))
+          output_io.write([uncompressed_size].pack("Q<"))
+
+          # TODO: Implement LZMA1 encoder
+          raise NotImplementedError,
+                "LZMA_Alone encoding not yet implemented. Use decompression only."
+        end
+
+        # Decompress LZMA_Alone stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Options
+        # @return [Hash] Metadata (lc, lp, pb, dict_size, uncompressed_size)
+        def decompress_stream(input_io, output_io, options = {})
+          require_relative "../algorithms/lzma/lzma_alone_decoder"
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(input_io, options)
+          result = decoder.decode_stream
+
+          output_io.write(result)
+
+          # Return metadata
+          {
+            lc: decoder.instance_variable_get(:@lc),
+            lp: decoder.instance_variable_get(:@lp),
+            pb: decoder.instance_variable_get(:@pb),
+            dict_size: decoder.instance_variable_get(:@dict_size),
+            uncompressed_size: decoder.instance_variable_get(:@uncompressed_size),
+          }
+        end
+
+        # Register LZMA_Alone format when loaded
+        def register!
+          FormatRegistry.register(".lzma", Omnizip::Formats::LzmaAlone)
+        end
+      end
+    end
+  end
+end
+
+# Auto-register on load
+Omnizip::Formats::LzmaAlone.register!

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

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require_relative "archive_verifier"
+require_relative "recovery_record"
+require_relative "parity_handler"
+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