omnizip 0.3.1

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "constants"
+require_relative "entry"
+
+module Omnizip
+  module Formats
+    module Cpio
+      # CPIO archive reader
+      #
+      # Reads CPIO archives in newc, CRC, ODC, and binary formats.
+      # Automatically detects format from magic number.
+      #
+      # @example Read CPIO archive
+      #   reader = Cpio::Reader.new('archive.cpio')
+      #   reader.open
+      #   reader.entries.each { |entry| puts entry.name }
+      #
+      # @example Extract CPIO archive
+      #   reader = Cpio::Reader.new('archive.cpio')
+      #   reader.open
+      #   reader.extract_all('output/')
+      class Reader
+        include Constants
+
+        # @return [String] Archive file path
+        attr_reader :file_path
+
+        # @return [Array<Entry>] Parsed entries
+        attr_reader :entries
+
+        # @return [Symbol, nil] Detected format
+        attr_reader :format
+
+        # Initialize CPIO reader
+        #
+        # @param file_path [String] Path to CPIO archive
+        def initialize(file_path)
+          @file_path = file_path
+          @entries = []
+          @format = nil
+        end
+
+        # Open and parse CPIO archive
+        #
+        # @raise [RuntimeError] if file cannot be opened or parsed
+        def open
+          File.open(@file_path, "rb") do |io|
+            parse_archive(io)
+          end
+          self
+        end
+
+        # List all entries
+        #
+        # @return [Array<Entry>] All entries except trailer
+        def list
+          @entries.reject(&:trailer?)
+        end
+
+        # Extract entry to output path
+        #
+        # @param entry_name [String] Entry name to extract
+        # @param output_path [String] Destination path
+        # @raise [RuntimeError] if entry not found
+        def extract_entry(entry_name, output_path)
+          entry = @entries.find { |e| e.name == entry_name }
+          raise "Entry not found: #{entry_name}" unless entry
+
+          extract_single_entry(entry, output_path)
+        end
+
+        # Extract all entries to directory
+        #
+        # @param output_dir [String] Output directory
+        def extract_all(output_dir)
+          FileUtils.mkdir_p(output_dir)
+
+          @entries.each do |entry|
+            next if entry.trailer?
+
+            output_path = File.join(output_dir, entry.name)
+            extract_single_entry(entry, output_path)
+          end
+        end
+
+        # Get archive format
+        #
+        # @return [String] Human-readable format name
+        def format_name
+          case @format
+          when :newc then "CPIO newc (SVR4)"
+          when :crc then "CPIO newc with CRC"
+          when :odc then "CPIO ODC (portable)"
+          when :binary then "CPIO binary (old)"
+          else "Unknown"
+          end
+        end
+
+        private
+
+        # Parse archive contents
+        #
+        # @param io [IO] Input stream
+        def parse_archive(io)
+          while !io.eof?
+            begin
+              entry = Entry.parse(io, format: @format)
+
+              # Detect format from first entry
+              @format ||= Entry.detect_format(entry.magic)
+
+              # Add entry (including trailer)
+              @entries << entry
+
+              # Stop at trailer
+              break if entry.trailer?
+            rescue StandardError => e
+              warn "Failed to parse CPIO entry: #{e.message}"
+              break
+            end
+          end
+        end
+
+        # Extract single entry
+        #
+        # @param entry [Entry] Entry to extract
+        # @param output_path [String] Destination path
+        def extract_single_entry(entry, output_path)
+          if entry.directory?
+            extract_directory(entry, output_path)
+          elsif entry.symlink?
+            extract_symlink(entry, output_path)
+          elsif entry.device?
+            # Skip device files (require root privileges)
+            warn "Skipping device file: #{entry.name}"
+          else
+            extract_file(entry, output_path)
+          end
+
+          # Set permissions and timestamps
+          set_entry_attributes(entry, output_path) unless entry.symlink?
+        end
+
+        # Extract directory
+        #
+        # @param entry [Entry] Directory entry
+        # @param output_path [String] Destination path
+        def extract_directory(_entry, output_path)
+          FileUtils.mkdir_p(output_path)
+        end
+
+        # Extract regular file
+        #
+        # @param entry [Entry] File entry
+        # @param output_path [String] Destination path
+        def extract_file(entry, output_path)
+          FileUtils.mkdir_p(File.dirname(output_path))
+          File.binwrite(output_path, entry.data)
+        end
+
+        # Extract symbolic link
+        #
+        # @param entry [Entry] Symlink entry
+        # @param output_path [String] Destination path
+        def extract_symlink(entry, output_path)
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          # Remove existing file/link if present
+          File.unlink(output_path) if File.exist?(output_path) || File.symlink?(output_path)
+
+          # Create symbolic link
+          File.symlink(entry.data, output_path)
+        end
+
+        # Set file attributes (permissions and timestamps)
+        #
+        # @param entry [Entry] Entry with attributes
+        # @param path [String] File path
+        def set_entry_attributes(entry, path)
+          # Set modification time
+          if entry.mtime&.positive?
+            mtime = Time.at(entry.mtime)
+            File.utime(mtime, mtime, path)
+          end
+
+          # Set permissions
+          File.chmod(entry.mode & 0o7777, path) if entry.mode
+        rescue Errno::EPERM, Errno::ENOENT
+          # Permission errors are non-fatal
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "constants"
+require_relative "entry"
+
+module Omnizip
+  module Formats
+    module Cpio
+      # CPIO archive writer
+      #
+      # Creates CPIO archives in newc, CRC, or ODC format.
+      # Ported from libarchive's archive_write_set_format_cpio_newc.c
+      #
+      # @example Create CPIO archive
+      #   writer = Cpio::Writer.new('archive.cpio')
+      #   writer.add_file('file.txt')
+      #   writer.add_directory('dir/')
+      #   writer.write
+      #
+      # @example With CRC format
+      #   writer = Cpio::Writer.new('archive.cpio', format: :crc)
+      #   writer.add_directory('initramfs/')
+      #   writer.write
+      class Writer
+        include Constants
+
+        # @return [String] Output archive path
+        attr_reader :output_path
+
+        # @return [Symbol] CPIO format (:newc, :crc, :odc)
+        attr_reader :format
+
+        # @return [Array<Entry>] Entries to write
+        attr_reader :entries
+
+        # Initialize CPIO writer
+        #
+        # @param output_path [String] Output CPIO file path
+        # @param format [Symbol] CPIO format (:newc, :crc, :odc)
+        def initialize(output_path, format: :newc)
+          @output_path = output_path
+          @format = validate_format(format)
+          @entries = []
+          @inode_counter = 1
+        end
+
+        # Add file to archive
+        #
+        # @param file_path [String] Source file path
+        # @param cpio_path [String, nil] Path in archive (defaults to file_path)
+        # @raise [ArgumentError] if file doesn't exist
+        def add_file(file_path, cpio_path = nil)
+          raise ArgumentError, "File not found: #{file_path}" unless
+            File.exist?(file_path) || File.symlink?(file_path)
+
+          # Default to basename if no cpio_path specified
+          cpio_path = File.basename(file_path) if cpio_path.nil?
+          # Use lstat to not follow symlinks
+          stat = File.lstat(file_path)
+
+          # Normalize path: remove leading slashes to make relative
+          cpio_path = cpio_path.sub(%r{^/+}, "")
+
+          # Read file data unless it's a symlink
+          data = if File.symlink?(file_path)
+                   File.readlink(file_path)
+                 elsif stat.file?
+                   File.binread(file_path)
+                 else
+                   ""
+                 end
+
+          entry = create_entry_from_stat(cpio_path, stat, data)
+          @entries << entry
+          @inode_counter += 1
+        end
+
+        # Add directory to archive
+        #
+        # @param dir_path [String] Source directory path
+        # @param recursive [Boolean] Include subdirectories
+        # @param cpio_path [String, nil] Path in archive
+        # @raise [ArgumentError] if directory doesn't exist
+        def add_directory(dir_path, recursive: true, cpio_path: nil)
+          raise ArgumentError, "Directory not found: #{dir_path}" unless
+            Dir.exist?(dir_path)
+
+          # Default to basename if no cpio_path specified
+          cpio_path = File.basename(dir_path) if cpio_path.nil?
+          # Normalize path: remove leading slashes to make relative
+          cpio_path = cpio_path.sub(%r{^/+}, "")
+          stat = File.lstat(dir_path)
+
+          # Add directory entry
+          entry = create_entry_from_stat(cpio_path, stat, "")
+          @entries << entry
+          @inode_counter += 1
+
+          # Add contents if recursive
+          if recursive
+            Dir.foreach(dir_path) do |item|
+              next if [".", ".."].include?(item)
+
+              item_path = File.join(dir_path, item)
+              item_cpio_path = "#{cpio_path}/#{item}"
+
+              if File.directory?(item_path)
+                add_directory(item_path, recursive: true,
+                                         cpio_path: item_cpio_path)
+              else
+                add_file(item_path, item_cpio_path)
+              end
+            end
+          end
+        end
+
+        # Write CPIO archive
+        #
+        # @raise [IOError] if write fails
+        def write
+          File.open(@output_path, "wb") do |io|
+            # Write all entries
+            @entries.each do |entry|
+              write_entry(io, entry)
+            end
+
+            # Write trailer
+            write_trailer(io)
+          end
+
+          @output_path
+        end
+
+        private
+
+        # Validate format
+        #
+        # @param format [Symbol] Format to validate
+        # @return [Symbol] Validated format
+        # @raise [ArgumentError] if format invalid
+        def validate_format(format)
+          unless %i[newc crc odc].include?(format)
+            raise ArgumentError, "Invalid CPIO format: #{format}. " \
+                                 "Must be :newc, :crc, or :odc"
+          end
+          format
+        end
+
+        # Create entry from file stat
+        #
+        # @param path [String] Entry path
+        # @param stat [File::Stat] File statistics
+        # @param data [String] File data
+        # @return [Entry] Created entry
+        def create_entry_from_stat(path, stat, data)
+          Entry.new(
+            magic: format_magic,
+            ino: @inode_counter,
+            mode: stat.mode,
+            uid: stat.uid,
+            gid: stat.gid,
+            nlink: stat.nlink,
+            mtime: stat.mtime.to_i,
+            filesize: data.bytesize,
+            dev_major: (stat.dev >> 8) & 0xFF,
+            dev_minor: stat.dev & 0xFF,
+            rdev_major: stat.rdev ? (stat.rdev >> 8) & 0xFF : 0,
+            rdev_minor: stat.rdev ? (stat.rdev & 0xFF) : 0,
+            namesize: path.bytesize + 1,
+            checksum: @format == :crc ? calculate_checksum(data) : 0,
+            name: path,
+            data: data,
+          )
+        end
+
+        # Get magic number for current format
+        #
+        # @return [String] Magic number
+        def format_magic
+          case @format
+          when :newc then MAGIC_NEWC
+          when :crc then MAGIC_CRC
+          when :odc then MAGIC_ODC
+          end
+        end
+
+        # Write entry to archive
+        #
+        # @param io [IO] Output stream
+        # @param entry [Entry] Entry to write
+        def write_entry(io, entry)
+          binary_data = entry.to_binary(format: @format)
+          io.write(binary_data)
+        end
+
+        # Write trailer entry
+        #
+        # @param io [IO] Output stream
+        def write_trailer(io)
+          trailer = Entry.new(
+            magic: format_magic,
+            ino: 0,
+            mode: 0,
+            uid: 0,
+            gid: 0,
+            nlink: 1,
+            mtime: 0,
+            filesize: 0,
+            dev_major: 0,
+            dev_minor: 0,
+            rdev_major: 0,
+            rdev_minor: 0,
+            namesize: TRAILER_NAME.bytesize + 1,
+            checksum: 0,
+            name: TRAILER_NAME,
+            data: "",
+          )
+
+          write_entry(io, trailer)
+        end
+
+        # Calculate checksum for CRC format
+        #
+        # @param data [String] Data to checksum
+        # @return [Integer] CRC32 checksum
+        def calculate_checksum(data)
+          require "zlib"
+          Zlib.crc32(data) & 0xFFFFFFFF
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/cpio.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "cpio/constants"
+require_relative "cpio/entry"
+require_relative "cpio/writer"
+require_relative "cpio/reader"
+
+module Omnizip
+  module Formats
+    # CPIO archive format support
+    #
+    # Provides read and write access to CPIO archives in multiple formats:
+    # - newc (SVR4 new ASCII format) - Most common, used in initramfs
+    # - CRC (newc with CRC checksums)
+    # - ODC (Old portable ASCII format)
+    #
+    # CPIO is commonly used for:
+    # - Linux initramfs/initrd
+    # - RPM package contents
+    # - Unix system backups
+    #
+    # @example Create CPIO archive
+    #   Omnizip::Formats::Cpio.create('archive.cpio') do |cpio|
+    #     cpio.add_directory('files/')
+    #   end
+    #
+    # @example Extract CPIO archive
+    #   Omnizip::Formats::Cpio.extract('archive.cpio', 'output/')
+    module Cpio
+      class << self
+        # Create CPIO archive
+        #
+        # @param path [String] Output CPIO file path
+        # @param format [Symbol] CPIO format (:newc, :crc, :odc)
+        # @yield [writer] Block for adding files/directories
+        # @yieldparam writer [Writer] CPIO writer
+        # @return [String] Path to created archive
+        #
+        # @example Create newc format archive
+        #   Omnizip::Formats::Cpio.create('archive.cpio') do |cpio|
+        #     cpio.add_file('kernel.img')
+        #     cpio.add_directory('modules/')
+        #   end
+        #
+        # @example Create with CRC checksums
+        #   Omnizip::Formats::Cpio.create('archive.cpio', format: :crc) do |cpio|
+        #     cpio.add_directory('initramfs/')
+        #   end
+        def create(path, format: :newc)
+          writer = Writer.new(path, format: format)
+
+          yield writer if block_given?
+
+          writer.write
+        end
+
+        # Open CPIO archive for reading
+        #
+        # @param path [String] Path to CPIO file
+        # @yield [reader] Block for reading archive
+        # @yieldparam reader [Reader] CPIO reader
+        # @return [Reader] CPIO reader
+        #
+        # @example Read CPIO archive
+        #   Omnizip::Formats::Cpio.open('archive.cpio') do |cpio|
+        #     cpio.entries.each { |entry| puts entry.name }
+        #   end
+        def open(path)
+          reader = Reader.new(path)
+          reader.open
+
+          if block_given?
+            yield reader
+          else
+            reader
+          end
+        end
+
+        # List CPIO archive contents
+        #
+        # @param path [String] Path to CPIO file
+        # @return [Array<Entry>] Archive entries
+        #
+        # @example List archive contents
+        #   entries = Omnizip::Formats::Cpio.list('archive.cpio')
+        #   entries.each { |e| puts "#{e.name} (#{e.filesize} bytes)" }
+        def list(path)
+          open(path, &:list)
+        end
+
+        # Extract CPIO archive
+        #
+        # @param cpio_path [String] Path to CPIO file
+        # @param output_dir [String] Output directory
+        #
+        # @example Extract archive
+        #   Omnizip::Formats::Cpio.extract('archive.cpio', 'output/')
+        def extract(cpio_path, output_dir)
+          open(cpio_path) do |cpio|
+            cpio.extract_all(output_dir)
+          end
+        end
+
+        # Get archive information
+        #
+        # @param path [String] Path to CPIO file
+        # @return [Hash] Archive information
+        #
+        # @example Get archive info
+        #   info = Omnizip::Formats::Cpio.info('archive.cpio')
+        #   puts "Format: #{info[:format]}"
+        #   puts "Files: #{info[:file_count]}"
+        def info(path)
+          open(path) do |cpio|
+            entries = cpio.list
+
+            {
+              format: cpio.format_name,
+              format_type: cpio.format,
+              entry_count: entries.size,
+              file_count: entries.count(&:file?),
+              directory_count: entries.count(&:directory?),
+              symlink_count: entries.count(&:symlink?),
+              total_size: entries.sum(&:filesize),
+            }
+          end
+        end
+
+        # Auto-register CPIO format when loaded
+        def register!
+          require_relative "../format_registry"
+          FormatRegistry.register(".cpio", Reader)
+        end
+      end
+    end
+  end
+end
+
+# Auto-register on load
+Omnizip::Formats::Cpio.register!