dnsruby 1.74.0 → 2.0.0

data/lib/dnsruby/zone_reader.rb

@@ -25,12 +25,10 @@ module Dnsruby
     #  Create a new ZoneReader. The zone origin is required. If the desired SOA minimum
     #  and TTL are passed in, then they are used as default values.
     def initialize(origin, soa_minimum = nil, soa_ttl = nil)
-      @origin = origin.to_s
-
-      if (!Name.create(@origin).absolute?)
-        @origin = @origin.to_s + "."
-      end
+      origin_name = parse_zone_name(origin)
+      @origin = Name.new(origin_name.labels, true).to_s(true)
       @soa_ttl = soa_ttl
+      @default_ttl = nil
       if (soa_minimum && !@last_explicit_ttl)
         @last_explicit_ttl = soa_minimum
       else
@@ -39,6 +37,7 @@ module Dnsruby
       @last_explicit_class = Classes.new("IN")
       @last_name = nil
       @continued_line = nil
+      @group_depth = 0
       @in_quoted_section = false
     end
 
@@ -72,60 +71,62 @@ module Dnsruby
           raise ParseException.new("Error reading line #{io.lineno} of #{io.inspect} : [#{line}]")
         end
       end
+      if @continued_line
+        raise ParseException.new("Unclosed parenthesis at end of #{io.inspect}")
+      end
       return zone
     end
 
     #  Process the next line of the file
     #  Returns a string representing the normalised line.
     def process_line(line, do_prefix_hack = false)
