dnsruby 1.55 → 1.56.0

data/lib/dnsruby/DNS.rb

@@ -0,0 +1,305 @@
+# --
+# 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.
+# ++
+require 'dnsruby/hosts'
+require 'dnsruby/config'
+require "dnsruby/resolver"
+module Dnsruby
+
+  # == Dnsruby::DNS class
+  # Resolv::DNS performs DNS queries.
+  # 
+  # === class methods
+  # * Dnsruby::DNS.new(config_info=nil)
+  # 
+  #     ((|config_info|)) should be nil, a string or a hash.
+  #     If nil is given, /etc/resolv.conf and platform specific information is used.
+  #     If a string is given, it should be a filename which format is same as /etc/resolv.conf.
+  #     If a hash is given, it may contains information for nameserver, search and ndots as follows.
+  # 
+  #       Dnsruby::DNS.new({:nameserver=>["210.251.121.21"], :search=>["ruby-lang.org"], :ndots=>1})
+  # 
+  # * Dnsruby::DNS.open(config_info=nil)
+  # * Dnsruby::Resolv::DNS.open(config_info=nil) {|dns| ...}
+  # 
+  # === methods
+  # * Dnsruby::DNS#close
+  # 
+  # * Dnsruby::DNS#getaddress(name)
+  # * Dnsruby::DNS#getaddresses(name)
+  # * Dnsruby::DNS#each_address(name) {|address| ...}
+  #     address lookup methods.
+  # 
+  #     ((|name|)) must be an instance of Dnsruby::Name or String.  Resultant
+  #     address is represented as an instance of Dnsruby::IPv4 or Dnsruby::IPv6.
+  # 
+  # * Dnsruby::DNS#getname(address)
+  # * Dnsruby::DNS#getnames(address)
+  # * Dnsruby::DNS#each_name(address) {|name| ...}
+  #     These methods lookup hostnames .
+  # 
+  #     ((|address|)) must be an instance of Dnsruby::IPv4, Dnsruby::IPv6 or String.
+  #     Resultant name is represented as an instance of Dnsruby::Name.
+  # 
+  # * Dnsruby::DNS#getresource(name, type, class)
+  # * Dnsruby::DNS#getresources(name, type, class)
+  # * Dnsruby::DNS#each_resource(name, type, class) {|resource| ...}
+  #     These methods lookup DNS resources of ((|name|)).
+  #     ((|name|)) must be a instance of Dnsruby::Name or String.
+  # 
+  #     ((|type|)) must be a member of Dnsruby::Types
+  #     ((|class|)) must be a member of Dnsruby::Classes
+  # 
+  #     Resultant resource is represented as an instance of (a subclass of)
+  #     Dnsruby::RR.
+  #     (Dnsruby::RR::IN::A, etc.)
+  # 
+  # The searchlist and other Config info is applied to the domain name if appropriate. All the nameservers
+  # are tried (if there is no timely answer from the first).
+  # 
+  # This class uses Resolver to perform the queries.
+  # 
+  # Information taken from the following places :
+  # * STD0013
+  # * RFC 1035, etc.
+  # * ftp://ftp.isi.edu/in-notes/iana/assignments/dns-parameters
+  # * etc.
+  class DNS
+
+    attr_accessor :do_caching
+
+    # Creates a new DNS resolver. See Resolv::DNS.new for argument details.
+    # 
+    # Yields the created DNS resolver to the block, if given, otherwise returns it.
+    def self.open(*args)
+      dns = new(*args)
+      return dns unless block_given?
+      begin
+        yield dns
+      ensure
+        dns.close
+      end
+    end
+
+    # Closes the resolver
+    def close
+      @resolver.close
+    end
+
+
+    def to_s
+      return "DNS : " + @config.to_s
+    end
+
+    # Creates a new DNS resolver
+    # 
+    # +config_info+ can be:
+    # 
+    # * nil:: Uses platform default (e.g. /etc/resolv.conf)
+    # * String:: Path to a file using /etc/resolv.conf's format
+    # * Hash:: Must contain :nameserver, :search and :ndots keys
+    #    example :
+    # 
+    #     Dnsruby::DNS.new({:nameserver => ['210.251.121.21'],
+    #                       :search => ['ruby-lang.org'],
+    #                       :ndots => 1})
+    def initialize(config_info=nil)
+      @do_caching = true
+      @config = Config.new()
+      @config.set_config_info(config_info)
+      @resolver = Resolver.new(@config)
+#      if (@resolver.single_resolvers.length == 0)
+#        raise ArgumentError.new("Must pass at least one valid resolver address")
+#      end
+    end
+
+    attr_reader :config
+
+    # Gets the first IP address of +name+ from the DNS resolver
+    # 
+    # +name+ can be a Dnsruby::Name or a String. Retrieved address will be a
+    # Dnsruby::IPv4 or a Dnsruby::IPv6
+    def getaddress(name)
+      each_address(name) {|address| return address}
+      raise ResolvError.new("DNS result has no information for #{name}")
+    end
+
+    # Gets all IP addresses of +name+ from the DNS resolver
+    # 
+    # +name+ can be a Dnsruby::Name or a String. Retrieved address will be a
+    # Dnsruby::IPv4 or a Dnsruby::IPv6
+    def getaddresses(name)
+      ret = []
+      each_address(name) {|address| ret << address}
+      return ret
+    end
+
+    # Iterates over all IP addresses of +name+ retrieved from the DNS resolver
+    # 
+    # +name+ can be a Dnsruby::Name or a String. Retrieved address will be a
+    # Dnsruby::IPv4 or a Dnsruby::IPv6
+    def each_address(name)
+      each_resource(name) {|resource| yield resource.address}
+    end
+
+    # Gets the first hostname for +address+ from the DNS resolver
+    # 
+    # +address+ must be a Dnsruby::IPv4, Dnsruby::IPv6 or a String. Retrieved
+    # name will be a Dnsruby::Name.
+    def getname(address)
+      each_name(address) {|name| return name}
+      raise ResolvError.new("DNS result has no information for #{address}")
+    end
+
+    # Gets all hostnames for +address+ from the DNS resolver
+    # 
+    # +address+ must be a Dnsruby::IPv4, Dnsruby::IPv6 or a String. Retrieved
+    # name will be a Dnsruby::Name.
+    def getnames(address)
+      ret = []
+      each_name(address) {|name| ret << name}
+      return ret
+    end
+
+    # Iterates over all hostnames for +address+ retrieved from the DNS resolver
+    # 
+    # +address+ must be a Dnsruby::IPv4, Dnsruby::IPv6 or a String. Retrieved
+    # name will be a Dnsruby::Name.
+    def each_name(address)
+      case address
+      when Name
+        ptr = address
+      when  IPv4, IPv6
+        ptr = address.to_name
+      when IPv4::Regex
+        ptr = IPv4.create(address).to_name
+      when IPv6::Regex
+        ptr = IPv6.create(address).to_name
+      else
+        raise ResolvError.new("cannot interpret as address: #{address}")
+      end
+      each_resource(ptr, Types.PTR, Classes.IN) {|resource| yield resource.domainname}
+    end
+
+    # Look up the first +type+, +klass+ resource for +name+
+    # 
+    # +type+ defaults to Dnsruby::Types.A
+    # +klass+ defaults to Dnsruby::Classes.IN
+    # 
+    # Returned resource is represented as a Dnsruby::RR instance, e.g.
+    # Dnsruby::RR::IN::A
+    def getresource(name, type=Types.A, klass=Classes.IN)
+      each_resource(name, type, klass) {|resource| return resource}
+      raise ResolvError.new("DNS result has no information for #{name}")
+    end
+
+    # Look up all +type+, +klass+ resources for +name+
+    # 
+    # +type+ defaults to Dnsruby::Types.A
+    # +klass+ defaults to Dnsruby::Classes.IN
+    # 
+    # Returned resource is represented as a Dnsruby::RR instance, e.g.
+    # Dnsruby::RR::IN::A
+    def getresources(name, type=Types.A, klass=Classes.IN)
+      ret = []
+      each_resource(name, type, klass) {|resource| ret << resource}
+      return ret
+    end
+
+    # Iterates over all +type+, +klass+ resources for +name+
+    # 
+    # +type+ defaults to Dnsruby::Types.A
+    # +klass+ defaults to Dnsruby::Classes.IN
+    # 
+    # Yielded resource is represented as a Dnsruby::RR instance, e.g.
+    # Dnsruby::RR::IN::A
+    def each_resource(name, type=Types.A, klass=Classes.IN, &proc)
+      type = Types.new(type)
+      klass = Classes.new(klass)
+      reply, reply_name = send_query(name, type, klass)
+      case reply.rcode.code
+      when RCode::NOERROR
+        extract_resources(reply, reply_name, type, klass, &proc)
+        return
+        #       when RCode::NXDomain
+        #         Dnsruby.log.debug("RCode::NXDomain returned - raising error")
+        #         raise Config::NXDomain.new(reply_name.to_s)
+      else
+        Dnsruby.log.error{"Unexpected rcode : #{reply.rcode.string}"}
+        raise Config::OtherResolvError.new(reply_name.to_s)
+      end
+    end
+
+    def extract_resources(msg, name, type, klass) # :nodoc:
+      if type == Types.ANY
+        n0 = Name.create(name)
+        msg.each_answer {|rec|
+          yield rec if n0 == rec.name
+        }
+      end
+      yielded = false
+      n0 = Name.create(name)
+      msg.each_answer {|rec|
+        if n0 == rec.name
+          case rec.type
+          when type
+            if (rec.klass == klass)
+              yield rec
+              yielded = true
+            end
+          when Types.CNAME
+            n0 = rec.domainname
+          end
+        end
+      }
+      return if yielded
+      msg.each_answer {|rec|
+        if n0 == rec.name
+          case rec.type
+          when type
+            if (rec.klass == klass)
+              yield rec
+            end
+          end
+        end
+      }
+    end
+
+    def send_query(name, type=Types.A, klass=Classes.IN) # :nodoc:
+      candidates = @config.generate_candidates(name)
+      exception = nil
+      candidates.each do |candidate|
+        q = Queue.new
+        msg = Message.new
+        msg.header.rd = 1
+        msg.add_question(candidate, type, klass)
+        msg.do_validation = false
+        msg.header.cd = false
+        msg.do_caching = do_caching
+        @resolver.do_validation = false
+        @resolver.send_async(msg, q)
+        id, ret, exception = q.pop
+        if (exception == nil && ret && ret.rcode == RCode.NOERROR)
+          return ret, ret.question[0].qname
+        end
+      end
+      raise exception
+    end
+
+  end
+end
+# --
+# @TODO@ Asynchronous interface. Some sort of Deferrable?
+# ++

