omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,65 @@
+# frozen_string: true
+
+require "fileutils"
+require "tmpdir"
+
+module Omnizip
+  module Formats
+    module Rar5
+      # RAR v5 archive writer
+      #
+      # @example Writing a RAR5 archive
+      #   writer = Rar5::Writer.new
+      #   File.open("archive.rar", "wb") do |file|
+      #     entries = [
+      #       {name: "file.txt", data: "content", time: Time.now}
+      #     ]
+      #     writer.write_archive(file, entries)
+      #   end
+      class Writer < Omnizip::Formats::Rar::RarFormatBase
+        # Initialize a RAR v5 writer
+        def initialize
+          super("rar5")
+        end
+
+        # Write a RAR v5 archive
+        #
+        # Delegates to the primary `Formats::Rar::Rar5::Writer` so the
+        # output is spec-conformant and unrar-verified: entries spill
+        # to a temporary file, the primary writer produces the
+        # archive, and the bytes are copied into the given IO.
+        # Compression methods above :store are not official-RAR
+        # compatible, so the primary writer stores them (with a
+        # warning) rather than emitting an undecodable stream.
+        #
+        # @param io [IO] The output stream
+        # @param entries [Array<Hash>] The entries to write
+        # @return [void]
+        def write_archive(io, entries)
+          Dir.mktmpdir("omnizip_rar5_write") do |tmp|
+            archive_path = File.join(tmp, "archive.rar")
+            primary = Rar::Rar5::Writer.new(archive_path,
+                                            include_mtime: true,
+                                            include_crc32: true)
+
+            entries.each do |entry|
+              name = entry[:name] || entry["name"]
+              data = entry[:data] || entry["data"]
+              mtime = entry[:time] || entry["time"] || Time.now
+
+              file_path = File.join(tmp, "entries", name)
+              FileUtils.mkdir_p(File.dirname(file_path))
+              File.binwrite(file_path, data.to_s)
+              File.utime(mtime, mtime, file_path)
+
+              primary.add_file(file_path, name)
+            end
+
+            primary.write
+            io.write(File.binread(archive_path))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar5.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # Standalone RAR5 reader/writer tree (see Formats::Rar for the
+    # primary RAR support). Classes under this namespace load lazily;
+    # require "omnizip" first so sibling namespaces resolve.
+    module Rar5
+      autoload :Compressor, "omnizip/formats/rar5/compressor"
+      autoload :Decompressor, "omnizip/formats/rar5/decompressor"
+      autoload :Reader, "omnizip/formats/rar5/reader"
+      autoload :Writer, "omnizip/formats/rar5/writer"
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM format constants
+      #
+      # Defines magic numbers, header constants, and type definitions
+      # for RPM package parsing.
+      module Constants
+        # RPM lead magic bytes
+        LEAD_MAGIC = "\xed\xab\xee\xdb".b
+
+        # RPM header magic bytes (8 bytes)
+        HEADER_MAGIC = "\x8e\xad\xe8\x01\x00\x00\x00\x00".b
+
+        # Lead structure size (96 bytes)
+        LEAD_SIZE = 96
+
+        # Header header size (16 bytes: magic + index_count + data_length)
+        HEADER_HEADER_SIZE = 16
+
+        # Tag entry size (16 bytes: tag + type + offset + count)
+        TAG_ENTRY_SIZE = 16
+
+        # Header signed type (signature present)
+        HEADER_SIGNED_TYPE = 5
+
+        # Package types
+        PACKAGE_BINARY = 0
+        PACKAGE_SOURCE = 1
+
+        # Dependency flags
+        FLAG_LESS = (1 << 1)
+        FLAG_GREATER = (1 << 2)
+        FLAG_EQUAL = (1 << 3)
+
+        # File flags
+        FILE_CONFIG = (1 << 0)
+        FILE_DOC = (1 << 1)
+        FILE_LICENSE = (1 << 3)
+        FILE_README = (1 << 4)
+
+        # Tag types
+        TYPE_NULL = 0
+        TYPE_CHAR = 1
+        TYPE_INT8 = 2
+        TYPE_INT16 = 3
+        TYPE_INT32 = 4
+        TYPE_INT64 = 5
+        TYPE_STRING = 6
+        TYPE_BINARY = 7
+        TYPE_STRING_ARRAY = 8
+        TYPE_I18NSTRING = 9
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM file entry
+      #
+      # Represents a single file within an RPM package.
+      # File information is assembled from multiple header tags.
+      class Entry
+        include Omnizip::Entry
+        include Omnizip::Formats::Rpm::Constants
+
+        def entry_name = path
+        def entry_directory? = mode && ::File.directory?(mode)
+        def entry_size = size
+        def entry_mtime = mtime
+
+        # @return [String] File path
+        attr_accessor :path
+
+        # @return [Integer] File size
+        attr_accessor :size
+
+        # @return [Integer] File mode
+        attr_accessor :mode
+
+        # @return [Integer] User ID
+        attr_accessor :uid
+
+        # @return [Integer] Group ID
+        attr_accessor :gid
+
+        # @return [Time] Modification time
+        attr_accessor :mtime
+
+        # @return [String] File digest (MD5/SHA)
+        attr_accessor :digest
+
+        # @return [String] User name
+        attr_accessor :user
+
+        # @return [String] Group name
+        attr_accessor :group
+
+        # @return [Integer] File flags
+        attr_accessor :flags
+
+        # @return [String] Symlink target (if symlink)
+        attr_accessor :link_to
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean]
+        def directory?
+          (@mode & 0o170_000) == 0o040_000
+        end
+
+        # Check if entry is a regular file
+        #
+        # @return [Boolean]
+        def file?
+          (@mode & 0o170_000) == 0o100_000
+        end
+
+        # Check if entry is a symbolic link
+        #
+        # @return [Boolean]
+        def symlink?
+          (@mode & 0o170_000) == 0o120_000
+        end
+
+        # Check if file is a config file
+        #
+        # @return [Boolean]
+        def config?
+          @flags.anybits?(FILE_CONFIG)
+        end
+
+        # Check if file is documentation
+        #
+        # @return [Boolean]
+        def doc?
+          @flags.anybits?(FILE_DOC)
+        end
+
+        # Get permission string
+        #
+        # @return [String] Unix-style permission string
+        def permissions
+          perms = (@mode & 0o777).to_s(8).rjust(3, "0")
+
+          type_char = if directory?
+                        "d"
+                      elsif symlink?
+                        "l"
+                      else
+                        "-"
+                      end
+
+          "#{type_char}#{perms}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM header parser
+      #
+      # Parses RPM header structure including the 16-byte header header,
+      # tag entries, and data blob. Used for both signature and main headers.
+      class Header
+        include Omnizip::Formats::Rpm::Constants
+
+        # @return [String] 8-byte header magic
+        attr_reader :magic
+
+        # @return [Integer] Number of tag entries
+        attr_reader :entry_count
+
+        # @return [Integer] Data blob length
+        attr_reader :data_length
+
+        # @return [Array<Tag>] Parsed tags
+        attr_reader :tags
+
+        # @return [Integer] Total header length
+        attr_reader :length
+
+        # Parse header from IO
+        #
+        # @param io [IO] Input stream positioned at header
+        # @return [Header] Parsed header object
+        # @raise [ArgumentError] If magic is invalid
+        def self.parse(io)
+          new.tap { |header| header.parse!(io) }
+        end
+
+        # Get tag value by name
+        #
+        # @param name [Symbol] Tag name
+        # @return [Object, nil] Tag value or nil if not found
+        def [](name)
+          tag = find_tag(name)
+          tag&.value
+        end
+
+        # Find tag by name
+        #
+        # @param name [Symbol] Tag name
+        # @return [Tag, nil] Tag object or nil
+        def find_tag(name)
+          @tags.find { |t| t.name == name }
+        end
+
+        # Get all tags as hash
+        #
+        # @return [Hash] Tag names to values
+        def to_h
+          @tags.to_h do |tag|
+            [tag.name, tag.value]
+          end
+        end
+
+        # Validate header
+        #
+        # @raise [ArgumentError] If validation fails
+        def validate!
+          unless @magic == HEADER_MAGIC
+            raise ArgumentError,
+                  "Invalid header magic: #{@magic.inspect}"
+          end
+        end
+
+        def parse!(io)
+          # Read header header (16 bytes)
+          header_data = io.read(HEADER_HEADER_SIZE)
+          raise ArgumentError, "Failed to read RPM header" unless header_data
+
+          @magic = header_data[0, 8]
+          @entry_count = header_data[8, 4].unpack1("N")
+          @data_length = header_data[12, 4].unpack1("N")
+
+          validate!
+
+          # Read tag entries
+          tag_data_size = @entry_count * TAG_ENTRY_SIZE
+          tag_entries_data = io.read(tag_data_size)
+
+          # Read data blob
+          data_blob = io.read(@data_length)
+
+          # Parse tags
+          @tags = []
+          @entry_count.times do |i|
+            offset = i * TAG_ENTRY_SIZE
+            entry = tag_entries_data[offset, TAG_ENTRY_SIZE].unpack("NNNN")
+
+            tag = Tag.new(entry[0], entry[1], entry[2], entry[3], data_blob)
+            @tags << tag
+          end
+
+          @length = HEADER_HEADER_SIZE + tag_data_size + @data_length
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rpm/lead.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM lead structure parser
+      #
+      # The lead is a 96-byte deprecated header at the start of RPM files.
+      # It contains basic package identification but most information
+      # is now stored in the main header.
+      class Lead
+        include Omnizip::Formats::Rpm::Constants
+
+        # @return [String] 4-byte magic
+        attr_reader :magic
+
+        # @return [Integer] Major version
+        attr_reader :major_version
+
+        # @return [Integer] Minor version
+        attr_reader :minor_version
+
+        # @return [Integer] Package type (binary=0, source=1)
+        attr_reader :type
+
+        # @return [Integer] Architecture number
+        attr_reader :architecture
+
+        # @return [String] Package name (66 bytes)
+        attr_reader :name
+
+        # @return [Integer] OS number
+        attr_reader :os
+
+        # @return [Integer] Signature type
+        attr_reader :signature_type
+
+        # @return [Integer] Total length (always 96)
+        attr_reader :length
+
+        # Initialize a parsed lead. All attributes are required; use
+        # +Lead.parse(io)+ for the typical read path.
+        def initialize(magic:, major_version:, minor_version:, type:,
+                       architecture:, name:, os:, signature_type:,
+                       length: LEAD_SIZE)
+          @magic = magic
+          @major_version = major_version
+          @minor_version = minor_version
+          @type = type
+          @architecture = architecture
+          @name = name
+          @os = os
+          @signature_type = signature_type
+          @length = length
+        end
+
+        # Parse lead from IO
+        #
+        # @param io [IO] Input stream positioned at lead
+        # @return [Lead] Parsed lead object
+        # @raise [ArgumentError] If magic is invalid
+        def self.parse(io)
+          data = io.read(LEAD_SIZE)
+          raise ArgumentError, "Failed to read RPM lead" unless data
+          raise ArgumentError, "Truncated RPM lead" if data.bytesize < LEAD_SIZE
+
+          # Unpack lead structure
+          # A4 = 4-byte string (magic)
+          # CC = 2 unsigned chars (major, minor)
+          # n = big-endian short (type)
+          # n = big-endian short (architecture)
+          # A66 = 66-byte string (name)
+          # n = big-endian short (os)
+          # n = big-endian short (signature_type)
+          # A16 = 16-byte reserved
+          magic, major, minor, type, arch, name, os, sig_type = data.unpack("A4 CC n n A66 n n A16")
+
+          new(
+            magic: magic,
+            major_version: major,
+            minor_version: minor,
+            type: type,
+            architecture: arch,
+            name: name.strip,
+            os: os,
+            signature_type: sig_type,
+          ).tap(&:validate!)
+        end
+
+        # Validate lead structure
+        #
+        # @raise [ArgumentError] If validation fails
+        def validate!
+          if @magic.nil? || @magic.bytesize < 4
+            raise ArgumentError, "Invalid RPM magic: missing or truncated"
+          end
+
+          unless @magic == LEAD_MAGIC
+            raise ArgumentError,
+                  format("Invalid RPM magic: 0x%08x (expected 0x%08x)",
+                         @magic.unpack1("N"), LEAD_MAGIC.unpack1("N"))
+          end
+
+          unless [PACKAGE_BINARY, PACKAGE_SOURCE].include?(@type)
+            raise ArgumentError, "Invalid RPM type: #{@type}"
+          end
+        end
+
+        # Check if package is binary
+        #
+        # @return [Boolean]
+        def binary?
+          @type == PACKAGE_BINARY
+        end
+
+        # Check if package is source
+        #
+        # @return [Boolean]
+        def source?
+          @type == PACKAGE_SOURCE
+        end
+
+        # Get type name
+        #
+        # @return [Symbol] :binary or :source
+        def type_name
+          binary? ? :binary : :source
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rpm/tag.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rpm
+      # RPM tag definitions and value extraction
+      #
+      # Maps tag IDs to symbolic names and handles typed value extraction
+      # from the header data blob.
+      class Tag
+        include Omnizip::Formats::Rpm::Constants
+
+        # Tag ID to name mapping (from rpm/rpmtag.h)
+        TAG_IDS = {
+          # Signature tags
+          257 => :sigsize,
+          261 => :sigmd5,
+          262 => :siggpg,
+          263 => :sigpgp5,
+          267 => :dsaheader,
+          268 => :rsaheader,
+          269 => :sha1header,
+          270 => :longsigsize,
+          271 => :longarchivesize,
+
+          # Header tags
+          1000 => :name,
+          1001 => :version,
+          1002 => :release,
+          1003 => :epoch,
+          1004 => :summary,
+          1005 => :description,
+          1006 => :buildtime,
+          1007 => :buildhost,
+          1009 => :size,
+          1010 => :distribution,
+          1011 => :vendor,
+          1014 => :license,
+          1015 => :packager,
+          1016 => :group,
+          1020 => :url,
+          1021 => :os,
+          1022 => :arch,
+          1023 => :prein,
+          1024 => :postin,
+          1025 => :preun,
+          1026 => :postun,
+          1027 => :oldfilenames,
+          1028 => :filesizes,
+          1029 => :filestates,
+          1030 => :filemodes,
+          1031 => :fileuids,
+          1032 => :filegids,
+          1033 => :filerdevs,
+          1034 => :filemtimes,
+          1035 => :filedigests,
+          1036 => :filelinktos,
+          1037 => :fileflags,
+          1039 => :fileusername,
+          1040 => :filegroupname,
+          1044 => :sourcerpm,
+          1046 => :archivesize,
+          1047 => :providename,
+          1048 => :requireflags,
+          1049 => :requirename,
+          1050 => :requireversion,
+          1053 => :conflictflags,
+          1054 => :conflictname,
+          1055 => :conflictversion,
+          1064 => :rpmversion,
+          1090 => :obsoletename,
+          1112 => :provideflags,
+          1113 => :provideversion,
+          1114 => :obsoleteflags,
+          1115 => :obsoleteversion,
+          1116 => :dirindexes,
+          1117 => :basenames,
+          1118 => :dirnames,
+          1124 => :payloadformat,
+          1125 => :payloadcompressor,
+          1126 => :payloadflags,
+
+          # Extended tags
+          5000 => :filenames,
+          5008 => :longfilesizes,
+          5009 => :longsize,
+          5013 => :evr,
+          5014 => :nvr,
+          5016 => :nevra,
+          5019 => :epochnum,
+        }.freeze
+
+        # Type ID to name mapping
+        TYPE_NAMES = {
+          TYPE_NULL => :null,
+          TYPE_CHAR => :char,
+          TYPE_INT8 => :int8,
+          TYPE_INT16 => :int16,
+          TYPE_INT32 => :int32,
+          TYPE_INT64 => :int64,
+          TYPE_STRING => :string,
+          TYPE_BINARY => :binary,
+          TYPE_STRING_ARRAY => :string_array,
+          TYPE_I18NSTRING => :i18nstring,
+        }.freeze
+
+        # @return [Integer] Tag ID
+        attr_reader :tag_id
+
+        # @return [Integer] Tag type
+        attr_reader :type_id
+
+        # @return [Integer] Offset into data blob
+        attr_reader :offset
+
+        # @return [Integer] Count of items
+        attr_reader :count
+
+        # @return [String] Data blob reference
+        attr_reader :data
+
+        # Initialize tag
+        #
+        # @param tag_id [Integer] Tag identifier
+        # @param type_id [Integer] Type identifier
+        # @param offset [Integer] Offset into data blob
+        # @param count [Integer] Item count
+        # @param data [String] Reference to data blob
+        def initialize(tag_id, type_id, offset, count, data)
+          @tag_id = tag_id
+          @type_id = type_id
+          @offset = offset
+          @count = count
+          @data = data
+          @value = nil
+        end
+
+        # Get tag name
+        #
+        # @return [Symbol, Integer] Tag name or ID if unknown
+        def name
+          TAG_IDS.fetch(@tag_id, @tag_id)
+        end
+
+        # Get type name
+        #
+        # @return [Symbol, Integer] Type name or ID if unknown
+        def type
+          TYPE_NAMES.fetch(@type_id, @type_id)
+        end
+
+        # Get tag value (lazy extraction)
+        #
+        # @return [Object] Extracted value based on type
+        def value
+          return @value if @value
+
+          @value = extract_value
+        end
+
+        private
+
+        # Extract value based on type
+        #
+        # @return [Object] Extracted value
+        def extract_value
+          case type
+          when :string, :i18nstring
+            extract_string
+          when :string_array
+            extract_string_array
+          when :binary
+            extract_binary
+          when :int8
+            extract_int8
+          when :int16
+            extract_int16
+          when :int32
+            extract_int32
+          when :int64
+            extract_int64
+          when :char
+            extract_char
+          else
+            extract_binary
+          end
+        end
+
+        def extract_string
+          @data[@offset..]&.split("\0", 2)&.first || ""
+        end
+
+        def extract_string_array
+          @data[@offset..].to_s.split("\0")[0...@count] || []
+        end
+
+        def extract_binary
+          @data[@offset, @count] || ""
+        end
+
+        def extract_int8
+          @data[@offset, @count].unpack("C" * @count)
+        end
+
+        def extract_int16
+          @data[@offset, 2 * @count].unpack("n" * @count)
+        end
+
+        def extract_int32
+          @data[@offset, 4 * @count].unpack("N" * @count)
+        end
+
+        def extract_int64
+          values = []
+          @count.times do |i|
+            high, low = @data[@offset + (i * 8), 8].unpack("NN")
+            values << ((high << 32) | low)
+          end
+          values
+        end
+
+        def extract_char
+          @data[@offset, @count].unpack("a" * @count)
+        end
+      end
+    end
+  end
+end