-      return nil if (line[0,1] == ";")
-      line = strip_comments(line)
-      return nil if (line.strip.length == 0)
-      return nil if (!line || (line.length == 0))
-      @in_quoted_section = false if !@continued_line
+      if !@continued_line
+        @in_quoted_section = false
+        @single_quoted_start = if /['(]/.match?(line)
+          Presentation.single_quoted_start(line, owner_omitted: line.start_with?(' ', "\t"))
+        end
+      end
+      previous_quote = @in_quoted_section
+      line, @group_depth, @in_quoted_section =
+        Presentation.scan(line, @group_depth, @in_quoted_section,
+          single_quoted_from: @continued_line && @single_quoted_start ? 0 : @single_quoted_start)
+
+      if @continued_line
+        # The scanner keeps literal newlines inside quotes and turns layout
+        # newlines into spaces. Do not strip trailing quoted data. Callers of
+        # process_line may also supply lines without a terminating newline.
+        separator = previous_quote ? (@continued_line.end_with?("\n") ? '' : "\n") : ' '
+        line = @continued_line + separator + line
+      end
+      if @group_depth.positive?
+        @continued_line = line
+        return nil
+      end
+      @continued_line = nil
+      return nil if line.strip.empty?
 
       if (line.index("$ORIGIN") == 0)
-        @origin = line.split()[1].strip #  $ORIGIN <domain-name> [<comment>]
+        @origin = absolute_name(Presentation.tokens(line)[1]).to_s(true) # $ORIGIN <domain-name>
         #                 print "Setting $ORIGIN to #{@origin}\n"
         return nil
       end
       if (line.index("$TTL") == 0)
-        @last_explicit_ttl = get_ttl(line.split()[1].strip) #  $TTL <ttl>
+        @default_ttl = get_ttl(line.split()[1].strip) #  $TTL <ttl>
         #                 print "Setting $TTL to #{ttl}\n"
         return nil
       end
-      if (@continued_line)
-        #  Add the next line until we see a ")"
-        #  REMEMBER TO STRIP OFF COMMENTS!!!
-        @continued_line = strip_comments(@continued_line)
-        line = @continued_line.rstrip.chomp + " " + line
-        if (line.index(")"))
-          #  OK
-          @continued_line = false
-        end
-      end
-      open_bracket = line.index("(")
-      if (open_bracket)
-        #  Keep going until we see ")"
-        index = line.index(")")
-        if (index && (index > open_bracket))
-          #  OK
-          @continued_line = false
-        else
-          @continued_line = line
-        end
-      end
-      return nil if @continued_line
+      line += "\n"
 
-      line = strip_comments(line) + "\n"
-
-      #  If SOA, then replace "3h" etc. with expanded seconds
-      #       begin
-      return normalise_line(line, do_prefix_hack)
-      #       rescue Exception => e
-      #         print "ERROR parsing line #{@line_num} : #{line}\n"
-      #         return "\n", Types::ANY
-      #       end
+      # Preserve the public normalization hook for subclasses and prepends.
+      # Only unchanged input has already been scanned. Overrides may replace
+      # or mutate the String before calling super, introducing new syntax.
+      previous_scanned_line = @scanned_line
+      begin
+        @scanned_line = [line, line.dup]
+        normalise_line(line, do_prefix_hack)
+      ensure
+        @scanned_line = previous_scanned_line
+      end
     end
 
     def strip_comments(line)
@@ -209,52 +210,68 @@ module Dnsruby
     #  Take a line from the input zone file, and return the normalised form
     #  do_prefix_hack should always be false
     def normalise_line(line, do_prefix_hack = false)
+      # Direct callers historically accepted unmatched grouping, just like
+      # RR.create. process_line has already scanned and checked its input.
+      unless @scanned_line && line.equal?(@scanned_line[0]) && line == @scanned_line[1]
+        single_quoted_start = if line.include?("'")
+          Presentation.single_quoted_start(line, owner_omitted: line.start_with?(' ', "\t"))
+        end
+        line, = Presentation.scan(line, allow_unbalanced: true, single_quoted_from: single_quoted_start)
+      end
+      normalise_scanned_line(line, do_prefix_hack)
+    end
+
+    def normalise_scanned_line(line, do_prefix_hack = false)
+
+      line = Presentation.escape_whitespace(line) if line.include?('\\')
+
       #  Note that a freestanding "@" is used to denote the current origin - we can simply replace that straight away
-      #  Remove the ( and )
       #  Note that no domain name may be specified in the RR - in that case, last_name should be used. How do we tell? Tab or space at start of line.
 
       #  If we have text in the record, then ignore that in the parsing, and stick it on again at the end
       stored_line = "";
-      if (line.index('"') != nil)
-          stored_line = line[line.index('"'), line.length];
-          line = line [0, line.index('"')]
+      #  TXT quotes a whole token, but SVCB and HTTPS quote mid-token
+      #  (alpn="h2,h3"), so remember which to put the text back as it came.
+      #  A parenthesis separates too, and the strip below may remove it first.
+      stored_line_was_separate = true
+      quote_index = Presentation.unescaped_quote(line)
+      if line.include?("'") && (rdata_start = Presentation.single_quoted_start(line,
+          owner_omitted: line.start_with?(' ', "\t")))
+        quote_index = [quote_index, line.index(/(?<=[\s(])'/, rdata_start)].compact.min
+      end
+      if quote_index
+          stored_line_was_separate = (quote_index == 0) || !(/[\s()]/ =~ line[quote_index - 1]).nil?
+          stored_line = line[quote_index, line.length];
+          line = line [0, quote_index]
       end
       if ((line[0,1] == " ") || (line[0,1] == "\t"))
         line = @last_name + " " + line
       end
       line.chomp!
-      line.sub!(/\s+@$/, " #{@origin}") # IN CNAME @
-      line.sub!(/^@\s+/, "#{@origin} ") # IN CNAME @
-      line.sub!(/\s+@\s+/, " #{@origin} ")
+      line.sub!(/\s+@$/) { " #{@origin}" } # IN CNAME @
+      line.sub!(/^@\s+/) { "#{@origin} " } # IN CNAME @
+      line.sub!(/\s+@\s+/) { " #{@origin} " }
       line.strip!
 
 
       #  o We need to identify the domain name in the record, and then
-      split = line.split(' ') # split on whitespace
-      name = split[0].strip
-      if (name.index"\\")
-
-        ls =[]
-        Name.create(name).labels.each {|el| ls.push(Name.decode(el.to_s))}
-        new_name = ls.join('.')
-
+      split = Presentation.tokens(line)
+      name = split[0]
+      new_name = absolute_name(name).to_s(true)
+      line.sub!(name) { new_name }
+      name = new_name
+      split = line.split
 
-        if (!(/\.\z/ =~ name))
-          new_name += "." + @origin
-        else
-          new_name += "."
+      # RFC 1035 section 5.1 permits either TTL/class or class/TTL.
+      # Canonicalize the latter before applying the inherited defaults below.
+      if split[2] && /\A(?:[0-9]+[smhdwSMHDW])*[0-9]*\z/.match?(split[2]) && !split[2].empty?
+        begin
+          Classes.new(split[1])
+          split[1], split[2] = split[2], split[1]
+          line = split.join(' ') + "\n"
+        rescue ArgumentError
+          # The second token is a TTL or record type, not a class.
         end
-        line = new_name + " "
-        (split.length - 1).times {|i| line += "#{split[i+1]} "}
-        line += "\n"
-        name = new_name
-        split = line.split
-        #  o add $ORIGIN to it if it is not absolute
-      elsif !(/\.\z/ =~ name)
-        new_name = name + "." + @origin
-        line.sub!(name, new_name)
-        name = new_name
-        split = line.split
       end
 
       #  If the second field is not a number, then we should add the TTL to the line
@@ -270,7 +287,8 @@ module Dnsruby
         split = line.split
       elsif (((split[1]).to_i == 0) && (split[1] != "0"))
         #  Add the TTL
-        if (!@last_explicit_ttl)
+        inherited_ttl = @default_ttl || @last_explicit_ttl
+        if (!inherited_ttl)
           #  If this is the SOA record, and no @last_explicit_ttl is defined,
           #  then we need to try the SOA TTL element from the config. Otherwise,
           #  find the SOA Minimum field, and use that.
@@ -281,7 +299,7 @@ module Dnsruby
           #  the actual type. If the type is not SOA then, then we can raise an error
           line = name + " %MISSING_TTL% "
         else
-          line = name + " #{@last_explicit_ttl} "
+          line = name + " #{inherited_ttl} "
         end
         (split.length - 1).times {|i| line += "#{split[i+1]} "}
         line += "\n"
@@ -292,7 +310,11 @@ module Dnsruby
 
       #  Now see if the clas is included. If not, then we should default to the last class used.
       begin
-        klass = Classes.new(split[2])
+        class_text = split[2]
+        if /\ACLASS\d+\z/.match?(class_text)
+          class_text = Classes.classesbyval(Classes.classesbyname(class_text))
+        end
+        klass = Classes.new(class_text)
         @last_explicit_class = klass
       rescue ArgumentError
         #  Wasn't a CLASS
@@ -307,22 +329,28 @@ module Dnsruby
       end
 
       #  Add the type so we can load the zone one RRSet at a time.
-      type = Types.new(split[3].strip)
+      type_text = split[3].strip
+      if /\ATYPE\d+\z/.match?(type_text)
+        type_text = Types.typesbyval(Types.typesbyname(type_text))
+      end
+      type = Types.new(type_text)
       is_soa = (type == Types::SOA)
       type_was = type
+      # RFC 3597 RDATA is already encoded wire data, even for known types.
+      # Its tokens must not be treated as textual names or SOA intervals.
+      generic_rdata = split[4]&.start_with?('\\#')
       if (type == Types.RRSIG)
         #  If this is an RRSIG record, then add the TYPE COVERED rather than the type - this allows us to load a complete RRSet at a time
-        type = Types.new(split[4].strip)
+        if generic_rdata
+          type = Dnsruby::RR.send(:new_from_normalised_string, line).type_covered if do_prefix_hack
+        else
+          type = Types.new(split[4].strip)
+        end
       end
 
       type_string=prefix_for_rrset_order(type, type_was)
       @last_name = name
 
-      if !([Types::NAPTR, Types::TXT].include?type_was)
-        line.sub!("(", "")
-        line.sub!(")", "")
-      end
-
       if (is_soa)
         if (@soa_ttl)
           #  Replace the %MISSING_TTL% text with the SOA TTL from the config
@@ -333,9 +361,9 @@ module Dnsruby
             line.sub!(" %MISSING_TTL% ", " #{@last_explicit_ttl} ")
           end
         end
-        line = replace_soa_ttl_fields(line)
+        line = replace_soa_ttl_fields(line) unless generic_rdata
         if (!@last_explicit_ttl)
-          soa_rr = Dnsruby::RR.create(line)
+          soa_rr = Dnsruby::RR.send(:new_from_normalised_string, line)
           @last_explicit_ttl = soa_rr.minimum
         end
       end
@@ -343,47 +371,66 @@ module Dnsruby
       line = line.strip
 
       if (stored_line && stored_line != "")
-        line += " " + stored_line.strip
-      end
-
-      #  We need to fix up any non-absolute names in the RR
-      #  Some RRs have a single name, at the end of the string -
-      #    to do these, we can just check the last character for "." and add the
-      #    "." + origin string if necessary
-      if ([Types::MX, Types::NS, Types::AFSDB, Types::NAPTR, Types::RT,
-            Types::SRV, Types::CNAME, Types::MB, Types::MG, Types::MR,
-            Types::PTR, Types::DNAME].include?type_was)
-        #         if (line[line.length-1, 1] != ".")
-        if (!(/\.\z/ =~ line))
-          line = line + "." + @origin.to_s
+        line += " " if stored_line_was_separate
+        line += stored_line.strip
+      end
+
+      if generic_rdata
+        return line + "\n", type_string, @last_name if do_prefix_hack
+        return line + "\n"
+      end
+
+      if [Types::TXT, Types::SPF].include?(type_was) && line.include?('\\')
+        header_and_data = line.split(/\s+/, 5)
+        if header_and_data[4]
+          header_and_data[4] = Presentation.character_string_escapes(header_and_data[4])
+          line = header_and_data.join(' ')
         end
       end
-      #  Other RRs have several names. These should be parsed by Dnsruby,
-      #    and the names adjusted there.
-      if ([Types::MINFO, Types::PX, Types::RP].include?type_was)
-        parsed_rr = Dnsruby::RR.create(line)
-        case parsed_rr.type
-        when Types::MINFO
-          if (!parsed_rr.rmailbx.absolute?)
-            parsed_rr.rmailbx = parsed_rr.rmailbx.to_s + "." + @origin.to_s
-          end
-          if (!parsed_rr.emailbx.absolute?)
-            parsed_rr.emailbx = parsed_rr.emailbx.to_s + "." + @origin.to_s
-          end
-        when Types::PX
-          if (!parsed_rr.map822.absolute?)
-            parsed_rr.map822 = parsed_rr.map822.to_s + "." + @origin.to_s
-          end
-          if (!parsed_rr.mapx400.absolute?)
-            parsed_rr.mapx400 = parsed_rr.mapx400.to_s + "." + @origin.to_s
-          end
-        when Types::RP
-          if (!parsed_rr.mailbox.absolute?)
-            parsed_rr.mailbox = parsed_rr.mailbox.to_s + "." + @origin.to_s
-          end
-          if (!parsed_rr.txtdomain.absolute?)
-            parsed_rr.txtdomain = parsed_rr.txtdomain.to_s + "." + @origin.to_s
-          end
+
+      # Qualify parsed labels so an escaped final dot stays inside its label.
+      if [Types::MX, Types::KX, Types::NS, Types::AFSDB, Types::NAPTR, Types::RT,
+          Types::SRV, Types::CNAME, Types::MB, Types::MG, Types::MR,
+          Types::PTR, Types::DNAME].include?(type_was)
+        line = line.sub(/\S+\z/) { |target| absolute_name(target).to_s(true) }
+      end
+      name_fields = case type_was
+      when Types::SOA then [:mname, :rname]
+      when Types::MINFO then [:rmailbx, :emailbx]
+      when Types::PX then [:map822, :mapx400]
+      when Types::RP then [:mailbox, :txtdomain]
+      end
+      if name_fields
+        parsed_rr = Dnsruby::RR.send(:new_from_normalised_string, line)
+        name_fields.each do |field|
+          parsed_rr.public_send("#{field}=", absolute_name(parsed_rr.public_send(field)))
+        end
+        line = parsed_rr.to_s
+      end
+      # These name fields precede other RDATA. Qualify their presentation
+      # tokens directly, preserving the remaining signature/key text and
+      # avoiding record serializers which omit a name's trailing dot.
+      case type_was
+      when Types::NSEC, Types::NXT, Types::RRSIG, Types::IPSECKEY, Types::HIP
+        fields = line.split
+        domain_fields = case type_was
+        when Types::NSEC, Types::NXT then [4]
+        when Types::RRSIG then [11]
+        when Types::IPSECKEY then fields[5].to_i == 3 ? [7] : []
+        when Types::HIP then (7...fields.length).to_a
+        end
+        domain_fields.each { |index| fields[index] = absolute_name(fields.fetch(index)).to_s(true) }
+        line = fields.join(' ')
+      end
+      #  SVCB and HTTPS carry their TargetName in the middle of the RDATA
+      #  (before the SvcParams), so the trailing-name logic above cannot reach
+      #  it. Parse the record and qualify a relative TargetName against the
+      #  origin; the root (".") is absolute, so the absolute? guard skips it.
+      if ([Types::SVCB, Types::HTTPS].include?type_was)
+        parsed_rr = Dnsruby::RR.send(:new_from_normalised_string, line)
+        if parsed_rr.is_a?(RR::SVCB) && parsed_rr.target && !parsed_rr.target.absolute?
+          origin = RR::SVCB.create_target_name(@origin.to_s)
+          parsed_rr.target = Name.new(parsed_rr.target.labels + origin.labels, true)
         end
         line = parsed_rr.to_s
       end
@@ -392,6 +439,25 @@ module Dnsruby
       end
       return line+"\n"
     end
+    private :normalise_scanned_line
+
+    def absolute_name(value)
+      name = parse_zone_name(value)
+      return name if name.absolute?
+      Name.new(name.labels + parse_zone_name(@origin).labels, true)
+    end
+    private :absolute_name
+
+    # Zone-file ASCII already represents wire octets. Preserve its case for
+    # record types such as SVCB whose signed TargetName is not case-folded.
+    def parse_zone_name(value)
+      if value.is_a?(String) && value.ascii_only?
+        Name.new(Name.split_escaped(value), /(?<!\\)(?:\\\\)*\.\z/.match?(value))
+      else
+        Name.create(value)
+      end
+    end
+    private :parse_zone_name
 
     #  Get the TTL in seconds from the m, h, d, w format
     def get_ttl(ttl_text_in)
@@ -410,15 +476,15 @@ module Dnsruby
         number = ttl_text[last_index + 1, index-last_index-1].to_i
         new_number = 0
         case letter
-        when 115 then # "s"
+        when "s"
           new_number = number
-        when 109 then # "m"
+        when "m"
           new_number = number * 60
-        when 104 then # "h"
+        when "h"
           new_number = number * 3600
-        when 100 then # "d"
+        when "d"
           new_number = number * 86400
-        when 119 then # "w"
+        when "w"
           new_number = number * 604800
         end
         total += new_number
@@ -426,6 +492,7 @@ module Dnsruby
         last_index = index
         index = ttl_text.index(/[whdms]/, last_index + 1)
       end
+      total += ttl_text[last_index + 1..].to_i
       return total
     end