dnsruby 1.74.0 → 2.0.0

data/lib/dnsruby/presentation.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Dnsruby
+  # Shared lexical handling for RR strings and zone-file continuation lines.
+  # Character-string escapes remain intact for the record-specific parser.
+  module Presentation #:nodoc: all
+    # Header tokens preserve escaped whitespace and punctuation in owners.
+    def self.tokens(text)
+      text.scan(/(?:\\.|[^\s])+/m)
+    end
+
+    # Decimal escapes keep escaped whitespace intact through older record
+    # parsers and layout normalization, without changing the represented octet.
+    def self.escape_whitespace(text)
+      text.gsub(/\\(.)/m) do |escaped|
+        /\s/.match?(escaped[1]) ? format('\\%03d', escaped[1].ord) : escaped
+      end
+    end
+
+    # TXT.parse historically accepts C-style escapes. Zone files instead use
+    # RFC 1035's literal nonnumeric escapes; express them as octets before
+    # handing the string to that compatibility parser.
+    def self.character_string_escapes(text)
+      text.gsub(/\\([^0-9])/m) do |escaped|
+        escaped[1].bytes.map { |octet| format('\\%03d', octet) }.join
+      end
+    end
+
+    def self.unescaped_quote(text)
+      position = 0
+      while (token = /\\.|"/m.match(text, position))
+        return token.begin(0) if token[0] == '"'
+        position = token.end(0)
+      end
+      nil
+    end
+
+    # TXT (and its SPF subclass) historically also accept single quotes. Do
+    # not extend that convention to domain names or other RDATA formats, where
+    # an apostrophe is an ordinary character. Return the end of the type token
+    # so that even a leading apostrophe in the owner cannot open a TXT string.
+    def self.single_quoted_start(text, owner_omitted: false)
+      # Grouping parentheses can touch the type (TXT('value')), while an
+      # escaped parenthesis in the owner remains part of that owner's token.
+      fields = []
+      position = 0
+      while fields.length < 4 && (field = /\G[\s()]*((?:\\.|[^\s()])+)/m.match(text, position))
+        fields << [field[1], field.end(0)]
+        position = field.end(0)
+      end
+      fields.shift unless owner_omitted
+      # Numeric classes learned from received records must not make parsing
+      # unrelated records rebuild an ever-growing regular expression.
+      ttl_seen = class_seen = false
+      2.times do
+        token = fields.first&.first
+        if token && !ttl_seen && /\A\d/.match?(token)
+          ttl_seen = true
+        elsif token && !class_seen && (Classes.to_code(token) || /\ACLASS\d+\z/i.match?(token))
+          class_seen = true
+        else
+          break
+        end
+        fields.shift
+      end
+      type_token = fields.first&.first
+      type_code = Types.to_code(type_token) if type_token
+      if !type_code && (numeric = /\ATYPE(\d+)\z/i.match(type_token.to_s))
+        type_code = numeric[1].to_i
+      end
+      fields.first.last if [Types::TXT, Types::SPF].include?(type_code)
+    end
+
+    def self.scan(text, depth = 0, quoted = false, allow_unbalanced: false,
+                  single_quoted_from: nil)
+      # Most zone records have no lexical syntax to interpret. Preserve the
+      # current continuation depth and only fold physical line endings.
+      if !quoted && !/[\\'"();]/.match?(text)
+        return [text.tr("\r\n", '  '), depth, false]
+      end
+
+      result = +''
+      quoted = '"' if quoted == true
+      just_closed_quote = false
+      position = 0
+
+      # Copy ordinary text in runs. Quoted TXT values often contain hundreds
+      # of characters but only two delimiters; allocating one String for each
+      # character makes that common case unnecessarily expensive. Regexp and
+      # String offsets both count characters, including for Unicode owners.
+      while (syntax = /[\\'"();\r\n]/.match(text, position))
+        index = syntax.begin(0)
+        if index > position
+          result << text[position...index]
+          just_closed_quote = false
+        end
+        char = syntax[0]
+        position = index + 1
+        after_quote = just_closed_quote
+        just_closed_quote = false
+
+        if char == '\\'
+          result << char
+          if (escaped = text[position])
+            result << escaped
+            position += 1
+          end
+        elsif char == '"' || (single_quoted_from && index >= single_quoted_from && char == "'" &&
+              (quoted == "'" || (!quoted && (after_quote || index.zero? || /[\s(]/.match?(text[index - 1])))))
+          result << char
+          if quoted == char
+            quoted = false
+            just_closed_quote = true
+          elsif !quoted
+            quoted = char
+          end
+        elsif !quoted && char == ';'
+          # Comments end only at LF, matching the zone reader's physical
+          # line handling. Leave that newline for the ordinary layout branch.
+          position = text.index("\n", position) || text.length
+        elsif !quoted && (char == '(' || char == ')')
+          depth += char == '(' ? 1 : -1
+          if depth.negative? && !allow_unbalanced
+            raise DecodeError.new('Unmatched closing parenthesis in record')
+          end
+          # Parentheses separate tokens when neither neighbor is whitespace.
+          # Preserve existing spacing otherwise; some older RR parsers use
+          # offsets into the original RDATA rather than whitespace tokens.
+          if !result.empty? && /\S/.match?(result[-1]) &&
+             text[index + 1] && /\S/.match?(text[index + 1])
+            result << ' '
+          end
+        elsif !quoted && (char == "\n" || char == "\r")
+          # A physical line break outside a quoted value is layout, not an
+          # octet in a TXT string or part of an RFC3597 hexadecimal value.
+          result << ' '
+        else
+          result << char
+        end
+      end
+      result << text[position..-1] if position < text.length
+
+      [result, depth, quoted]
+    end
+  end
+  private_constant :Presentation
+end

data/lib/dnsruby/query_control.rb

@@ -0,0 +1,132 @@
+require 'dnsruby/transport_clock'
+
+module Dnsruby
+  # A deadline and cancellation signal shared by related lookups. This carries
+  # no DNSSEC policy; the caller decides how a stopped operation is reported.
+  class QueryControl # :nodoc: all
+    # These must bypass ordinary lookup and verification fallback handlers.
+    class Stopped < StandardError; end
+    class Cancelled < Stopped; end
+    class DeadlineExceeded < Stopped; end
+
+    # A normal Queue whose producers also wake deadline/cancellation waiters.
+    # Keeping the notification alongside push avoids polling and works on Ruby
+    # versions which do not support Queue#pop(timeout:).
+    class Queue < ::Queue
+      def initialize
+        super
+        @wait_mutex = Mutex.new
+        @condition = ConditionVariable.new
+      end
+
+      def push(value)
+        @wait_mutex.synchronize do
+          super
+          @condition.broadcast
+        end
+        self
+      end
+      alias << push
+      alias enq push
+
+      def close
+        @wait_mutex.synchronize do
+          super
+          @condition.broadcast
+        end
+        self
+      end
+
+      def wake_waiters
+        @wait_mutex.synchronize { @condition.broadcast }
+      end
+
+      def pop_with_control(control)
+        control.add_waiter(self)
+        @wait_mutex.synchronize do
+          loop do
+            control.check!
+            begin
+              return pop(true)
+            rescue ThreadError
+              return nil if closed?
+              remaining = control.deadline && control.deadline - TransportClock.now
+              @condition.wait(@wait_mutex, remaining && [remaining, 0].max)
+            end
+          end
+        end
+      ensure
+        control.remove_waiter(self)
+      end
+    end
+
+    attr_reader :deadline
+
+    def self.current
+      Thread.current[:dnsruby_query_control]
+    end
+
+    def self.with(control)
+      previous = current
+      Thread.current[:dnsruby_query_control] = control
+      control.check!
+      result = yield
+      control.check!
+      result
+    ensure
+      Thread.current[:dnsruby_query_control] = previous
+    end
+
+    def initialize(deadline: nil, parent: nil)
+      @parent = parent
+      @deadline = [deadline, parent&.deadline].compact.min
+      @cancelled = false
+      @mutex = Mutex.new
+      @waiters = []
+    end
+
+    def cancel
+      waiters = @mutex.synchronize do
+        @cancelled = true
+        @waiters.dup
+      end
+      waiters.each(&:wake_waiters)
+      true
+    end
+
+    def check!
+      @parent&.check!
+      raise Cancelled, 'Query cancelled' if @mutex.synchronize { @cancelled }
+      raise DeadlineExceeded, 'Query deadline exceeded' if @deadline && TransportClock.now >= @deadline
+      true
+    end
+
+    def add_waiter(queue)
+      @parent&.add_waiter(queue)
+      @mutex.synchronize { @waiters << queue }
+    end
+
+    def remove_waiter(queue)
+      @mutex.synchronize do
+        index = @waiters.index(queue)
+        @waiters.delete_at(index) if index
+      end
+      @parent&.remove_waiter(queue)
+    end
+
+    def pop(queue)
+      return queue.pop_with_control(self) if queue.is_a?(Queue)
+
+      # Preserve support for caller-supplied ordinary queues, whose producers
+      # cannot notify this control. Internal lookups use the queue above.
+      loop do
+        check!
+        begin
+          return queue.pop(true)
+        rescue ThreadError
+          sleep(@deadline ? (@deadline - TransportClock.now).clamp(0, 0.01) : 0.01)
+        end
+      end
+    end
+  end
+end