omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Cpio
+      # CPIO format constants
+      #
+      # Defines magic numbers, file types, and format specifications
+      # for different CPIO archive formats.
+      module Constants
+        # Magic numbers for different CPIO formats
+        MAGIC_BINARY = 0o070707 # Old binary format
+        MAGIC_ODC = "070707"   # Old portable ASCII format
+        MAGIC_NEWC = "070701"  # New ASCII format (SVR4, most common)
+        MAGIC_CRC = "070702"   # New ASCII with CRC
+
+        # File type masks (from POSIX)
+        S_IFMT = 0o170000   # File type mask
+        S_IFSOCK = 0o140000 # Socket
+        S_IFLNK = 0o120000  # Symbolic link
+        S_IFREG = 0o100000  # Regular file
+        S_IFBLK = 0o060000  # Block device
+        S_IFDIR = 0o040000  # Directory
+        S_IFCHR = 0o020000  # Character device
+        S_IFIFO = 0o010000  # FIFO/pipe
+
+        # Permission bits
+        S_ISUID = 0o004000  # Set UID bit
+        S_ISGID = 0o002000  # Set GID bit
+        S_ISVTX = 0o001000  # Sticky bit
+        S_IRWXU = 0o000700  # User permissions
+        S_IRUSR = 0o000400  # User read
+        S_IWUSR = 0o000200  # User write
+        S_IXUSR = 0o000100  # User execute
+        S_IRWXG = 0o000070  # Group permissions
+        S_IRGRP = 0o000040  # Group read
+        S_IWGRP = 0o000020  # Group write
+        S_IXGRP = 0o000010  # Group execute
+        S_IRWXO = 0o000007  # Other permissions
+        S_IROTH = 0o000004  # Other read
+        S_IWOTH = 0o000002  # Other write
+        S_IXOTH = 0o000001  # Other execute
+
+        # CPIO newc header size (110 bytes for newc format)
+        NEWC_HEADER_SIZE = 110
+
+        # Trailer entry name
+        TRAILER_NAME = "TRAILER!!!"
+
+        # Alignment for newc format (4 bytes)
+        NEWC_ALIGNMENT = 4
+      end
+    end
+  end
+end

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

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Cpio
+      # CPIO archive entry
+      #
+      # Represents a file, directory, or special file in a CPIO archive.
+      # Supports newc, CRC, and ODC formats.
+      class Entry
+        include Omnizip::Entry
+        include Omnizip::Formats::Cpio::Constants
+
+        # @return [String] Magic number identifying format
+        attr_accessor :magic
+
+        # @return [Integer] Inode number
+        attr_accessor :ino
+
+        # @return [Integer] File mode and type
+        attr_accessor :mode
+
+        # @return [Integer] User ID
+        attr_accessor :uid
+
+        # @return [Integer] Group ID
+        attr_accessor :gid
+
+        # @return [Integer] Number of hard links
+        attr_accessor :nlink
+
+        # @return [Integer] Modification time (Unix timestamp)
+        attr_accessor :mtime
+
+        # @return [Integer] File size in bytes
+        attr_accessor :filesize
+
+        # @return [Integer] Device major number
+        attr_accessor :dev_major
+
+        # @return [Integer] Device minor number
+        attr_accessor :dev_minor
+
+        # @return [Integer] Special device major number (for device files)
+        attr_accessor :rdev_major
+
+        # @return [Integer] Special device minor number (for device files)
+        attr_accessor :rdev_minor
+
+        # @return [Integer] Filename length (including null terminator)
+        attr_accessor :namesize
+
+        # @return [Integer] Checksum (CRC format only)
+        attr_accessor :checksum
+
+        # @return [String] Entry name/path
+        attr_accessor :name
+
+        # @return [String] File data
+        attr_accessor :data
+
+        def entry_name = name
+        def entry_directory? = directory?
+        def entry_size = filesize
+        def entry_mtime = mtime
+
+        # Initialize CPIO entry
+        #
+        # @param attributes [Hash] Entry attributes
+        def initialize(attributes = {})
+          @magic = attributes.fetch(:magic, MAGIC_NEWC)
+          @ino = attributes.fetch(:ino, 0)
+          @mode = attributes.fetch(:mode, S_IFREG | 0o644)
+          @uid = attributes.fetch(:uid, 0)
+          @gid = attributes.fetch(:gid, 0)
+          @nlink = attributes.fetch(:nlink, 1)
+          @mtime = attributes.fetch(:mtime, Time.now.to_i)
+          @filesize = attributes.fetch(:filesize, 0)
+          @dev_major = attributes.fetch(:dev_major, 0)
+          @dev_minor = attributes.fetch(:dev_minor, 0)
+          @rdev_major = attributes.fetch(:rdev_major, 0)
+          @rdev_minor = attributes.fetch(:rdev_minor, 0)
+          @namesize = attributes.fetch(:namesize, 0)
+          @checksum = attributes.fetch(:checksum, 0)
+          @name = attributes.fetch(:name, "")
+          @data = attributes.fetch(:data, "")
+
+          # Auto-calculate namesize if not provided
+          @namesize = @name.bytesize + 1 if @namesize.zero? && !@name.empty?
+          @filesize = @data.bytesize if @filesize.zero? && !@data.empty?
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean] true if directory
+        def directory?
+          (@mode & S_IFMT) == S_IFDIR
+        end
+
+        # Check if entry is a regular file
+        #
+        # @return [Boolean] true if regular file
+        def file?
+          (@mode & S_IFMT) == S_IFREG
+        end
+
+        # Check if entry is a symbolic link
+        #
+        # @return [Boolean] true if symlink
+        def symlink?
+          (@mode & S_IFMT) == S_IFLNK
+        end
+
+        # Check if entry is a device
+        #
+        # @return [Boolean] true if device (block or character)
+        def device?
+          type = @mode & S_IFMT
+          [S_IFBLK, S_IFCHR].include?(type)
+        end
+
+        # Check if entry is the trailer
+        #
+        # @return [Boolean] true if trailer entry
+        def trailer?
+          @name == TRAILER_NAME
+        end
+
+        # Convert entry to binary format
+        #
+        # @param format [Symbol] CPIO format (:newc, :crc, :odc)
+        # @return [String] Binary representation
+        def to_binary(format: :newc)
+          case format
+          when :newc, :crc
+            to_newc_binary
+          when :odc
+            to_odc_binary
+          else
+            raise ArgumentError, "Unsupported CPIO format: #{format}"
+          end
+        end
+
+        # Convert to newc format binary
+        #
+        # @return [String] Binary data in newc format
+        def to_newc_binary
+          # Build header (110 bytes, ASCII hex)
+          header = format(
+            "%06s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
+            @magic,
+            @ino & 0xFFFFFFFF,
+            @mode & 0xFFFFFFFF,
+            @uid & 0xFFFFFFFF,
+            @gid & 0xFFFFFFFF,
+            @nlink & 0xFFFFFFFF,
+            @mtime & 0xFFFFFFFF,
+            @filesize & 0xFFFFFFFF,
+            @dev_major & 0xFFFFFFFF,
+            @dev_minor & 0xFFFFFFFF,
+            @rdev_major & 0xFFFFFFFF,
+            @rdev_minor & 0xFFFFFFFF,
+            @namesize & 0xFFFFFFFF,
+            @checksum & 0xFFFFFFFF,
+          )
+
+          # Assemble complete entry
+          result = +""
+          result << header
+          result << @name
+          result << "\x00"
+
+          # Pad header+name to 4-byte boundary
+          header_name_size = header.bytesize + @name.bytesize + 1
+          padding = padding_to_align(header_name_size, NEWC_ALIGNMENT)
+          result << ("\x00" * padding) if padding.positive?
+
+          # Add file data
+          result << @data
+
+          # Pad data to 4-byte boundary
+          data_padding = padding_to_align(@data.bytesize, NEWC_ALIGNMENT)
+          result << ("\x00" * data_padding) if data_padding.positive?
+
+          result
+        end
+
+        # Convert to ODC format binary
+        #
+        # @return [String] Binary data in ODC format
+        def to_odc_binary
+          # ODC format uses 6-character octal fields
+          header = format(
+            "%06o%06o%06o%06o%06o%06o%06o%06o%011o%06o%011o",
+            MAGIC_BINARY,
+            (@dev_major << 8) | @dev_minor,
+            @ino & 0o777777,
+            @mode & 0o777777,
+            @uid & 0o777777,
+            @gid & 0o777777,
+            @nlink & 0o777777,
+            (@rdev_major << 8) | @rdev_minor,
+            @mtime & 0o77777777777,
+            @namesize & 0o777777,
+            @filesize & 0o77777777777,
+          )
+
+          result = +""
+          result << header
+          result << @name
+          result << "\x00"
+          result << @data
+
+          result
+        end
+
+        # Parse entry from binary data
+        #
+        # @param io [IO] Input stream
+        # @param format [Symbol, nil] Format hint (:newc, :crc, :odc, nil=auto-detect)
+        # @return [Entry] Parsed entry
+        def self.parse(io, format: nil)
+          # Read magic to detect format
+          magic = io.read(6)
+          io.seek(-6, ::IO::SEEK_CUR) # Rewind
+
+          format ||= detect_format(magic)
+
+          case format
+          when :newc, :crc
+            parse_newc(io)
+          when :odc
+            parse_odc(io)
+          else
+            raise Omnizip::InvalidArchiveError, "Unknown CPIO format"
+          end
+        end
+
+        # Detect CPIO format from magic
+        #
+        # @param magic [String] Magic bytes
+        # @return [Symbol] Format type
+        def self.detect_format(magic)
+          case magic
+          when MAGIC_NEWC then :newc
+          when MAGIC_CRC then :crc
+          when MAGIC_ODC then :odc
+          else
+            # Try binary format
+            magic_int = magic.unpack1("n")
+            magic_int == MAGIC_BINARY ? :binary : nil
+          end
+        end
+
+        # Parse newc format entry
+        #
+        # @param io [IO] Input stream
+        # @return [Entry] Parsed entry
+        def self.parse_newc(io)
+          header = io.read(NEWC_HEADER_SIZE)
+          raise Omnizip::InvalidArchiveError, "Truncated CPIO header" unless header && header.bytesize == NEWC_HEADER_SIZE
+
+          # Parse ASCII hex fields
+          magic = header[0, 6]
+          ino = header[6, 8].to_i(16)
+          mode = header[14, 8].to_i(16)
+          uid = header[22, 8].to_i(16)
+          gid = header[30, 8].to_i(16)
+          nlink = header[38, 8].to_i(16)
+          mtime = header[46, 8].to_i(16)
+          filesize = header[54, 8].to_i(16)
+          dev_major = header[62, 8].to_i(16)
+          dev_minor = header[70, 8].to_i(16)
+          rdev_major = header[78, 8].to_i(16)
+          rdev_minor = header[86, 8].to_i(16)
+          namesize = header[94, 8].to_i(16)
+          checksum = header[102, 8].to_i(16)
+
+          # Read filename
+          name_data = io.read(namesize)
+          name = name_data.chomp("\x00")
+
+          # Skip padding to 4-byte boundary
+          header_name_size = NEWC_HEADER_SIZE + namesize
+          padding = padding_to_align(header_name_size, NEWC_ALIGNMENT)
+          io.read(padding) if padding.positive?
+
+          # Read file data
+          data = io.read(filesize)
+
+          # Skip padding to 4-byte boundary
+          data_padding = padding_to_align(filesize, NEWC_ALIGNMENT)
+          io.read(data_padding) if data_padding.positive?
+
+          new(
+            magic: magic,
+            ino: ino,
+            mode: mode,
+            uid: uid,
+            gid: gid,
+            nlink: nlink,
+            mtime: mtime,
+            filesize: filesize,
+            dev_major: dev_major,
+            dev_minor: dev_minor,
+            rdev_major: rdev_major,
+            rdev_minor: rdev_minor,
+            namesize: namesize,
+            checksum: checksum,
+            name: name,
+            data: data || "",
+          )
+        end
+
+        # Parse ODC format entry
+        #
+        # @param io [IO] Input stream
+        # @return [Entry] Parsed entry
+        def self.parse_odc(io)
+          header = io.read(76)
+          raise Omnizip::InvalidArchiveError, "Truncated CPIO header" unless header && header.bytesize == 76
+
+          # Parse octal fields
+          magic = header[0, 6]
+          dev = header[6, 6].to_i(8)
+          ino = header[12, 6].to_i(8)
+          mode = header[18, 6].to_i(8)
+          uid = header[24, 6].to_i(8)
+          gid = header[30, 6].to_i(8)
+          nlink = header[36, 6].to_i(8)
+          rdev = header[42, 6].to_i(8)
+          mtime = header[48, 11].to_i(8)
+          namesize = header[59, 6].to_i(8)
+          filesize = header[65, 11].to_i(8)
+
+          # Extract device numbers
+          dev_major = dev >> 8
+          dev_minor = dev & 0xFF
+          rdev_major = rdev >> 8
+          rdev_minor = rdev & 0xFF
+
+          # Read filename
+          name_data = io.read(namesize)
+          name = name_data.chomp("\x00")
+
+          # Read file data
+          data = io.read(filesize)
+
+          new(
+            magic: magic,
+            ino: ino,
+            mode: mode,
+            uid: uid,
+            gid: gid,
+            nlink: nlink,
+            mtime: mtime,
+            filesize: filesize,
+            dev_major: dev_major,
+            dev_minor: dev_minor,
+            rdev_major: rdev_major,
+            rdev_minor: rdev_minor,
+            namesize: namesize,
+            checksum: 0,
+            name: name,
+            data: data || "",
+          )
+        end
+
+        private
+
+        # Calculate padding needed to align to boundary
+        #
+        # @param size [Integer] Current size
+        # @param alignment [Integer] Alignment boundary
+        # @return [Integer] Padding bytes needed
+        def padding_to_align(size, alignment)
+          remainder = size % alignment
+          remainder.zero? ? 0 : alignment - remainder
+        end
+
+        # Class method for padding calculation
+        def self.padding_to_align(size, alignment)
+          remainder = size % alignment
+          remainder.zero? ? 0 : alignment - remainder
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+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 Omnizip::Formats::Cpio::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 Errno::ENOENT, "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