elftools 2.0.0 → 2.1.0

data/lib/elftools/util.rb

@@ -3,6 +3,11 @@
 module ELFTools
   # Define some util methods.
   module Util
+    # How many bytes {ClassMethods#cstring} takes from a stream at a time. Long
+    # enough that a name is usually read in one, short enough that reading one
+    # never reaches far past its end.
+    CSTRING_CHUNK = 64
+
     # Class methods.
     module ClassMethods
       # Round up the number to be multiple of
@@ -23,6 +28,26 @@ module ELFTools
         (num + n) & ~(n - 1)
       end
 
+      # Checks a value is one the bits recording it can hold.
+      #
+      # Several of the values a file records share a byte with others, so a
+      # value too large for its bits would be written over its neighbours
+      # instead of being rejected.
+      # @param [Integer] value The value.
+      # @param [Integer] bits How many bits record it.
+      # @param [String] name What the value is, for the error to name.
+      # @return [Integer] The value.
+      # @raise [ArgumentError] If the bits cannot hold it.
+      # @example
+      #   Util.fits!(16, 4, 'Symbol binding')
+      #   #=> ArgumentError: Symbol binding must be in 0..15, got 16
+      def fits!(value, bits, name)
+        highest = (1 << bits) - 1
+        return value if value.is_a?(Integer) && value.between?(0, highest)
+
+        raise ArgumentError, format('%s must be in 0..%d, got %p', name, highest, value)
+      end
+
       # Fetch the correct value from module +mod+.
       #
       # See {ELFTools::ELFFile#segment_by_type} for how to
@@ -38,20 +63,22 @@ module ELFTools
         module_name = mod.name.sub('ELFTools::', '')
         # if val is an integer, check if exists in mod
         if val.is_a?(Integer)
-          return val if mod.constants.any? { |c| mod.const_get(c) == val }
+          return val if values_of(mod).key?(val)
 
           raise ArgumentError, "No constants in #{module_name} is #{val}"
         end
         val = val.to_s.upcase
         prefix = module_name.split('::')[-1]
         val = "#{prefix}_#{val}" unless val.start_with?(prefix)
-        val = val.to_sym
-        raise ArgumentError, "No constants in #{module_name} named \"#{val}\"" unless mod.const_defined?(val)
+        value = constants_of(mod)[val]
+        raise ArgumentError, "No constants in #{module_name} named \"#{val}\"" if value.nil?
 
-        mod.const_get(val)
+        value
       end
 
       # Read from stream until reach a null-byte.
+      #
+      # The stream is left just past the null-byte.
       # @param [#pos=, #read] stream Streaming object.
       # @param [Integer] offset Start from here.
       # @return [String] Result string will never contain null byte.
@@ -60,16 +87,19 @@ module ELFTools
       #   #=> "\x7FELF\x02\x01\x01"
       def cstring(stream, offset)
         stream.pos = offset
-        # read until "\x00"
-        ret = ''
+        ret = +''
         loop do
-          c = stream.read(1)
-          return nil if c.nil? # reach EOF
-          break if c == "\x00"
+          chunk = stream.read(CSTRING_CHUNK)
+          return nil if chunk.nil? # reach EOF
+
+          stop = chunk.index("\x00")
+          if stop
+            stream.pos = offset + ret.bytesize + stop + 1
+            return ret << chunk.byteslice(0, stop)
+          end
 
-          ret += c
+          ret << chunk
         end
-        ret
       end
 
       # Select objects from enumerator with +.type+ property
@@ -93,6 +123,33 @@ module ELFTools
           end
         end
       end
+
+      private
+
+      # What a module names each of its constants, and what each is worth.
+      #
+      # Names are compared upcased, which is how a constant keeping the case
+      # the ABI wrote it in, +SHT_GNU_verneed+ for one, is found by the name it
+      # is asked for. Read once per module, because reading them is more work
+      # than the lookup it is for.
+      # @param [Module] mod The module.
+      # @return [Hash{String => Integer}] The constants, by their upcased name.
+      def constants_of(mod)
+        (@constants_of ||= {})[mod] ||= mod.constants.each_with_object({}) do |constant, table|
+          # A constant still waiting to be autoloaded is left alone, so that
+          # asking after one never loads what nothing has asked for.
+          next if mod.autoload?(constant)
+
+          table[constant.to_s.upcase] ||= mod.const_get(constant)
+        end
+      end
+
+      # Which values a module names a constant for.
+      # @param [Module] mod The module.
+      # @return [Hash{Integer => Boolean}] The values, as the keys.
+      def values_of(mod)
+        (@values_of ||= {})[mod] ||= constants_of(mod).values.to_h { |value| [value, true] }
+      end
     end
     extend ClassMethods
   end

