omnizip 0.4.7-x86_64-linux

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+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 Omnizip::Formats::Cpio::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,132 @@
+# frozen_string_literal: true
+
+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
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/formats/cpio/constants"
+      autoload :Entry, "omnizip/formats/cpio/entry"
+      autoload :Writer, "omnizip/formats/cpio/writer"
+      autoload :Reader, "omnizip/formats/cpio/reader"
+
+      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
+      end
+    end
+  end
+end

data/lib/omnizip/formats/format_spec_loader.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "yaml"
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+module Omnizip
+  module Formats
+    # Loads and manages format specifications from YAML configuration files
+    #
+    # This class provides a configuration-driven architecture for archive formats,
+    # allowing format specifications to be externalized in YAML files rather than
+    # hardcoded in the application.
+    #
+    # @example Loading a format specification
+    #   spec = FormatSpecLoader.load("rar5")
+    #   spec.format.name # => "RAR5"
+    #   spec.format.magic_bytes # => [0x52, 0x61, 0x72, ...]
+    #
+    # @example Getting all loaded specifications
+    #   specs = FormatSpecLoader.all_specs
+    #   specs.keys # => ["rar3", "rar5", "zip", ...]
+    class FormatSpecLoader
+      class << self
+        # Load a format specification from a YAML file
+        #
+        # @param format_name [String] The name of the format (e.g., "rar5")
+        # @param config_dir [String] The directory containing format specs
+        # @return [FormatSpecification] The loaded format specification
+        # @raise [FormatError] If the specification file is not found
+        #   or invalid
+        def load(format_name, config_dir: default_config_dir)
+          spec_file = File.join(config_dir, "#{format_name}_spec.yml")
+
+          unless File.exist?(spec_file)
+            raise FormatError,
+                  "Format specification not found: #{spec_file}"
+          end
+
+          yaml_content = File.read(spec_file)
+          parsed_yaml = YAML.safe_load(
+            yaml_content,
+            permitted_classes: [Symbol],
+            symbolize_names: true,
+          )
+
+          validate_spec(parsed_yaml, format_name)
+
+          spec = FormatSpecification.new(parsed_yaml)
+          register_spec(format_name, spec)
+          spec
+        rescue Psych::SyntaxError => e
+          raise FormatError,
+                "Invalid YAML in #{spec_file}: #{e.message}"
+        end
+
+        # Get all loaded format specifications
+        #
+        # @return [Hash<String, FormatSpecification>] All loaded specs
+        def all_specs
+          @all_specs ||= {}
+        end
+
+        # Clear all loaded specifications (primarily for testing)
+        #
+        # @return [void]
+        def clear_specs
+          @all_specs = {}
+        end
+
+        # Check if a format specification is loaded
+        #
+        # @param format_name [String] The format name
+        # @return [Boolean] True if loaded, false otherwise
+        def loaded?(format_name)
+          all_specs.key?(format_name)
+        end
+
+        # Get a loaded specification
+        #
+        # @param format_name [String] The format name
+        # @return [FormatSpecification, nil] The spec or nil if not loaded
+        def get(format_name)
+          all_specs[format_name]
+        end
+
+        # Load all format specifications from a directory
+        #
+        # @param config_dir [String] The directory containing format specs
+        # @return [Hash<String, FormatSpecification>] All loaded specs
+        def load_all(config_dir: default_config_dir)
+          return all_specs unless Dir.exist?(config_dir)
+
+          Dir.glob(File.join(config_dir, "*_spec.yml")).each do |spec_file|
+            format_name = File.basename(spec_file, "_spec.yml")
+            unless loaded?(format_name)
+              load(format_name,
+                   config_dir: config_dir)
+            end
+          end
+
+          all_specs
+        end
+
+        private
+
+        # Default configuration directory for format specifications
+        #
+        # @return [String] The default config directory path
+        def default_config_dir
+          File.join(__dir__, "../../../config/formats")
+        end
+
+        # Register a loaded specification
+        #
+        # @param format_name [String] The format name
+        # @param spec [FormatSpecification] The specification to register
+        # @return [void]
+        def register_spec(format_name, spec)
+          all_specs[format_name] = spec
+        end
+
+        # Validate a parsed YAML specification
+        #
+        # @param parsed_yaml [Hash] The parsed YAML content
+        # @param format_name [String] The format name
+        # @return [void]
+        # @raise [FormatError] If the spec is invalid
+        def validate_spec(parsed_yaml, format_name)
+          unless parsed_yaml.is_a?(Hash) && parsed_yaml[:format]
+            raise FormatError,
+                  "Invalid format specification for #{format_name}: " \
+                  "missing 'format' key"
+          end
+
+          format_data = parsed_yaml[:format]
+          required_keys = %i[name version magic_bytes]
+
+          required_keys.each do |key|
+            next if format_data[key]
+
+            raise FormatError,
+                  "Invalid format specification for #{format_name}: " \
+                  "missing required key '#{key}'"
+          end
+        end
+      end
+    end
+
+    # Model class for encryption data
+    class EncryptionData < Lutaml::Model::Serializable
+      attribute :supported, :boolean
+      attribute :algorithms, :string, collection: true
+      attribute :key_derivation, :string
+      attribute :kdf_iterations, :integer
+      attribute :salt_size, :integer
+    end
+
+    # Model class for checksum data
+    class ChecksumData < Lutaml::Model::Serializable
+      attribute :algorithm, :string
+      attribute :size, :integer
+    end
+
+    # Model class for format data
+    class FormatData < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :version, :string
+      attribute :extension, :string
+      attribute :magic_bytes, :integer, collection: true
+      attribute :block_types, :hash
+      attribute :archive_flags, :hash
+      attribute :main_header_flags, :hash
+      attribute :file_header_flags, :hash
+      attribute :file_flags, :hash
+      attribute :encryption_flags, :hash
+      attribute :compression_methods, :hash
+      attribute :host_os, :hash
+      attribute :dictionary_sizes, :hash
+      attribute :encryption, EncryptionData
+      attribute :checksum, ChecksumData
+      attribute :features, :hash
+      attribute :compression_features, :hash
+      attribute :advanced_features, :hash
+      attribute :extra_records, :hash
+    end
+
+    # Model class representing a format specification
+    #
+    # This class uses Lutaml::Model to provide a structured representation
+    # of format specifications loaded from YAML files.
+    class FormatSpecification < Lutaml::Model::Serializable
+      attribute :format, FormatData
+
+      # Get a value from the format specification
+      #
+      # @param key [Symbol, String] The key to retrieve
+      # @return [Object] The value for the key
+      def [](key)
+        format.public_send(key)
+      end
+
+      # Get magic bytes as an array of integers
+      #
+      # @return [Array<Integer>] The magic bytes
+      def magic_bytes
+        format.magic_bytes
+      end
+
+      # Get the format name
+      #
+      # @return [String] The format name
+      def name
+        format.name
+      end
+
+      # Get the format version
+      #
+      # @return [String] The format version
+      def version
+        format.version
+      end
+    end
+  end
+end