omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/xar/header.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Xar
+      # XAR archive header parser and builder
+      #
+      # The XAR header is 28 bytes (or 64 bytes for extended format):
+      # - Bytes 0-3:   Magic number (0x78617221 = "xar!")
+      # - Bytes 4-5:   Header size (little-endian)
+      # - Bytes 6-7:   Format version (little-endian)
+      # - Bytes 8-15:  TOC compressed size (big-endian uint64)
+      # - Bytes 16-23: TOC uncompressed size (big-endian uint64)
+      # - Bytes 24-27: Checksum algorithm (big-endian uint32)
+      # - Bytes 28-63: (Optional) Checksum name for CKSUM_OTHER
+      class Header
+        include Omnizip::Formats::Xar::Constants
+
+        attr_reader :magic, :header_size, :version, :toc_compressed_size,
+                    :toc_uncompressed_size, :checksum_algorithm,
+                    :checksum_name
+
+        # Parse header from binary data
+        #
+        # @param data [String] Binary header data (28+ bytes)
+        # @return [Header] Parsed header object
+        # @raise [ArgumentError] If data is invalid
+        def self.parse(data)
+          if data.bytesize < HEADER_SIZE
+            raise ArgumentError,
+                  "Header data too short (#{data.bytesize} bytes)"
+          end
+
+          magic = data[0, 4].unpack1("N")
+          # XAR spec: header_size and version are little-endian, rest are big-endian
+          # However, some tools (like macOS xar) store these in big-endian format.
+          # We detect this by checking if the parsed values make sense.
+          header_size_le = data[4, 2].unpack1("v")  # little-endian
+          header_size_be = data[4, 2].unpack1("n")  # big-endian
+          version_le = data[6, 2].unpack1("v")      # little-endian
+          version_be = data[6, 2].unpack1("n")      # big-endian
+
+          # Detect endianness: standard header is 28 bytes, version is 1
+          # If little-endian gives valid values, use it; otherwise use big-endian
+          if header_size_le == HEADER_SIZE && version_le == XAR_VERSION
+            header_size = header_size_le
+            version = version_le
+          elsif header_size_be == HEADER_SIZE && version_be == XAR_VERSION
+            header_size = header_size_be
+            version = version_be
+          else
+            # Default to little-endian (spec-compliant)
+            header_size = header_size_le
+            version = version_le
+            # Normalize version 256 to 1 (big-endian encoding of version 1)
+            version = 1 if version == 256
+          end
+          toc_compressed_size = data[8, 8].unpack1("Q>") # big-endian uint64
+          toc_uncompressed_size = data[16, 8].unpack1("Q>") # big-endian uint64
+          checksum_algorithm = data[24, 4].unpack1("N")
+
+          # Parse checksum name for custom algorithms
+          checksum_name = nil
+          if checksum_algorithm == CKSUM_OTHER && data.bytesize >= HEADER_SIZE_EX
+            checksum_name = data[28, 36].strip
+          end
+
+          new(
+            magic: magic,
+            header_size: header_size,
+            version: version,
+            toc_compressed_size: toc_compressed_size,
+            toc_uncompressed_size: toc_uncompressed_size,
+            checksum_algorithm: checksum_algorithm,
+            checksum_name: checksum_name,
+          )
+        end
+
+        # Read header from file
+        #
+        # @param file [IO] File handle positioned at start
+        # @return [Header] Parsed header
+        def self.read(file)
+          data = file.read(HEADER_SIZE_EX) # Read max possible size
+          raise ArgumentError, "Failed to read header" unless data
+
+          # Parse to get actual header size
+          header = parse(data)
+
+          # Seek back if we read too much
+          if data.bytesize > header.header_size
+            file.seek(header.header_size, ::IO::SEEK_SET)
+          end
+
+          header
+        end
+
+        # Initialize header
+        #
+        # @param magic [Integer] Magic number
+        # @param header_size [Integer] Header size in bytes
+        # @param version [Integer] Format version
+        # @param toc_compressed_size [Integer] Compressed TOC size
+        # @param toc_uncompressed_size [Integer] Uncompressed TOC size
+        # @param checksum_algorithm [Integer] Checksum algorithm constant
+        # @param checksum_name [String, nil] Checksum name for CKSUM_OTHER
+        def initialize(magic: MAGIC,
+                       header_size: HEADER_SIZE,
+                       version: XAR_VERSION,
+                       toc_compressed_size: 0,
+                       toc_uncompressed_size: 0,
+                       checksum_algorithm: CKSUM_SHA1,
+                       checksum_name: nil)
+          @magic = magic
+          @header_size = checksum_algorithm == CKSUM_OTHER && checksum_name ? HEADER_SIZE_EX : header_size
+          @version = version
+          @toc_compressed_size = toc_compressed_size
+          @toc_uncompressed_size = toc_uncompressed_size
+          @checksum_algorithm = checksum_algorithm
+          @checksum_name = checksum_name
+        end
+
+        # Validate header
+        #
+        # @return [Boolean] true if valid
+        # @raise [ArgumentError] If header is invalid
+        def validate!
+          unless @magic == MAGIC
+            raise ArgumentError,
+                  format("Invalid magic: 0x%08x (expected 0x%08x)", @magic,
+                         MAGIC)
+          end
+
+          unless @header_size >= HEADER_SIZE
+            raise ArgumentError, "Header size too small: #{@header_size}"
+          end
+
+          unless @version == XAR_VERSION
+            raise ArgumentError, "Unsupported version: #{@version}"
+          end
+
+          unless [CKSUM_NONE, CKSUM_SHA1, CKSUM_MD5,
+                  CKSUM_OTHER].include?(@checksum_algorithm)
+            raise ArgumentError,
+                  "Unknown checksum algorithm: #{@checksum_algorithm}"
+          end
+
+          if @checksum_algorithm == CKSUM_OTHER && @checksum_name.to_s.strip.empty?
+            raise ArgumentError, "Custom checksum requires checksum_name"
+          end
+
+          true
+        end
+
+        # Check if header is valid
+        #
+        # @return [Boolean] true if valid
+        def valid?
+          validate!
+        rescue ArgumentError
+          false
+        end
+
+        # Get checksum algorithm name
+        #
+        # @return [String] Checksum algorithm name
+        def checksum_algorithm_name
+          if @checksum_algorithm == CKSUM_OTHER
+            @checksum_name || "unknown"
+          else
+            CHECKSUM_NAMES[@checksum_algorithm] || "unknown"
+          end
+        end
+
+        # Get checksum size in bytes
+        #
+        # @return [Integer] Checksum size
+        def checksum_size
+          CHECKSUM_SIZES[checksum_algorithm_name] || 0
+        end
+
+        # Check if checksum is used
+        #
+        # @return [Boolean] true if checksum is used
+        def checksum?
+          @checksum_algorithm != CKSUM_NONE
+        end
+
+        # Serialize header to binary
+        #
+        # @return [String] Binary header data
+        def to_bytes
+          data = +""
+          data << [@magic].pack("N")                    # 4 bytes, big-endian
+          data << [@header_size].pack("v")              # 2 bytes, little-endian
+          data << [@version].pack("v")                  # 2 bytes, little-endian
+          data << [@toc_compressed_size].pack("Q>")     # 8 bytes, big-endian
+          data << [@toc_uncompressed_size].pack("Q>")   # 8 bytes, big-endian
+          data << [@checksum_algorithm].pack("N")       # 4 bytes, big-endian
+
+          # Add checksum name for custom algorithms
+          if @checksum_algorithm == CKSUM_OTHER && @checksum_name
+            name_bytes = @checksum_name.to_s.encode("ASCII").ljust(36, "\x00")
+            data << name_bytes[0, 36]
+          end
+
+          data
+        end
+
+        # Update TOC sizes
+        #
+        # @param compressed [Integer] Compressed TOC size
+        # @param uncompressed [Integer] Uncompressed TOC size
+        # @return [Header] self for chaining
+        def update_toc_sizes(compressed, uncompressed)
+          @toc_compressed_size = compressed
+          @toc_uncompressed_size = uncompressed
+          self
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xar/reader.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "digest"
+require "fileutils"
+require "stringio"
+
+module Omnizip
+  module Formats
+    module Xar
+      # XAR archive reader
+      #
+      # Provides read access to XAR archives with support for:
+      # - Multiple compression algorithms (gzip, bzip2, lzma, xz, none)
+      # - Checksum verification
+      # - Extended attributes
+      # - Hardlinks and symlinks
+      class Reader
+        include Omnizip::Formats::Xar::Constants
+
+        attr_reader :file_path, :header, :toc, :entries
+
+        # Open a XAR archive for reading
+        #
+        # @param file_path [String] Path to XAR file
+        # @return [Reader] Reader instance
+        def self.open(file_path)
+          reader = new(file_path)
+          reader.open
+
+          if block_given?
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          else
+            reader
+          end
+        end
+
+        # Read and list entries from XAR archive
+        #
+        # @param file_path [String] Path to XAR file
+        # @return [Array<Entry>] List of entries
+        def self.list(file_path)
+          open(file_path, &:entries) # rubocop:disable Security/Open
+        end
+
+        # Extract XAR archive to directory
+        #
+        # @param file_path [String] Path to XAR file
+        # @param output_dir [String] Output directory
+        def self.extract(file_path, output_dir)
+          open(file_path) do |reader| # rubocop:disable Security/Open
+            reader.extract_all(output_dir)
+          end
+        end
+
+        # Initialize reader
+        #
+        # @param file_path [String] Path to XAR file
+        def initialize(file_path)
+          @file_path = file_path
+          @file = nil
+          @header = nil
+          @toc = nil
+          @entries = []
+          @heap_offset = 0
+        end
+
+        # Open and parse the archive
+        #
+        # @return [Reader] self
+        def open
+          @file = File.open(@file_path, "rb")
+          read_header
+          read_toc
+          self
+        end
+
+        # Close the archive
+        def close
+          @file&.close
+          @file = nil
+        end
+
+        # Check if archive is open
+        #
+        # @return [Boolean] true if open
+        def open?
+          !@file.nil?
+        end
+
+        # Get all entries
+        #
+        # @return [Array<Entry>] List of entries
+        def list
+          @entries
+        end
+
+        # Get entry by name
+        #
+        # @param name [String] Entry name
+        # @return [Entry, nil] Entry or nil if not found
+        def get_entry(name)
+          @entries.find { |e| e.name == name }
+        end
+
+        # Read entry data
+        #
+        # @param entry [Entry] Entry to read
+        # @return [String, nil] Entry data or nil if no data
+        def read_data(entry)
+          return nil unless entry.data_length&.positive?
+          return nil unless @file
+
+          @file.seek(@heap_offset + entry.data_offset)
+          # In XAR format:
+          # - data_length is the compressed (archived) size (what to read from heap)
+          # - data_size is the uncompressed (extracted) size (decompressed size)
+          compressed_data = @file.read(entry.data_length)
+
+          decompress_data(compressed_data, entry.data_encoding, entry.data_size)
+        end
+
+        # Extract all entries to directory
+        #
+        # @param output_dir [String] Output directory
+        def extract_all(output_dir)
+          FileUtils.mkdir_p(output_dir)
+
+          # Sort entries to ensure directories are created first
+          sorted_entries = @entries.sort_by do |e|
+            [e.directory? ? 0 : 1, e.name]
+          end
+
+          sorted_entries.each do |entry|
+            extract_entry(entry, output_dir)
+          end
+        end
+
+        # Extract single entry to directory
+        #
+        # @param entry [Entry] Entry to extract
+        # @param output_dir [String] Output directory
+        def extract_entry(entry, output_dir)
+          full_path = File.join(output_dir, entry.name)
+
+          case entry.type
+          when TYPE_DIRECTORY
+            FileUtils.mkdir_p(full_path)
+          when TYPE_SYMLINK
+            extract_symlink(entry, full_path)
+          when TYPE_HARDLINK
+            extract_hardlink(entry, full_path, output_dir)
+          when TYPE_FILE
+            extract_file(entry, full_path)
+          when TYPE_BLOCK, TYPE_CHAR
+            extract_device(entry, full_path)
+          when TYPE_FIFO
+            extract_fifo(entry, full_path)
+          else
+            # Unknown type, try to extract as file
+            extract_file(entry, full_path) if entry.data_size&.positive?
+          end
+
+          # Set file metadata
+          set_entry_metadata(entry, full_path)
+        end
+
+        # Get archive information
+        #
+        # @return [Hash] Archive info
+        def info
+          {
+            file_path: @file_path,
+            header: {
+              version: @header&.version,
+              checksum_algorithm: @header&.checksum_algorithm_name,
+              toc_compressed_size: @header&.toc_compressed_size,
+              toc_uncompressed_size: @header&.toc_uncompressed_size,
+            },
+            entry_count: @entries.size,
+            file_count: @entries.count(&:file?),
+            directory_count: @entries.count(&:directory?),
+            symlink_count: @entries.count(&:symlink?),
+            total_size: @entries.sum { |e| e.size || 0 },
+          }
+        end
+
+        private
+
+        # Read and parse header
+        def read_header
+          @header = Header.read(@file)
+          @header.validate!
+        end
+
+        # Read and parse TOC
+        def read_toc
+          # Read compressed TOC
+          @file.seek(@header.header_size)
+          compressed_toc = @file.read(@header.toc_compressed_size)
+
+          raise Omnizip::InvalidArchiveError, "Failed to read TOC" unless compressed_toc
+
+          # Parse TOC
+          @toc = Toc.parse(compressed_toc, @header.toc_uncompressed_size)
+          @entries = @toc.entries
+
+          # Calculate heap offset:
+          # The heap starts immediately after the compressed TOC.
+          # The TOC checksum is stored INSIDE the heap (at offset 0), not after it.
+          # File data offsets in the TOC are relative to the heap start.
+          @heap_offset = @header.header_size + @header.toc_compressed_size
+        end
+
+        # Decompress data based on encoding
+        #
+        # @param data [String] Compressed data
+        # @param encoding [String] Compression encoding
+        # @param expected_size [Integer] Expected decompressed size
+        # @return [String] Decompressed data
+        def decompress_data(data, encoding, _expected_size = nil)
+          case encoding
+          when COMPRESSION_GZIP, "application/x-gzip"
+            decompress_gzip(data)
+          when COMPRESSION_BZIP2, "application/x-bzip2"
+            decompress_bzip2(data)
+          when COMPRESSION_LZMA, "application/x-lzma"
+            decompress_lzma(data)
+          when COMPRESSION_XZ, "application/x-xz"
+            decompress_xz(data)
+          else
+            # No compression or unknown
+            data || +""
+          end
+        end
+
+        # Decompress gzip data
+        #
+        # @param data [String] Zlib compressed data (XAR uses zlib, not actual gzip)
+        # @return [String] Decompressed data
+        def decompress_gzip(data)
+          # XAR "gzip" compression is actually zlib format (with 0x78xx header)
+          # Try different decompression methods for robustness
+
+          # Method 1: Standard zlib format (with header)
+          begin
+            result = Zlib::Inflate.inflate(data)
+            return result
+          rescue Zlib::Error
+            # Continue to next method
+          end
+
+          # Method 2: Raw deflate (some implementations may use this)
+          begin
+            inf = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inf.inflate(data)
+            inf.finish
+            inf.close
+            return result
+          rescue Zlib::Error
+            # Continue to next method
+          end
+
+          # Method 3: Raw deflate without finish (for truncated data)
+          begin
+            inf = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            result = inf.inflate(data)
+            inf.close
+            result
+          rescue Zlib::Error => e
+            raise Omnizip::DecompressionError, "Failed to decompress data: #{e.message}"
+          end
+        end
+
+        # Decompress bzip2 data
+        #
+        # @param data [String] Bzip2 compressed data
+        # @return [String] Decompressed data
+        def decompress_bzip2(data)
+          decompressor = Omnizip::Algorithms::Bzip2::Decompressor.new
+          decompressor.decompress(data)
+        end
+
+        # Decompress LZMA data
+        #
+        # @param data [String] LZMA compressed data
+        # @return [String] Decompressed data
+        def decompress_lzma(data)
+          decoder = Omnizip::Algorithms::Lzma::Decoder.new
+          decoder.decode(data)
+        end
+
+        # Decompress XZ data
+        #
+        # @param data [String] XZ compressed data
+        # @return [String] Decompressed data
+        def decompress_xz(data)
+          reader = Omnizip::Formats::Xz::StreamReader.new(StringIO.new(data))
+          reader.read
+        ensure
+          reader&.close
+        end
+
+        # Extract file
+        #
+        # @param entry [Entry] File entry
+        # @param path [String] Output path
+        def extract_file(entry, path)
+          FileUtils.mkdir_p(File.dirname(path))
+
+          data = read_data(entry)
+          return unless data
+
+          File.binwrite(path, data)
+        end
+
+        # Extract symlink
+        #
+        # @param entry [Entry] Symlink entry
+        # @param path [String] Output path
+        def extract_symlink(entry, path)
+          FileUtils.mkdir_p(File.dirname(path))
+
+          target = entry.link_target
+          return unless target
+
+          File.unlink(path) if File.symlink?(path)
+          File.symlink(target, path)
+        end
+
+        # Extract hardlink
+        #
+        # @param entry [Entry] Hardlink entry
+        # @param path [String] Output path
+        # @param output_dir [String] Output directory
+        def extract_hardlink(entry, path, output_dir)
+          FileUtils.mkdir_p(File.dirname(path))
+
+          target = entry.link_target
+          return unless target
+
+          target_path = File.join(output_dir, target)
+
+          # If target exists, create hardlink
+          if File.exist?(target_path)
+            FileUtils.rm_f(path)
+            File.link(target_path, path)
+          end
+        end
+
+        # Extract device node
+        #
+        # @param entry [Entry] Device entry
+        # @param path [String] Output path
+        def extract_device(entry, path)
+          # Creating device nodes requires root privileges
+          # This is a no-op on most systems
+        end
+
+        # Extract FIFO
+        #
+        # @param entry [Entry] FIFO entry
+        # @param path [String] Output path
+        def extract_fifo(entry, path)
+          # Creating FIFOs may require privileges
+          # This is a no-op on most systems
+        end
+
+        # Set entry metadata on extracted file
+        #
+        # @param entry [Entry] Entry
+        # @param path [String] File path
+        def set_entry_metadata(entry, path)
+          return unless File.exist?(path)
+
+          # Set mode
+          File.chmod(entry.mode, path) if entry.mode&.positive?
+
+          # Set timestamps
+          if entry.mtime
+            File.utime(entry.atime || entry.mtime, entry.mtime, path)
+          end
+
+          # Set ownership (requires privileges)
+          if entry.uid && entry.gid
+            begin
+              File.chown(entry.uid, entry.gid, path)
+            rescue Errno::EPERM
+              # Ignore permission errors
+            end
+          end
+        end
+      end
+    end
+  end
+end