omnizip 0.3.39 → 0.3.41

data/lib/omnizip/converter/seven_zip_to_zip_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tmpdir"
+
 module Omnizip
   module Converter
     # Convert 7-Zip archives to ZIP format
@@ -8,18 +10,22 @@ module Omnizip
       # @return [ConversionResult] Conversion result
       def convert
         start_time = Time.now
-        0
 
-        # Open source 7z archive
         reader = Omnizip::Formats::SevenZip::Reader.new(source_path)
-        reader.read
+        reader.open
+        entry_count = reader.list_files.size
 
-        # Collect entries
-        entries_data = collect_seven_zip_entries(reader)
-        entry_count = entries_data.size
+        Dir.mktmpdir("omnizip_convert") do |tmp|
+          reader.extract_all(tmp)
 
-        # Create target ZIP archive
-        create_zip(entries_data)
+          writer = Omnizip::Formats::Zip::Writer.new(target_path)
+          Dir.glob(File.join(tmp, "**", "*")).each do |path|
+            next if File.directory?(path)
+
+            writer.add_file(path, path.delete_prefix("#{tmp}/"))
+          end
+          writer.write
+        end
 
         create_result(start_time, entry_count)
       end
@@ -43,50 +49,6 @@ module Omnizip
       def self.can_convert?(source, target)
         source.end_with?(".7z") && target.end_with?(".zip")
       end
-
-      private
-
-      def collect_seven_zip_entries(reader)
-        entries = []
-
-        reader.entries.each do |entry|
-          data = {
-            name: entry.name,
-            content: nil,
-            mtime: entry.mtime || Time.now,
-          }
-
-          # Extract entry data
-          unless entry.name.end_with?("/")
-            File.open(source_path, "rb") do |io|
-              data[:content] = reader.extract_entry_data(io, entry)
-            end
-          end
-
-          entries << data
-        end
-
-        entries
-      end
-
-      def create_zip(entries)
-        Omnizip::Zip::File.create(target_path) do |zip|
-          entries.each do |entry_data|
-            if entry_data[:name].end_with?("/")
-              # Directory entry
-              zip.add(entry_data[:name])
-            else
-              # File entry
-              zip.add(entry_data[:name]) { entry_data[:content] }
-            end
-          end
-
-          # Set archive comment if preserving metadata
-          if options.preserve_metadata
-            zip.comment = "Converted from 7z by Omnizip"
-          end
-        end
-      end
     end
   end
 end

data/lib/omnizip/converter/zip_to_seven_zip_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tmpdir"
+
 module Omnizip
   module Converter
     # Convert ZIP archives to 7-Zip format
@@ -10,14 +12,20 @@ module Omnizip
         start_time = Time.now
         entry_count = 0
 
-        # Open source ZIP archive
-        Omnizip::Zip::File.open(source_path) do |zip|
-          # Collect all entries and their data
-          entries_data = collect_entries(zip)
-          entry_count = entries_data.size
+        Dir.mktmpdir("omnizip_convert_zip") do |tmp|
+          # Extract the ZIP through the native reader; directories are
+          # implied by extracted file paths
+          Omnizip::Formats::Zip.extract(source_path, tmp)
+
+          writer = Omnizip::Formats::SevenZip::Writer.new(target_path,
+                                                          writer_options)
+          Dir.glob(File.join(tmp, "**", "*")).each do |path|
+            next if File.directory?(path)
 
-          # Create target 7z archive
-          create_seven_zip(entries_data)
+            entry_count += 1
+            writer.add_file(path, path.delete_prefix("#{tmp}/"))
+          end
+          writer.write
         end
 
         create_result(start_time, entry_count)
@@ -45,62 +53,12 @@ module Omnizip
 
       private
 
-      def collect_entries(zip)
-        entries = []
-
-        zip.entries.each do |entry|
-          data = {
-            name: entry.name,
-            directory: entry.directory?,
-            mtime: entry.time,
-            content: nil,
-          }
-
-          unless entry.directory?
-            data[:content] = zip.get_input_stream(entry)
-
-            if options.preserve_metadata && entry.unix_perms.positive?
-              data[:unix_perms] = entry.unix_perms
-            end
-          end
-
-          entries << data
-        end
-
-        entries
-      end
-
-      def create_seven_zip(entries)
-        writer = Omnizip::Formats::SevenZip::Writer.new(target_path)
-
-        # Set compression options
-        compression = options.compression || :lzma2
-        level = options.compression_level || 5
-        options.solid.nil? || options.solid
-
-        # Add each entry
-        entries.each do |entry_data|
-          if entry_data[:directory]
-            # 7z doesn't have explicit directory entries
-            # Directories are implied by file paths
-            next
-          end
-
-          writer.add_data(
-            entry_data[:name],
-            entry_data[:content],
-            algorithm: compression,
-            level: level,
-          )
-        end
-
-        # Apply filter if specified
-        if options.filter
-          add_warning("Filters not yet supported in 7z conversion")
-        end
-
-        # Write the archive
-        writer.write
+      # SevenZip::Writer takes algorithm/level/solid as keywords
+      def writer_options
+        {
+          algorithm: options.compression || :lzma2,
+          level: options.compression_level || 5,
+        }
       end
     end
   end

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

