dnsruby 1.55 → 1.56.0

data/lib/dnsruby/message/question.rb

@@ -0,0 +1,86 @@
+# A Dnsruby::Question object represents a record in the
+# question section of a DNS packet.
+# 
+# RFC 1035 Section 4.1.2
+module Dnsruby
+class Question
+
+  #  The Question name
+  attr_reader :qname
+  #  The Question type
+  attr_reader :qtype
+  #  The Question class
+  attr_reader :qclass
+
+  #  Creates a question object from the domain, type, and class passed
+  #  as arguments.
+  # 
+  #  If a String is passed in, a Name, IPv4 or IPv6 object is created.
+  # 
+  #  If an IPv4 or IPv6 object is used then the type is set to PTR.
+  def initialize(qname, qtype = :not_provided, qclass = :not_provided)
+
+    raise ArgumentError.new('qname must not be nil') if qname.nil?
+
+    @qtype  = (qtype  == :not_provided) ? Types::A    : Types.new(qtype)
+    @qclass = (qclass == :not_provided) ? Classes::IN : Classes.new(qclass)
+    set_qname(qname, qtype == :not_provided)
+  end
+
+  def qtype=(qtype)
+    @qtype = Types.new(qtype)
+  end
+
+  def qclass=(qclass)
+    @qclass = Classes.new(qclass)
+  end
+
+  def set_qname(qname, write_PTR_to_qtype_if_ip = true)
+    is_ipv4_addr_string = qname.is_a?(String) && IPv4::Regex.match(qname)
+    is_ipv6_addr_string = qname.is_a?(String) && IPv6::Regex.match(qname)
+    is_ip_addr_string = is_ipv4_addr_string || is_ipv6_addr_string
+
+    is_ip_addr = [IPv4, IPv6].any? { |klass| qname.is_a?(klass) }
+
+    if is_ipv4_addr_string
+      @qname = IPv4.create(qname).to_name
+    elsif is_ipv6_addr_string
+      @qname = IPv6.create(qname).to_name
+    else
+      @qname = Name.create(qname)
+    end
+
+    #  If the name looks like an IP address then do an appropriate
+    #  PTR query, unless the user specified the qtype
+    if write_PTR_to_qtype_if_ip && (is_ip_addr || is_ip_addr_string)
+      @qtype = Types.PTR
+    end
+    @qname.absolute = true
+  end
+
+  def qname=(qname)
+    set_qname(qname, true)
+  end
+
+  def ==(other)
+    other.is_a?(Question) &&
+        self.qname  == other.qname  &&
+        self.qtype  == other.qtype  &&
+        self.qclass == other.qclass
+  end
+
+  #  Returns a string representation of the question record.
+  def to_s
+    "#{@qname}.\t#{@qclass.string}\t#{@qtype.string}"
+  end
+
+  #  For Updates, the qname field is redefined to zname (RFC2136, section 2.3)
+  alias zname qname
+  #  For Updates, the qtype field is redefined to ztype (RFC2136, section 2.3)
+  alias ztype qtype
+  #  For Updates, the qclass field is redefined to zclass (RFC2136, section 2.3)
+  alias zclass qclass
+
+  alias type qtype
+end
+end

data/lib/dnsruby/message/section.rb

