omnizip 0.3.2 → 0.3.4

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "tag"
+
+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 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 do |header|
+            header.send(:parse!, io)
+          end
+        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.each_with_object({}) do |tag, hash|
+            hash[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
+
+        private
+
+        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,122 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+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 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
+
+        # 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
+
+          new.tap do |lead|
+            lead.instance_variable_set(:@length, 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
+            fields = data.unpack("A4 CC n n A66 n n A16")
+
+            lead.instance_variable_set(:@magic, fields[0])
+            lead.instance_variable_set(:@major_version, fields[1])
+            lead.instance_variable_set(:@minor_version, fields[2])
+            lead.instance_variable_set(:@type, fields[3])
+            lead.instance_variable_set(:@architecture, fields[4])
+            lead.instance_variable_set(:@name, fields[5].strip)
+            lead.instance_variable_set(:@os, fields[6])
+            lead.instance_variable_set(:@signature_type, fields[7])
+
+            lead.validate!
+          end
+        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,230 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+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 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