omnizip 0.3.1

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,197 @@
+# frozen_string_literal: true
+
+require_relative "volume_descriptor"
+require_relative "directory_record"
+require_relative "path_table"
+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 "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.name)
+            extract_entry(entry.name, 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 "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 "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.instance_variable_set(:@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.instance_variable_get(:@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

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

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # Rock Ridge Extensions for ISO 9660
+      #
+      # Implements System Use Sharing Protocol (SUSP) and Rock Ridge
+      # extensions to store Unix file attributes, permissions, symbolic links,
+      # and device nodes in ISO 9660 images.
+      #
+      # Rock Ridge allows ISO images to preserve full Unix filesystem semantics.
+      module RockRidge
+        # SUSP/Rock Ridge signature identifiers
+        module Signatures
+          SP = "SP" # System Use Sharing Protocol indicator
+          CE = "CE" # Continuation area
+          PX = "PX" # POSIX file attributes
+          PN = "PN" # POSIX device number
+          SL = "SL" # Symbolic link
+          NM = "NM" # Alternate name
+          CL = "CL" # Child link
+          PL = "PL" # Parent link
+          RE = "RE" # Relocated directory
+          TF = "TF" # Time stamps
+          SF = "SF" # Sparse file
+        end
+
+        # System Use Entry
+        class SUEntry
+          attr_accessor :signature, :length, :version, :data
+
+          # Initialize entry
+          #
+          # @param signature [String] 2-byte signature
+          # @param version [Integer] Entry version
+          # @param data [String] Entry data
+          def initialize(signature, version: 1, data: "")
+            @signature = signature
+            @length = 4 + data.bytesize
+            @version = version
+            @data = data
+          end
+
+          # Convert to binary
+          #
+          # @return [String] Binary representation
+          def to_binary
+            result = +""
+            result << @signature # 2 bytes
+            result << [@length].pack("C")  # 1 byte
+            result << [@version].pack("C") # 1 byte
+            result << @data
+            result
+          end
+
+          # Parse from binary
+          #
+          # @param data [String] Binary data
+          # @param offset [Integer] Starting offset
+          # @return [SUEntry] Parsed entry
+          def self.parse(data, offset = 0)
+            signature = data[offset, 2]
+            length = data.getbyte(offset + 2)
+            version = data.getbyte(offset + 3)
+            entry_data = data[offset + 4, length - 4]
+
+            new(signature, version: version, data: entry_data)
+          end
+        end
+
+        # Add Rock Ridge extensions to directory record
+        #
+        # @param record_data [String] Directory record data
+        # @param file_stat [File::Stat] File statistics
+        # @param name [String] File name
+        # @param is_symlink [Boolean] Is this a symbolic link
+        # @return [String] Updated record with Rock Ridge fields
+        def self.add_extensions(record_data, file_stat, name, is_symlink: false)
+          system_use = +""
+
+          # Add SP entry (first entry in root directory only)
+          # This indicates Rock Ridge is being used
+          # For simplicity, we'll add to all entries
+
+          # Add PX (POSIX attributes)
+          system_use << build_px_entry(file_stat).to_binary
+
+          # Add TF (timestamps)
+          system_use << build_tf_entry(file_stat).to_binary
+
+          # Add NM (alternate name) if different from ISO name
+          unless name == File.basename(name).upcase
+            system_use << build_nm_entry(name).to_binary
+          end
+
+          # Add SL (symbolic link) if applicable
+          if is_symlink
+            link_target = File.readlink(file_stat)
+            system_use << build_sl_entry(link_target).to_binary
+          end
+
+          # Append system use to record
+          record_data + system_use
+        end
+
+        # Build PX (POSIX attributes) entry
+        #
+        # @param stat [File::Stat] File statistics
+        # @return [SUEntry] PX entry
+        def self.build_px_entry(stat)
+          data = +""
+
+          # File mode (both-endian)
+          data << [stat.mode].pack("V")
+          data << [stat.mode].pack("N")
+
+          # Number of links (both-endian)
+          data << [stat.nlink].pack("V")
+          data << [stat.nlink].pack("N")
+
+          # User ID (both-endian)
+          data << [stat.uid].pack("V")
+          data << [stat.uid].pack("N")
+
+          # Group ID (both-endian)
+          data << [stat.gid].pack("V")
+          data << [stat.gid].pack("N")
+
+          # Inode number (both-endian) - optional
+          data << [stat.ino].pack("V")
+          data << [stat.ino].pack("N")
+
+          SUEntry.new(Signatures::PX, data: data)
+        end
+
+        # Build TF (timestamps) entry
+        #
+        # @param stat [File::Stat] File statistics
+        # @return [SUEntry] TF entry
+        def self.build_tf_entry(stat)
+          # Flags indicating which timestamps are present
+          # Bit 0: Creation time
+          # Bit 1: Modify time
+          # Bit 2: Access time
+          # Bit 3: Attributes time
+          # Bit 4: Backup time
+          # Bit 5: Expiration time
+          # Bit 6: Effective time
+          # Bit 7: Long format (17 bytes instead of 7)
+
+          flags = 0b00000110 # Modify and access times, short format
+
+          data = +""
+          data << [flags].pack("C")
+
+          # Modification time (7-byte format)
+          data << encode_time_7byte(stat.mtime)
+
+          # Access time (7-byte format)
+          data << encode_time_7byte(stat.atime)
+
+          SUEntry.new(Signatures::TF, data: data)
+        end
+
+        # Build NM (alternate name) entry
+        #
+        # @param name [String] File name
+        # @return [SUEntry] NM entry
+        def self.build_nm_entry(name)
+          # Flags
+          # Bit 0: CONTINUE (name continues in next NM)
+          # Bit 1: CURRENT (name is ".")
+          # Bit 2: PARENT (name is "..")
+          flags = 0
+
+          data = +""
+          data << [flags].pack("C")
+          data << name
+
+          SUEntry.new(Signatures::NM, data: data)
+        end
+
+        # Build SL (symbolic link) entry
+        #
+        # @param target [String] Link target
+        # @return [SUEntry] SL entry
+        def self.build_sl_entry(target)
+          # Flags
+          # Bit 0: CONTINUE (link continues in next SL)
+          flags = 0
+
+          data = +""
+          data << [flags].pack("C")
+
+          # Component flags
+          # Bit 0: CONTINUE (component continues)
+          # Bit 1: CURRENT (component is ".")
+          # Bit 2: PARENT (component is "..")
+          # Bit 3: ROOT (component is root)
+          comp_flags = 0
+
+          # Component length
+          data << [comp_flags].pack("C")
+          data << [target.bytesize].pack("C")
+          data << target
+
+          SUEntry.new(Signatures::SL, data: data)
+        end
+
+        # Build PN (POSIX device number) entry
+        #
+        # @param stat [File::Stat] File statistics
+        # @return [SUEntry] PN entry
+        def self.build_pn_entry(stat)
+          data = +""
+
+          # Device number high (both-endian)
+          dev_high = (stat.rdev >> 32) & 0xFFFFFFFF
+          data << [dev_high].pack("V")
+          data << [dev_high].pack("N")
+
+          # Device number low (both-endian)
+          dev_low = stat.rdev & 0xFFFFFFFF
+          data << [dev_low].pack("V")
+          data << [dev_low].pack("N")
+
+          SUEntry.new(Signatures::PN, data: data)
+        end
+
+        # Encode time in 7-byte format
+        #
+        # @param time [Time] Time to encode
+        # @return [String] 7-byte encoded time
+        def self.encode_time_7byte(time)
+          [
+            time.year - 1900,
+            time.month,
+            time.day,
+            time.hour,
+            time.min,
+            time.sec,
+            0, # GMT offset
+          ].pack("C7")
+        end
+
+        # Parse Rock Ridge extensions from system use field
+        #
+        # @param system_use [String] System use field data
+        # @return [Hash] Parsed attributes
+        def self.parse_extensions(system_use)
+          attributes = {}
+          offset = 0
+
+          while offset < system_use.bytesize
+            entry = SUEntry.parse(system_use, offset)
+
+            case entry.signature
+            when Signatures::PX
+              attributes[:posix] = parse_px_entry(entry)
+            when Signatures::TF
+              attributes[:times] = parse_tf_entry(entry)
+            when Signatures::NM
+              attributes[:name] = parse_nm_entry(entry)
+            when Signatures::SL
+              attributes[:symlink] = parse_sl_entry(entry)
+            end
+
+            offset += entry.length
+          end
+
+          attributes
+        end
+
+        # Parse PX entry
+        #
+        # @param entry [SUEntry] PX entry
+        # @return [Hash] Parsed POSIX attributes
+        def self.parse_px_entry(entry)
+          data = entry.data
+          {
+            mode: data[0, 4].unpack1("V"),
+            nlink: data[8, 4].unpack1("V"),
+            uid: data[16, 4].unpack1("V"),
+            gid: data[24, 4].unpack1("V"),
+            ino: data[32, 4].unpack1("V"),
+          }
+        end
+
+        # Parse TF entry
+        #
+        # @param entry [SUEntry] TF entry
+        # @return [Hash] Parsed timestamps
+        def self.parse_tf_entry(entry)
+          # Parse based on flags
+          flags = entry.data.getbyte(0)
+          times = {}
+
+          offset = 1
+          if flags & 0x02 # Modify time
+            times[:mtime] = parse_time_7byte(entry.data[offset, 7])
+            offset += 7
+          end
+
+          if flags & 0x04 # Access time
+            times[:atime] = parse_time_7byte(entry.data[offset, 7])
+          end
+
+          times
+        end
+
+        # Parse NM entry
+        #
+        # @param entry [SUEntry] NM entry
+        # @return [String] Alternate name
+        def self.parse_nm_entry(entry)
+          entry.data[1..]
+        end
+
+        # Parse SL entry
+        #
+        # @param entry [SUEntry] SL entry
+        # @return [String] Symbolic link target
+        def self.parse_sl_entry(entry)
+          # Skip flags byte, component flags, read length and target
+          comp_len = entry.data.getbyte(2)
+          entry.data[3, comp_len]
+        end
+
+        # Parse 7-byte time format
+        #
+        # @param data [String] 7-byte time data
+        # @return [Time] Parsed time
+        def self.parse_time_7byte(data)
+          year = 1900 + data.getbyte(0)
+          month = data.getbyte(1)
+          day = data.getbyte(2)
+          hour = data.getbyte(3)
+          minute = data.getbyte(4)
+          second = data.getbyte(5)
+
+          Time.new(year, month, day, hour, minute, second)
+        rescue ArgumentError
+          Time.now
+        end
+      end
+    end
+  end
+end