@@ -45,6 +45,7 @@ module Omnizip
         # @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)
@@ -73,12 +74,23 @@ module Omnizip
             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.
-          entry.name = entry.name.tr("\\", "/")
+          # 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
@@ -111,7 +123,14 @@ module Omnizip
           remaining = head_size - (name_size + 32)
           remaining -= 8 if head_flags.anybits?(FILE_LARGE)
           io.read(remaining) if remaining.positive?
-          io.read(pack_size) # Skip compressed data
+          # 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
@@ -135,6 +154,10 @@ module Omnizip
           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)
@@ -155,7 +178,7 @@ module Omnizip
 
           # Read file name
           name_bytes = io.read(name_length)
-          entry.name = name_bytes.force_encoding("UTF-8")
+          entry.name = name_bytes.to_s.scrub.force_encoding("UTF-8")
 
           # Set entry properties
           entry.size = unpack_size
@@ -168,13 +191,26 @@ module Omnizip
           entry.is_dir = file_flags.anybits?(RAR5_FLAG_IS_DIR)
           entry.version = 5
 
-          # Skip extra area, then compressed data
+          # 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?
-          io.read(data_size) if data_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

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

@@ -236,18 +236,45 @@ module Omnizip
           end
 
           # Extract entry with command
+          #
+          # unrar cannot extract a single entry without walking the
+          # archive, so the archive spills to a cache directory ONCE
+          # per archive path; subsequent extractions copy out of the
+          # cache instead of re-running unrar over the whole file.
           def extract_entry_with_command(archive_path, entry_name,
                                          output_path, password)
-            temp_dir = Dir.mktmpdir
-            cmd = build_extract_command(archive_path, temp_dir, password)
-            unless system(*cmd)
-              raise "Command entry extraction failed: #{entry_name}"
+            cache_key = begin
+              File.realpath(archive_path)
+            rescue StandardError
+              archive_path
+            end
+
+            cached_dir = extract_cache[cache_key]
+            unless cached_dir
+              cached_dir = Dir.mktmpdir("omnizip_unrar")
+              cmd = build_extract_command(archive_path, cached_dir, password)
+              unless system(*cmd)
+                FileUtils.rm_rf(cached_dir)
+                raise "Command entry extraction failed: #{entry_name}"
+              end
+              extract_cache[cache_key] = cached_dir
             end
 
-            source = File.join(temp_dir, entry_name)
-            FileUtils.mv(source, output_path) if File.exist?(source)
-          ensure
-            FileUtils.rm_rf(temp_dir) if temp_dir
+            source = File.join(cached_dir, entry_name)
+            FileUtils.cp(source, output_path) if File.exist?(source)
+          end
+
+          # Extracted-archive cache: archive path => spill directory.
+          # Cleared by .clear_extract_cache! (tests); directories live
+          # in the system temp dir until process exit.
+          def extract_cache
+            @extract_cache ||= {}
+          end
+
+          # Drop the extraction cache and remove its directories
+          def clear_extract_cache!
+            extract_cache.each_value { |dir| FileUtils.rm_rf(dir) }
+            extract_cache.clear
           end
 
           # Build extract command

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

@@ -85,7 +85,9 @@ module Omnizip
         # Parse RAR4 header
         #
         # The 7-byte signature consumed by #parse IS the marker
-        # block, so the main header follows immediately.
+        # block, so the main header follows immediately. Minimal
+        # archives skip the main header and start with a file block —
+        # accept those by rewinding to the block.
         #
         # @param io [IO] Input stream
         def parse_rar4_header(io)
@@ -94,6 +96,12 @@ module Omnizip
           head_flags = read_uint16(io)
           head_size = read_uint16(io)
 
+          if head_type == BLOCK_FILE
+            io.seek(-7, ::IO::SEEK_CUR)
+            @flags = 0
+            return
+          end
+
           unless head_type == BLOCK_ARCHIVE
             raise "Expected archive block, got 0x#{head_type.to_s(16)}"
           end
