omnizip 0.3.1

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR header parser
+      # Parses RAR4 and RAR5 archive headers
+      class Header
+        include Constants
+
+        attr_reader :version, :flags, :is_multi_volume, :is_solid,
+                    :is_locked, :comment_present
+
+        # Read and parse RAR header
+        #
+        # @param io [IO] Input stream
+        # @return [Header] Parsed header
+        # @raise [RuntimeError] if invalid header
+        def self.read(io)
+          new.tap { |h| h.parse(io) }
+        end
+
+        # Initialize header
+        def initialize
+          @version = nil
+          @flags = 0
+          @is_multi_volume = false
+          @is_solid = false
+          @is_locked = false
+          @comment_present = false
+        end
+
+        # Parse header from IO
+        #
+        # @param io [IO] Input stream
+        # @raise [RuntimeError] if invalid header
+        def parse(io)
+          # RAR4 signature is 7 bytes, RAR5 is 8 bytes
+          # Read 7 bytes first to check for RAR4
+          signature = io.read(7)
+          return unless signature
+
+          sig_bytes = signature.bytes
+
+          if sig_bytes == RAR4_SIGNATURE
+            @version = 4
+            parse_rar4_header(io)
+          elsif sig_bytes == RAR5_SIGNATURE[0..6]
+            # Might be RAR5, read one more byte
+            extra_byte = io.read(1)
+            if extra_byte && (sig_bytes + extra_byte.bytes) == RAR5_SIGNATURE
+              @version = 5
+              parse_rar5_header(io)
+            else
+              raise "Invalid RAR signature: #{(sig_bytes + (extra_byte&.bytes || [])).inspect}"
+            end
+          else
+            raise "Invalid RAR signature: #{sig_bytes.inspect}"
+          end
+        end
+
+        # Check if header is valid
+        #
+        # @return [Boolean] true if valid
+        def valid?
+          !@version.nil?
+        end
+
+        # Check if RAR5 format
+        #
+        # @return [Boolean] true if RAR5
+        def rar5?
+          @version == 5
+        end
+
+        # Check if RAR4 format
+        #
+        # @return [Boolean] true if RAR4
+        def rar4?
+          @version == 4
+        end
+
+        private
+
+        # Parse RAR4 header
+        #
+        # @param io [IO] Input stream
+        def parse_rar4_header(io)
+          # Read marker block
+          read_uint16(io)
+          head_type = io.read(1)&.ord
+          read_uint16(io)
+          read_uint16(io)
+
+          unless head_type == BLOCK_MARKER
+            raise "Expected marker block, got 0x#{head_type.to_s(16)}"
+          end
+
+          # Read archive header
+          read_uint16(io)
+          head_type = io.read(1)&.ord
+          head_flags = read_uint16(io)
+          head_size = read_uint16(io)
+
+          unless head_type == BLOCK_ARCHIVE
+            raise "Expected archive block, got 0x#{head_type.to_s(16)}"
+          end
+
+          @flags = head_flags
+          @is_multi_volume = head_flags.anybits?(ARCHIVE_VOLUME)
+          @is_solid = head_flags.anybits?(ARCHIVE_SOLID)
+          @is_locked = head_flags.anybits?(ARCHIVE_LOCKED)
+          @comment_present = head_flags.anybits?(ARCHIVE_COMMENT)
+
+          # Skip rest of archive header
+          # head_size includes TYPE(1) + FLAGS(2) + SIZE(2) = 5 bytes already read
+          remaining = head_size - 5
+          io.read(remaining) if remaining.positive?
+        end
+
+        # Parse RAR5 header
+        #
+        # @param io [IO] Input stream
+        def parse_rar5_header(io)
+          # RAR5 uses variable-length integer encoding
+          read_uint32(io)
+          read_vint(io)
+          header_type = read_vint(io)
+          header_flags = read_vint(io)
+
+          unless header_type == RAR5_HEADER_MAIN
+            raise "Expected main header, got #{header_type}"
+          end
+
+          @flags = header_flags
+          @is_multi_volume = header_flags.anybits?(RAR5_FLAG_MULTI_VOLUME)
+
+          # Read extra area if present
+          return unless header_flags.anybits?(RAR5_FLAG_EXTRA_AREA)
+
+          extra_size = read_vint(io)
+          io.read(extra_size) if extra_size.positive?
+        end
+
+        # Read 16-bit unsigned integer (little-endian)
+        #
+        # @param io [IO] Input stream
+        # @return [Integer] Value
+        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)
+        #
+        # @param io [IO] Input stream
+        # @return [Integer] Value
+        def read_uint32(io)
+          bytes = io.read(4)
+          return 0 unless bytes&.size == 4
+
+          bytes.unpack1("V")
+        end
+
+        # Read variable-length integer (RAR5)
+        #
+        # @param io [IO] Input stream
+        # @return [Integer] Value
+        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

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # Validates WinRAR license ownership
+      #
+      # This class ensures users confirm they own a valid WinRAR license
+      # before allowing RAR archive creation, as RAR compression is proprietary.
+      class LicenseValidator
+        class << self
+          # Check if user has confirmed license ownership
+          #
+          # @return [Boolean] true if license confirmed
+          def license_confirmed?
+            File.exist?(license_file_path) && valid_confirmation?
+          end
+
+          # Prompt user to confirm license and save confirmation
+          #
+          # @return [Boolean] true if user confirms
+          def confirm_license!
+            return true if license_confirmed?
+
+            puts "\n#{'=' * 70}"
+            puts "RAR License Confirmation Required"
+            puts "=" * 70
+            puts
+            puts "RAR compression is proprietary and requires a WinRAR license."
+            puts "By proceeding, you confirm that you own a valid WinRAR license."
+            puts
+            puts "License information:"
+            puts "  - License can be purchased at: https://www.rarlab.com/"
+            puts "  - Price: ~$29 for single user license"
+            puts "  - License is perpetual (no subscription)"
+            puts
+            print "Do you own a valid WinRAR license? (yes/no): "
+
+            response = $stdin.gets&.strip&.downcase
+
+            if response == "yes"
+              save_confirmation
+              puts "\nLicense confirmed. You can now create RAR archives."
+              true
+            else
+              puts "\nRAR creation requires a valid license."
+              puts "Consider using 7z format as a free alternative."
+              false
+            end
+          end
+
+          # Reset license confirmation
+          #
+          # This removes the saved confirmation file
+          def reset_confirmation
+            FileUtils.rm_f(license_file_path)
+          end
+
+          private
+
+          # Get path to license confirmation file
+          #
+          # @return [String] Path to confirmation file
+          def license_file_path
+            config_dir = File.join(Dir.home, ".omnizip")
+            FileUtils.mkdir_p(config_dir)
+            File.join(config_dir, "rar_license_confirmed")
+          end
+
+          # Save license confirmation
+          def save_confirmation
+            File.write(license_file_path, confirmation_data)
+          end
+
+          # Validate saved confirmation
+          #
+          # @return [Boolean] true if confirmation is valid
+          def valid_confirmation?
+            data = File.read(license_file_path)
+            data.include?("CONFIRMED") && data.include?(Time.now.year.to_s)
+          rescue StandardError
+            false
+          end
+
+          # Generate confirmation data
+          #
+          # @return [String] Confirmation data
+          def confirmation_data
+            <<~CONF
+              WinRAR License Confirmation
+              Confirmed at: #{Time.now.iso8601}
+              Year: #{Time.now.year}
+              User: #{ENV['USER'] || ENV['USERNAME'] || 'unknown'}
+              Hostname: #{begin
+                Socket.gethostname
+              rescue StandardError
+                'unknown'
+              end}
+              Status: CONFIRMED
+
+              This file indicates that the user has confirmed ownership
+              of a valid WinRAR license for creating RAR archives.
+            CONF
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Models
+        # Represents a RAR archive with metadata
+        class RarArchive
+          attr_accessor :path, :version, :flags, :volumes, :entries,
+                        :total_size, :compressed_size, :is_multi_volume,
+                        :comment, :has_recovery, :recovery_percent,
+                        :recovery_files
+
+          # Initialize RAR archive
+          #
+          # @param path [String] Path to RAR archive
+          def initialize(path)
+            @path = path
+            @version = nil
+            @flags = 0
+            @volumes = []
+            @entries = []
+            @total_size = 0
+            @compressed_size = 0
+            @is_multi_volume = false
+            @comment = nil
+            @has_recovery = false
+            @recovery_percent = 0
+            @recovery_files = []
+          end
+
+          # Check if archive has recovery records
+          #
+          # @return [Boolean] true if recovery available
+          def has_recovery_records?
+            @has_recovery || @recovery_files.any?
+          end
+
+          # Get recovery file paths
+          #
+          # @return [Array<String>] Paths to .rev files
+          def recovery_file_paths
+            @recovery_files
+          end
+
+          # Check if archive is multi-volume
+          #
+          # @return [Boolean] true if multi-volume archive
+          def multi_volume?
+            @is_multi_volume
+          end
+
+          # Get total number of volumes
+          #
+          # @return [Integer] Number of volumes
+          def total_volumes
+            @volumes.size
+          end
+
+          # Get RAR format version string
+          #
+          # @return [String] Version string (RAR4 or RAR5)
+          def format_version
+            @version == 5 ? "RAR5" : "RAR4"
+          end
+
+          # Get total number of entries
+          #
+          # @return [Integer] Number of entries
+          def entry_count
+            @entries.size
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Models
+        # Represents a file entry in RAR archive
+        # Contains file metadata and extraction information
+        class RarEntry
+          attr_accessor :name, :size, :compressed_size, :crc, :is_dir,
+                        :host_os, :mtime, :attributes, :method,
+                        :version, :flags, :volume_index, :split_before,
+                        :split_after, :encrypted
+
+          # Initialize RAR entry
+          def initialize
+            @name = nil
+            @size = 0
+            @compressed_size = 0
+            @crc = nil
+            @is_dir = false
+            @host_os = 0
+            @mtime = nil
+            @attributes = nil
+            @method = 0
+            @version = 0
+            @flags = 0
+            @volume_index = 0
+            @split_before = false
+            @split_after = false
+            @encrypted = false
+          end
+
+          # Check if entry is a directory
+          #
+          # @return [Boolean] true if directory
+          def directory?
+            @is_dir
+          end
+
+          # Check if entry is a file
+          #
+          # @return [Boolean] true if regular file
+          def file?
+            !@is_dir
+          end
+
+          # Check if entry is encrypted
+          #
+          # @return [Boolean] true if encrypted
+          def encrypted?
+            @encrypted
+          end
+
+          # Check if entry spans volumes
+          #
+          # @return [Boolean] true if split across volumes
+          def split?
+            @split_before || @split_after
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Models
+        # Represents a RAR volume in a multi-volume set
+        class RarVolume
+          attr_accessor :path, :volume_number, :is_first, :is_last,
+                        :size, :archive_flags
+
+          # Initialize RAR volume
+          #
+          # @param path [String] Path to volume file
+          # @param volume_number [Integer] Volume number (0-based)
+          def initialize(path, volume_number = 0)
+            @path = path
+            @volume_number = volume_number
+            @is_first = false
+            @is_last = false
+            @size = nil
+            @archive_flags = 0
+          end
+
+          # Check if this is the first volume
+          #
+          # @return [Boolean] true if first volume
+          def first?
+            @is_first
+          end
+
+          # Check if this is the last volume
+          #
+          # @return [Boolean] true if last volume
+          def last?
+            @is_last
+          end
+
+          # Get volume file size
+          #
+          # @return [Integer] File size in bytes
+          def file_size
+            @file_size ||= File.size(@path)
+          end
+
+          # Check if file exists
+          #
+          # @return [Boolean] true if volume file exists
+          def exist?
+            File.exist?(@path)
+          end
+        end
+      end
+    end
+  end
+end