omnizip 0.4.7-arm-linux

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

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

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Volume Descriptor Builder
+      #
+      # Builds primary and supplementary volume descriptors for ISO images.
+      # Handles proper encoding of volume metadata and root directory information.
+      class VolumeBuilder
+        # @return [String] Volume identifier
+        attr_reader :volume_id
+
+        # @return [String] System identifier
+        attr_reader :system_id
+
+        # @return [String] Publisher
+        attr_reader :publisher
+
+        # @return [String] Preparer
+        attr_reader :preparer
+
+        # @return [String] Application
+        attr_reader :application
+
+        # @return [Integer] ISO level
+        attr_reader :level
+
+        # @return [Boolean] Rock Ridge enabled
+        attr_reader :rock_ridge
+
+        # @return [Boolean] Joliet enabled
+        attr_reader :joliet
+
+        # Initialize volume builder
+        #
+        # @param options [Hash] Builder options
+        def initialize(options = {})
+          @volume_id = options.fetch(:volume_id, "OMNIZIP")
+          @system_id = options.fetch(:system_id, "LINUX")
+          @publisher = options.fetch(:publisher, "")
+          @preparer = options.fetch(:preparer, "")
+          @application = options.fetch(:application, "OMNIZIP")
+          @level = options.fetch(:level, 2)
+          @rock_ridge = options.fetch(:rock_ridge, false)
+          @joliet = options.fetch(:joliet, false)
+        end
+
+        # Build primary volume descriptor
+        #
+        # @param root_dir [Hash] Root directory information
+        # @return [String] Primary VD sector (2048 bytes)
+        def build_primary(root_dir)
+          sector = +""
+
+          # Byte 0: Volume descriptor type (1 = Primary)
+          sector << [Iso::VD_PRIMARY].pack("C")
+
+          # Bytes 1-5: Standard identifier "CD001"
+          sector << VolumeDescriptor::ISO_IDENTIFIER
+
+          # Byte 6: Version (1)
+          sector << [1].pack("C")
+
+          # Byte 7: Unused (0)
+          sector << "\x00"
+
+          # Bytes 8-39: System identifier (a-characters, space-padded)
+          sector << pad_a_string(@system_id, 32)
+
+          # Bytes 40-71: Volume identifier (d-characters, space-padded)
+          sector << pad_d_string(@volume_id, 32)
+
+          # Bytes 72-79: Unused (zeros)
+          sector << ("\x00" * 8)
+
+          # Bytes 80-87: Volume space size (both-endian)
+          volume_sectors = root_dir[:total_sectors] || 100
+          sector << [volume_sectors].pack("V") # Little-endian
+          sector << [volume_sectors].pack("N") # Big-endian
+
+          # Bytes 88-119: Unused (zeros)
+          sector << ("\x00" * 32)
+
+          # Bytes 120-123: Volume set size (both-endian)
+          sector << [1].pack("v")
+          sector << [1].pack("n")
+
+          # Bytes 124-127: Volume sequence number (both-endian)
+          sector << [1].pack("v")
+          sector << [1].pack("n")
+
+          # Bytes 128-131: Logical block size (both-endian)
+          sector << [Iso::SECTOR_SIZE].pack("v")
+          sector << [Iso::SECTOR_SIZE].pack("n")
+
+          # Bytes 132-139: Path table size (both-endian)
+          path_table_size = root_dir[:path_table_size] || 10
+          sector << [path_table_size].pack("V")
+          sector << [path_table_size].pack("N")
+
+          # Bytes 140-143: Location of type L path table
+          sector << [root_dir[:path_table_location] || 19].pack("V")
+
+          # Bytes 144-147: Location of optional type L path table
+          sector << [0].pack("V")
+
+          # Bytes 148-151: Location of type M path table
+          sector << [root_dir[:path_table_location_be] || 20].pack("N")
+
+          # Bytes 152-155: Location of optional type M path table
+          sector << [0].pack("N")
+
+          # Bytes 156-189: Root directory record (34 bytes)
+          sector << build_root_directory_record(root_dir)
+
+          # Bytes 190-317: Volume set identifier
+          sector << pad_d_string("", 128)
+
+          # Bytes 318-445: Publisher identifier
+          sector << pad_a_string(@publisher, 128)
+
+          # Bytes 446-573: Data preparer identifier
+          sector << pad_a_string(@preparer, 128)
+
+          # Bytes 574-701: Application identifier
+          sector << pad_a_string(@application, 128)
+
+          # Bytes 702-738: Copyright file identifier
+          sector << pad_d_string("", 37)
+
+          # Bytes 739-775: Abstract file identifier
+          sector << pad_d_string("", 37)
+
+          # Bytes 776-812: Bibliographic file identifier
+          sector << pad_d_string("", 37)
+
+          # Bytes 813-829: Volume creation date/time
+          now = Time.now
+          sector << encode_volume_datetime(now)
+
+          # Bytes 830-846: Volume modification date/time
+          sector << encode_volume_datetime(now)
+
+          # Bytes 847-863: Volume expiration date/time (not set)
+          sector << encode_volume_datetime(nil)
+
+          # Bytes 864-880: Volume effective date/time (not set)
+          sector << encode_volume_datetime(nil)
+
+          # Byte 881: File structure version (1)
+          sector << [1].pack("C")
+
+          # Byte 882: Unused (0)
+          sector << "\x00"
+
+          # Bytes 883-1395: Application use
+          sector << ("\x00" * 513)
+
+          # Bytes 1396-2047: Reserved
+          sector << ("\x00" * 652)
+
+          sector
+        end
+
+        # Build Joliet supplementary volume descriptor
+        #
+        # @param root_dir [Hash] Root directory information
+        # @return [String] Joliet SVD sector (2048 bytes)
+        def build_joliet(root_dir)
+          # Joliet is similar to primary VD but with:
+          # - Type = 2 (supplementary)
+          # - UCS-2 encoding for strings
+          # - Escape sequences for character set
+
+          sector = build_primary(root_dir)
+
+          # Modify type to supplementary
+          sector.setbyte(0, Iso::VD_SUPPLEMENTARY)
+
+          # Add escape sequences for UCS-2
+          # Bytes 88-90: %/@  %/C  %/E for levels 1, 2, 3
+          sector.setbyte(88, 0x25)  # '%'
+          sector.setbyte(89, 0x2F)  # '/'
+          sector.setbyte(90, 0x45)  # 'E'
+
+          # Convert volume ID to UCS-2
+          volume_id_ucs2 = @volume_id.encode("UTF-16BE")
+          padded_volume_id = pad_string(volume_id_ucs2,
+                                        32).force_encoding("ASCII-8BIT")
+
+          # Replace bytes 40-71 with UCS-2 volume ID
+          32.times do |i|
+            sector.setbyte(40 + i, padded_volume_id.getbyte(i))
+          end
+
+          sector
+        end
+
+        private
+
+        # Build root directory record
+        #
+        # @param root_dir [Hash] Root directory info
+        # @return [String] 34-byte directory record
+        def build_root_directory_record(root_dir)
+          record = +""
+
+          # Length of record (34 bytes for root)
+          record << [34].pack("C")
+
+          # Extended attribute length (0)
+          record << [0].pack("C")
+
+          # Location of extent (both-endian)
+          location = root_dir[:location] || 21
+          record << [location].pack("V")
+          record << [location].pack("N")
+
+          # Data length (both-endian)
+          data_length = root_dir[:size] || Iso::SECTOR_SIZE
+          record << [data_length].pack("V")
+          record << [data_length].pack("N")
+
+          # Recording date
+          record << encode_record_datetime(Time.now)
+
+          # Flags (directory)
+          record << [Iso::FLAG_DIRECTORY].pack("C")
+
+          # File unit size, interleave gap
+          record << [0, 0].pack("C2")
+
+          # Volume sequence number (both-endian)
+          record << [1].pack("v")
+          record << [1].pack("n")
+
+          # File identifier length (1 for root)
+          record << [1].pack("C")
+
+          # File identifier (0x00 for root)
+          record << "\x00"
+
+          record
+        end
+
+        # Encode volume date/time (17-byte format)
+        #
+        # @param time [Time, nil] Time to encode
+        # @return [String] 17-byte encoded time
+        def encode_volume_datetime(time)
+          if time.nil?
+            # All zeros for unset time
+            return "#{'0' * 16}\u0000"
+          end
+
+          format(
+            "%04d%02d%02d%02d%02d%02d%02d",
+            time.year,
+            time.month,
+            time.day,
+            time.hour,
+            time.min,
+            time.sec,
+            0, # Centiseconds
+          ) + [0].pack("c") # GMT offset
+        end
+
+        # Encode recording date/time (7-byte format)
+        #
+        # @param time [Time] Time to encode
+        # @return [String] 7-byte encoded time
+        def encode_record_datetime(time)
+          [
+            time.year - 1900,
+            time.month,
+            time.day,
+            time.hour,
+            time.min,
+            time.sec,
+            0, # GMT offset
+          ].pack("C7")
+        end
+
+        # Pad string with spaces (a-characters)
+        #
+        # @param str [String] String to pad
+        # @param length [Integer] Target length
+        # @return [String] Padded string
+        def pad_a_string(str, length)
+          str = str[0, length] if str.bytesize > length
+          str + (" " * (length - str.bytesize))
+        end
+
+        # Pad string with spaces (d-characters)
+        #
+        # @param str [String] String to pad
+        # @param length [Integer] Target length
+        # @return [String] Padded string
+        def pad_d_string(str, length)
+          pad_a_string(str, length)
+        end
+
+        # Pad generic string
+        #
+        # @param str [String] String to pad
+        # @param length [Integer] Target length
+        # @return [String] Padded string
+        def pad_string(str, length)
+          str = str[0, length] if str.bytesize > length
+          padding = "\x00".encode(str.encoding) * (length - str.bytesize)
+          str + padding
+        end
+      end
+    end
+  end
+end