@@ -117,11 +125,20 @@ module Omnizip
           # RAR5 uses variable-length integer encoding. Layout per the
           # RAR 5.0 format: HeaderCRC32(4), Header size(vint), Header
           # type(vint), Header flags(vint), then type-specific fields.
+          header_start = io.pos
           read_uint32(io)
           read_vint(io) # header size (redundant: areas carry their own)
           header_type = read_vint(io)
           header_flags = read_vint(io)
 
+          # Minimal archives skip the main header and start with a
+          # file header (type 2) — rewind so block iteration reads it
+          if header_type == RAR5_HEADER_FILE
+            io.seek(header_start, ::IO::SEEK_SET)
+            @flags = 0
+            return
+          end
+
           unless header_type == RAR5_HEADER_MAIN
             raise "Expected main header, got #{header_type}"
           end

data/lib/omnizip/formats/rar/models/rar_entry.rb

@@ -10,7 +10,7 @@ module Omnizip
           attr_accessor :name, :size, :compressed_size, :crc, :is_dir,
                         :host_os, :mtime, :attributes, :method,
                         :version, :flags, :volume_index, :split_before,
-                        :split_after, :encrypted
+                        :split_after, :encrypted, :data_offset
 
           # Initialize RAR entry
           def initialize

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

@@ -268,7 +268,7 @@ module Omnizip
           # fall back to unrar.
           data = output.string
           if entry.crc && Zlib.crc32(data) != entry.crc
-            raise Compression::DecompressionError,
+            raise Compression::Dispatcher::DecompressionError,
                   "CRC mismatch for #{entry.name}"
           end
 
@@ -296,19 +296,26 @@ module Omnizip
         # @param entry [Models::RarEntry] File entry
         # @return [StringIO] Compressed data stream
         def read_compressed_data(entry)
-          # Find the entry's data offset in the archive
+          # 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|
-            # 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
 
@@ -317,45 +324,33 @@ module Omnizip
 
               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
+                io.read(2) # FLAGS
                 size = io.read(2)&.unpack1("v") || 0
 
-                # Skip rest of block (size includes TYPE+FLAGS+SIZE = 5 bytes)
-                remaining = size - 5
+                # 7 bytes consumed (CRC/TYPE/FLAGS/SIZE); skip the rest
+                remaining = size - 7
                 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
+                data_start = io.pos - entry.compressed_size
 
                 io.seek(data_start)
-                compressed = io.read(entry.compressed_size)
-
-                return StringIO.new(compressed)
+                return StringIO.new(io.read(entry.compressed_size) || "")
               end
             end
           end
 
-          # If we didn't find it, return empty
           StringIO.new("")
         end
       end

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

@@ -169,7 +169,7 @@ module Omnizip
             warn "RAR4 writer ignores volume_size: not implemented " \
                  "(no corresponding flag is written)"
           end
-          return unless @options[:recovery].to_i.positive?
+          return unless @options[:recovery]&.to_i&.positive?
 
           warn "RAR4 writer ignores recovery: not implemented " \
                "(no corresponding flag is written)"

data/lib/omnizip/formats/rar.rb

@@ -125,6 +125,27 @@ module Omnizip
       end
 
       class << self
+        # Create a RAR archive, yielding the writer for entries.
+        # RAR5 is the default; pass version: 4 for the RAR4 writer.
+        # RAR5-only options (solid, multi-volume, password, recovery)
+        # are ignored for RAR4 — its writer warns about the
+        # unimplemented ones and raises for passwords.
+        #
+        # @param path [String] Output archive path
+        # @param options [Hash] Writer options
+        # @return [String, Array<String>] Path(s) of the created
+        #   archive (a volume set returns every volume)
+        def create(path, options = {})
+          version = options.fetch(:version, 5)
+          writer = if version == 4
+                     Writer.new(path, options)
+                   else
+                     Rar5::Writer.new(path, rar5_options(options))
+                   end
+          yield writer if block_given?
+          writer.write
+        end
+
         # Check if RAR extraction is available
         #
         # @return [Boolean] true if unrar available
@@ -155,6 +176,16 @@ module Omnizip
         def repair(archive_path, output_path)
           ArchiveRepairer.new.repair(archive_path, output_path)
         end
+
+        private
+
+        # Writer keywords the RAR5 writer understands
+        def rar5_options(options)
+          options.slice(:compression, :level, :solid, :multi_volume,
+                        :volume_size, :volume_naming, :password,
+                        :kdf_iterations, :recovery, :recovery_percent,
+                        :include_mtime, :include_crc32, :dict_size)
+        end
       end
     end
   end