@@ -0,0 +1,96 @@
+module Dnsruby
+class Section < Array
+
+  def initialize(msg = nil)
+    @msg = msg
+    super(0)
+  end
+
+  #  Return the rrset of the specified type in this section
+  def rrset(name, type=Types.A, klass=Classes::IN)
+    rrs = select{|rr|
+      type_ok = (rr.type==type)
+      if rr.type == Types::RRSIG
+        type_ok = (rr.type_covered == type)
+      end
+      unless /\.\z/ =~ name.to_s
+        name = name.to_s + '.'
+      end
+      type_ok && (rr.klass == klass) && (rr.name.to_s(true).downcase == name.to_s().downcase)
+    }
+    rrset = RRSet.new()
+    rrs.each do |rr|
+      rrset.add(rr)
+    end
+    rrset
+  end
+
+  #  Return an array of all the rrsets in the section
+  def rrsets(type = nil, include_opt = false)
+    if type && !(Types === type)
+      type = Types.new(type)
+    end
+    ret = []
+    each do |rr|
+      next if (!include_opt && (rr.type == Types::OPT))
+      #           if (type)
+      #             next if ((rr.type == Types.RRSIG) && (type != Types.RRSIG) && (rr.type_covered != type))
+      #             next if (rr.type != type)
+      #           end
+      if (type)
+        #  if this is an rrsig type, then :
+        #     only include it if the type_covered is the type requested,
+        #     OR if the type requested is an RRSIG
+        if rr.type == Types::RRSIG
+          if (rr.type_covered == type) || (type == Types::RRSIG)
+          else
+            next
+          end
+          #               next if ((rr.type_covered != type) || (type != Types.RRSIG))
+        elsif rr.type != type
+          next
+        end
+      end
+
+      found_rrset = false
+      ret.each do |rrset|
+        found_rrset = rrset.add(rr)
+        break if found_rrset
+      end
+      unless found_rrset
+        ret.push(RRSet.new(rr))
+      end
+    end
+    ret
+  end
+
+  def ==(other)
+    return false unless (other.instance_of?(Message::Section))
+    return false if other.rrsets(nil, true).length != self.rrsets(nil, true).length
+
+    otherrrsets = other.rrsets(nil, true)
+    self.rrsets(nil, true).each {|rrset|
+      return false unless otherrrsets.include?(rrset)
+    }
+
+    true
+  end
+
+  def remove_rrset(name, type)
+    #  Remove all RRs with the name and type from the section.
+    #  Need to worry about header counts here - can we get Message to
+    #  update the counts itself, rather than the section worrying about it?
+    rrs_to_delete = []
+    each do |rr|
+      next if rr.rr_type == Types::OPT
+      if (rr.name.to_s.downcase == name.to_s.downcase) &&
+          ((rr.type == type) ||
+              ((rr.type == Types::RRSIG) && (rr.type_covered == type)))
+        rrs_to_delete.push(rr)
+      end
+    end
+    rrs_to_delete.each { |rr| delete(rr) }
+    @msg.update_counts if @msg
+  end
+end
+end

data/lib/{Dnsruby → dnsruby}/name.rb

@@ -1,51 +1,51 @@
-#--
-#Copyright 2007 Nominet UK
-#
-#Licensed under the Apache License, Version 2.0 (the "License");
-#you may not use this file except in compliance with the License. 
-#You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0 
-#
-#Unless required by applicable law or agreed to in writing, software 
-#distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#See the License for the specific language governing permissions and 
-#limitations under the License.
-#++
+# --
+# Copyright 2007 Nominet UK
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
 module Dnsruby
-  #== Dnsruby::Name class
-  #
-  #A representation of a DNS name
-  #(RFC1035, section 3.1)
-  #
-  #== methods
-  #
-  #* Name::create(namestring)
-  #* Name#absolute?
-  #* Name#wild?
-  #* Name#subdomain_of?(other)
-  #* Name#labels
-  #
+  # == Dnsruby::Name class
+  # 
+  # A representation of a DNS name
+  # (RFC1035, section 3.1)
+  # 
+  # == methods
+  # 
+  # * Name::create(namestring)
+  # * Name#absolute?
+  # * Name#wild?
+  # * Name#subdomain_of?(other)
+  # * Name#labels
+  # 
   class Name
     include Comparable
     MaxNameLength=255
-    #--
-    # A Name is a collection of Labels. Each label is presentation-formatted
-    # When a Name is wire-encoded, the label array is walked, and each label is wire-encoded.
-    # When a Name is unencoded, each label is unencoded, and added to the Name collection of labels.
-    # When a Name is made from a string, the Name is split into Labels.
-    #++
-    #Creates a new Dnsruby::Name from +arg+. +arg+ can be :
-    #
-    #* Name:: returns +arg+
-    #* String:: returns a new Name
+    # --
+    #  A Name is a collection of Labels. Each label is presentation-formatted
+    #  When a Name is wire-encoded, the label array is walked, and each label is wire-encoded.
+    #  When a Name is unencoded, each label is unencoded, and added to the Name collection of labels.
+    #  When a Name is made from a string, the Name is split into Labels.
+    # ++
+    # Creates a new Dnsruby::Name from +arg+. +arg+ can be :
+    # 
+    # * Name:: returns +arg+
+    # * String:: returns a new Name
     def self.create(arg)
       case arg
       when Name
         return Name.new(arg.labels, arg.absolute?)
       when String
