omnizip 0.4.7-x86_64-linux

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Volume Descriptor
+      # Represents the primary volume descriptor containing metadata
+      class VolumeDescriptor
+        attr_reader :type, :identifier, :version, :volume_identifier,
+                    :volume_space_size, :volume_set_size, :volume_sequence_number,
+                    :logical_block_size, :path_table_size, :path_table_location,
+                    :root_directory_record, :volume_set_identifier,
+                    :publisher_identifier, :preparer_identifier,
+                    :application_identifier, :creation_date, :modification_date,
+                    :system_identifier
+
+        # Standard identifier for ISO 9660
+        ISO_IDENTIFIER = "CD001"
+
+        # Parse volume descriptor from binary data
+        #
+        # @param data [String] Binary sector data (2048 bytes)
+        # @return [VolumeDescriptor] Parsed descriptor
+        def self.parse(data)
+          new.tap { |vd| vd.parse(data) }
+        end
+
+        # Parse descriptor data
+        #
+        # @param data [String] Binary data
+        def parse(data)
+          raise Omnizip::InvalidArchiveError, "Invalid volume descriptor size" unless data.bytesize >= 2048
+
+          # Byte 0: Volume descriptor type
+          @type = data.getbyte(0)
+
+          # Bytes 1-5: Standard identifier "CD001"
+          @identifier = data[1, 5]
+          unless @identifier == ISO_IDENTIFIER
+            raise Omnizip::InvalidArchiveError, "Invalid ISO identifier: expected #{ISO_IDENTIFIER}, got #{@identifier}"
+          end
+
+          # Byte 6: Version (should be 1)
+          @version = data.getbyte(6)
+
+          # Parse based on type
+          case @type
+          when Iso::VD_PRIMARY
+            parse_primary_volume_descriptor(data)
+          when Iso::VD_TERMINATOR
+            # Terminator has no additional data
+          else
+            # Skip other types for now
+          end
+        end
+
+        # Check if this is a primary volume descriptor
+        #
+        # @return [Boolean] true if primary VD
+        def primary?
+          @type == Iso::VD_PRIMARY
+        end
+
+        # Check if this is a terminator
+        #
+        # @return [Boolean] true if terminator
+        def terminator?
+          @type == Iso::VD_TERMINATOR
+        end
+
+        private
+
+        # Parse primary volume descriptor fields
+        #
+        # @param data [String] Binary data
+        def parse_primary_volume_descriptor(data)
+          # Byte 7: Unused (0)
+          # Bytes 8-39: System identifier
+          @system_identifier = data[8, 32].strip
+
+          # Bytes 40-71: Volume identifier
+          @volume_identifier = data[40, 32].strip
+
+          # Bytes 72-79: Unused (zeros)
+
+          # Bytes 80-87: Volume space size (both-endian)
+          @volume_space_size = data[80, 4].unpack1("V")
+
+          # Bytes 88-119: Unused (zeros)
+
+          # Bytes 120-123: Volume set size (both-endian)
+          @volume_set_size = data[120, 2].unpack1("v")
+
+          # Bytes 124-127: Volume sequence number (both-endian)
+          @volume_sequence_number = data[124, 2].unpack1("v")
+
+          # Bytes 128-131: Logical block size (both-endian)
+          @logical_block_size = data[128, 2].unpack1("v")
+
+          # Bytes 132-139: Path table size (both-endian)
+          @path_table_size = data[132, 4].unpack1("V")
+
+          # Bytes 140-143: Path table location (little-endian)
+          @path_table_location = data[140, 4].unpack1("V")
+
+          # Bytes 144-147: Optional path table location
+          # Bytes 148-151: Path table location (big-endian)
+          # Bytes 152-155: Optional path table location
+
+          # Bytes 156-189: Root directory record (34 bytes)
+          @root_directory_record = DirectoryRecord.parse(data[156, 34])
+
+          # Bytes 190-317: Volume set identifier
+          @volume_set_identifier = data[190, 128].strip
+
+          # Bytes 318-445: Publisher identifier
+          @publisher_identifier = data[318, 128].strip
+
+          # Bytes 446-573: Data preparer identifier
+          @preparer_identifier = data[446, 128].strip
+
+          # Bytes 574-701: Application identifier
+          @application_identifier = data[574, 128].strip
+
+          # Bytes 702-738: Copyright file identifier
+          # Bytes 739-775: Abstract file identifier
+          # Bytes 776-812: Bibliographic file identifier
+
+          # Bytes 813-829: Volume creation date/time
+          @creation_date = parse_datetime(data[813, 17])
+
+          # Bytes 830-846: Volume modification date/time
+          @modification_date = parse_datetime(data[830, 17])
+
+          # Bytes 847-863: Volume expiration date/time
+          # Bytes 864-880: Volume effective date/time
+
+          # Byte 881: File structure version
+          # Bytes 882-1395: Application use
+          # Bytes 1396-2047: Reserved
+        end
+
+        # Parse ISO 9660 datetime format
+        #
+        # @param data [String] 17-byte datetime string
+        # @return [Time, nil] Parsed time or nil if invalid
+        def parse_datetime(data)
+          return nil if data.nil? || data.bytesize < 17
+
+          year = data[0, 4].to_i
+          month = data[4, 2].to_i
+          day = data[6, 2].to_i
+          hour = data[8, 2].to_i
+          minute = data[10, 2].to_i
+          second = data[12, 2].to_i
+          # Centiseconds at 14-15 (ignored)
+          # Timezone offset at 16 (ignored for now)
+
+          return nil if year.zero?
+
+          Time.new(year, month, day, hour, minute, second)
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,543 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 image writer
+      #
+      # Creates ISO 9660 filesystem images (CD/DVD images) from files and directories.
+      # Supports ISO 9660 levels 1-3, Rock Ridge, and Joliet extensions.
+      #
+      # @example Create simple ISO image
+      #   writer = Iso::Writer.new('cdrom.iso')
+      #   writer.add_directory('files/')
+      #   writer.write
+      #
+      # @example With Rock Ridge and Joliet
+      #   writer = Iso::Writer.new('backup.iso',
+      #     volume_id: 'BACKUP_2024',
+      #     rock_ridge: true,
+      #     joliet: true
+      #   )
+      #   writer.add_directory('documents/')
+      #   writer.write
+      class Writer
+        # @return [String] Output ISO file path
+        attr_reader :output_path
+
+        # @return [Hash] Writer options
+        attr_reader :options
+
+        # @return [String] Volume identifier (label)
+        attr_accessor :volume_id
+
+        # @return [String] System identifier
+        attr_accessor :system_id
+
+        # @return [String] Publisher
+        attr_accessor :publisher
+
+        # @return [String] Preparer
+        attr_accessor :preparer
+
+        # @return [String] Application identifier
+        attr_accessor :application
+
+        # @return [Integer] ISO 9660 level (1, 2, or 3)
+        attr_accessor :level
+
+        # @return [Boolean] Use Rock Ridge extensions
+        attr_accessor :rock_ridge
+
+        # @return [Boolean] Use Joliet extensions
+        attr_accessor :joliet
+
+        # @return [Array<Hash>] Files to add
+        attr_reader :files
+
+        # @return [Array<Hash>] Directories to add
+        attr_reader :directories
+
+        # Initialize ISO writer
+        #
+        # @param output_path [String] Output ISO file path
+        # @param options [Hash] Writer options
+        # @option options [String] :volume_id Volume label
+        # @option options [String] :system_id System identifier
+        # @option options [String] :publisher Publisher name
+        # @option options [String] :preparer Preparer name
+        # @option options [String] :application Application name
+        # @option options [Integer] :level ISO 9660 level (1-3)
+        # @option options [Boolean] :rock_ridge Enable Rock Ridge
+        # @option options [Boolean] :joliet Enable Joliet
+        def initialize(output_path, options = {})
+          @output_path = output_path
+          @options = default_options.merge(options)
+
+          @volume_id = @options[:volume_id]
+          @system_id = @options[:system_id]
+          @publisher = @options[:publisher]
+          @preparer = @options[:preparer]
+          @application = @options[:application]
+          @level = @options[:level]
+          @rock_ridge = @options[:rock_ridge]
+          @joliet = @options[:joliet]
+
+          @files = []
+          @directories = []
+        end
+
+        # Add file to ISO image
+        #
+        # @param file_path [String] Source file path
+        # @param iso_path [String, nil] Path in ISO (defaults to basename)
+        # @raise [ArgumentError] if file doesn't exist
+        def add_file(file_path, iso_path = nil)
+          raise ArgumentError, "File not found: #{file_path}" unless
+            File.exist?(file_path)
+
+          iso_path ||= File.basename(file_path)
+
+          @files << {
+            source: File.expand_path(file_path),
+            iso_path: sanitize_path(iso_path),
+            stat: File.stat(file_path),
+          }
+        end
+
+        # Add directory to ISO image
+        #
+        # @param dir_path [String] Source directory path
+        # @param recursive [Boolean] Include subdirectories
+        # @param iso_path [String, nil] Path in ISO (defaults to basename)
+        # @raise [ArgumentError] if directory doesn't exist
+        def add_directory(dir_path, recursive: true, iso_path: nil)
+          raise ArgumentError, "Directory not found: #{dir_path}" unless
+            Dir.exist?(dir_path)
+
+          iso_path ||= File.basename(dir_path)
+          iso_path = sanitize_path(iso_path)
+
+          if recursive
+            add_directory_recursive(dir_path, iso_path)
+          else
+            add_directory_flat(dir_path, iso_path)
+          end
+        end
+
+        # Create ISO image
+        #
+        # @raise [IOError] if write fails
+        def write
+          File.open(@output_path, "wb") do |io|
+            # Build directory structure
+            builder = DirectoryBuilder.new(
+              @files,
+              @directories,
+              level: @level,
+              rock_ridge: @rock_ridge,
+            )
+            dir_structure = builder.build
+
+            # Build volume descriptor
+            volume_builder = VolumeBuilder.new(
+              volume_id: @volume_id,
+              system_id: @system_id,
+              publisher: @publisher,
+              preparer: @preparer,
+              application: @application,
+              level: @level,
+              rock_ridge: @rock_ridge,
+              joliet: @joliet,
+            )
+
+            # Write ISO structure
+            write_system_area(io)
+            write_volume_descriptors(io, volume_builder, dir_structure)
+            write_path_tables(io, dir_structure)
+            write_directories(io, dir_structure)
+            write_file_data(io)
+          end
+
+          @output_path
+        end
+
+        private
+
+        # Default writer options
+        #
+        # @return [Hash] Default options
+        def default_options
+          {
+            volume_id: "OMNIZIP_ISO",
+            system_id: "LINUX",
+            publisher: "OMNIZIP",
+            preparer: "OMNIZIP #{Omnizip::VERSION}",
+            application: "OMNIZIP",
+            level: 2,
+            # Rock Ridge System Use fields and Joliet UCS-2 directory
+            # trees are not implemented; advertising either extension
+            # makes readers misparse the image (e.g. 7-Zip reads the
+            # ASCII names as UCS-2 via the cloned SVD), so both stay
+            # off until real implementations land.
+            rock_ridge: false,
+            joliet: false,
+          }
+        end
+
+        # Add directory recursively
+        #
+        # @param dir_path [String] Source directory
+        # @param iso_path [String] ISO path
+        def add_directory_recursive(dir_path, iso_path)
+          # Add directory itself
+          @directories << {
+            source: File.expand_path(dir_path),
+            iso_path: iso_path,
+            stat: File.stat(dir_path),
+            directory: true,
+          }
+
+          # Add all contents
+          Dir.foreach(dir_path) do |entry|
+            next if [".", ".."].include?(entry)
+
+            source_path = File.join(dir_path, entry)
+            target_path = "#{iso_path}/#{entry}"
+
+            if File.directory?(source_path)
+              add_directory_recursive(source_path, target_path)
+            else
+              add_file(source_path, target_path)
+            end
+          end
+        end
+
+        # Add directory flat (non-recursive)
+        #
+        # @param dir_path [String] Source directory
+        # @param iso_path [String] ISO path
+        def add_directory_flat(dir_path, iso_path)
+          @directories << {
+            source: File.expand_path(dir_path),
+            iso_path: iso_path,
+            stat: File.stat(dir_path),
+            directory: true,
+          }
+
+          Dir.foreach(dir_path) do |entry|
+            next if [".", ".."].include?(entry)
+
+            source_path = File.join(dir_path, entry)
+            next if File.directory?(source_path)
+
+            add_file(source_path, "#{iso_path}/#{entry}")
+          end
+        end
+
+        # Sanitize path for ISO filesystem
+        #
+        # @param path [String] Input path
+        # @return [String] Sanitized path
+        def sanitize_path(path)
+          # Remove leading/trailing slashes
+          path = path.gsub(%r{^/+}, "").gsub(%r{/+$}, "")
+
+          # Normalize separators
+          path.split("/").map do |component|
+            sanitize_filename(component)
+          end.join("/")
+        end
+
+        # Sanitize filename for ISO level
+        #
+        # @param name [String] Filename
+        # @return [String] Sanitized filename
+        def sanitize_filename(name)
+          case @level
+          when 1
+            # Level 1: 8.3 format, A-Z 0-9 _ only
+            base = name.upcase.gsub(/[^A-Z0-9_]/, "_")[0, 8]
+            ext = ""
+            if name.include?(".")
+              ext = "." + name.split(".").last.upcase.gsub(/[^A-Z0-9]/, "")[0,
+                                                                            3]
+            end
+            base + ext
+          when 2
+            # Level 2: Up to 31 chars, more relaxed
+            name.gsub(/[^A-Za-z0-9_.-]/, "_")[0, 31]
+          else
+            # Level 3: No restrictions
+            name
+          end
+        end
+
+        # Write system area (first 16 sectors)
+        #
+        # @param io [IO] Output IO
+        def write_system_area(io)
+          # System area is reserved, write zeros
+          io.write("\x00" * (Iso::SECTOR_SIZE * Iso::SYSTEM_AREA_SECTORS))
+        end
+
+        # Write volume descriptors
+        #
+        # @param io [IO] Output IO
+        # @param builder [VolumeBuilder] Volume builder
+        # @param dir_structure [Hash] Directory structure
+        def write_volume_descriptors(io, builder, dir_structure)
+          # Fixed layout: 16 PVD, 17 terminator, 18 path table (L),
+          # 19 path table (BE), directory data from sector 22.
+          root = dir_structure[:root].merge(
+            total_sectors: dir_structure[:total_sectors],
+            path_table_size: dir_structure[:path_table_size],
+            path_table_location: 18,
+            path_table_location_be: 19,
+          )
+
+          # Write primary volume descriptor
+          pvd = builder.build_primary(root)
+          io.write(pvd)
+
+          # Write Joliet supplementary descriptor if enabled
+          if @joliet
+            svd = builder.build_joliet(root)
+            io.write(svd)
+          end
+
+          # Write terminator
+          terminator = build_terminator
+          io.write(terminator)
+        end
+
+        # Build volume descriptor set terminator
+        #
+        # @return [String] Terminator sector (2048 bytes)
+        def build_terminator
+          sector = +""
+          sector << [Iso::VD_TERMINATOR].pack("C") # Type
+          sector << VolumeDescriptor::ISO_IDENTIFIER # "CD001"
+          sector << [1].pack("C")                    # Version
+          sector << ("\x00" * (Iso::SECTOR_SIZE - 7))
+          sector
+        end
+
+        # Write path tables
+        #
+        # @param io [IO] Output IO
+        # @param dir_structure [Hash] Directory structure
+        def write_path_tables(io, dir_structure)
+          # Path tables provide quick directory lookup
+          # For simplicity, we'll write minimal path tables
+
+          # Little-endian path table
+          path_table = build_path_table(dir_structure[:directories])
+          io.write(path_table)
+
+          # Pad to sector boundary
+          padding = Iso::SECTOR_SIZE - (path_table.bytesize % Iso::SECTOR_SIZE)
+          io.write("\x00" * padding) if padding < Iso::SECTOR_SIZE
+
+          # Big-endian path table (required by spec)
+          path_table_be = build_path_table(dir_structure[:directories],
+                                           big_endian: true)
+          io.write(path_table_be)
+
+          # Pad to sector boundary
+          padding = Iso::SECTOR_SIZE - (path_table_be.bytesize % Iso::SECTOR_SIZE)
+          io.write("\x00" * padding) if padding < Iso::SECTOR_SIZE
+        end
+
+        # Build path table
+        #
+        # @param directories [Array<Hash>] Directory list
+        # @param big_endian [Boolean] Use big-endian format
+        # @return [String] Path table data
+        def build_path_table(directories, big_endian: false)
+          table = +""
+
+          directories.each_with_index do |dir, _idx|
+            name = dir[:name]
+            parent = dir[:parent_idx] || 1
+
+            # Name length
+            table << [name.bytesize].pack("C")
+
+            # Extended attribute record length
+            table << [0].pack("C")
+
+            # Location of extent
+            pack_format = big_endian ? "N" : "V"
+            table << [dir[:location]].pack(pack_format)
+
+            # Parent directory number (1-based)
+            pack_format = big_endian ? "n" : "v"
+            table << [parent + 1].pack(pack_format)
+
+            # Directory name
+            table << name
+
+            # Pad to even length
+            table << "\x00" if name.bytesize.odd?
+          end
+
+          table
+        end
+
+        # Write directory records
+        #
+        # @param io [IO] Output IO
+        # @param dir_structure [Hash] Directory structure
+        def write_directories(io, dir_structure)
+          dir_structure[:directories].each do |dir_info|
+            write_directory_record(io, dir_info)
+          end
+        end
+
+        # Write single directory record
+        #
+        # @param io [IO] Output IO
+        # @param dir_info [Hash] Directory information
+        def write_directory_record(io, dir_info)
+          # Seek to directory location
+          io.seek(dir_info[:location] * Iso::SECTOR_SIZE)
+
+          # Write directory entries
+          dir_data = build_directory_data(dir_info)
+          io.write(dir_data)
+
+          # Pad to sector boundary
+          padding = Iso::SECTOR_SIZE - (dir_data.bytesize % Iso::SECTOR_SIZE)
+          io.write("\x00" * padding) if padding < Iso::SECTOR_SIZE
+        end
+
+        # Build directory data with all entries
+        #
+        # @param dir_info [Hash] Directory information
+        # @return [String] Directory record data
+        def build_directory_data(dir_info)
+          data = +""
+
+          # Add "." entry (current directory)
+          data << build_directory_entry("\x00", dir_info, is_self: true)
+
+          # Add ".." entry (parent directory)
+          parent = dir_info[:parent] || dir_info
+          data << build_directory_entry("\x01", parent, is_self: false)
+
+          # Add child entries
+          dir_info[:children].each do |child|
+            name = child[:name]
+            data << build_directory_entry(name, child, is_self: false)
+          end
+
+          data
+        end
+
+        # Build single directory entry
+        #
+        # @param name [String] Entry name
+        # @param entry_info [Hash] Entry information
+        # @param is_self [Boolean] Is this the "." entry
+        # @return [String] Directory entry record
+        def build_directory_entry(name, entry_info, is_self:)
+          record = +""
+
+          # Extended attribute length (0)
+          ext_attr_len = 0
+
+          # Calculate record length
+          name_len = name.bytesize
+          padding = name_len.even? ? 1 : 0
+          record_len = 33 + name_len + padding
+
+          # Byte 0: Length of directory record
+          record << [record_len].pack("C")
+
+          # Byte 1: Extended attribute record length
+          record << [ext_attr_len].pack("C")
+
+          # Bytes 2-9: Location of extent (both-endian)
+          location = entry_info[:location] || 0
+          record << [location].pack("V") # Little-endian
+          record << [location].pack("N") # Big-endian
+
+          # 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
+          record << encode_record_datetime(entry_info[:mtime] || Time.now)
+
+          # Byte 25: File flags
+          flags = 0
+          flags |= Iso::FLAG_DIRECTORY if entry_info[:directory]
+          record << [flags].pack("C")
+
+          # Byte 26: File unit size (0 for non-interleaved)
+          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
+          record << name
+
+          # Padding byte if name length is even
+          record << "\x00" if name_len.even?
+
+          record
+        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,  # Years since 1900
+            time.month,        # Month (1-12)
+            time.day,          # Day (1-31)
+            time.hour,         # Hour (0-23)
+            time.min,          # Minute (0-59)
+            time.sec,          # Second (0-59)
+            0, # GMT offset (0 = GMT)
+          ].pack("C7")
+        end
+
+        # Write file data
+        #
+        # @param io [IO] Output IO
+        def write_file_data(io)
+          @files.each do |file_info|
+            # Seek to file location
+            io.seek(file_info[:location] * Iso::SECTOR_SIZE)
+
+            # Write file data
+            File.open(file_info[:source], "rb") do |src|
+              while (data = src.read(Iso::SECTOR_SIZE))
+                # Pad to sector boundary
+                if data.bytesize < Iso::SECTOR_SIZE
+                  data += "\x00" * (Iso::SECTOR_SIZE - data.bytesize)
+                end
+                io.write(data)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end