omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/iso/joliet.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # Joliet Extensions for ISO 9660
+      #
+      # Implements Microsoft's Joliet extensions to support long filenames
+      # (up to 64 characters) and Unicode (UCS-2) encoding in ISO 9660 images.
+      #
+      # Joliet creates a parallel directory structure in a Supplementary Volume
+      # Descriptor with UCS-2 encoded filenames, allowing Windows systems to
+      # display proper long filenames while maintaining ISO 9660 compatibility.
+      module Joliet
+        # Joliet escape sequences for UCS-2 encoding
+        # Level 1: %/@
+        # Level 2: %/C
+        # Level 3: %/E (most common, supports UCS-2)
+        ESCAPE_SEQUENCE_LEVEL_3 = "%/E"
+
+        # Maximum Joliet filename length in characters
+        MAX_FILENAME_LENGTH = 64
+
+        # Encode string to UCS-2 (UTF-16BE)
+        #
+        # @param str [String] String to encode
+        # @param max_length [Integer] Maximum length in characters
+        # @return [String] UCS-2 encoded string
+        def self.encode_ucs2(str, max_length = MAX_FILENAME_LENGTH)
+          # Truncate to max length
+          str = str[0, max_length] if str.length > max_length
+
+          # Encode to UTF-16BE (UCS-2)
+          str.encode("UTF-16BE")
+        rescue Encoding::UndefinedConversionError
+          # Fallback to ASCII if conversion fails
+          str.encode("UTF-16BE", undef: :replace, replace: "_")
+        end
+
+        # Decode UCS-2 string to UTF-8
+        #
+        # @param ucs2_data [String] UCS-2 encoded data
+        # @return [String] UTF-8 string
+        def self.decode_ucs2(ucs2_data)
+          ucs2_data.force_encoding("UTF-16BE").encode("UTF-8")
+        rescue Encoding::UndefinedConversionError
+          # Fallback if decoding fails
+          ucs2_data.force_encoding("UTF-16BE").encode("UTF-8",
+                                                      undef: :replace,
+                                                      replace: "?")
+        end
+
+        # Build Joliet directory record
+        #
+        # @param name [String] Entry name
+        # @param entry_info [Hash] Entry information
+        # @param is_directory [Boolean] Is this a directory
+        # @return [String] Joliet directory record
+        def self.build_directory_record(name, entry_info, is_directory: false)
+          # Encode name to UCS-2
+          name_ucs2 = encode_ucs2(name)
+          name_len = name_ucs2.bytesize
+
+          # Calculate record length
+          # No padding needed for UCS-2 names (always even length)
+          record_len = 33 + name_len
+
+          record = +""
+
+          # Byte 0: Length of directory record
+          record << [record_len].pack("C")
+
+          # Byte 1: Extended attribute record length
+          record << [0].pack("C")
+
+          # Bytes 2-9: Location of extent (both-endian)
+          location = entry_info[:location] || 0
+          record << [location].pack("V")
+          record << [location].pack("N")
+
+          # Bytes 10-17: Data length (both-endian)
+          data_length = entry_info[:size] || 0
+          record << [data_length].pack("V")
+          record << [data_length].pack("N")
+
+          # Bytes 18-24: Recording date and time
+          mtime = entry_info[:mtime] || entry_info[:stat]&.mtime || Time.now
+          record << encode_record_datetime(mtime)
+
+          # Byte 25: File flags
+          flags = 0
+          flags |= Iso::FLAG_DIRECTORY if is_directory
+          record << [flags].pack("C")
+
+          # Byte 26: File unit size
+          record << [0].pack("C")
+
+          # Byte 27: Interleave gap size
+          record << [0].pack("C")
+
+          # Bytes 28-31: Volume sequence number (both-endian)
+          record << [1].pack("v")
+          record << [1].pack("n")
+
+          # Byte 32: Length of file identifier
+          record << [name_len].pack("C")
+
+          # Bytes 33+: File identifier (UCS-2 encoded)
+          record << name_ucs2
+
+          record
+        end
+
+        # Sanitize filename for Joliet
+        #
+        # @param name [String] Original filename
+        # @return [String] Sanitized filename
+        def self.sanitize_filename(name)
+          # Joliet allows most Unicode characters
+          # Maximum 64 characters
+          # Disallow: / * ? < > | " : \
+
+          sanitized = name.gsub(/[\/*?<>|":\\]/, "_")
+          if sanitized.length > MAX_FILENAME_LENGTH
+            sanitized = sanitized[0,
+                                  MAX_FILENAME_LENGTH]
+          end
+          sanitized
+        end
+
+        # Check if filename requires Joliet
+        #
+        # @param name [String] Filename
+        # @return [Boolean] true if Joliet needed
+        def self.requires_joliet?(name)
+          # Check if name exceeds ISO 9660 Level 2 limits
+          return true if name.length > 31
+
+          # Check if name contains non-ASCII or lowercase
+          return true if /[^A-Z0-9_.-]/.match?(name)
+
+          # Check if name contains Unicode
+          name.encoding != Encoding::ASCII && name.bytes.any? { |b| b > 127 }
+        end
+
+        # Build Joliet supplementary volume descriptor
+        #
+        # @param primary_vd [String] Primary volume descriptor data
+        # @param root_dir [Hash] Root directory information
+        # @return [String] Joliet SVD (2048 bytes)
+        def self.build_supplementary_vd(primary_vd, _root_dir)
+          # Start with primary VD as template
+          svd = primary_vd.dup
+
+          # Change type to supplementary
+          svd[0] = [Iso::VD_SUPPLEMENTARY].pack("C")
+
+          # Add Joliet escape sequence
+          # Bytes 88-90: Escape sequences
+          svd[88, 3] = ESCAPE_SEQUENCE_LEVEL_3
+
+          # Encode volume identifier to UCS-2
+          volume_id = primary_vd[40, 32].strip
+          volume_id_ucs2 = encode_ucs2(volume_id, 16)
+          svd[40, 32] = pad_ucs2_string(volume_id_ucs2, 32)
+
+          # Update root directory record with UCS-2 name
+          # Root is always "\x00" so no change needed
+
+          svd
+        end
+
+        # Pad UCS-2 string to specified length
+        #
+        # @param ucs2_str [String] UCS-2 string
+        # @param byte_length [Integer] Target length in bytes
+        # @return [String] Padded string
+        def self.pad_ucs2_string(ucs2_str, byte_length)
+          if ucs2_str.bytesize > byte_length
+            ucs2_str[0, byte_length]
+          else
+            ucs2_str + (" ".encode("UTF-16BE") * ((byte_length - ucs2_str.bytesize) / 2))
+          end
+        end
+
+        # Encode recording date/time (7-byte format)
+        #
+        # @param time [Time] Time to encode
+        # @return [String] 7-byte encoded time
+        def self.encode_record_datetime(time)
+          [
+            time.year - 1900,
+            time.month,
+            time.day,
+            time.hour,
+            time.min,
+            time.sec,
+            0, # GMT offset
+          ].pack("C7")
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/iso/path_table.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Path Table
+      # Provides efficient directory hierarchy lookup
+      class PathTable
+        attr_reader :entries
+
+        # Path table entry
+        class Entry
+          attr_reader :name, :location, :parent_directory_number
+
+          # Initialize entry
+          #
+          # @param name [String] Directory name
+          # @param location [Integer] LBA location
+          # @param parent_directory_number [Integer] Parent directory index
+          def initialize(name, location, parent_directory_number)
+            @name = name
+            @location = location
+            @parent_directory_number = parent_directory_number
+          end
+
+          # Get full path by traversing parent entries
+          #
+          # @param entries [Array<Entry>] All path table entries
+          # @return [String] Full path
+          def full_path(entries)
+            return "/" if @parent_directory_number == 1 # Root
+
+            parts = [@name]
+            current_parent = @parent_directory_number
+
+            while current_parent > 1
+              parent = entries[current_parent - 1]
+              break unless parent
+
+              parts.unshift(parent.name)
+              current_parent = parent.parent_directory_number
+            end
+
+            "/#{parts.join('/')}"
+          end
+        end
+
+        # Initialize path table
+        def initialize
+          @entries = []
+        end
+
+        # Parse path table from binary data
+        #
+        # @param data [String] Binary path table data
+        # @param size [Integer] Size of path table in bytes
+        # @return [PathTable] Parsed path table
+        def self.parse(data, size)
+          new.tap { |pt| pt.parse(data, size) }
+        end
+
+        # Parse path table data
+        #
+        # @param data [String] Binary data
+        # @param size [Integer] Size in bytes
+        def parse(data, size)
+          offset = 0
+
+          while offset < size
+            # Byte 0: Length of directory identifier
+            name_length = data.getbyte(offset)
+            break if name_length.zero?
+
+            # Byte 1: Extended attribute record length
+            data.getbyte(offset + 1)
+
+            # Bytes 2-5: Location of extent (little-endian)
+            location = data[offset + 2, 4].unpack1("V")
+
+            # Bytes 6-7: Parent directory number
+            parent = data[offset + 6, 2].unpack1("v")
+
+            # Bytes 8+: Directory identifier
+            name = data[offset + 8, name_length].strip
+
+            # Handle root directory (zero-length name)
+            name = "/" if name.empty?
+
+            # Create entry
+            @entries << Entry.new(name, location, parent)
+
+            # Move to next entry
+            # Length is 8 + name_length, padded to even boundary
+            record_length = 8 + name_length
+            record_length += 1 if record_length.odd?
+            offset += record_length
+          end
+        end
+
+        # Find entry by directory name
+        #
+        # @param name [String] Directory name
+        # @return [Entry, nil] Found entry or nil
+        def find_by_name(name)
+          @entries.find { |e| e.name == name }
+        end
+
+        # Find entry by location
+        #
+        # @param location [Integer] LBA location
+        # @return [Entry, nil] Found entry or nil
+        def find_by_location(location)
+          @entries.find { |e| e.location == location }
+        end
+
+        # Get root directory entry
+        #
+        # @return [Entry] Root entry
+        def root
+          @entries.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 image reader
+      # Provides read-only access to ISO filesystem
+      class Reader
+        attr_reader :file_path, :primary_volume_descriptor, :entries,
+                    :path_table
+
+        # Initialize reader
+        #
+        # @param file_path [String] Path to ISO file
+        def initialize(file_path)
+          @file_path = file_path
+          @primary_volume_descriptor = nil
+          @entries = []
+          @path_table = nil
+          @io = nil
+        end
+
+        # Open and parse ISO image
+        #
+        # @raise [RuntimeError] if file cannot be opened or is invalid
+        def open
+          @io = File.open(@file_path, "rb")
+          parse_volume_descriptors
+          parse_directory_structure
+          self
+        end
+
+        # Close ISO file
+        def close
+          @io&.close
+          @io = nil
+        end
+
+        # Get volume identifier
+        #
+        # @return [String] Volume name
+        def volume_identifier
+          @primary_volume_descriptor&.volume_identifier || ""
+        end
+
+        # Get system identifier
+        #
+        # @return [String] System identifier
+        def system_identifier
+          @primary_volume_descriptor&.system_identifier || ""
+        end
+
+        # Get volume size in bytes
+        #
+        # @return [Integer] Total volume size
+        def volume_size
+          return 0 unless @primary_volume_descriptor
+
+          @primary_volume_descriptor.volume_space_size * Iso::SECTOR_SIZE
+        end
+
+        # Extract entry to file
+        #
+        # @param entry_path [String] Path in ISO
+        # @param output_path [String] Destination path
+        def extract_entry(entry_path, output_path)
+          entry = find_entry(entry_path)
+          raise Errno::ENOENT, "Entry not found: #{entry_path}" unless entry
+
+          if entry.directory?
+            FileUtils.mkdir_p(output_path)
+          else
+            FileUtils.mkdir_p(File.dirname(output_path))
+            data = read_file_data(entry)
+            File.binwrite(output_path, data)
+
+            # Set modification time if available
+            File.utime(entry.mtime, entry.mtime, output_path) if entry.mtime
+          end
+        end
+
+        # Extract all entries
+        #
+        # @param output_dir [String] Output directory
+        def extract_all(output_dir)
+          FileUtils.mkdir_p(output_dir)
+
+          @entries.each do |entry|
+            next if entry.current_directory? || entry.parent_directory?
+
+            output_path = File.join(output_dir, entry.full_path)
+            extract_entry(entry.full_path, output_path)
+          end
+        end
+
+        # List all entries
+        #
+        # @return [Array<DirectoryRecord>] All entries
+        def list_files
+          @entries.reject { |e| e.current_directory? || e.parent_directory? }
+        end
+
+        private
+
+        # Parse volume descriptors
+        def parse_volume_descriptors
+          sector = Iso::VOLUME_DESCRIPTOR_START
+
+          loop do
+            @io.seek(sector * Iso::SECTOR_SIZE)
+            data = @io.read(Iso::SECTOR_SIZE)
+            raise Omnizip::InvalidArchiveError, "Failed to read volume descriptor" unless data
+
+            vd = VolumeDescriptor.parse(data)
+
+            case vd.type
+            when Iso::VD_PRIMARY
+              @primary_volume_descriptor = vd
+            when Iso::VD_TERMINATOR
+              break
+            end
+
+            sector += 1
+          end
+
+          return if @primary_volume_descriptor
+
+          raise Omnizip::InvalidArchiveError, "No primary volume descriptor found"
+        end
+
+        # Parse directory structure
+        def parse_directory_structure
+          return unless @primary_volume_descriptor
+
+          root = @primary_volume_descriptor.root_directory_record
+          parse_directory(root, "")
+        end
+
+        # Recursively parse directory
+        #
+        # @param dir_record [DirectoryRecord] Directory record
+        # @param path_prefix [String] Path prefix
+        def parse_directory(dir_record, path_prefix)
+          # Read directory data
+          @io.seek(dir_record.location * Iso::SECTOR_SIZE)
+          dir_data = @io.read(dir_record.data_length)
+
+          offset = 0
+          while offset < dir_data.bytesize
+            length = dir_data.getbyte(offset)
+            break if length.zero? # End of directory
+
+            record = DirectoryRecord.parse(dir_data, offset)
+
+            # Skip current and parent directory entries
+            unless record.current_directory? || record.parent_directory?
+              # Set full path
+              full_path = path_prefix.empty? ? record.name : "#{path_prefix}/#{record.name}"
+              record.full_path = full_path
+
+              @entries << record
+
+              # Recursively parse subdirectories
+              parse_directory(record, full_path) if record.directory?
+            end
+
+            offset += length
+          end
+        end
+
+        # Find entry by path
+        #
+        # @param path [String] Entry path
+        # @return [DirectoryRecord, nil] Found entry
+        def find_entry(path)
+          # Normalize path
+          path = path.gsub(%r{^/+}, "").gsub(%r{/+$}, "")
+          @entries.find { |e| e.full_path == path }
+        end
+
+        # Read file data
+        #
+        # @param entry [DirectoryRecord] File entry
+        # @return [String] File data
+        def read_file_data(entry)
+          @io.seek(entry.location * Iso::SECTOR_SIZE)
+          @io.read(entry.size)
+        end
+      end
+    end
+  end
+end