omnizip 0.4.7-x86_64-linux

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

@@ -0,0 +1,461 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "digest"
+require "fileutils"
+require "stringio"
+
+module Omnizip
+  module Formats
+    module Xar
+      # XAR archive writer
+      #
+      # Provides write access to create XAR archives with support for:
+      # - Multiple compression algorithms (gzip, bzip2, lzma, xz, none)
+      # - Checksum generation (md5, sha1, sha256, etc.)
+      # - Extended attributes
+      # - Hardlinks and symlinks
+      class Writer
+        include Omnizip::Formats::Xar::Constants
+
+        attr_reader :output_path, :entries, :options
+
+        # Create a XAR archive
+        #
+        # @param output_path [String] Path to output file
+        # @param options [Hash] Archive options
+        # @yield [Writer] Writer instance for adding files
+        # @return [String] Path to created archive
+        def self.create(output_path, options = {})
+          writer = new(output_path, options)
+
+          yield writer if block_given?
+
+          writer.write
+          output_path
+        end
+
+        # Initialize writer
+        #
+        # @param output_path [String] Path to output file
+        # @param options [Hash] Archive options
+        # @option options [String] :compression Compression algorithm (gzip, bzip2, lzma, xz, none)
+        # @option options [Integer] :compression_level Compression level (1-9)
+        # @option options [String] :toc_checksum TOC checksum algorithm (sha1, md5, sha256)
+        # @option options [String] :file_checksum File checksum algorithm (sha1, md5, sha256)
+        def initialize(output_path, options = {})
+          @output_path = output_path
+          @options = {
+            compression: DEFAULT_COMPRESSION,
+            compression_level: DEFAULT_COMPRESSION_LEVEL,
+            toc_checksum: DEFAULT_TOC_CHECKSUM,
+            file_checksum: DEFAULT_FILE_CHECKSUM,
+          }.merge(options)
+
+          @entries = []
+          @heap_data = +""
+          @next_id = 1
+          @hardlinks = {} # inode -> entry mapping for hardlink detection
+        end
+
+        # Add file to archive
+        #
+        # @param path [String] File path (on disk)
+        # @param archive_path [String, nil] Path in archive (defaults to basename)
+        # @return [Entry] Added entry
+        def add_file(path, archive_path = nil)
+          archive_path ||= File.basename(path)
+          stat = File.stat(path)
+
+          entry = Entry.new(archive_path, {
+                              type: TYPE_FILE,
+                              mode: stat.mode & 0o7777,
+                              uid: stat.uid,
+                              gid: stat.gid,
+                              size: stat.size,
+                              mtime: stat.mtime,
+                              atime: stat.atime,
+                              ctime: to_time(stat.ctime),
+                            })
+
+          # Check for hardlink
+          if stat.nlink > 1
+            inode_key = "#{stat.dev}:#{stat.ino}"
+            if (existing = @hardlinks[inode_key])
+              # Create hardlink entry instead
+              entry.type = TYPE_HARDLINK
+              entry.link_type = "hard"
+              entry.link_target = existing.name
+              entry.nlink = stat.nlink
+            else
+              @hardlinks[inode_key] = entry
+              read_and_add_file_data(entry, path)
+            end
+          else
+            read_and_add_file_data(entry, path)
+          end
+
+          add_entry(entry)
+        end
+
+        # Add directory to archive
+        #
+        # @param path [String] Directory path (on disk)
+        # @param archive_path [String, nil] Path in archive
+        # @return [Entry] Added entry
+        def add_directory(path, archive_path = nil)
+          archive_path ||= File.basename(path)
+          stat = File.stat(path)
+
+          entry = Entry.new(archive_path, {
+                              type: TYPE_DIRECTORY,
+                              mode: stat.mode & 0o7777,
+                              uid: stat.uid,
+                              gid: stat.gid,
+                              mtime: stat.mtime,
+                              atime: stat.atime,
+                              ctime: to_time(stat.ctime),
+                            })
+
+          add_entry(entry)
+        end
+
+        # Add symlink to archive
+        #
+        # @param path [String] Symlink path (on disk)
+        # @param archive_path [String, nil] Path in archive
+        # @return [Entry] Added entry
+        def add_symlink(path, archive_path = nil)
+          archive_path ||= File.basename(path)
+          stat = File.lstat(path)
+
+          entry = Entry.new(archive_path, {
+                              type: TYPE_SYMLINK,
+                              mode: stat.mode & 0o7777,
+                              uid: stat.uid,
+                              gid: stat.gid,
+                              mtime: stat.mtime,
+                              atime: stat.atime,
+                              link_type: "symbolic",
+                              link_target: File.readlink(path),
+                            })
+
+          add_entry(entry)
+        end
+
+        # Add entry from data
+        #
+        # @param archive_path [String] Path in archive
+        # @param data [String] File data
+        # @param options [Hash] Entry options
+        # @return [Entry] Added entry
+        def add_data(archive_path, data, options = {})
+          entry = Entry.new(archive_path, {
+                              type: TYPE_FILE,
+                              mode: options[:mode] || 0o644,
+                              mtime: options[:mtime] || Time.now,
+                              atime: options[:atime] || Time.now,
+                              **options,
+                            })
+
+          entry.data = data
+          compress_and_add_entry_data(entry, data)
+          add_entry(entry)
+        end
+
+        # Add entry to archive
+        #
+        # @param entry [Entry] Entry to add
+        # @return [Entry] Added entry
+        def add_entry(entry)
+          entry.id ||= @next_id
+          @next_id = [@next_id, entry.id + 1].max
+          @entries << entry
+          entry
+        end
+
+        # Add tree (directory recursively) to archive
+        #
+        # @param path [String] Root directory path
+        # @param archive_path [String, nil] Base path in archive
+        def add_tree(path, archive_path = nil)
+          stat = File.lstat(path)
+
+          if stat.symlink?
+            add_symlink(path, archive_path)
+          elsif stat.directory?
+            add_directory(path, archive_path)
+
+            Dir.foreach(path) do |entry|
+              next if [".", ".."].include?(entry)
+
+              child_path = File.join(path, entry)
+              child_archive_path = if archive_path
+                                     File.join(archive_path,
+                                               entry)
+                                   else
+                                     entry
+                                   end
+              add_tree(child_path, child_archive_path)
+            end
+          else
+            add_file(path, archive_path)
+          end
+        end
+
+        # Write archive to disk
+        #
+        # @return [String] Output path
+        def write
+          File.open(@output_path, "wb") do |file|
+            # Reserve space for header (will write at end)
+            header = Header.new(
+              checksum_algorithm: checksum_to_constant(@options[:toc_checksum]),
+              checksum_name: checksum_needs_name(@options[:toc_checksum]) ? @options[:toc_checksum] : nil,
+            )
+            file.write("\x00" * header.header_size)
+
+            # Build TOC with heap offsets
+            toc = build_toc
+
+            # Write compressed TOC
+            compressed_toc = toc.compress
+            toc_uncompressed_size = toc.uncompressed_size
+            file.write(compressed_toc)
+
+            # Calculate and write TOC checksum
+            file.pos
+            toc_checksum_data = compute_checksum(compressed_toc,
+                                                 @options[:toc_checksum])
+            file.write(toc_checksum_data)
+            toc_checksum_size = toc_checksum_data.bytesize
+
+            # Update TOC checksum info
+            toc.checksum_offset = 0
+            toc.checksum_size = toc_checksum_size
+
+            # Write heap data
+            file.pos
+            file.write(@heap_data)
+
+            # Now write header at beginning
+            header = Header.new(
+              toc_compressed_size: compressed_toc.bytesize,
+              toc_uncompressed_size: toc_uncompressed_size,
+              checksum_algorithm: checksum_to_constant(@options[:toc_checksum]),
+              checksum_name: checksum_needs_name(@options[:toc_checksum]) ? @options[:toc_checksum] : nil,
+            )
+            file.seek(0)
+            file.write(header.to_bytes)
+          end
+
+          @output_path
+        end
+
+        private
+
+        # Coerce a ctime value (File::Stat returns Time on Unix, may
+        # return other types on Windows) into a Time.
+        def to_time(value)
+          return value if value.is_a?(Time)
+          return value.to_time if value.is_a?(Date) || value.is_a?(DateTime)
+
+          value
+        end
+
+        # Read file data and add to heap
+        #
+        # @param entry [Entry] Entry to populate
+        # @param path [String] File path
+        def read_and_add_file_data(entry, path)
+          data = File.binread(path)
+          entry.size = data.bytesize
+          compress_and_add_entry_data(entry, data)
+        end
+
+        # Compress and add entry data to heap
+        #
+        # @param entry [Entry] Entry to populate
+        # @param data [String] Uncompressed data
+        def compress_and_add_entry_data(entry, data)
+          return if data.nil? || data.empty?
+
+          # Calculate extracted checksum
+          entry.extracted_checksum = compute_checksum_hex(data,
+                                                          @options[:file_checksum])
+          entry.extracted_checksum_style = @options[:file_checksum]
+
+          # Compress data
+          compressed = compress_data(data)
+          entry.data_encoding = @options[:compression]
+          entry.data_length = compressed.bytesize
+          entry.data_size = data.bytesize
+
+          # Calculate archived checksum
+          entry.archived_checksum = compute_checksum_hex(compressed,
+                                                         @options[:file_checksum])
+          entry.archived_checksum_style = @options[:file_checksum]
+
+          # Add to heap
+          # Data offset must account for TOC checksum at start of heap
+          checksum_size = CHECKSUM_SIZES[@options[:toc_checksum]] || 0
+          entry.data_offset = checksum_size + @heap_data.bytesize
+          @heap_data << compressed
+        end
+
+        # Compress data based on configured algorithm
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] Compressed data
+        def compress_data(data)
+          case @options[:compression]
+          when COMPRESSION_GZIP
+            compress_gzip(data)
+          when COMPRESSION_BZIP2
+            compress_bzip2(data)
+          when COMPRESSION_LZMA
+            compress_lzma(data)
+          when COMPRESSION_XZ
+            compress_xz(data)
+          else
+            data
+          end
+        end
+
+        # Compress with gzip
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] Gzip compressed data
+        def compress_gzip(data)
+          level = @options[:compression_level] || DEFAULT_COMPRESSION_LEVEL
+          zlib = Zlib::Deflate.new(level, -Zlib::MAX_WBITS)
+          result = zlib.deflate(data, Zlib::FINISH)
+          zlib.close
+          result
+        end
+
+        # Compress with bzip2
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] Bzip2 compressed data
+        def compress_bzip2(data)
+          compressor = Omnizip::Algorithms::Bzip2::Compressor.new(
+            level: @options[:compression_level] || DEFAULT_COMPRESSION_LEVEL,
+          )
+          compressor.compress(data)
+        end
+
+        # Compress with LZMA
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] LZMA compressed data
+        def compress_lzma(data)
+          encoder = Omnizip::Algorithms::Lzma::Encoder.new(
+            level: @options[:compression_level] || DEFAULT_COMPRESSION_LEVEL,
+          )
+          encoder.encode(data)
+        end
+
+        # Compress with XZ
+        #
+        # @param data [String] Uncompressed data
+        # @return [String] XZ compressed data
+        def compress_xz(data)
+          output = StringIO.new
+          writer = Omnizip::Formats::Xz::StreamWriter.new(output,
+                                                          level: @options[:compression_level] || DEFAULT_COMPRESSION_LEVEL)
+          writer.write(data)
+          writer.close
+          output.string
+        end
+
+        # Compute checksum (returns binary data)
+        #
+        # @param data [String] Data to checksum
+        # @param algorithm [String] Checksum algorithm
+        # @return [String] Binary checksum
+        def compute_checksum(data, algorithm)
+          case algorithm.to_s.downcase
+          when "md5"
+            Digest::MD5.digest(data)
+          when "sha1"
+            Digest::SHA1.digest(data)
+          when "sha224"
+            Digest::SHA2.new(224).digest(data)
+          when "sha256"
+            Digest::SHA256.digest(data)
+          when "sha384"
+            Digest::SHA2.new(384).digest(data)
+          when "sha512"
+            Digest::SHA512.digest(data)
+          else
+            ""
+          end
+        end
+
+        # Compute checksum as hex string (for XML attributes)
+        #
+        # @param data [String] Data to checksum
+        # @param algorithm [String] Checksum algorithm
+        # @return [String] Hex checksum string
+        def compute_checksum_hex(data, algorithm)
+          case algorithm.to_s.downcase
+          when "md5"
+            Digest::MD5.hexdigest(data)
+          when "sha1"
+            Digest::SHA1.hexdigest(data)
+          when "sha224"
+            Digest::SHA2.new(224).hexdigest(data)
+          when "sha256"
+            Digest::SHA256.hexdigest(data)
+          when "sha384"
+            Digest::SHA2.new(384).hexdigest(data)
+          when "sha512"
+            Digest::SHA512.hexdigest(data)
+          else
+            ""
+          end
+        end
+
+        # Convert checksum name to constant
+        #
+        # @param name [String] Checksum name
+        # @return [Integer] Checksum constant
+        def checksum_to_constant(name)
+          case name.to_s.downcase
+          when "none"
+            CKSUM_NONE
+          when "sha1"
+            CKSUM_SHA1
+          when "md5"
+            CKSUM_MD5
+          else
+            CKSUM_OTHER
+          end
+        end
+
+        # Check if checksum needs name in header
+        #
+        # @param name [String] Checksum name
+        # @return [Boolean] true if name needed
+        def checksum_needs_name(name)
+          !["none", "sha1", "md5"].include?(name.to_s.downcase)
+        end
+
+        # Build TOC from entries
+        #
+        # @return [Toc] TOC object
+        def build_toc
+          toc = Toc.new
+          toc.checksum_style = @options[:toc_checksum]
+
+          @entries.each do |entry|
+            toc.add_entry(entry)
+          end
+
+          toc
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xar.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # XAR archive format support
+    #
+    # XAR (eXtensible ARchive) format is primarily used on macOS for:
+    # - Software packages (.pkg files)
+    # - OS installers
+    # - Software distribution
+    #
+    # Features:
+    # - GZIP-compressed XML Table of Contents (TOC)
+    # - Multiple compression algorithms (gzip, bzip2, lzma, xz, none)
+    # - Checksum verification (MD5, SHA1, SHA256, etc.)
+    # - Extended attributes (xattrs)
+    # - Hardlinks and symlinks
+    # - Device nodes and FIFOs
+    #
+    # @example Create XAR archive
+    #   Omnizip::Formats::Xar.create('archive.xar') do |xar|
+    #     xar.add_file('document.pdf')
+    #     xar.add_directory('resources/')
+    #   end
+    #
+    # @example Extract XAR archive
+    #   Omnizip::Formats::Xar.extract('archive.xar', 'output/')
+    #
+    # @example List XAR contents
+    #   entries = Omnizip::Formats::Xar.list('archive.xar')
+    #   entries.each { |e| puts "#{e.name} (#{e.size} bytes)" }
+    module Xar
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/formats/xar/constants"
+      autoload :Header, "omnizip/formats/xar/header"
+      autoload :Entry, "omnizip/formats/xar/entry"
+      autoload :Toc, "omnizip/formats/xar/toc"
+      autoload :Reader, "omnizip/formats/xar/reader"
+      autoload :Writer, "omnizip/formats/xar/writer"
+
+      # Re-export constants for external access
+      CKSUM_NONE = Constants::CKSUM_NONE
+      CKSUM_SHA1 = Constants::CKSUM_SHA1
+      CKSUM_MD5 = Constants::CKSUM_MD5
+      CKSUM_OTHER = Constants::CKSUM_OTHER
+
+      class << self
+        # Create XAR archive
+        #
+        # @param path [String] Output XAR file path
+        # @param options [Hash] Archive options
+        # @option options [String] :compression Compression algorithm (gzip, bzip2, lzma, xz, none)
+        # @option options [Integer] :compression_level Compression level (1-9)
+        # @option options [String] :toc_checksum TOC checksum algorithm (sha1, md5, sha256)
+        # @option options [String] :file_checksum File checksum algorithm (sha1, md5, sha256)
+        # @yield [writer] Block for adding files/directories
+        # @yieldparam writer [Writer] XAR writer
+        # @return [String] Path to created archive
+        #
+        # @example Create archive with gzip compression
+        #   Omnizip::Formats::Xar.create('archive.xar', compression: 'gzip') do |xar|
+        #     xar.add_file('config.yml')
+        #     xar.add_directory('config.d/')
+        #   end
+        #
+        # @example Create archive with bzip2 and SHA256 checksums
+        #   Omnizip::Formats::Xar.create('archive.xar',
+        #     compression: 'bzip2',
+        #     toc_checksum: 'sha256',
+        #     file_checksum: 'sha256'
+        #   ) do |xar|
+        #     xar.add_file('data.bin')
+        #   end
+        def create(path, options = {})
+          Writer.create(path, options) do |writer|
+            yield writer if block_given?
+          end
+        end
+
+        # Open XAR archive for reading
+        #
+        # @param path [String] Path to XAR file
+        # @yield [reader] Block for reading archive
+        # @yieldparam reader [Reader] XAR reader
+        # @return [Reader] XAR reader
+        #
+        # @example Read XAR archive
+        #   Omnizip::Formats::Xar.open('archive.xar') do |xar|
+        #     xar.entries.each { |entry| puts entry.name }
+        #   end
+        def open(path)
+          reader = Reader.open(path)
+
+          if block_given?
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          else
+            reader
+          end
+        end
+
+        # List XAR archive contents
+        #
+        # @param path [String] Path to XAR file
+        # @return [Array<Entry>] Archive entries
+        #
+        # @example List archive contents
+        #   entries = Omnizip::Formats::Xar.list('archive.xar')
+        #   entries.each { |e| puts "#{e.name} (#{e.size} bytes)" }
+        def list(path)
+          open(path, &:entries) # rubocop:disable Security/Open
+        end
+
+        # Extract XAR archive
+        #
+        # @param xar_path [String] Path to XAR file
+        # @param output_dir [String] Output directory
+        #
+        # @example Extract archive
+        #   Omnizip::Formats::Xar.extract('archive.xar', 'output/')
+        def extract(xar_path, output_dir)
+          open(xar_path) do |xar| # rubocop:disable Security/Open
+            xar.extract_all(output_dir)
+          end
+        end
+
+        # Get archive information
+        #
+        # @param path [String] Path to XAR file
+        # @return [Hash] Archive information
+        #
+        # @example Get archive info
+        #   info = Omnizip::Formats::Xar.info('archive.xar')
+        #   puts "Format: XAR version #{info[:header][:version]}"
+        #   puts "Files: #{info[:file_count]}"
+        def info(path)
+          open(path, &:info) # rubocop:disable Security/Open
+        end
+      end
+    end
+  end
+end