elftools 2.0.0 → 2.2.0

data/lib/elftools/sections/symbol.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/structs'
+require 'elftools/util'
 
 module ELFTools
   module Sections
     # Class of symbol.
     class Symbol
-      attr_reader :header # @return [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] Section header.
       attr_reader :stream # @return [#pos=, #read] Streaming object.
 
       # Instantiate a {ELFTools::Sections::Symbol} object.
-      # @param [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] header
-      #   The symbol header.
+      # @param [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym, ELFTools::Structs::Fields] header
+      #   The symbol header, or what the file records in one. {ELFTools::Structs::Fields}
+      #   answers what the symbol records until something asks for {#header}
+      #   itself, which builds the structure then.
       # @param [#pos=, #read] stream The streaming object.
       # @param [ELFTools::Sections::StrTabSection, Proc] symstr
       #   The symbol string section.
@@ -19,17 +22,76 @@ module ELFTools
       #   access {Symbol#name}.
       # @param [Integer] machine
       #   The machine of the ELF file, which a name of a value depends on.
-      def initialize(header, stream, symstr: nil, machine: nil)
-        @header = header
+      # @param [Proc] version
+      #   Call this to get the version this symbol binds to, which only the
+      #   symbols a file is loaded by have.
+      def initialize(header, stream, symstr: nil, machine: nil, version: nil)
+        @fields = header.is_a?(Structs::Fields) ? header : Structs::Fields.of(header)
         @stream = stream
         @symstr = symstr
         @machine = machine
+        @version = version
+      end
+
+      # The structure the file records this symbol in.
+      #
+      # One is built here for a symbol read without it, which is what assigning
+      # to a field of a symbol needs and what {ELFTools::ELFFile#patches}
+      # reports the changes of.
+      # @return [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] The structure.
+      def header
+        @fields.struct
       end
 
       # Return the symbol name.
       # @return [String] The name.
       def name
-        @name ||= @symstr.call.name_at(header.st_name)
+        @name ||= @symstr.call.name_at(@fields[:st_name])
+      end
+
+      # The version this symbol binds to.
+      #
+      # Only the symbols a file is loaded by have one, and only where the file
+      # records the versions at all. {#name} is left as the file records it,
+      # without the version appended.
+      # @return [String, nil] The name of the version.
+      # @example
+      #   elf.dynamic.symbol_by_name('printf').version
+      #   #=> 'GLIBC_2.2.5'
+      def version
+        binding_version&.name
+      end
+
+      # Whether {#version} is one the symbol asks for by name rather than the
+      # default one of its name.
+      # @return [Boolean] The answer.
+      def version_hidden?
+        binding_version&.hidden? || false
+      end
+
+      # What this symbol is worth, which for most of them is the address of
+      # what they name.
+      #
+      # A symbol of a file that is not loaded anywhere records an offset into
+      # the section holding it instead, and one the linker is still to place,
+      # which {ELFTools::Constants::SHN_COMMON} marks, records the alignment it
+      # needs. The ABI leaves the field to the kind of symbol for that reason,
+      # and this answers with what is recorded either way.
+      # @return [Integer] The value.
+      # @example
+      #   elf.section_by_name('.symtab').symbol_by_name('main').value
+      #   #=> 4196061 # 0x4006dd
+      def value
+        @fields[:st_value]
+      end
+
+      # How many bytes what this symbol names takes.
+      # @return [Integer] The number, zero where the file records none.
+      # @example
+      #   elf.section_by_name('.symtab').symbol_by_name('main').size
+      #   #=> 142
+      def size
+        @fields[:st_size]
       end
 
       # What kind of entity this symbol refers to.
@@ -40,7 +102,16 @@ module ELFTools
       #   symbol.type == ELFTools::Constants::STT_FUNC
       #   #=> true
       def type
-        header.st_info & 0xf
+        @fields[:st_info] & 0xf
+      end
+
+      # Sets what kind of entity this symbol refers to.
+      # @param [Integer] type The type.
+      # @raise [ArgumentError] If the four bits recording it cannot hold it.
+      # @example
+      #   symbol.type = ELFTools::Constants::STT_FUNC
+      def type=(type)
+        header.st_info = (bind << 4) | Util.fits!(type, 4, 'Symbol type')
       end
 
       # The name of {#type}.
@@ -63,7 +134,16 @@ module ELFTools
       #   symbol.bind == ELFTools::Constants::STB_GLOBAL
       #   #=> true
       def bind
-        header.st_info >> 4
+        @fields[:st_info] >> 4
+      end
+
+      # Sets how this symbol is linked against others with the same name.
+      # @param [Integer] bind The binding.
+      # @raise [ArgumentError] If the four bits recording it cannot hold it.
+      # @example
+      #   symbol.bind = ELFTools::Constants::STB_WEAK
+      def bind=(bind)
+        header.st_info = (Util.fits!(bind, 4, 'Symbol binding') << 4) | type
       end
 
       # The name of {#bind}.
@@ -84,7 +164,20 @@ module ELFTools
       #   symbol.visibility == ELFTools::Constants::STV_HIDDEN
       #   #=> true
       def visibility
