omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/gzip.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module Omnizip
+  module Formats
+    # GZIP compression format
+    #
+    # GZIP is a file compression format that wraps Deflate compression
+    # with a 10-byte header and 8-byte footer containing CRC32 and
+    # uncompressed size.
+    #
+    # Format structure:
+    # - Header (10 bytes minimum):
+    #   - Magic bytes: 0x1F 0x8B
+    #   - Compression method: 0x08 (Deflate)
+    #   - Flags
+    #   - Modification time (4 bytes)
+    #   - Extra flags
+    #   - OS type
+    # - Compressed data (Deflate)
+    # - Footer (8 bytes):
+    #   - CRC32 (4 bytes)
+    #   - Uncompressed size (4 bytes, modulo 2^32)
+    module Gzip
+      # GZIP magic bytes
+      GZIP_MAGIC = [0x1F, 0x8B].pack("C*")
+
+      # Compression method (Deflate)
+      CM_DEFLATE = 8
+
+      # Flag bits
+      FTEXT = 0x01      # File is text
+      FHCRC = 0x02      # Header CRC present
+      FEXTRA = 0x04     # Extra fields present
+      FNAME = 0x08      # Original filename present
+      FCOMMENT = 0x10   # Comment present
+
+      # OS types
+      OS_FAT = 0        # FAT filesystem
+      OS_UNIX = 3       # Unix
+      OS_UNKNOWN = 255  # Unknown
+
+      class << self
+        # Compress a file with GZIP
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output GZIP file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :level Compression level (0-9)
+        # @option options [String] :original_name Original filename
+        # @option options [Time] :mtime Modification time
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            original_name = options[:original_name] ||
+              File.basename(input_path)
+            compress_stream(
+              StringIO.new(input_data),
+              output,
+              options.merge(original_name: original_name),
+            )
+          end
+        end
+
+        # Decompress a GZIP file
+        #
+        # @param input_path [String] Input GZIP file path
+        # @param output_path [String] Output file path
+        def decompress(input_path, output_path)
+          File.open(input_path, "rb") do |input|
+            File.open(output_path, "wb") do |output|
+              decompress_stream(input, output)
+            end
+          end
+        end
+
+        # Compress data stream with GZIP
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, output_io, options = {})
+          input_data = input_io.read
+          level = options[:level] || Zlib::DEFAULT_COMPRESSION
+          mtime = options[:mtime] || Time.now
+          original_name = options[:original_name]
+
+          # Write GZIP header
+          write_header(output_io, mtime, original_name)
+
+          # RFC 1952 member: header + RAW deflate + CRC32/ISIZE footer.
+          # The old implementation layered zlib's own GZIP wrapper
+          # under this header (a second 1F 8B magic) — the gem's
+          # reader tolerated it, but every standard gzip tool
+          # rejected the output. Raw-window mode emits bare DEFLATE.
+          deflate = Zlib::Deflate.new(level, -Zlib::MAX_WBITS)
+          output_io.write(deflate.deflate(input_data, Zlib::FINISH))
+          deflate.close
+
+          # Write GZIP footer
+          write_footer(output_io, input_data)
+        end
+
+        # Decompress GZIP stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @return [Hash] Metadata (original_name, mtime)
+        def decompress_stream(input_io, output_io)
+          data = input_io.read
+
+          # Metadata comes from the header either way (cheap parse).
+          metadata = read_header(StringIO.new(data))
+
+          # The tier gets the WHOLE member (header + deflate + trailer)
+          # — the Rust "gzip" name decodes the container end-to-end.
+          decompressed = Backends.decompress("gzip", data, Backends::UNKNOWN_LENGTH) do
+            body = StringIO.new(data)
+            read_header(body) # skip past the header
+            # Legacy double-header members (written before the RFC
+            # 1952 fix) carry zlib's own 10-byte GZIP header here;
+            # standard members carry bare DEFLATE.
+            rest = body.read
+            rest = rest.byteslice(10..) if rest.byteslice(0, 2) == "\x1F\x8B".b
+            inflate = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inflate.inflate(rest)
+            inflate.close
+            result
+          end
+
+          output_io.write(decompressed)
+
+          metadata
+        end
+
+        private
+
+        # Write GZIP header
+        #
+        # @param output [IO] Output stream
+        # @param mtime [Time] Modification time
+        # @param original_name [String, nil] Original filename
+        def write_header(output, mtime, original_name = nil)
+          flags = 0
+          flags |= FNAME if original_name
+
+          header = [
+            0x1F, 0x8B,           # Magic
+            CM_DEFLATE,           # Compression method
+            flags,                # Flags
+            mtime.to_i,           # Modification time
+            0,                    # Extra flags
+            OS_UNIX               # OS type
+          ].pack("C C C C V C C")
+
+          output.write(header)
+
+          # Write original filename if present
+          return unless original_name
+
+          output.write(original_name)
+          output.write("\0")
+        end
+
+        # Read GZIP header
+        #
+        # @param input [IO] Input stream
+        # @return [Hash] Header metadata
+        def read_header(input)
+          magic = input.read(2)
+          unless magic == GZIP_MAGIC
+            raise Error, "Not a GZIP file (invalid magic bytes)"
+          end
+
+          cm = input.read(1).unpack1("C")
+          unless cm == CM_DEFLATE
+            raise Error, "Unsupported GZIP compression method: #{cm}"
+          end
+
+          flags = input.read(1).unpack1("C")
+          mtime = Time.at(input.read(4).unpack1("V"))
+          _xfl = input.read(1)
+          _os = input.read(1)
+
+          metadata = { mtime: mtime }
+
+          # Read extra fields if present
+          if flags.anybits?(FEXTRA)
+            xlen = input.read(2).unpack1("v")
+            input.read(xlen) # Skip extra data
+          end
+
+          # Read original filename if present
+          if flags.anybits?(FNAME)
+            name = +""
+            loop do
+              byte = input.read(1)
+              break if byte == "\0"
+
+              name << byte
+            end
+            metadata[:original_name] = name
+          end
+
+          # Read comment if present
+          if flags.anybits?(FCOMMENT)
+            loop do
+              byte = input.read(1)
+              break if byte == "\0"
+            end
+          end
+
+          # Read header CRC if present
+          input.read(2) if flags.anybits?(FHCRC)
+
+          metadata
+        end
+
+        # Write GZIP footer
+        #
+        # @param output [IO] Output stream
+        # @param uncompressed_data [String] Original uncompressed data
+        def write_footer(output, uncompressed_data)
+          crc32 = Zlib.crc32(uncompressed_data)
+          size = uncompressed_data.bytesize & 0xFFFFFFFF
+
+          footer = [crc32, size].pack("VV")
+          output.write(footer)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,321 @@
+# 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)
+
+          # Tree nodes are separate hashes from @files entries; copy
+          # the allocated file locations onto the tree so directory
+          # records reference the real extents (otherwise every
+          # record points at sector 0).
+          assign_file_locations(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
+
+        # Copy allocated file locations onto the matching tree nodes
+        #
+        # @param tree [Hash] Directory tree root
+        def assign_file_locations(tree)
+          walk = lambda do |node|
+            (node[:children] || []).each do |child|
+              if child[:directory]
+                walk.call(child)
+              else
+                match = @files.find { |f| f[:iso_path] == child[:iso_path] }
+                child[:location] = match[:location] if match
+                child[:size] = match[:size] if match
+              end
+            end
+          end
+          walk.call(tree)
+        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,162 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Iso
+      # ISO 9660 Directory Record
+      # Represents a file or directory entry
+      class DirectoryRecord
+        include Omnizip::Entry
+
+        attr_accessor :full_path
+        attr_reader :length, :extended_attr_length, :location, :data_length, :recording_date, :flags, :file_unit_size, :interleave_gap_size, :volume_sequence_number, :name, :system_use
+
+        def entry_name = full_path || name
+        def entry_directory? = directory?
+        def entry_size = data_length
+        def entry_mtime = recording_date
+
+        # Set the full path for this record, used by Reader when walking
+        # a directory tree. Allows callers to look up records by path
+        # without re-joining parent names.
+
+        # 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