-        #        arg.gsub!(/\.$/o, "")
+        #         arg.gsub!(/\.$/o, "")
         if (arg==".")
           return Name.new([],true)
         end
@@ -53,14 +53,14 @@ module Dnsruby
           return Name.new([],false)
         end
         return Name.new(split_escaped(arg), /\.\z/ =~ arg ? true : false)
-        #        return Name.new(Label.split(arg), /\.\z/ =~ arg ? true : false)
+        #         return Name.new(Label.split(arg), /\.\z/ =~ arg ? true : false)
       when Array
         return Name.new(arg, /\.\z/ =~ (arg.last ? ((arg.last.kind_of?String)?arg.last : arg.last.string) : arg.last) ? true : false)
-      else        
+      else
         raise ArgumentError.new("cannot interpret as DNS name: #{arg.inspect}")
       end
     end
-    
+
     def self.split_escaped(arg) #:nodoc: all
       encodedlabels = name2encodedlabels(arg)
       return encodedlabels
@@ -71,37 +71,37 @@ module Dnsruby
       labels = encodedlabels.each  {|el| Name.decode(el.to_s)}
       return labels
     end
-    
+
     attr_accessor :labels
-    
-    #This method should only be called internally.
-    #Use Name::create to create a new Name
+
+    # This method should only be called internally.
+    # Use Name::create to create a new Name
     def initialize(labels, absolute=true) #:nodoc: all
       total_length=labels.length-1
-      labels.each do |l| 
+      labels.each do |l|
         if (!l.kind_of?Label)
           raise ArgumentError.new("Name::new called with non-labels. Use Name::create instead?")
         end
-        total_length+=l.length 
+        total_length+=l.length
       end
-      if (total_length > MaxNameLength) 
+      if (total_length > MaxNameLength)
         raise ResolvError.new("Name length is #{total_length}, greater than max of #{MaxNameLength} octets!")
       end
       @labels = labels
       @absolute = absolute
     end
-    
+
     def downcase
       labels = []
       @labels.each do |label| labels << Label.new(label.downcase) end
       return Name.new(labels)
     end
-    
+
     def inspect # :nodoc:
       "#<#{self.class}: #{self.to_s}#{@absolute ? '.' : ''}>"
     end
-    
-    #Returns true if this Name is absolute
+
+    # Returns true if this Name is absolute
     def absolute?
       return @absolute
     end
@@ -114,8 +114,8 @@ module Dnsruby
       n = Name.new(self.labels()[1, self.labels.length-1], self.absolute?)
       return n
     end
-    
-    #Is this name a wildcard?
+
+    # Is this name a wildcard?
     def wild?
       if (labels.length == 0)
         return false
@@ -123,9 +123,9 @@ module Dnsruby
       return (labels[0].string == '*')
     end
 
-    # Return the canonical form of this name (RFC 4034 section 6.2)
+    #  Return the canonical form of this name (RFC 4034 section 6.2)
     def canonical
-      #
+      # 
       return MessageEncoder.new {|msg|
         msg.put_name(self, true)
       }.to_s
@@ -133,7 +133,7 @@ module Dnsruby
     end
 
     def <=>(other)
-      # return -1 if other less than us, +1 if greater than us
+      #  return -1 if other less than us, +1 if greater than us
       return 0 if (canonical == other.canonical)
       if (canonically_before(other))
         return +1
@@ -145,20 +145,20 @@ module Dnsruby
       if (!(Name === n))
         n = Name.create(n)
       end