data/lib/{Dnsruby/Cache.rb → dnsruby/cache.rb}

@@ -1,153 +1,153 @@
-#--
-#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.
-#++
-
-
-## This class implements a cache.
-# It stores data under qname-qclass-qtype tuples.
-# Each tuple indexes a CacheData object (which
-# stores a Message, and an expiration).
-# If a new Message is stored to a tuple, it will
-# overwrite the previous Message.
-# When a Message is retrieved from the cache, the header
-# and ttls will be "fixed" - i.e. AA cleared, etc.
-
-
-
-#@TODO@ Max size for cache?
-module Dnsruby
-  class Cache # :nodoc: all
-    def initialize()
-    @cache = Hash.new
-    @mutex = Mutex.new
-    end
-    def cache
-      @cache
-    end
-    def clear()
-      @mutex.synchronize {
-        @cache = Hash.new
-      }
-    end
-    def length
-      return @cache.length
-    end
-    def add(message)
-      q = message.question[0]
-      key = CacheKey.new(q.qname, q.qtype, q.qclass).to_s
-      data = CacheData.new(message)
-      @mutex.synchronize {
-        if (@cache[key])
-          TheLog.debug("CACHE REPLACE : #{q.qname}, #{q.qtype}\n")
-        else
-          TheLog.debug("CACHE ADD : #{q.qname}, #{q.qtype}\n")
-        end
-        @cache[key] = data
-      }
-    end
-    # This method "fixes up" the response, so that the header and ttls are OK
-    # The resolver will still need to copy the flags and ID across from the query
-    def find(qname, qtype, qclass = Classes.IN)
-#      print "CACHE find : #{qname}, #{qtype}\n"
-      qn = Name.create(qname)
-      qn.absolute = true
-      key = CacheKey.new(qn, qtype, qclass).to_s
-      @mutex.synchronize {
-        data = @cache[key]
-        if (!data)
-#          print "CACHE lookup failed\n"
-          return nil
-        end
-        if (data.expiration <= Time.now.to_i)
-          @cache.delete(key)
-          TheLog.debug("CACHE lookup stale\n")
-          return nil
-        end
-        m = data.message
-        TheLog.debug("CACHE found\n")
-        return m
-      }
-    end
-    def Cache.delete(qname, qtype, qclass = Classes.IN)
-      key = CacheKey.new(qname, qtype, qclass)
-      @mutex.synchronize {
-        @cache.delete(key)
-      }
-    end
-    class CacheKey # :nodoc: all
-      attr_accessor :qname, :qtype, :qclass
-      def initialize(*args)
-        self.qclass = Classes.IN
-        if (args.length > 0)
-          self.qname = Name.create(args[0])
-          self.qname.absolute = true
-          if (args.length > 1)
-            self.qtype = Types.new(args[1])
-            if (args.length > 2)
-              self.qclass = Classes.new(args[2])
-            end
-          end
-        end
-      end
-      def to_s
-        return "#{qname.inspect.downcase} #{qclass} #{qtype}"
-      end
-    end
-    class CacheData # :nodoc: all
-      attr_reader :expiration
-      def message=(m)
-        @expiration = get_expiration(m)
-        @message = Message.decode(m.encode)
-        @message.cached = true
-      end
-      def message
-        m = Message.decode(@message.encode)
-        m.cached = true
-        # @TODO@ What do we do about answerfrom, answersize, etc.?
-        m.header.aa = false # Anything else to do here?
-        # Fix up TTLs!!
-        offset = (Time.now - @time_stored).to_i
-        m.each_resource {|rr|
-          next if rr.type == Types::OPT
-          rr.ttl = rr.ttl - offset
-        }
-        return m
-      end
-      def get_expiration(m)
-        # Find the minimum ttl of any of the rrsets
-        min_ttl = 9999999
-        m.each_section {|section|
-          section.rrsets.each {|rrset|
-            if (rrset.ttl < min_ttl)
-              min_ttl = rrset.ttl
-            end
-          }
-        }
-        if (min_ttl == 9999999)
-          return 0
-        end
-        return (Time.now.to_i + min_ttl)
-      end
-      def initialize(*args)
-        @expiration = 0
-        @time_stored = Time.now.to_i
-        self.message=(args[0])
-      end
-      def to_s
-        return "#{self.message}"
-      end
-    end
-  end
+# --
+# 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.
+# ++
+
+
+# # This class implements a cache.
+# It stores data under qname-qclass-qtype tuples.
+# Each tuple indexes a CacheData object (which
+# stores a Message, and an expiration).
+# If a new Message is stored to a tuple, it will
+# overwrite the previous Message.
+# When a Message is retrieved from the cache, the header
+# and ttls will be "fixed" - i.e. AA cleared, etc.
+
+
+
+# @TODO@ Max size for cache?
+module Dnsruby
+  class Cache # :nodoc: all
+    def initialize()
+    @cache = Hash.new
+    @mutex = Mutex.new
+    end
+    def cache
+      @cache
+    end
+    def clear()
+      @mutex.synchronize {
+        @cache = Hash.new
+      }
+    end
+    def length
+      return @cache.length
+    end
+    def add(message)
+      q = message.question[0]
+      key = CacheKey.new(q.qname, q.qtype, q.qclass).to_s
+      data = CacheData.new(message)
+      @mutex.synchronize {
+        if (@cache[key])
+          TheLog.debug("CACHE REPLACE : #{q.qname}, #{q.qtype}\n")
+        else
+          TheLog.debug("CACHE ADD : #{q.qname}, #{q.qtype}\n")
+        end
+        @cache[key] = data
+      }
+    end
+    #  This method "fixes up" the response, so that the header and ttls are OK
+    #  The resolver will still need to copy the flags and ID across from the query
+    def find(qname, qtype, qclass = Classes.IN)
+#      print "CACHE find : #{qname}, #{qtype}\n"
+      qn = Name.create(qname)
+      qn.absolute = true
+      key = CacheKey.new(qn, qtype, qclass).to_s
+      @mutex.synchronize {
+        data = @cache[key]
+        if (!data)
+#          print "CACHE lookup failed\n"
+          return nil
+        end
+        if (data.expiration <= Time.now.to_i)
+          @cache.delete(key)
+          TheLog.debug("CACHE lookup stale\n")
+          return nil
+        end
+        m = data.message
+        TheLog.debug("CACHE found\n")
+        return m
+      }
+    end
+    def Cache.delete(qname, qtype, qclass = Classes.IN)
+      key = CacheKey.new(qname, qtype, qclass)
+      @mutex.synchronize {
+        @cache.delete(key)
+      }
+    end
+    class CacheKey # :nodoc: all
+      attr_accessor :qname, :qtype, :qclass
+      def initialize(*args)
+        self.qclass = Classes.IN
+        if (args.length > 0)
+          self.qname = Name.create(args[0])
+          self.qname.absolute = true
+          if (args.length > 1)
+            self.qtype = Types.new(args[1])
+            if (args.length > 2)
+              self.qclass = Classes.new(args[2])
+            end
+          end
+        end
+      end
+      def to_s
+        return "#{qname.inspect.downcase} #{qclass} #{qtype}"
+      end
+    end
+    class CacheData # :nodoc: all
+      attr_reader :expiration
+      def message=(m)
+        @expiration = get_expiration(m)
+        @message = Message.decode(m.encode)
+        @message.cached = true
+      end
+      def message
+        m = Message.decode(@message.encode)
+        m.cached = true
+        #  @TODO@ What do we do about answerfrom, answersize, etc.?
+        m.header.aa = false # Anything else to do here?
+        #  Fix up TTLs!!
+        offset = (Time.now - @time_stored).to_i
+        m.each_resource {|rr|
+          next if rr.type == Types::OPT
+          rr.ttl = rr.ttl - offset
+        }
+        return m
+      end
+      def get_expiration(m)
+        #  Find the minimum ttl of any of the rrsets
+        min_ttl = 9999999
+        m.each_section {|section|
+          section.rrsets.each {|rrset|
+            if (rrset.ttl < min_ttl)
+              min_ttl = rrset.ttl
+            end
+          }
+        }
+        if (min_ttl == 9999999)
+          return 0
+        end
+        return (Time.now.to_i + min_ttl)
+      end
+      def initialize(*args)
+        @expiration = 0
+        @time_stored = Time.now.to_i
+        self.message=(args[0])
+      end
+      def to_s
+        return "#{self.message}"
+      end
+    end
+  end
 end