omnizip 0.3.1

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

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Directory Structure Builder
+      #
+      # Builds the hierarchical directory structure for an ISO image,
+      # allocating sectors for directories and files.
+      class DirectoryBuilder
+        # @return [Array<Hash>] Files to add
+        attr_reader :files
+
+        # @return [Array<Hash>] Directories to add
+        attr_reader :directories
+
+        # @return [Integer] ISO level
+        attr_reader :level
+
+        # @return [Boolean] Rock Ridge enabled
+        attr_reader :rock_ridge
+
+        # Initialize directory builder
+        #
+        # @param files [Array<Hash>] Files to include
+        # @param directories [Array<Hash>] Directories to include
+        # @param options [Hash] Builder options
+        def initialize(files, directories, options = {})
+          @files = files
+          @directories = directories
+          @level = options.fetch(:level, 2)
+          @rock_ridge = options.fetch(:rock_ridge, false)
+          @current_sector = 22 # After volume descriptors and path tables
+        end
+
+        # Build directory structure
+        #
+        # @return [Hash] Complete directory structure with allocations
+        def build
+          # Build directory tree
+          tree = build_directory_tree
+
+          # Allocate sectors for directories and files
+          allocate_sectors(tree)
+
+          # Build path table
+          path_table = build_path_table(tree)
+
+          {
+            root: tree,
+            directories: flatten_directories(tree),
+            files: @files,
+            path_table: path_table,
+            path_table_size: path_table.bytesize,
+            total_sectors: @current_sector,
+          }
+        end
+
+        private
+
+        # Build directory tree from files and directories
+        #
+        # @return [Hash] Root directory node
+        def build_directory_tree
+          root = {
+            name: "\x00", # Root directory identifier
+            iso_path: "",
+            children: [],
+            directory: true,
+            stat: nil,
+          }
+
+          # Add all directories first
+          @directories.each do |dir_info|
+            add_to_tree(root, dir_info[:iso_path], dir_info)
+          end
+
+          # Add all files
+          @files.each do |file_info|
+            add_to_tree(root, file_info[:iso_path], file_info)
+          end
+
+          root
+        end
+
+        # Add entry to directory tree
+        #
+        # @param root [Hash] Root node
+        # @param path [String] Entry path
+        # @param info [Hash] Entry information
+        def add_to_tree(root, path, info)
+          parts = path.split("/")
+          current = root
+
+          # Navigate/create directory structure
+          parts[0...-1].each do |part|
+            # Ensure current node has children array (it should be a directory)
+            current[:children] ||= []
+            child = current[:children].find { |c| c[:name] == part }
+
+            unless child
+              child = {
+                name: part,
+                iso_path: [current[:iso_path], part].reject(&:empty?).join("/"),
+                children: [],
+                directory: true,
+                stat: nil,
+              }
+              current[:children] << child
+            end
+
+            current = child
+          end
+
+          # Add the actual entry
+          entry_name = parts.last
+          entry = {
+            name: entry_name,
+            iso_path: path,
+            children: info[:directory] ? [] : nil,
+            directory: info[:directory] || false,
+            stat: info[:stat],
+            source: info[:source],
+            size: info[:directory] ? 0 : File.size(info[:source]),
+          }
+
+          # Ensure current node has children array
+          current[:children] ||= []
+          current[:children] << entry
+        end
+
+        # Allocate sectors for all entries
+        #
+        # @param tree [Hash] Directory tree
+        def allocate_sectors(tree)
+          # Allocate for root directory
+          allocate_directory_sectors(tree)
+
+          # Recursively allocate for children
+          allocate_children_sectors(tree)
+
+          # Allocate for files
+          allocate_file_sectors
+        end
+
+        # Allocate sectors for a directory
+        #
+        # @param dir_node [Hash] Directory node
+        def allocate_directory_sectors(dir_node)
+          # Calculate directory size
+          dir_size = calculate_directory_size(dir_node)
+          sectors_needed = (dir_size.to_f / Iso::SECTOR_SIZE).ceil
+
+          # Allocate location
+          dir_node[:location] = @current_sector
+          dir_node[:size] = dir_size
+
+          @current_sector += sectors_needed
+        end
+
+        # Calculate directory data size
+        #
+        # @param dir_node [Hash] Directory node
+        # @return [Integer] Size in bytes
+        def calculate_directory_size(dir_node)
+          size = 0
+
+          # Size for "." entry (34 bytes minimum)
+          size += 34
+
+          # Size for ".." entry
+          size += 34
+
+          # Size for each child entry
+          dir_node[:children].each do |child|
+            name_len = child[:name].bytesize
+            padding = name_len.even? ? 1 : 0
+            entry_size = 33 + name_len + padding
+
+            # Add Rock Ridge System Use fields if enabled
+            entry_size += calculate_rock_ridge_size(child) if @rock_ridge
+
+            size += entry_size
+          end
+
+          # Round up to sector boundary
+          ((size.to_f / Iso::SECTOR_SIZE).ceil * Iso::SECTOR_SIZE)
+        end
+
+        # Calculate Rock Ridge System Use field size
+        #
+        # @param entry [Hash] Entry information
+        # @return [Integer] Size in bytes
+        def calculate_rock_ridge_size(_entry)
+          # Basic Rock Ridge fields:
+          # - PX (POSIX attributes): 44 bytes
+          # - TF (timestamps): 26 bytes
+          # - NM (alternate name): variable
+          # For now, estimate 100 bytes
+          100
+        end
+
+        # Allocate sectors for children recursively
+        #
+        # @param dir_node [Hash] Directory node
+        def allocate_children_sectors(dir_node)
+          dir_node[:children].each do |child|
+            next unless child[:directory]
+
+            allocate_directory_sectors(child)
+            allocate_children_sectors(child)
+          end
+        end
+
+        # Allocate sectors for files
+        def allocate_file_sectors
+          @files.each do |file_info|
+            file_size = file_info[:stat].size
+            sectors_needed = (file_size.to_f / Iso::SECTOR_SIZE).ceil
+
+            file_info[:location] = @current_sector
+            file_info[:size] = file_size
+
+            @current_sector += sectors_needed
+          end
+        end
+
+        # Build path table from directory tree
+        #
+        # @param tree [Hash] Directory tree
+        # @return [String] Path table data
+        def build_path_table(tree)
+          table = +""
+          directories = []
+
+          # Collect all directories in path table order
+          collect_directories_for_path_table(tree, directories)
+
+          # Build path table entries
+          directories.each_with_index do |dir, _idx|
+            name = dir[:name] == "\x00" ? "\x00" : dir[:name]
+            parent_idx = dir[:parent_idx] || 0
+
+            # Name length
+            table << [name.bytesize].pack("C")
+
+            # Extended attribute length
+            table << [0].pack("C")
+
+            # Location of extent
+            table << [dir[:location]].pack("V")
+
+            # Parent directory number (1-based)
+            table << [parent_idx + 1].pack("v")
+
+            # Directory name
+            table << name
+
+            # Pad to even length
+            table << "\x00" if name.bytesize.odd?
+          end
+
+          table
+        end
+
+        # Collect directories in depth-first order for path table
+        #
+        # @param node [Hash] Current node
+        # @param list [Array<Hash>] Output list
+        # @param parent_idx [Integer, nil] Parent index
+        def collect_directories_for_path_table(node, list, parent_idx = nil)
+          current_idx = list.size
+          node[:parent_idx] = parent_idx
+          list << node
+
+          node[:children].select { |c| c[:directory] }.each do |child|
+            collect_directories_for_path_table(child, list, current_idx)
+          end
+        end
+
+        # Flatten directory tree to array
+        #
+        # @param tree [Hash] Directory tree
+        # @return [Array<Hash>] Flat directory list
+        def flatten_directories(tree)
+          result = [tree]
+
+          tree[:children].select { |c| c[:directory] }.each do |child|
+            result.concat(flatten_directories(child))
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Directory Record
+      # Represents a file or directory entry
+      class DirectoryRecord
+        attr_reader :length, :extended_attr_length, :location, :data_length,
+                    :recording_date, :flags, :file_unit_size, :interleave_gap_size,
+                    :volume_sequence_number, :name, :system_use
+
+        # Parse directory record from binary data
+        #
+        # @param data [String] Binary record data
+        # @param offset [Integer] Offset in data to start parsing
+        # @return [DirectoryRecord] Parsed record
+        def self.parse(data, offset = 0)
+          new.tap { |record| record.parse(data, offset) }
+        end
+
+        # Parse record data
+        #
+        # @param data [String] Binary data
+        # @param offset [Integer] Starting offset
+        def parse(data, offset = 0)
+          # Byte 0: Length of directory record
+          @length = data.getbyte(offset)
+          return if @length.zero? # Padding
+
+          # Byte 1: Extended attribute record length
+          @extended_attr_length = data.getbyte(offset + 1)
+
+          # Bytes 2-9: Location of extent (both-endian)
+          @location = data[offset + 2, 4].unpack1("V")
+
+          # Bytes 10-17: Data length (both-endian)
+          @data_length = data[offset + 10, 4].unpack1("V")
+
+          # Bytes 18-24: Recording date and time
+          @recording_date = parse_record_datetime(data[offset + 18, 7])
+
+          # Byte 25: File flags
+          @flags = data.getbyte(offset + 25)
+
+          # Byte 26: File unit size (for interleaved files)
+          @file_unit_size = data.getbyte(offset + 26)
+
+          # Byte 27: Interleave gap size
+          @interleave_gap_size = data.getbyte(offset + 27)
+
+          # Bytes 28-31: Volume sequence number (both-endian)
+          @volume_sequence_number = data[offset + 28, 2].unpack1("v")
+
+          # Byte 32: Length of file identifier
+          name_length = data.getbyte(offset + 32)
+
+          # Bytes 33+: File identifier
+          @name = data[offset + 33, name_length]
+
+          # Parse file identifier
+          parse_name
+
+          # System Use field (Rock Ridge extensions, etc.)
+          # Located after name and padding
+          su_offset = offset + 33 + name_length
+          su_offset += 1 if name_length.even? # Padding byte
+
+          return unless su_offset < offset + @length
+
+          @system_use = data[su_offset, offset + @length - su_offset]
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean] true if directory
+        def directory?
+          @flags.anybits?(Iso::FLAG_DIRECTORY)
+        end
+
+        # Check if entry is hidden
+        #
+        # @return [Boolean] true if hidden
+        def hidden?
+          @flags.anybits?(Iso::FLAG_HIDDEN)
+        end
+
+        # Check if this is the current directory entry
+        #
+        # @return [Boolean] true if current directory
+        def current_directory?
+          @name == "\x00"
+        end
+
+        # Check if this is the parent directory entry
+        #
+        # @return [Boolean] true if parent directory
+        def parent_directory?
+          @name == "\x01"
+        end
+
+        # Get file size
+        #
+        # @return [Integer] Size in bytes
+        def size
+          @data_length
+        end
+
+        # Get modification time
+        #
+        # @return [Time, nil] Modification time
+        def mtime
+          @recording_date
+        end
+
+        private
+
+        # Parse directory record datetime (7-byte format)
+        #
+        # @param data [String] 7-byte datetime
+        # @return [Time, nil] Parsed time
+        def parse_record_datetime(data)
+          return nil if data.nil? || data.bytesize < 7
+
+          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)
+          # Timezone offset at byte 6 (15-minute intervals from GMT)
+
+          Time.new(year, month, day, hour, minute, second)
+        rescue ArgumentError
+          nil
+        end
+
+        # Parse file identifier name
+        def parse_name
+          # Special cases for current and parent directory
+          return if @name == "\x00" || @name == "\x01"
+
+          # Remove version number (;1) if present
+          @name = @name.split(";").first if @name.include?(";")
+
+          # Convert to UTF-8 and strip
+          @name = @name.force_encoding("UTF-8").strip
+        end
+      end
+    end
+  end
+end

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