-      # Work out whether this name is canonically before the passed Name
-      # RFC 4034 section 6.1
-      # For the purposes of DNS security, owner names are ordered by treating
-      #individual labels as unsigned left-justified octet strings.  The
-      #absence of a octet sorts before a zero value octet, and uppercase
-      #US-ASCII letters are treated as if they were lowercase US-ASCII
-      #letters.
-      #To compute the canonical ordering of a set of DNS names, start by
-      #sorting the names according to their most significant (rightmost)
-      #labels.  For names in which the most significant label is identical,
-      #continue sorting according to their next most significant label, and
-      #so forth.
-
-      # Get the list of labels for both names, and then swap them
+      #  Work out whether this name is canonically before the passed Name
+      #  RFC 4034 section 6.1
+      #  For the purposes of DNS security, owner names are ordered by treating
+      # individual labels as unsigned left-justified octet strings.  The
+      # absence of a octet sorts before a zero value octet, and uppercase
+      # US-ASCII letters are treated as if they were lowercase US-ASCII
+      # letters.
+      # To compute the canonical ordering of a set of DNS names, start by
+      # sorting the names according to their most significant (rightmost)
+      # labels.  For names in which the most significant label is identical,
+      # continue sorting according to their next most significant label, and
+      # so forth.
+
+      #  Get the list of labels for both names, and then swap them
       my_labels = @labels.reverse
       other_labels = n.labels.reverse
       my_labels.each_index {|i|
@@ -170,23 +170,23 @@ module Dnsruby
       }
       return true
     end
-    
+
     def ==(other) # :nodoc:
       return false if other.class != Name
       return @labels == other.labels && @absolute == other.absolute?
     end
     alias eql? == # :nodoc:
-    
-    # Tests subdomain-of relation : returns true if this name 
-    # is a subdomain of +other+.
-    #
-    #   domain = Resolv::Name.create("y.z")
-    #   p Resolv::Name.create("w.x.y.z").subdomain_of?(domain) #=> true
-    #   p Resolv::Name.create("x.y.z").subdomain_of?(domain) #=> true
-    #   p Resolv::Name.create("y.z").subdomain_of?(domain) #=> false
-    #   p Resolv::Name.create("z").subdomain_of?(domain) #=> false
-    #   p Resolv::Name.create("x.y.z.").subdomain_of?(domain) #=> false
-    #   p Resolv::Name.create("w.z").subdomain_of?(domain) #=> false
+
+    #  Tests subdomain-of relation : returns true if this name
+    #  is a subdomain of +other+.
+    # 
+    #    domain = Resolv::Name.create("y.z")
+    #    p Resolv::Name.create("w.x.y.z").subdomain_of?(domain) #=> true
+    #    p Resolv::Name.create("x.y.z").subdomain_of?(domain) #=> true
+    #    p Resolv::Name.create("y.z").subdomain_of?(domain) #=> false
+    #    p Resolv::Name.create("z").subdomain_of?(domain) #=> false
+    #    p Resolv::Name.create("x.y.z.").subdomain_of?(domain) #=> false
+    #    p Resolv::Name.create("w.z").subdomain_of?(domain) #=> false
     def subdomain_of?(other)
       raise ArgumentError, "not a domain name: #{other.inspect}" unless Name === other
       return false if @absolute != other.absolute?
@@ -194,33 +194,33 @@ module Dnsruby
       return false if @labels.length <= other_len
       return @labels[-other_len, other_len] == other.to_a
     end
-    
+
     def hash # :nodoc:
       return @labels.hash ^ @absolute.hash
     end
-    
+
     def to_a #:nodoc: all
       return @labels
     end
-    
+
     def length #:nodoc: all
       return @labels.length
     end
-    
+
     def [](i) #:nodoc: all
       return @labels[i]
     end
-    
-    # returns the domain name as a string.
-    #
-    # The domain name doesn't have a trailing dot even if the name object is
-    # absolute.
+
+    #  returns the domain name as a string.
+    # 
+    #  The domain name doesn't have a trailing dot even if the name object is
+    #  absolute.
+    # 
+    #  Example :
+    # 
+    #    p Resolv::Name.create("x.y.z.").to_s #=> "x.y.z"
+    #    p Resolv::Name.create("x.y.z").to_s #=> "x.y.z"
     # 
-    # Example : 
-    #
-    #   p Resolv::Name.create("x.y.z.").to_s #=> "x.y.z"
-    #   p Resolv::Name.create("x.y.z").to_s #=> "x.y.z"
-    #
     def to_s(include_absolute=false)
       ret = to_str(@labels)
       if (@absolute && include_absolute)
@@ -233,18 +233,18 @@ module Dnsruby
       ls =[]
       labels.each {|el| ls.push(Name.decode(el.to_s))}
       return ls.join('.')
-      #      return @labels.collect{|l| (l.kind_of?String) ? l : l.string}.join('.')
+      #       return @labels.collect{|l| (l.kind_of?String) ? l : l.string}.join('.')
     end