data/lib/elftools/version.rb

@@ -2,5 +2,5 @@
 
 module ELFTools
   # Current gem version
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/lib/elftools/version_tables.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+require 'elftools/structs'
+
+module ELFTools
+  # The two tables a file records its versions in.
+  #
+  # One holds the versions the file needs of the files it is loaded with, the
+  # other the versions it defines for what it exports, and a symbol names one
+  # of either by the same index. Both are chains, each entry saying how far
+  # off the next one is, and both are recorded twice over: the tags point at
+  # them, and so do sections.
+  class VersionTables
+    # The name each index of either table names.
+    # @param [Array<ELFTools::VersionTables::Requirement>] requirements The requirements.
+    # @param [Array<ELFTools::VersionTables::Definition>] definitions The definitions.
+    # @return [Hash{Integer => String}] The names.
+    def self.names(requirements, definitions)
+      (requirements.flat_map(&:versions) + definitions).to_h { |version| [version.index, version.name] }
+    end
+
+    # The version a symbol records, read against the names of the tables.
+    # @param [Integer, nil] recorded
+    #   What the symbol records, which is an index with the highest bit marking
+    #   a version asked for by name rather than the default one.
+    # @param [Hash{Integer => String}] names What {names} answered.
+    # @return [ELFTools::VersionTables::Version, nil]
+    #   The version, +nil+ where the symbol names none: a symbol of the file
+    #   itself, a symbol of no version at all, and a name nothing records.
+    def self.version(recorded, names)
+      return if recorded.nil?
+
+      index = recorded & ~Constants::VER_NDX_HIDDEN
+      return if index <= Constants::VER_NDX_GLOBAL
+
+      name = names[index]
+      Version.new(name, index, hidden: !(recorded & Constants::VER_NDX_HIDDEN).zero?) if name
+    end
+
+    # Instantiate a {ELFTools::VersionTables} object.
+    # @param [#pos=, #read] stream Streaming object.
+    # @param [#name_at] strtab The table the names are recorded in.
+    # @param [Symbol] endian +:little+ or +:big+.
+    def initialize(stream, strtab, endian:)
+      @stream = stream
+      @strtab = strtab
+      @endian = endian
+    end
+
+    # Reads the versions a file needs of the files it is loaded with.
+    # @param [Integer] at The file offset the table starts at.
+    # @param [Integer] count How many entries it has.
+    # @return [Array<ELFTools::VersionTables::Requirement>] The requirements.
+    def requirements(at, count)
+      chain(at, count, Structs::ELF_Verneed, :vn_next) do |need, from|
+        versions = chain(from + need.vn_aux.to_i, need.vn_cnt.to_i, Structs::ELF_Vernaux, :vna_next) do |aux, _|
+          Version.new(@strtab.name_at(aux.vna_name.to_i), aux.vna_other.to_i)
+        end
+        Requirement.new(@strtab.name_at(need.vn_file.to_i), versions)
+      end
+    end
+
+    # Reads the versions a file defines for what it exports.
+    # @param [Integer] at The file offset the table starts at.
+    # @param [Integer] count How many entries it has.
+    # @return [Array<ELFTools::VersionTables::Definition>] The definitions.
+    def definitions(at, count)
+      chain(at, count, Structs::ELF_Verdef, :vd_next) do |defn, from|
+        names = chain(from + defn.vd_aux.to_i, defn.vd_cnt.to_i, Structs::ELF_Verdaux, :vda_next) do |aux, _|
+          @strtab.name_at(aux.vda_name.to_i)
+        end
+        # The first name is the version's own, the rest are what it descends from.
+        Definition.new(names.first, defn.vd_ndx.to_i, names.drop(1),
+                       base: !(defn.vd_flags.to_i & Constants::VER_FLG_BASE).zero?)
+      end
+    end
+
+    private
+
+    # Reads a chain of entries, each saying how far off the one after it is.
+    # @return [Array] What the block makes of each entry.
+    def chain(at, count, klass, following)
+      Array.new(count) do
+        entry = klass.new(endian: @endian, offset: at)
+        @stream.pos = at
+        entry.read(@stream)
+        yield(entry, at).tap { at += entry.send(following).to_i }
+      end
+    end
+
+    # A version a file needs or defines.
+    class Version
+      attr_reader :name # @return [String] The name, +GLIBC_2.2.5+ for instance.
+      attr_reader :index # @return [Integer] The index the symbols name it with.
+
+      # Instantiate a {ELFTools::VersionTables::Version} object.
+      # @param [String] name The name.
+      # @param [Integer] index The index.
+      # @param [Boolean] hidden Whether a symbol binds to it as a version that is not the default.
+      def initialize(name, index, hidden: false)
+        @name = name
+        @index = index
+        @hidden = hidden
+      end
+
+      # Whether the symbol binding to this version binds to something other
+      # than the default, which is what more than one version of a name means.
+      # @return [Boolean] The answer.
+      def hidden?
+        @hidden
+      end
+    end
+
+    # The versions a file needs of one of the files it is loaded with.
+    class Requirement
+      attr_reader :file # @return [String] The name of the file, +libc.so.6+ for instance.
+      attr_reader :versions # @return [Array<ELFTools::VersionTables::Version>] The versions needed of it.
+
+      # Instantiate a {ELFTools::VersionTables::Requirement} object.
+      # @param [String] file The name of the file.
+      # @param [Array<ELFTools::VersionTables::Version>] versions The versions.
+      def initialize(file, versions)
+        @file = file
+        @versions = versions
+      end
+    end
+
+    # A version a file defines for what it exports.
+    class Definition
+      attr_reader :name # @return [String] The name.
+      attr_reader :index # @return [Integer] The index the symbols name it with.
+      attr_reader :parents # @return [Array<String>] The names of the versions it descends from.
+
+      # Instantiate a {ELFTools::VersionTables::Definition} object.
+      # @param [String] name The name.
+      # @param [Integer] index The index.
+      # @param [Array<String>] parents The names it descends from.
+      # @param [Boolean] base Whether it names the file rather than a version of it.
+      def initialize(name, index, parents, base: false)
+        @name = name
+        @index = index
+        @parents = parents
+        @base = base
+      end
+
+      # Whether this names the file itself rather than a version of it, which
+      # the first definition of a file does.
+      # @return [Boolean] The answer.
+      def base?
+        @base
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elftools
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - david942j
@@ -224,20 +224,26 @@ files:
 - lib/elftools/dynamic/string_table.rb
 - lib/elftools/dynamic/symbols.rb
 - lib/elftools/dynamic/tag.rb
