omnizip 0.3.1

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

@@ -0,0 +1,386 @@
+# 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 Rar3
+      # RAR v3 archive reader
+      #
+      # Reads RAR 3.x format archives, parsing headers and extracting file data
+      # according to the RAR v3 specification.
+      #
+      # @example Reading a RAR3 archive
+      #   reader = Rar3::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 v3 reader
+        def initialize
+          super("rar3")
+        end
+
+        # Read a RAR v3 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 v3 signature"
+          end
+
+          entries = []
+
+          # RAR4 marker is the signature itself (7 bytes): "Rar!\x1a\x07\x00"
+          # Skip past the marker to read the archive header
+          io.seek(7, ::IO::SEEK_SET)
+
+          # Read first block - could be archive header or file block (for minimal archives)
+          first_block = read_block_header(io)
+
+          if first_block.type == block_type_code(:archive)
+            # Standard archive with archive header
+            @archive_flags = first_block.flags
+
+            # Skip past archive header block (header + data)
+            # SIZE field contains total block size
+            block_end = first_block.header_start + first_block.size
+            io.seek(block_end, ::IO::SEEK_SET)
+          elsif first_block.type == block_type_code(:file)
+            # Minimal archive without archive header - process as file block
+            entry = read_file_entry(io, first_block)
+            entries << entry if entry
+          else
+            raise FormatError, "Expected archive header or file header, got type #{first_block.type}"
+          end
+
+          # Read file blocks until end
+          loop do
+            block = read_block_header(io)
+            break if block.type == block_type_code(:terminator)
+
+            case block.type
+            when block_type_code(:file)
+              entry = read_file_entry(io, block)
+              entries << entry if entry
+            when block_type_code(:comment)
+              read_comment_block(io, block)
+            when block_type_code(:recovery)
+              skip_block_data(io, block)
+            else
+              skip_block_data(io, block)
+            end
+          end
+
+          entries
+        rescue EOFError, FormatError
+          # Handle truncated or malformed files gracefully
+          entries
+        end
+
+        private
+
+        # Read a block header
+        #
+        # @param io [IO] The input stream
+        # @return [BlockHeader] The block header
+        def read_block_header(io)
+          # Record position BEFORE reading header
+          header_start = io.pos
+
+          header_crc = io.read(2)&.unpack1("v")
+          type = io.read(1)&.unpack1("C")
+          flags = io.read(2)&.unpack1("v")
+          size = io.read(2)&.unpack1("v")
+
+          raise FormatError, "Unexpected EOF" unless size
+
+          # For FILE blocks, the SIZE field directly contains the total header size
+          # The file_header structure starts immediately after the 7-byte block header
+          # No additional 4-byte field needed for FILE blocks
+          header_size = 7 # CRC(2) + TYPE(1) + FLAGS(2) + SIZE(2)
+
+          BlockHeader.new(
+            crc: header_crc,
+            type: type,
+            flags: flags,
+            size: size,
+            header_start: header_start,
+            header_size: header_size,
+          )
+        end
+
+        # Skip to the data portion of a block (after header)
+        #
+        # @param io [IO] The input stream
+        # @param block [BlockHeader] The block header
+        def skip_to_block_data(io, block)
+          target_pos = block.header_start + block.header_size
+          current_pos = io.pos
+          if target_pos > current_pos
+            io.seek(target_pos, ::IO::SEEK_SET)
+          end
+        end
+
+        # Read a file entry from archive
+        #
+        # @param io [IO] The input stream
+        # @param block [BlockHeader] The file block header
+        # @return [Entry] The file entry
+        def read_file_entry(io, block)
+          # The SIZE field contains the total size of the block header (including data after 7-byte prefix)
+          # The data portion after the 7-byte block header is: size - 7 bytes
+          block.header_start + 7 # Start of header data after 7-byte prefix
+          header_data_size = block.size - 7
+
+          # Read all header data at once
+          header_data = io.read(header_data_size)
+          raise FormatError, "Unexpected EOF reading file header" unless header_data
+
+          # Now parse the file_header from the start of header_data
+          pos = 0
+
+          packed_size = header_data[pos, 4].unpack1("V")
+          pos += 4
+
+          unpacked_size = header_data[pos, 4].unpack1("V")
+          pos += 4
+
+          host_os = header_data[pos, 1].unpack1("C")
+          pos += 1
+
+          file_crc = header_data[pos, 4].unpack1("V")
+          pos += 4
+
+          file_time = header_data[pos, 4].unpack1("V")
+          pos += 4
+
+          header_data[pos, 1].unpack1("C")
+          pos += 1
+
+          method = header_data[pos, 1].unpack1("C")
+          pos += 1
+
+          name_size = header_data[pos, 2].unpack1("v")
+          pos += 2
+
+          attr = header_data[pos, 4].unpack1("V")
+          pos += 4
+
+          # Read filename
+          name_bytes = header_data[pos, name_size]
+          pos += name_size
+          filename = decode_filename(name_bytes, block.flags)
+
+          # Handle large file sizes
+          if block.flags & 0x0100 != 0 # large_file flag
+            high_packed = header_data[pos, 4].unpack1("V")
+            high_unpacked = header_data[pos + 4, 4].unpack1("V")
+            packed_size |= (high_packed << 32)
+            unpacked_size |= (high_unpacked << 32)
+            pos += 8
+          end
+
+          # Read salt if encrypted
+          salt = nil
+          if block.flags & 0x0400 != 0 # salt flag
+            salt = header_data[pos, 8]
+            pos += 8
+          end
+
+          # Read extended time if present
+          mtime = parse_dos_time(file_time)
+          if block.flags & 0x1000 != 0 # ext_time flag
+            # Extended time format: mtime[4] + ctime[4] + atime[4] + arctime[4] + flags
+            # Plus additional 3 bytes for each present time
+            mtime, = read_extended_time_data(header_data, pos)
+          end
+
+          # We've already read all header data, no need to seek
+          # Just skip to end of block and then past file data
+
+          # Record data offset (start of file data)
+          data_offset = block.header_start + block.size
+
+          # Current position should be at end of header data
+          # Skip past file data to prepare for next block
+          # Use read instead of seek for better compatibility with non-seekable streams
+          if packed_size.positive?
+            begin
+              io.seek(packed_size, ::IO::SEEK_CUR)
+            rescue Errno::EINVAL, Errno::ESPIPE
+              # Stream doesn't support seeking - read and discard instead
+              remaining = packed_size
+              while remaining.positive?
+                chunk = io.read([remaining, 8192].min)
+                break unless chunk
+
+                remaining -= chunk.bytesize
+              end
+            end
+          end
+
+          Entry.new(
+            name: filename,
+            compressed_size: packed_size,
+            uncompressed_size: unpacked_size,
+            crc32: file_crc,
+            compression_method: compression_method_name(method),
+            modified_time: mtime,
+            attributes: attr,
+            encrypted: block.flags.anybits?(0x0004), # encrypted flag
+            data_offset: data_offset,
+            host_os: host_os,
+            salt: salt,
+          )
+        end
+
+        # Read extended time from header data
+        #
+        # @param data [String] The header data
+        # @param pos [Integer] Current position in data
+        # @return [Array<Time, Integer>] The modification time and new position
+        def read_extended_time_data(data, pos)
+          return [Time.now, pos] if pos + 4 > data.bytesize
+
+          mtime = parse_dos_time(data[pos, 4].unpack1("V"))
+          pos += 4
+
+          # Skip ctime, atime, arctime if present
+          begin
+            data[pos, 1].unpack1("C")
+          rescue StandardError
+            0
+          end
+          pos += 1
+
+          # For now, just skip the remaining extended time data
+          # The format is complex and varies
+
+          [mtime, pos]
+        rescue ArgumentError
+          [Time.now, pos]
+        end
+
+        # Decode filename based on encoding flags
+        #
+        # @param bytes [String] The filename bytes
+        # @param flags [Integer] The file flags
+        # @return [String] The decoded filename
+        def decode_filename(bytes, flags)
+          if flags.nobits?(spec.format.file_flags[:unicode])
+            # Legacy encoding - assume CP437 or system encoding
+            bytes.force_encoding("CP437").encode("UTF-8", invalid: :replace)
+          else
+            # Unicode filename - decode UTF-8
+            bytes.force_encoding("UTF-8")
+          end
+        end
+
+        # Parse DOS date/time to Ruby Time
+        #
+        # @param dos_time [Integer] The DOS timestamp
+        # @return [Time] The parsed time
+        def parse_dos_time(dos_time)
+          second = (dos_time & 0x1F) * 2
+          minute = (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, minute, second)
+        rescue ArgumentError
+          Time.now
+        end
+
+        # Read extended time information
+        #
+        # @param io [IO] The input stream
+        # @return [Time] The extended time
+        def read_extended_time(io)
+          io.read(2)&.unpack1("v")
+          # Extended time format varies, simplified implementation
+          Time.now
+        end
+
+        # Read comment block
+        #
+        # @param io [IO] The input stream
+        # @param block [BlockHeader] The block header
+        # @return [String] The comment text
+        def read_comment_block(io, block)
+          current_pos = io.pos
+          header_end = block.header_start + block.header_size
+          data_size = block.size - block.header_size
+          remaining = data_size - (current_pos - header_end)
+          comment = io.read(remaining) if remaining.positive?
+          comment&.force_encoding("UTF-8")
+        end
+
+        # Skip block data
+        #
+        # @param io [IO] The input stream
+        # @param block [BlockHeader] The block header
+        # @return [void]
+        def skip_block_data(io, block)
+          # block.size is the total size, calculate remaining bytes
+          current_pos = io.pos
+          header_end = block.header_start + block.header_size
+          data_size = block.size - block.header_size
+          remaining = data_size - (current_pos - header_end)
+          io.seek(remaining, ::IO::SEEK_CUR) if remaining.positive?
+        end
+      end
+
+      # RAR v3 block header model
+      class BlockHeader
+        attr_accessor :crc, :type, :flags, :size, :header_start, :header_size
+
+        def initialize(crc: nil, type: nil, flags: nil, size: nil,
+                       header_start: nil, header_size: 7)
+          @crc = crc
+          @type = type
+          @flags = flags
+          @size = size
+          @header_start = header_start
+          @header_size = header_size
+        end
+      end
+
+      # RAR archive entry model
+      class Entry
+        attr_accessor :name, :compressed_size, :uncompressed_size, :crc32,
+                      :compression_method, :modified_time, :attributes,
+                      :encrypted, :data_offset, :host_os, :salt
+
+        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, salt: 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
+          @salt = salt
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# 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 Rar3
+      # RAR v3 archive writer
+      #
+      # Writes RAR 3.x format archives, creating headers and compressing file
+      # data according to the RAR v3 specification.
+      #
+      # @example Writing a RAR3 archive
+      #   writer = Rar3::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 v3 writer
+        def initialize
+          super("rar3")
+          @compressor = Compressor.new
+        end
+
+        # Write a RAR v3 archive
+        #
+        # @param io [IO] The output stream
+        # @param entries [Array<Hash>] The entries to write
+        # @return [void]
+        def write_archive(io, entries)
+          # Write marker block
+          write_marker_block(io)
+
+          # Write archive header
+          write_archive_header(io)
+
+          # Write file entries
+          entries.each do |entry|
+            write_file_entry(io, entry)
+          end
+
+          # Write terminator block
+          write_terminator_block(io)
+        end
+
+        private
+
+        # Write marker block (RAR signature)
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_marker_block(io)
+          io.write(spec.magic_bytes.pack("C*"))
+        end
+
+        # Write archive header block
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_archive_header(io)
+          flags = 0
+          # Set default flags if needed
+
+          header_data = StringIO.new
+          # Reserved fields
+          header_data.write([0, 0].pack("vv"))
+
+          header = create_block_header(
+            type: block_type_code(:archive),
+            flags: flags,
+            data: header_data.string,
+          )
+
+          write_block_header(io, header)
+          io.write(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
+          packed_size = compressed_data.bytesize
+          unpacked_size = data.bytesize
+          file_crc = calculate_crc32(data)
+
+          # Encode filename
+          name_bytes = name.encode("UTF-8")
+          name_size = name_bytes.bytesize
+
+          # Set flags
+          flags = spec.format.file_flags[:unicode]
+          if unpacked_size > 0xFFFFFFFF
+            flags |= spec.format.file_flags[:large_file]
+          end
+
+          # Build file header data
+          header_data = StringIO.new
+          header_data.write([packed_size & 0xFFFFFFFF].pack("V"))
+          header_data.write([unpacked_size & 0xFFFFFFFF].pack("V"))
+          header_data.write([spec.format.host_os[:win32]].pack("C"))
+          header_data.write([file_crc].pack("V"))
+          header_data.write([encode_dos_time(mtime)].pack("V"))
+          header_data.write([0x14].pack("C"))  # Version needed
+          header_data.write([compression_method_code(method)].pack("C"))
+          header_data.write([name_size].pack("v"))
+          header_data.write([0x20].pack("V"))  # File attributes
+          header_data.write(name_bytes)
+
+          # Add high size fields if needed
+          if flags & spec.format.file_flags[:large_file] != 0
+            header_data.write([(packed_size >> 32) & 0xFFFFFFFF].pack("V"))
+            header_data.write([(unpacked_size >> 32) & 0xFFFFFFFF].pack("V"))
+          end
+
+          # Create and write block header
+          header = create_block_header(
+            type: block_type_code(:file),
+            flags: flags,
+            data: header_data.string,
+          )
+
+          write_block_header(io, header)
+          io.write(header_data.string)
+          io.write(compressed_data)
+        end
+
+        # Write terminator block
+        #
+        # @param io [IO] The output stream
+        # @return [void]
+        def write_terminator_block(io)
+          header = create_block_header(
+            type: block_type_code(:terminator),
+            flags: 0x4000, # Archive end flag
+            data: "",
+          )
+
+          write_block_header(io, header)
+        end
+
+        # Create a block header
+        #
+        # @param type [Integer] The block type
+        # @param flags [Integer] The block flags
+        # @param data [String] The block data
+        # @return [Hash] The block header
+        def create_block_header(type:, flags:, data:)
+          size = 7 + data.bytesize # Header size + data size
+
+          # Calculate header CRC
+          temp = StringIO.new
+          temp.write([type].pack("C"))
+          temp.write([flags].pack("v"))
+          temp.write([size].pack("v"))
+          temp.write(data) unless data.empty?
+
+          header_crc = calculate_crc32(temp.string) & 0xFFFF
+
+          {
+            crc: header_crc,
+            type: type,
+            flags: flags,
+            size: size,
+          }
+        end
+
+        # Write a block header to stream
+        #
+        # @param io [IO] The output stream
+        # @param header [Hash] The header data
+        # @return [void]
+        def write_block_header(io, header)
+          io.write([header[:crc]].pack("v"))
+          io.write([header[:type]].pack("C"))
+          io.write([header[:flags]].pack("v"))
+          io.write([header[:size]].pack("v"))
+        end
+
+        # Encode Ruby Time to DOS date/time format
+        #
+        # @param time [Time] The time to encode
+        # @return [Integer] The DOS timestamp
+        def encode_dos_time(time)
+          second = time.sec / 2
+          minute = time.min
+          hour = time.hour
+          day = time.day
+          month = time.month
+          year = time.year - 1980
+
+          (year << 25) | (month << 21) | (day << 16) |
+            (hour << 11) | (minute << 5) | second
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "../rar/rar_format_base"
+require_relative "../../error"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 compressor
+      #
+      # Compresses data using RAR v5 compression algorithms.
+      # This implementation uses DEFLATE as a compatible fallback
+      # for demonstration purposes. Full RAR5 compression requires
+      # proprietary algorithms.
+      #
+      # @example Compressing data
+      #   compressor = Rar5::Compressor.new
+      #   compressed = compressor.compress("Hello, World!", method: :normal)
+      class Compressor < Rar::RarFormatBase
+        # Initialize a RAR v5 compressor
+        def initialize
+          super("rar5")
+        end
+
+        # Compress data using RAR v5 methods
+        #
+        # @param data [String] The data to compress
+        # @param method [Symbol] The compression method
+        # @param options [Hash] Compression options
+        # @return [String] The compressed data
+        def compress(data, method: :normal, **_options)
+          case method
+          when :store
+            compress_store(data)
+          when :fastest
+            compress_deflate(data, level: Zlib::BEST_SPEED)
+          when :fast
+            compress_deflate(data, level: 3)
+          when :normal
+            compress_deflate(data, level: Zlib::DEFAULT_COMPRESSION)
+          when :good
+            compress_deflate(data, level: 7)
+          when :best
+            compress_deflate(data, level: Zlib::BEST_COMPRESSION)
+          else
+            raise FormatError,
+                  "Unsupported compression method: #{method}"
+          end
+        end
+
+        private
+
+        # Store data without compression
+        #
+        # @param data [String] The data to store
+        # @return [String] The uncompressed data
+        def compress_store(data)
+          data
+        end
+
+        # Compress using DEFLATE (compatible fallback)
+        #
+        # @param data [String] The data to compress
+        # @param level [Integer] The compression level
+        # @return [String] The compressed data
+        def compress_deflate(data, level:)
+          Zlib::Deflate.deflate(data, level)
+        end
+      end
+    end
+  end
+end