-    
-    # Utility function
-    #
-    # name2labels to translate names from presentation format into an
-    # array of "wire-format" labels.        
-    # in: dName a string with a domain name in presentation format (1035
-    # sect 5.1)
-    # out: an array of labels in wire format.
+
+    #  Utility function
+    # 
+    #  name2labels to translate names from presentation format into an
+    #  array of "wire-format" labels.
+    #  in: dName a string with a domain name in presentation format (1035
+    #  sect 5.1)
+    #  out: an array of labels in wire format.
     def self.name2encodedlabels (dName) #:nodoc: all
-      # Check for "\" in the name  : If there, then decode properly - otherwise, cheat and split on "."
+      #  Check for "\" in the name  : If there, then decode properly - otherwise, cheat and split on "."
       if (dName.index("\\"))
         names=[]
         j=0;
@@ -252,7 +252,7 @@ module Dnsruby
           names[j],dName = encode(dName)
           j+=1
         end
-      
+
         return names
       else
         labels = []
@@ -262,14 +262,14 @@ module Dnsruby
         return labels
       end
     end
-    
+
     def self.decode(wire) #:nodoc: all
       presentation=""
       length=wire.length
-      # There must be a nice regexp to do this.. but since I failed to
-      # find one I scan the name string until I find a '\', at that time
-      # I start looking forward and do the magic.
-      
+      #  There must be a nice regexp to do this.. but since I failed to
+      #  find one I scan the name string until I find a '\', at that time
+      #  I start looking forward and do the magic.
+
       i=0;
 
       unpacked = wire.unpack("C*")
@@ -300,20 +300,20 @@ module Dnsruby
       end
 
       return presentation
-      #      return Label.new(presentation)
+      #       return Label.new(presentation)
     end
-    
-    
-    
-    # wire,leftover=presentation2wire(leftover)
-    # Will parse the input presentation format and return everything before
-    # the first non-escaped "." in the first element of the return array and
-    # all that has not been parsed yet in the 2nd argument.
+
+
+
+    #  wire,leftover=presentation2wire(leftover)
+    #  Will parse the input presentation format and return everything before
+    #  the first non-escaped "." in the first element of the return array and
+    #  all that has not been parsed yet in the 2nd argument.
     def self.encode(presentation) #:nodoc: all
       presentation=presentation.to_s
       wire="";
       length=presentation.length;
-    
+
       i=0;
 
       while (i < length )
@@ -323,9 +323,9 @@ module Dnsruby
           return Label.new(wire),endstring
         end
         if (c == 92) # ord'\\'
-          #backslash found
+          # backslash found
           pos = i+1
-          # pos sets where next pattern matching should start
+          #  pos sets where next pattern matching should start
           if (presentation.index(/\G(\d\d\d)/o, pos))
             wire=wire+[$1.to_i].pack("C")
             i=i+3
@@ -353,30 +353,30 @@ module Dnsruby
         end
         i=i+1
       end
-    
+
       return Label.new(wire)
     end
-    
-    #  end
-    
-    
-    #== Dnsruby::Label class
-    #
-    #(RFC1035, section 3.1)
-    #
+
+    #   end
+
+
+    # == Dnsruby::Label class
+    # 
+    # (RFC1035, section 3.1)
+    # 
     class Label
       include Comparable
       MaxLabelLength = 63
       @@max_length=MaxLabelLength
-      # Split a Name into its component Labels
+      #  Split a Name into its component Labels
       def self.split(arg)
         return Name.split(arg)
       end
-      
+
       def self.set_max_length(l)
         @@max_length=l
       end
-      
+
       def initialize(string)
         if (string.length > @@max_length)
           raise ResolvError.new("Label too long (#{string.length}, max length=#{MaxLabelLength}). Label = #{string}")
@@ -386,15 +386,15 @@ module Dnsruby
         @string_length = string.length
       end
       attr_reader :string, :downcase
-      
+
       def to_s
         return @string.to_s # + "."
       end
-      
+
       def length
         return @string_length
       end
-      
+
       def inspect
         return "#<#{self.class} #{self.to_s}>"
       end
@@ -403,7 +403,7 @@ module Dnsruby
         return (@downcase <=> other.downcase)
       end
 
-      
+
       def ==(other)
         return @downcase == other.downcase
       end