+- lib/elftools/dynamic/versions.rb
 - lib/elftools/elf_file.rb
 - lib/elftools/exceptions.rb
 - lib/elftools/lazy_array.rb
 - lib/elftools/note.rb
+- lib/elftools/relative_relocations.rb
 - lib/elftools/relocation.rb
 - lib/elftools/sections/dynamic_section.rb
 - lib/elftools/sections/note_section.rb
 - lib/elftools/sections/null_section.rb
+- lib/elftools/sections/relative_relocation_section.rb
 - lib/elftools/sections/relocation_section.rb
 - lib/elftools/sections/section.rb
 - lib/elftools/sections/sections.rb
 - lib/elftools/sections/str_tab_section.rb
 - lib/elftools/sections/sym_tab_section.rb
 - lib/elftools/sections/symbol.rb
+- lib/elftools/sections/version_definition_section.rb
+- lib/elftools/sections/version_need_section.rb
+- lib/elftools/sections/version_section.rb
 - lib/elftools/segments/dynamic_segment.rb
 - lib/elftools/segments/interp_segment.rb
 - lib/elftools/segments/load_segment.rb
@@ -247,12 +253,13 @@ files:
 - lib/elftools/structs.rb
 - lib/elftools/util.rb
 - lib/elftools/version.rb
+- lib/elftools/version_tables.rb
 homepage: https://github.com/david942j/rbelftools
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  changelog_uri: https://github.com/david942j/rbelftools/blob/v2.0.0/CHANGELOG.md
+  changelog_uri: https://github.com/david942j/rbelftools/blob/v2.1.0/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib