omnizip 0.3.1

data/lib/omnizip/formats/rar5/decompressor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "../rar/rar_format_base"
+require_relative "../../error"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 decompressor
+      #
+      # Decompresses data using RAR v5 decompression algorithms.
+      # This implementation uses DEFLATE as a compatible fallback
+      # for demonstration purposes. Full RAR5 decompression requires
+      # proprietary algorithms.
+      #
+      # @example Decompressing data
+      #   decompressor = Rar5::Decompressor.new
+      #   original = decompressor.decompress(compressed, method: :normal)
+      class Decompressor < Rar::RarFormatBase
+        # Initialize a RAR v5 decompressor
+        def initialize
+          super("rar5")
+        end
+
+        # Decompress data using RAR v5 methods
+        #
+        # @param data [String] The compressed data
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Decompression options
+        # @return [String] The decompressed data
+        def decompress(data, method: :normal, **_options)
+          case method
+          when :store
+            decompress_store(data)
+          when :fastest, :fast, :normal, :good, :best
+            decompress_deflate(data)
+          else
+            raise FormatError,
+                  "Unsupported decompression method: #{method}"
+          end
+        end
+
+        private
+
+        # Return stored data without decompression
+        #
+        # @param data [String] The stored data
+        # @return [String] The uncompressed data
+        def decompress_store(data)
+          data
+        end
+
+        # Decompress using DEFLATE (compatible fallback)
+        #
+        # @param data [String] The compressed data
+        # @return [String] The decompressed data
+        def decompress_deflate(data)
+          Zlib::Inflate.inflate(data)
+        rescue Zlib::Error => e
+          raise FormatError, "Decompression failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+require_relative "../rar/rar_format_base"
+require_relative "decompressor"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 archive reader
+      #
+      # Reads RAR 5.x format archives, parsing headers and extracting file data
+      # according to the RAR v5 specification.
+      #
+      # RAR 5 uses variable-length integers (vint) and improved header structure.
+      #
+      # @example Reading a RAR5 archive
+      #   reader = Rar5::Reader.new
+      #   File.open("archive.rar", "rb") do |file|
+      #     entries = reader.read_archive(file)
+      #     entries.each { |entry| puts entry.name }
+      #   end
+      class Reader < Rar::RarFormatBase
+        # Initialize a RAR v5 reader
+        def initialize
+          super("rar5")
+        end
+
+        # Read a RAR v5 archive
+        #
+        # @param io [IO] The input stream
+        # @return [Array<Entry>] The archive entries
+        # @raise [FormatError] If the archive format is invalid
+        def read_archive(io)
+          unless verify_magic_bytes(io)
+            raise FormatError, "Invalid RAR v5 signature"
+          end
+
+          # Skip past the magic bytes (8 bytes)
+          io.seek(8, ::IO::SEEK_SET)
+
+          entries = []
+
+          # Read main header
+          main_header = read_header(io)
+          unless main_header.type == block_type_code(:main_header)
+            raise FormatError, "Expected main archive header"
+          end
+
+          @archive_flags = main_header.flags
+
+          # Skip to end of main header
+          skip_to_header_end(io, main_header)
+
+          # Read blocks until end marker or EOF/error
+          loop do
+            header = read_header(io)
+            break if header.type == block_type_code(:end_marker)
+
+            case header.type
+            when block_type_code(:file_header)
+              entry = read_file_entry(io, header)
+              entries << entry if entry
+            when block_type_code(:service_header)
+              skip_header_data(io, header)
+            when block_type_code(:encryption_header)
+              read_encryption_header(io, header)
+            else
+              skip_header_data(io, header)
+            end
+          rescue EOFError, RangeError, FormatError
+            # Truncated or corrupted file - return what we have
+            break
+          end
+
+          entries
+        rescue EOFError, RangeError, FormatError
+          # Handle truncated/invalid files gracefully
+          []
+        end
+
+        private
+
+        # Skip to the end of a header
+        #
+        # @param io [IO] The input stream
+        # @param header [HeaderBlock] The header
+        def skip_to_header_end(io, header)
+          # Calculate end of header: header_start + 4 (CRC) + header_size + vint_length
+          header_end = header.header_start + 4 + header.size.to_i + header.vint_length.to_i
+
+          # Validate the offset is reasonable (max 1GB)
+          max_offset = 1_073_741_824
+          raise RangeError, "Header offset too large" if header_end > max_offset
+          raise RangeError, "Header offset negative" if header_end.negative?
+
+          io.seek(header_end, ::IO::SEEK_SET)
+        end
+
+        # Read a RAR v5 header
+        #
+        # @param io [IO] The input stream
+        # @return [HeaderBlock] The header block
+        def read_header(io)
+          # Record start position (before CRC)
+          header_start = io.pos
+
+          header_crc = io.read(4)&.unpack1("V")
+
+          # Read header size vint and track its length
+          header_size, vint_length = read_vint_with_length(io)
+
+          # Now we're at the start of header content
+          # header_size is the size of the content (from header_type to end)
+          content_start = io.pos
+
+          header_type = read_vint(io)
+          header_flags = read_vint(io)
+
+          # Read extra size if present
+          extra_size = 0
+          extra_size = read_vint(io) if header_flags & 0x0001 != 0
+
+          # Read data size if present
+          data_size = 0
+          data_size = read_vint(io) if header_flags & 0x0002 != 0
+
+          # Store positions for proper skipping
+          HeaderBlock.new(
+            crc: header_crc,
+            size: header_size,
+            vint_length: vint_length,
+            type: header_type,
+            flags: header_flags,
+            extra_size: extra_size,
+            data_size: data_size,
+            header_start: header_start,
+            content_start: content_start,
+          )
+        end
+
+        # Read a vint and return both value and length
+        #
+        # @param io [IO] The input stream
+        # @return [Array<Integer, Integer>] Value and length in bytes
+        def read_vint_with_length(io)
+          result = 0
+          shift = 0
+          length = 0
+
+          loop do
+            byte = io.read(1)&.unpack1("C")
+            raise FormatError, "Unexpected EOF" unless byte
+
+            length += 1
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          [result, length]
+        end
+
+        # Read a file entry from archive
+        #
+        # @param io [IO] The input stream
+        # @param header [HeaderBlock] The file header
+        # @return [Entry] The file entry
+        def read_file_entry(io, header)
+          flags = read_vint(io)
+          unpacked_size = read_vint(io)
+          attributes = read_vint(io)
+
+          # Read modification time if present
+          mtime = Time.now
+          if flags & 0x02 != 0 # time_present flag
+            mtime = read_file_time(io)
+          end
+
+          # Read CRC32 if present
+          data_crc = 0
+          if flags & 0x04 != 0 # crc32_present flag
+            data_crc = io.read(4)&.unpack1("V")
+          end
+
+          # Read compression info
+          compression_flags = read_vint(io)
+          host_os = read_vint(io)
+          name_length = read_vint(io)
+
+          # Read filename (UTF-8 encoded)
+          name_bytes = io.read(name_length)
+          filename = name_bytes.force_encoding("UTF-8")
+
+          # Determine if directory
+          is_directory = flags.anybits?(0x01) # directory flag
+
+          # Skip to end of header
+          skip_to_header_end(io, header)
+
+          # Record data offset before skipping
+          data_offset = io.pos
+
+          # Skip file data (so we can read the next header)
+          io.seek(header.data_size, ::IO::SEEK_CUR) if header.data_size.to_i.positive?
+
+          Entry.new(
+            name: filename,
+            compressed_size: header.data_size || 0,
+            uncompressed_size: unpacked_size,
+            crc32: data_crc,
+            compression_method: extract_compression_method(compression_flags),
+            modified_time: mtime,
+            attributes: attributes,
+            encrypted: header.flags.anybits?(0x04),
+            data_offset: data_offset,
+            host_os: host_os,
+            is_directory: is_directory,
+          )
+        end
+
+        # Extract compression method from flags
+        #
+        # @param flags [Integer] The compression flags
+        # @return [Symbol] The compression method
+        def extract_compression_method(flags)
+          method_code = flags & 0x07
+
+          case method_code
+          when 0 then :store
+          when 1 then :fastest
+          when 2 then :fast
+          when 3 then :normal
+          when 4 then :good
+          when 5 then :best
+          else :normal
+          end
+        end
+
+        # Read file time in RAR5 format
+        #
+        # @param io [IO] The input stream
+        # @return [Time] The file time
+        def read_file_time(io)
+          read_vint(io)
+
+          # Simplified time reading - actual format is more complex
+          unix_time = io.read(8)&.unpack1("Q<")
+          Time.at(unix_time / 10_000_000.0) if unix_time
+        rescue ArgumentError
+          Time.now
+        end
+
+        # Read encryption header
+        #
+        # @param io [IO] The input stream
+        # @param header [HeaderBlock] The header
+        # @return [void]
+        def read_encryption_header(io, header)
+          # Read and skip encryption data
+          skip_header_data(io, header)
+        end
+
+        # Skip header data
+        #
+        # @param io [IO] The input stream
+        # @param header [HeaderBlock] The header
+        # @return [void]
+        def skip_header_data(io, header)
+          # Calculate end of header: header_start + 4 (CRC) + header_size + vint_length
+          header_end = header.header_start.to_i + 4 + header.size.to_i + header.vint_length.to_i
+          current_pos = io.pos
+
+          # Validate the offset is reasonable (max 1GB)
+          max_offset = 1_073_741_824
+          if header_end > max_offset || header_end.negative?
+            raise RangeError, "Invalid header offset"
+          end
+
+          if header_end > current_pos
+            io.seek(header_end - current_pos, ::IO::SEEK_CUR)
+          end
+
+          # Skip data section if present (with bounds checking)
+          data_size = header.data_size.to_i
+          if data_size.positive? && data_size < max_offset
+            io.seek(data_size, ::IO::SEEK_CUR)
+          end
+        end
+      end
+
+      # RAR v5 header block model
+      class HeaderBlock
+        attr_accessor :crc, :size, :vint_length, :type, :flags, :extra_size,
+                      :data_size, :header_start, :content_start
+
+        def initialize(crc: nil, size: nil, vint_length: 1, type: nil, flags: nil,
+                       extra_size: nil, data_size: nil, header_start: nil, content_start: nil)
+          @crc = crc
+          @size = size
+          @vint_length = vint_length
+          @type = type
+          @flags = flags
+          @extra_size = extra_size
+          @data_size = data_size
+          @header_start = header_start
+          @content_start = content_start
+        end
+      end
+
+      # RAR v5 archive entry model
+      class Entry
+        attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
+                      :compression_method, :modified_time, :attributes,
+                      :encrypted, :data_offset, :host_os, :is_directory
+
+        def initialize(name: nil, compressed_size: nil, uncompressed_size: nil,
+                       crc32: nil, compression_method: nil, modified_time: nil,
+                       attributes: nil, encrypted: nil, data_offset: nil,
+                       host_os: nil, is_directory: nil)
+          @name = name
+          @compressed_size = compressed_size
+          @uncompressed_size = uncompressed_size
+          @crc32 = crc32
+          @compression_method = compression_method
+          @modified_time = modified_time
+          @attributes = attributes
+          @encrypted = encrypted
+          @data_offset = data_offset
+          @host_os = host_os
+          @is_directory = is_directory
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar5/writer.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+require "stringio"
+require_relative "../rar/rar_format_base"
+require_relative "compressor"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 archive writer
+      #
+      # Writes RAR 5.x format archives, creating headers and compressing file
+      # data according to the RAR v5 specification.
+      #
+      # RAR 5 uses variable-length integers and improved header structure.
+      #
+      # @example Writing a RAR5 archive
+      #   writer = Rar5::Writer.new
+      #   File.open("archive.rar", "wb") do |file|
+      #     entries = [
+      #       {name: "file.txt", data: "content", time: Time.now}
+      #     ]
+      #     writer.write_archive(file, entries)
+      #   end
+      class Writer < Rar::RarFormatBase
+        # Initialize a RAR v5 writer
+        def initialize
+          super("rar5")
+          @compressor = Compressor.new
+        end
+
+        # Write a RAR v5 archive
+        #
+        # @param io [IO] The output stream
+        # @param entries [Array<Hash>] The entries to write
+        # @return [void]
+        def write_archive(io, entries)
+          # Write magic bytes
+          io.write(spec.magic_bytes.pack("C*"))
+
+          # Write main header
+          write_main_header(io)
+
+          # Write file entries
+          entries.each do |entry|
+            write_file_entry(io, entry)
+          end
+
+          # Write end marker
+          write_end_marker(io)
+        end
+
+        private
+
+        # Write main archive header
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_main_header(io)
+          flags = 0
+
+          header_data = StringIO.new
+          write_vint(header_data, flags)
+
+          write_header(
+            io,
+            type: block_type_code(:main_header),
+            flags: 0,
+            data: header_data.string,
+          )
+        end
+
+        # Write a file entry
+        #
+        # @param io [IO] The output stream
+        # @param entry [Hash] The entry data
+        # @return [void]
+        def write_file_entry(io, entry)
+          name = entry[:name] || entry["name"]
+          data = entry[:data] || entry["data"]
+          mtime = entry[:time] || entry["time"] || Time.now
+          method = entry[:method] || entry["method"] || :normal
+
+          # Compress data
+          compressed_data = @compressor.compress(data, method: method)
+
+          # Calculate sizes and CRC
+          compressed_data.bytesize
+          unpacked_size = data.bytesize
+          file_crc = calculate_crc32(data)
+
+          # Encode filename to UTF-8
+          name_bytes = name.encode("UTF-8")
+          name_length = name_bytes.bytesize
+
+          # Build file header data
+          file_flags = spec.format.file_header_flags[:time_present] |
+            spec.format.file_header_flags[:crc32_present]
+
+          compression_info = compression_method_code(method) & 0x07
+
+          header_data = StringIO.new
+          write_vint(header_data, file_flags)
+          write_vint(header_data, unpacked_size)
+          write_vint(header_data, 0x20) # Attributes (normal file)
+
+          # Write modification time
+          write_file_time(header_data, mtime)
+
+          # Write CRC32
+          header_data.write([file_crc].pack("V"))
+
+          # Write compression info
+          write_vint(header_data, compression_info)
+          write_vint(header_data, spec.format.host_os[:windows])
+          write_vint(header_data, name_length)
+          header_data.write(name_bytes)
+
+          # Write header with data
+          write_header(
+            io,
+            type: block_type_code(:file_header),
+            flags: 0x0002, # Has data size
+            data: header_data.string,
+            data_section: compressed_data,
+          )
+        end
+
+        # Write end marker
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_end_marker(io)
+          write_header(
+            io,
+            type: block_type_code(:end_marker),
+            flags: 0x0004, # Archive end flag
+            data: "",
+          )
+        end
+
+        # Write a RAR v5 header
+        #
+        # @param io [IO] The output stream
+        # @param type [Integer] The header type
+        # @param flags [Integer] The header flags
+        # @param data [String] The header data
+        # @param data_section [String, nil] Optional data section
+        # @return [void]
+        def write_header(io, type:, flags:, data:, data_section: nil)
+          header_io = StringIO.new
+
+          # Calculate header size (not including CRC)
+          size_bytes = StringIO.new
+          write_vint(size_bytes, type)
+          write_vint(size_bytes, flags)
+
+          if data_section
+            flags |= 0x0002 # Has data size flag
+            write_vint(size_bytes, data_section.bytesize)
+          end
+
+          size_bytes.write(data)
+
+          header_size = size_bytes.string.bytesize
+
+          # Write size vint
+          write_vint(header_io, header_size)
+
+          # Write type and flags
+          write_vint(header_io, type)
+          write_vint(header_io, flags)
+
+          # Write data size if present
+          write_vint(header_io, data_section.bytesize) if data_section
+
+          # Write header data
+          header_io.write(data)
+
+          # Calculate CRC32 of header (excluding CRC field itself)
+          header_crc = calculate_crc32(header_io.string)
+
+          # Write CRC and header to output
+          io.write([header_crc].pack("V"))
+          io.write(header_io.string)
+
+          # Write data section if present
+          io.write(data_section) if data_section
+        end
+
+        # Write file time in RAR5 format
+        #
+        # @param io [IO] The output stream
+        # @param time [Time] The time to write
+        # @return [void]
+        def write_file_time(io, time)
+          # RAR5 uses Windows FILETIME format (100-nanosecond intervals since
+          # 1601-01-01). Simplified implementation.
+          unix_time = time.to_i
+          windows_time = (unix_time + 11_644_473_600) * 10_000_000
+
+          write_vint(io, 0x01) # Time flags (modification time present)
+          io.write([windows_time].pack("Q<"))
+        end
+      end
+    end
+  end
+end