dnsruby 1.74.0 → 2.0.0

data/lib/dnsruby/resource/TXT.rb

@@ -58,12 +58,19 @@ module Dnsruby
         in_string = false
         count = -1
         strings = []
-        current_binary = ""
+        input_encoding = input.encoding
+        finish_strings = lambda do
+          strings.each do |string|
+            string.force_encoding(input_encoding)
+            string.force_encoding(Encoding::BINARY) unless string.valid_encoding?
+          end
+        end
+        current_binary = +""
         current_quote_char = '"'
         unquoted = false
         seen_strings = false
         pos = 0
-        input = input.sub(/^\s*\(\s*/, "")
+        input = input.b.sub(/^\s*\(\s*/, "")
         input.sub!(/\s*\)\s*$/, "")
         input.each_char {|c|
           if (((c == "'") || (c == '"')) && (!in_escaped) && (!unquoted))
@@ -72,24 +79,24 @@ module Dnsruby
               current_quote_char = c
               in_string = true
               count+=1
-              strings[count] = ""
+              strings[count] = "".b
             else
               if (c == current_quote_char)
                 in_string = false
               else
-                strings[count]+=c
+                strings[count] << c
               end
             end
           else
             if (seen_strings && !in_string)
               if (c == ";")
                  # Comment in zone file!
-                 return strings
+                 return finish_strings.call
               end
               if (c != " " && c != "\t")
                 in_string = true
                 count+=1
-                strings[count] = ""
+                strings[count] = "".b
               else
                 next
               end
@@ -97,11 +104,11 @@ module Dnsruby
             if (pos == 0)
               unquoted = true
               count+=1
-              strings[count] = ""
+              strings[count] = "".b
             elsif (unquoted)
               if (c == " ")
                 count+=1
-                strings[count] = ""
+                strings[count] = "".b
                 pos += 1
                 next
               end
@@ -110,7 +117,7 @@ module Dnsruby
             if (c == "\\")
               if (in_escaped)
                 in_escaped = false
-                strings[count]+=(c)
+                strings[count] << c
               else
                 in_escaped = true
               end
@@ -118,63 +125,48 @@ module Dnsruby
               if (in_escaped)
                 #  Build up the binary
                 if (c == ";") || (c == '"')
-                  strings[count]+=c
+                  strings[count] << c
                   in_escaped = false
                 elsif (ESCAPE_CHARS[c])
                   in_escaped=false
-                  strings[count]+=ESCAPE_CHARS[c].chr
+                  strings[count] << ESCAPE_CHARS[c].chr
                 elsif (c<"0" || c>"9")
                   in_escaped = false
-                  strings[count]+=c
+                  strings[count] << c
                 else
                   #  Must be building up three digit string to identify binary value?
 #                  if (c >= "0" && c <= "9")
-                    current_binary += c
+                    current_binary << c
 #                  end
                   if ((current_binary.length == 3) ) # || (c < "0" || c > "9"))
-                    strings[count]+=current_binary.to_i.chr
+                    strings[count] << current_binary.to_i.chr
                     in_escaped = false
-                    current_binary = ""
+                    current_binary = +""
                   end
                 end
               else
-                strings[count]+=(c)
+                strings[count] << c
               end
             end
           end
           pos += 1
         }
-        return strings
+        finish_strings.call
       end
 
       def TXT.display(str, do_escapes = true)
-        output = ""
-        #  Probably need to scan through each string manually
-        #  Make sure to remember to escape binary characters.
-        #  Go through copying to output, and adding "\" characters as necessary?
-        str.each_byte {|c|
-          if (c == 34) || (c == 92) # || (c == 59)
-            if (do_escapes)
-            output+='\\'
-            end
-            output+=c.chr
-          elsif (c < 32) # c is binary
-            if (ESCAPE_CODES[c])
-              output +=  c.chr
-            else
-              output+= '\\'
-              num = c.to_i.to_s
-              (3-num.length).times {|i|
-                num="0"+num
-              }
-              output+= num # Need a 3 digit number here.
-            end
-
+        output = "".b
+        str.each_byte do |octet|
+          if octet == 34 || octet == 92
+            output << 92 if do_escapes
+            output << octet
+          elsif octet < 32 && !ESCAPE_CODES.key?(octet)
+            output << format('\\%03d', octet)
           else
-            output += c.chr
+            output << octet
           end
-        }
-        return output
+        end
+        output
       end
 
       def rdata_to_string

data/lib/dnsruby/resource/domain_name.rb

@@ -44,7 +44,7 @@ module Dnsruby
 
       def encode_rdata(msg, canonical=false) #:nodoc: all
         if !([Classes::NONE, Classes::ANY].include? klass) || @rdata.length > 0
-          msg.put_name(@domainname, canonical)
+          msg.put_name(@domainname, canonical || type == Types::DNAME, canonical)
         end
       end
 

data/lib/dnsruby/resource/generic.rb

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ++
+require 'dnsruby/resource/generic_cache'
+
 module Dnsruby
   class RR
     # Class to store generic RRs (RFC 3597)
@@ -44,6 +46,9 @@ module Dnsruby
       end
 
       def self.create(type_value, class_value) #:nodoc:
+        if GenericCache.automatic?(type_value, class_value)
+          return GenericCache.create(type_value, class_value)
+        end
         c = Class.new(Generic)
         #           c.type = type_value
         #           c.klass = class_value
@@ -53,6 +58,29 @@ module Dnsruby
         ClassHash[[type_value, class_value]] = c
         return c
       end
+
+      def self.name
+        @generic_cache_entry&.klass.equal?(self) ? @generic_display_name : super
+      end
+
+      def self.to_s
+        @generic_cache_entry&.klass.equal?(self) ? @generic_display_name.dup : super
+      end
+
+      def self.inspect
+        @generic_cache_entry&.klass.equal?(self) ? @generic_display_name.dup : super
+      end
+
+      def self.const_missing(name)
+        # A subclass lookup with inherit=false must still reject a native
+        # ancestor binding. Only virtual generated names need this fallback.
+        return super if !equal?(Generic) && GenericConstantInspection::NATIVE_DEFINED.bind_call(self, name)
+        found = GenericCache.named(name.to_s)
+        return found if found
+        pair = /\AType(\d+)_Class(\d+)\z/.match(name.to_s)
+        return RR.find_class(*pair.captures.map(&:to_i)) if pair
+        super
+      end
     end
 
     # --
@@ -169,3 +197,6 @@ require 'dnsruby/resource/DHCID'
 require 'dnsruby/resource/GPOS'
 require 'dnsruby/resource/NXT'
 require 'dnsruby/resource/CAA'
+require 'dnsruby/resource/SVCB'
+require 'dnsruby/resource/HTTPS'
+require 'dnsruby/resource/generic_constants'

data/lib/dnsruby/resource/generic_cache.rb

@@ -0,0 +1,384 @@
+require 'thread'
+require 'weakref'
+
+module Dnsruby
+  class RR
+    # Only automatically generated integer pairs belong to this cache. Explicit
+    # registrations and the public Generic.create factory retain their lifetime.
+    module GenericCache # :nodoc: all
+      LIMIT = 256
+      READ = Hash.instance_method(:fetch)
+      WRITE = Hash.instance_method(:[]=)
+      DELETE = Hash.instance_method(:delete)
+      KEYS = Hash.instance_method(:keys)
+      HAS_KEY = Hash.instance_method(:key?)
+      REMOVE_CONSTANT = Module.instance_method(:remove_const)
+      Entry = Struct.new(:name, :pair, :klass, :registry_key, :version, :automatic, :index)
+      NameIndex = Struct.new(:current)
+      # The FIFO and its ClassHash entries retain automatic classes. The
+      # name index is weak and also resolves caller-held classes after explicit
+      # registry deletion. Entry#automatic distinguishes reusable entries from
+      # those retained only for constant lookup.
+      # Each automatic class owns its Entry and the name's stable index cell.
+      # The cell refers weakly to the latest Entry, so an older caller-held class
+      # does not retain its replacement. Updating the cell avoids replacing a
+      # WeakMap value (unsafe on Ruby 3.2) or rebuilding maps (whose finalizers
+      # can retain every previous map on older Ruby versions).
+      # Entry versions prevent older mutation cleanup discarding a publication.
+      @lock = Mutex.new
+      @names = ObjectSpace::WeakMap.new
+      # Ruby 3.2 WeakMap enumeration can remove a dead forward entry without
+      # clearing its inverse reference. A later finalizer can then remove an
+      # unrelated entry whose key reused that address. Enumerate self-mapped
+      # index cells instead: each inverse reference has the same lifetime as
+      # its key, and @names is used only for lookup and publication.
+      @indices = ObjectSpace::WeakMap.new
+      @fifo = {}.compare_by_identity
+      @version = 0
+
+      class << self
+        def eligible?(type, klass)
+          type.instance_of?(Integer) && klass.instance_of?(Integer) && type >= 0 && klass >= 0
+        end
+
+        def key(type, klass)
+          # WeakMap uses object identity. Deduplicated strings give equal pairs
+          # the same collectible key, which the live Class owns.
+          -("Type#{type}_Class#{klass}".encode(Encoding::UTF_8))
+        end
+
+        def named(name)
+          return nil unless name.ascii_only?
+          @lock.synchronize { indexed_entry(-name.encode(Encoding::UTF_8))&.klass }
+        end
+
+        def find(type, klass)
+          return nil unless eligible?(type, klass)
+          pair = [type, klass]
+          @lock.synchronize do
+            registered = READ.bind_call(ClassHash, pair, nil)
+            return registered if registered
+            found = automatic_entry(key(type, klass))
+            retain(found) if reusable?(found)
+          end
+        end
+
+        def peek(type, klass)
+          return nil unless eligible?(type, klass)
+          @lock.synchronize { automatic_entry(key(type, klass))&.klass }
+        end
+
+        def factory(type, klass)
+          previous = Thread.current[:dnsruby_generic_factory]
+          Thread.current[:dnsruby_generic_factory] = eligible?(type, klass) ? [type, klass] : nil
+          yield
+        ensure
+          Thread.current[:dnsruby_generic_factory] = previous
+        end
+
+        def automatic?(type, klass)
+          return false unless eligible?(type, klass) && Thread.current[:dnsruby_generic_factory] == [type, klass]
+          Thread.current[:dnsruby_generic_factory] = nil
+          true
+        end
+
+        def create(type, klass)
+          # Class.new invokes the application's inherited hook. Never hold the
+          # registry lock while running it, or while setting up the new Class.
+          generated = Class.new(Generic)
+          generated.const_set(:TypeValue, type)
+          generated.const_set(:ClassValue, klass)
+          name = key(type, klass)
+          generated.instance_variable_set(:@generic_display_name, "Dnsruby::RR::Generic::#{name}".freeze)
+          entry = Entry.new(name, [type, klass].freeze, generated, nil, nil, true)
+          # WeakMap's values are weak too. The class keeps its mutable bookkeeping
+          # alive even when a client freezes the class itself.
+          generated.instance_variable_set(:@generic_cache_entry, entry)
+          @lock.synchronize do
+            registered = READ.bind_call(ClassHash, entry.pair, nil)
+            return registered if registered
+            found = automatic_entry(name)
+            return retain(found) if reusable?(found)
+            # A previous explicit factory call may have left a native constant
+            # after its registry entry was deleted. Let lookup (including YAML)
+            # reach the replacement class instead of that stale binding.
+            if GenericConstantInspection::NATIVE_DEFINED.bind_call(Generic, name, false)
+              REMOVE_CONSTANT.bind_call(Generic, name)
+            end
+            index = @names[name]
+            entry.index = index || NameIndex.new
+            entry.index.current = WeakRef.new(entry)
+            unless index
+              @names[name] = entry.index
+              @indices[entry.index] = entry.index
+            end
+            retain(entry)
+          end
+        end
+
+        # Custom Hash keys can address a different pair from their Array
+        # contents, or need not be Arrays at all. Resolve them with Ruby's own
+        # stored-key comparison, outside the cache lock (hash/eql? may call back).
+        def registry_pair(pair)
+          return pair if ClassHash.compare_by_identity?
+          native_method = Object.instance_method(:method)
+          if Array === pair && native_method.bind_call(pair, :hash).owner == Array && native_method.bind_call(pair, :eql?).owner == Array
+            return pair
+          end
+          copy = Hash.instance_method(:dup).bind_call(ClassHash)
+          keys = KEYS.bind_call(copy)
+          index = 0
+          Hash.instance_method(:transform_values!).bind_call(copy) do |_|
+            stored = keys[index]
+            index += 1
+            stored
+          end
+          missing = Object.new
+          stored = READ.bind_call(copy, pair, missing)
+          return stored unless stored.equal?(missing)
+          # A live entry may already have left the FIFO. An explicit deletion
+          # still invalidates that entry when the custom key addresses its pair.
+          entries = @lock.synchronize { automatic_entries }
+          weak = entries.to_h { |entry| [entry.pair, entry.pair] }
+          READ.bind_call(weak, pair, pair)
+        end
+
+        # Native Hash mutations run outside the lock. Their cleanup must not
+        # remove a newer publication by a concurrent or reentrant lookup.
+        def snapshot(pair = nil)
+          name = pair_name(pair) if pair
+          return {} if pair && !name
+          @lock.synchronize do
+            entries = if pair && ClassHash.compare_by_identity?
+              @fifo.keys.select { |entry| entry.registry_key.equal?(pair) }
+            elsif pair
+              [automatic_entry(name)].compact
+            else
+              automatic_entries + @fifo.keys
+            end
+            entries.each_with_object({}.compare_by_identity) { |entry, saved| saved[entry] = entry.version }
+          end
+        end
+
+        def forget(snapshot, pairs = nil, removed_only: false)
+          names = pairs&.filter_map { |pair| pair_name(pair) }
+          @lock.synchronize do
+            entries = snapshot.keys
+            entries.select! { |entry| names.include?(entry.name) } if names
+            entries += names ? names.filter_map { |name| automatic_entry(name) } : @fifo.keys
+            entries.each do |entry|
+              next if pairs && !pairs.any? { |pair| targets?(entry, pair) }
+              unchanged = snapshot.key?(entry) && snapshot[entry] == entry.version
+              unchanged &&= !READ.bind_call(ClassHash, registry_key(entry), nil).equal?(entry.klass) if removed_only
+              discard(entry) if unchanged || stale?(entry)
+            end
+          end
+        end
+
+        def register(snapshot, pair, value)
+          name = pair_name(pair)
+          return unless name
+          @lock.synchronize do
+            identity = ClassHash.compare_by_identity?
+            previous = snapshot.keys.find do |entry|
+              entry.klass.equal?(value) && targets?(entry, pair) && (identity ? entry.registry_key.equal?(pair) : entry.name == name)
+            end
+            # FIFO eviction may have run after the explicit write but before its
+            # cleanup. Preserve a successfully assigned automatic class.
+            if previous && previous.automatic && !@fifo.key?(previous) && !moved?(previous) && !READ.bind_call(ClassHash, registry_key(previous), nil)
+              actual = identity ? pair : previous.pair.dup
+              WRITE.bind_call(ClassHash, actual, value)
+            end
+            entries = identity ? @fifo.keys.select { |entry| entry.registry_key.equal?(pair) } : [automatic_entry(name)].compact
+            entries.each do |entry|
+              next unless targets?(entry, pair)
+              discard(entry) if READ.bind_call(ClassHash, registry_key(entry), nil).equal?(value)
+            end
+          end
+        end
+
+        def rehash
+          @lock.synchronize do
+            (automatic_entries + @fifo.keys).each { |entry| discard(entry) if moved?(entry) || stale?(entry) }
+          end
+        end
+
+        private
+
+        def automatic_entry(name)
+          entry = indexed_entry(name)
+          entry if entry&.automatic
+        end
+
+        def automatic_entries
+          @indices.keys.filter_map { |index| dereference(index) }.select(&:automatic)
+        end
+
+        def indexed_entry(name)
+          dereference(@names[name])
+        end
+
+        def dereference(index)
+          index&.current&.__getobj__
+        rescue WeakRef::RefError
+          nil
+        end
+
+        def pair_name(pair)
+          return unless Array === pair
+          # A native slice strips singleton methods, unlike Array#to_a.
+          pair = Array.instance_method(:[]).bind_call(pair, 0, 3)
+          key(*pair) if pair.length == 2 && eligible?(*pair)
+        end
+
+        def targets?(entry, pair)
+          return entry.registry_key.equal?(pair) if ClassHash.compare_by_identity?
+          return false unless pair_name(pair) == entry.name
+          keys = KEYS.bind_call(ClassHash)
+          pair.equal?(entry.registry_key) || !keys.any? { |item| item.equal?(pair) } || !keys.any? { |item| item.equal?(entry.registry_key) }
+        end
+
+        def moved?(entry)
+          entry.registry_key && !ClassHash.compare_by_identity? && !entry.pair.eql?(entry.registry_key)
+        end
+
+        def reusable?(entry)
+          return false unless entry
+          discard(entry) if moved?(entry)
+          !moved?(entry) && !ClassHash.compare_by_identity?
+        end
+
+        def registry_key(entry)
+          ClassHash.compare_by_identity? ? entry.registry_key : entry.pair
+        end
+
+        def stale?(entry)
+          @fifo.key?(entry) && !READ.bind_call(ClassHash, registry_key(entry), nil).equal?(entry.klass)
+        end
+
+        def discard(entry)
+          entry.automatic = false
+          @fifo.delete(entry)
+        end
+
+        def retain(entry)
+          pair = entry.pair
+          inserted = pair.dup
+          actual = inserted
+          unless ClassHash.compare_by_identity?
+            registered = READ.bind_call(ClassHash, pair, nil)
+            return registered if registered
+            if HAS_KEY.bind_call(ClassHash, pair)
+              actual = KEYS.bind_call(ClassHash).find { |item| pair.eql?(item) } || actual
+            end
+          end
+          WRITE.bind_call(ClassHash, inserted, entry.klass)
+          entry.registry_key = actual
+          entry.version = (@version += 1)
+          @fifo[entry] = true
+          while @fifo.length > LIMIT
+            old, = @fifo.shift
+            if moved?(old)
+              discard(old)
+            elsif READ.bind_call(ClassHash, registry_key(old), nil).equal?(old.klass)
+              DELETE.bind_call(ClassHash, registry_key(old))
+            end
+          end
+          entry.klass
+        end
+      end
+    end
+
+    # User edits to the public registry invalidate automatic lookup entries.
+    # Native Hash operations above distinguish internal eviction from deletion.
+    module GenericRegistryChanges # :nodoc: all
+      def []=(key, value)
+        return super unless equal?(Dnsruby::ClassHash) && !frozen?
+        pair = GenericCache.registry_pair(key)
+        before = GenericCache.snapshot(pair)
+        result = super
+        GenericCache.register(before, pair, value)
+        result
+      end
+      alias store []=
+
+      def delete(key, &block)
+        return super unless equal?(Dnsruby::ClassHash) && !frozen?
+        pair = GenericCache.registry_pair(key)
+        before = GenericCache.snapshot(pair)
+        result = super
+        GenericCache.forget(before, [pair], removed_only: true)
+        result
+      end
+
+      def clear
+        return super unless equal?(Dnsruby::ClassHash) && !frozen?
+        before = GenericCache.snapshot
+        result = super
+        GenericCache.forget(before)
+        GenericCache.rehash
+        result
+      end
+
+      def replace(other)
+        return super unless equal?(Dnsruby::ClassHash) && !frozen?
+        # Native conversion can call back into the factory. Snapshot afterwards
+        # so entries returned by to_hash become explicit registrations too.
+        replacement = {}.replace(other)
+        before = GenericCache.snapshot
+        result = super(replacement)
+        replacement.each_pair do |key, value|
+          GenericCache.register(before, GenericCache.registry_pair(key), value)
+        end
+        GenericCache.forget(before)
+        GenericCache.rehash
+        result
+      end
+
+      def rehash
+        result = super
+        GenericCache.rehash if equal?(Dnsruby::ClassHash)
+        result
+      end
+
+      [:merge!, :update].each do |operation|
+        define_method(operation) do |*args, &block|
+          return super(*args, &block) unless equal?(Dnsruby::ClassHash) && !frozen?
+          before = keys
+          snapshot = GenericCache.snapshot
+          touched = []
+          begin
+            super(*args) do |key, old, value|
+              value = block.call(key, old, value) if block
+              touched << [key, value]
+              value
+            end
+          ensure
+            touched.each { |key, value| GenericCache.register(snapshot, key, value) }
+            GenericCache.forget(snapshot, (keys - before) | touched.map(&:first))
+            GenericCache.rehash
+          end
+        end
+      end
+
+      [:delete_if, :reject!, :keep_if, :select!, :filter!, :shift,
+       :transform_keys!, :transform_values!, :compact!].each do |operation|
+        define_method(operation) do |*args, &block|
+          return super(*args, &block) unless equal?(Dnsruby::ClassHash) && !frozen?
+          before = dup
+          snapshot = GenericCache.snapshot
+          begin
+            super(*args, &block)
+          ensure
+            changed = (before.keys | keys).reject do |key|
+              before.key?(key) && key?(key) && before[key].equal?(self[key])
+            end
+            GenericCache.forget(snapshot, changed)
+            GenericCache.rehash
+          end
+        end
+      end
+    end
+  end
+  ClassHash.extend(RR::GenericRegistryChanges)
+end

data/lib/dnsruby/resource/generic_constants.rb

@@ -0,0 +1,79 @@
+module Dnsruby
+  class RR
+    module GenericConstantInspection
+      NATIVE_DEFINED = Module.instance_method(:const_defined?)
+      NATIVE_GET = Module.instance_method(:const_get)
+      NATIVE_ANCESTORS = Module.instance_method(:ancestors)
+      EMPTY = Module.new
+
+      def self.native_defined?(receiver, path, inherit, nested = false)
+        if nested
+          first = path.split('::', -1).first
+          NATIVE_DEFINED.bind_call(EMPTY, first, false) # Validate; never reinterpret :: as an absolute suffix.
+          ancestors = inherit ? NATIVE_ANCESTORS.bind_call(receiver) : [receiver]
+          ancestors = ancestors.take_while { |ancestor| !ancestor.equal?(Object) } unless receiver.equal?(Object)
+          return false unless ancestors.any? { |ancestor| NATIVE_DEFINED.bind_call(ancestor, first, false) }
+        end
+        NATIVE_DEFINED.bind_call(receiver, path, inherit)
+      end
+
+      def self.nested_defined?(receiver, path, inherit)
+        native_defined?(receiver, path, inherit, true) || virtual_defined?(receiver, path, inherit, true)
+      end
+
+      def self.virtual_defined?(receiver, path, inherit, nested = false)
+        parts = path.split('::', -1)
+        parts.each_index do |index|
+          prefix = parts[0..index].join('::')
+          next if prefix.empty? && index.zero?
+          next if native_defined?(receiver, prefix, inherit, nested)
+          owner = if index.zero?
+            receiver
+          elsif index == 1 && parts.first.empty?
+            Object
+          else
+            NATIVE_GET.bind_call(receiver, parts[0...index].join('::'), inherit)
+          end
+          generic = Dnsruby::RR::Generic
+          return false unless owner.equal?(generic) || (inherit && owner.is_a?(Class) && owner < generic)
+          local = parts[index]
+          found = GenericCache.named(local)
+          numeric = /\AType(\d+)_Class(\d+)\z/.match(local)
+          return false unless found || numeric
+          return true if index == parts.length - 1
+          suffix = parts[(index + 1)..].join('::')
+          if found
+            return nested_defined?(found, suffix, inherit)
+          end
+          type, klass = numeric.captures.map(&:to_i)
+          registered = Dnsruby::ClassHash[[type, klass]] || GenericCache.peek(type, klass)
+          if registered
+            raise TypeError, "#{path} does not refer to class/module" unless registered.is_a?(Module)
+            return nested_defined?(registered, suffix, inherit)
+          end
+          NATIVE_DEFINED.bind_call(EMPTY, suffix, false) # Preserve delimiter validation before a projected value.
+          # These are the only constants every newly reconstructed Class owns.
+          if ['TypeValue', 'ClassValue'].include?(parts[index + 1])
+            return true if index + 2 == parts.length
+            raise TypeError, "#{path} does not refer to class/module"
+          end
+          ancestor = Dnsruby::RR::ClassInsensitiveTypes[type] || generic
+          return nested_defined?(inherit ? ancestor : EMPTY, suffix, inherit)
+        end
+        false
+      end
+
+      def const_defined?(name, inherit = true)
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          original = name
+          name = String.try_convert(name)
+          raise TypeError, "no implicit conversion of #{original.class} into String" unless name
+        end
+        return true if super(name, inherit)
+        path = name.is_a?(Symbol) ? name.to_s : String.new(name)
+        GenericConstantInspection.virtual_defined?(self, path, inherit)
+      end
+    end
+  end
+end
+Dnsruby::RR::Generic.singleton_class.prepend(Dnsruby::RR::GenericConstantInspection)