-        header.st_other & 0x3
+        @fields[:st_other] & 0x3
+      end
+
+      # Sets how this symbol is accessed once it becomes part of an executable
+      # or shared object.
+      #
+      # The rest of +st_other+ is left alone, which some machines record their
+      # own thing in.
+      # @param [Integer] visibility The visibility.
+      # @raise [ArgumentError] If the two bits recording it cannot hold it.
+      # @example
+      #   symbol.visibility = ELFTools::Constants::STV_HIDDEN
+      def visibility=(visibility)
+        header.st_other = (header.st_other.to_i & 0xfc) | Util.fits!(visibility, 2, 'Symbol visibility')
       end
 
       # The name of {#visibility}.
@@ -96,6 +189,15 @@ module ELFTools
         Constants::STV.mapping(@machine, visibility)
       end
 
+      # The version this symbol binds to, whatever is asked of it.
+      # @return [ELFTools::Dynamic::Versions::Version, nil] The version.
+      def binding_version
+        return @binding_version if defined?(@binding_version)
+
+        @binding_version = @version&.call
+      end
+      private :binding_version
+
       # The index of the section this symbol is defined in.
       #
       # Values in {ELFTools::Constants::SHN} have special meanings instead of
@@ -105,7 +207,7 @@ module ELFTools
       #   symbol.section_index == ELFTools::Constants::SHN_UNDEF
       #   #=> true # the symbol is undefined and to be resolved at runtime
       def section_index
-        header.st_shndx.to_i
+        @fields[:st_shndx]
       end
     end
   end

data/lib/elftools/sections/version_definition_section.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+require 'elftools/version_tables'
+
+module ELFTools
+  module Sections
+    # Class of the section recording the versions a file defines for what it
+    # exports.
+    #
+    # This section is usually named .gnu.version_d, and records the very
+    # versions the +DT_VERDEF+ tag points at.
+    class VersionDefinitionSection < Section
+      # Instantiate a {VersionDefinitionSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Proc] section_at
+      #   The method for fetching other sections by index, which is where the
+      #   names are recorded.
+      def initialize(header, stream, section_at: nil, **_kwargs)
+        @section_at = section_at
+        super
+      end
+
+      # The versions this file defines for what it exports.
+      # @return [Array<ELFTools::VersionTables::Definition>]
+      #   The definitions, in the order the section records them.
+      # @example
+      #   section.definitions.map(&:name).first(3)
+      #   #=> ['libc.so.6', 'GLIBC_2.2.5', 'GLIBC_2.2.6']
+      def definitions
+        @definitions ||= VersionTables.new(stream, @section_at.call(header.sh_link),
+                                           endian: header.class.self_endian)
+                                      .definitions(header.sh_offset.to_i, header.sh_info.to_i)
+      end
+    end
+  end
+end

data/lib/elftools/sections/version_need_section.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+require 'elftools/version_tables'
+
+module ELFTools
+  module Sections
+    # Class of the section recording the versions a file needs of the files it
+    # is loaded with.
+    #
+    # This section is usually named .gnu.version_r, and records the very
+    # versions the +DT_VERNEED+ tag points at.
+    class VersionNeedSection < Section
+      # Instantiate a {VersionNeedSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Proc] section_at
+      #   The method for fetching other sections by index, which is where the
+      #   names are recorded.
+      def initialize(header, stream, section_at: nil, **_kwargs)
+        @section_at = section_at
+        super
+      end
+
+      # The versions this file needs of the files it is loaded with.
+      # @return [Array<ELFTools::VersionTables::Requirement>]
+      #   The requirements, in the order the section records them.
+      # @example
+      #   section.requirements.map { |need| [need.file, need.versions.map(&:name)] }
+      #   #=> [['libc.so.6', ['GLIBC_2.4', 'GLIBC_2.2.5']]]
+      def requirements
+        @requirements ||= VersionTables.new(stream, @section_at.call(header.sh_link),
+                                            endian: header.class.self_endian)
+                                       .requirements(header.sh_offset.to_i, header.sh_info.to_i)
+      end
+    end
+  end
+end

data/lib/elftools/sections/version_section.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+
+module ELFTools
+  module Sections
+    # Class of the section recording which version each symbol binds to.
+    #
+    # This section is usually named .gnu.version, and holds an index per symbol
+    # of the table its +sh_link+ names, the very indices the +DT_VERSYM+ tag
+    # points at.
+    class VersionSection < Section
+      # How many symbols the section records a version for.
+      # @return [Integer] The number.
+      def num_versions
+        header.sh_size.to_i / entry_size
+      end
+
+      # What the +n+-th symbol records as its version, which is an index into
+      # the versions a file needs or defines, with the highest bit marking a
+      # version the symbol asks for by name rather than the default one.
+      # @param [Integer] n The symbol index.
+      # @return [Integer, nil] The index, +nil+ if the section records none for it.
+      # @example
+      #   section.version_at(1)
+      #   #=> 2
+      def version_at(n)
+        return if n.negative? || n >= num_versions
+
+        stream.pos = header.sh_offset.to_i + (n * entry_size)
+        stream.read(entry_size).unpack1(header.class.self_endian == :big ? 'S>' : 'S<')
+      end
+
+      private
+
+      # What an entry takes, which the section records and the format fixes at
+      # two bytes either way.
+      # @return [Integer] The number of bytes.
+      def entry_size
+        2
+      end
+    end
+  end
+end