net-dns 0.6.1 → 0.7.0

data/lib/net/dns/question.rb

@@ -1,10 +1,4 @@
-require 'net/dns'
-require 'net/dns/names/names'
-require 'net/dns/rr/types'
-require 'net/dns/rr/classes'
-
-
-module Net # :nodoc:
+module Net
   module DNS 
 
     #
@@ -40,35 +34,15 @@ module Net # :nodoc:
     # the Perl version of the library, as long as methods name which are
     # more or less the same. 
     #
-    # =Error classes
-    #
-    # Some error classes has been defined for the Net::DNS::Header class,
-    # which are listed here to keep a light and browsable main documentation.
-    # We have:
-    #
-    # ArgumentError::   Argument Error for class Net::DNS::Question
-    # NameError::       An error in the +name+ part of a Question entry
-    #
-    # =Copyright
-    # 
-    # Copyright (c) 2006 Marco Ceresa
-    #
-    # All rights reserved. This program is free software; you may redistribute 
-    # it and/or modify it under the same terms as Ruby itself.
-    #
     class Question
-      include Net::DNS::Names
-      
-      # Argument Error for class Net::DNS::Question
-      class ArgumentError < ArgumentError
-      end
-      
+      include Names
+
       # Base error class.
       class Error < StandardError
       end
       
       # An error in the +name+ part of a Question entry
-      class NameError < Error
+      class NameInvalid < Error
       end
       
       # +name+ part of a Question entry
@@ -191,27 +165,24 @@ module Net # :nodoc:
         result
       end
       
-      def check_name(name)
-        name.strip!
+      def check_name(input)
+        name = input.to_s.strip
         if name =~ /[^\w\.\-_]/
-          raise NameError, "Question name #{name.inspect} not valid"          
-        else
-          name
+          raise NameInvalid, "Invalid Question Name `#{name}'"
         end
-      rescue
-        raise NameError, "Question name #{name.inspect} not valid"                  
+        name
       end
       
       def new_from_binary(data)
-        str,type,cls = data.unpack("a#{data.size-4}nn")
+        str,type,cls = data.unpack("a#{data.size - 4}nn")
         @qName = build_qName(str)
         @qType = Net::DNS::RR::Types.new type
         @qClass = Net::DNS::RR::Classes.new cls
       rescue StandardError => e
-        raise ArgumentError, "Invalid data: #{data.inspect}\n{e.backtrace}"
+        raise ArgumentError, "Invalid data: #{data.inspect}"
       end
 
     end
     
   end
-end
+end

data/lib/net/dns/resolver.rb

@@ -1,57 +1,52 @@
 require 'rbconfig'
 require 'socket'
 require 'timeout'
-require 'ipaddr'
-require 'logger'
 require 'net/dns/packet'
 require 'net/dns/resolver/timeouts'
 
-alias old_send send
-
+# Resolver helper method.
 #
-# = Resolver helper method
-# 
 # Calling the resolver directly:
-# 
+#
 #   require 'net/dns/resolver'
 #   puts Resolver("www.google.com").answer.size
-#   #=> 5
+#   # => 5
 #
 # An optional block can be passed yielding the Net::DNS::Packet object.
 #
-#   Resolver("www.google.com") {|packet| puts packet.size + " bytes"}
-#   #=> 484 bytes
+#   Resolver("www.google.com") { |packet| puts packet.size + " bytes" }
+#   # => 484 bytes
 #
-def Resolver(name,type=Net::DNS::A,cls=Net::DNS::IN,&blk)
-  obj = Net::DNS::Resolver.start(name,type,cls)
+def Resolver(name, type = Net::DNS::A, cls = Net::DNS::IN, &block)
+  resolver = Net::DNS::Resolver.start(name, type, cls)
   if block_given?
-    yield obj
+    yield resolver
   else
-    return obj
+    resolver
   end
 end
 
-module Net # :nodoc:
-  module DNS 
-    
+module Net
+  module DNS
+
     include Logger::Severity
 
     # = Net::DNS::Resolver - DNS resolver class
     #
     # The Net::DNS::Resolver class implements a complete DNS resolver written
-    # in pure Ruby, without a single C line of code. It has all of the 
-    # tipical properties of an evoluted resolver, and a bit of OO which 
-    # comes from having used Ruby. 
-    # 
-    # This project started as a porting of the Net::DNS Perl module, 
+    # in pure Ruby, without a single C line of code. It has all of the
+    # tipical properties of an evoluted resolver, and a bit of OO which
+    # comes from having used Ruby.
+    #
+    # This project started as a porting of the Net::DNS Perl module,
     # written by Martin Fuhr, but turned out (in the last months) to be
     # an almost complete rewriting. Well, maybe some of the features of
     # the Perl version are still missing, but guys, at least this is
-    # readable code! 
+    # readable code!
     #
     # == Environment
     #
-    # The Following Environment variables can also be used to configure 
+    # The Following Environment variables can also be used to configure
     # the resolver:
     #
     # * +RES_NAMESERVERS+: A space-separated list of nameservers to query.
@@ -63,7 +58,7 @@ module Net # :nodoc:
     #      # C Shell
     #      % setenv RES_NAMESERVERS "192.168.1.1 192.168.2.2 192.168.3.3"
     #
-    # * +RES_SEARCHLIST+: A space-separated list of domains to put in the 
+    # * +RES_SEARCHLIST+: A space-separated list of domains to put in the
     #   search list.
     #
     #      # Bourne Shell
@@ -72,7 +67,7 @@ module Net # :nodoc:
     #
     #      # C Shell
     #      % setenv RES_SEARCHLIST "example.com sub1.example.com sub2.example.com"
-    #  
+    #
     # * +LOCALDOMAIN+: The default domain.
     #
     #      # Bourne Shell
@@ -82,7 +77,7 @@ module Net # :nodoc:
     #      # C Shell
     #      % setenv LOCALDOMAIN example.com
     #
-    # * +RES_OPTIONS+: A space-separated list of resolver options to set.  
+    # * +RES_OPTIONS+: A space-separated list of resolver options to set.
     #   Options that take values are specified as option:value.
     #
     #      # Bourne Shell
@@ -91,23 +86,18 @@ module Net # :nodoc:
     #
     #      # C Shell
     #      % setenv RES_OPTIONS "retrans:3 retry:2 debug"
-    #        
+    #
     class Resolver
-      
-      # Argument Error for class Net::DNS::Resolver.
-      class ArgumentError < ArgumentError
-      end
-      
+
       class Error < StandardError
       end
-      
+
       class NoResponseError < Error
       end
-      
-      
+
       # An hash with the defaults values of almost all the
       # configuration parameters of a resolver object. See
-      # the description for each parameter to have an 
+      # the description for each parameter to have an
       # explanation of its usage.
       Defaults = {
         :config_file => "/etc/resolv.conf",
@@ -118,6 +108,7 @@ module Net # :nodoc:
         :domain => "",
         :source_port => 0,
         :source_address => IPAddr.new("0.0.0.0"),
+        :source_address_inet6 => IPAddr.new('::'),
         :retry_interval => 5,
         :retry_number => 4,
         :recursive => true,
@@ -129,10 +120,36 @@ module Net # :nodoc:
         :tcp_timeout => TcpTimeout.new(5),
         :udp_timeout => UdpTimeout.new(5),
       }
-      
-      # Create a new resolver object.
-      # 
-      # Argument +config+ can either be empty or be an hash with 
+
+
+      class << self
+
+        C = Object.const_get(defined?(RbConfig) ? :RbConfig : :Config)::CONFIG
+
+        # Quick resolver method. Bypass the configuration using
+        # the defaults.
+        #
+        #   Net::DNS::Resolver.start "www.google.com"
+        #
+        def start(*params)
+          new.search(*params)
+        end
+
+        # Returns true if running on a Windows platform.
+        #
+        # Note. This method doesn't rely on the RUBY_PLATFORM constant
+        # because the comparison will fail when running on JRuby.
+        # On JRuby RUBY_PLATFORM == 'java'.
+        def platform_windows?
+          !!(C["host_os"] =~ /msdos|mswin|djgpp|mingw/i)
+        end
+
+      end
+
+
+      # Creates a new resolver object.
+      #
+      # Argument +config+ can either be empty or be an hash with
       # some configuration parameters. To know what each parameter
       # do, look at the description of each.
       # Some example:
@@ -142,17 +159,17 @@ module Net # :nodoc:
       #
       #   # Specify a configuration file
       #   res = Net::DNS::Resolver.new(:config_file => '/my/dns.conf')
-      #   
+      #
       #   # Set some option
       #   res = Net::DNS::Resolver.new(:nameservers => "172.16.1.1",
       #                                :recursive => false,
       #                                :retry => 10)
       #
       # == Config file
-      # 
+      #
       # Net::DNS::Resolver uses a config file to read the usual
       # values a resolver needs, such as nameserver list and
-      # domain names. On UNIX systems the defaults are read from the 
+      # domain names. On UNIX systems the defaults are read from the
       # following files, in the order indicated:
       #
       # * /etc/resolv.conf
@@ -165,32 +182,32 @@ module Net # :nodoc:
       # * search: a space-separated list of domains to put in the search list.
       # * nameserver: a space-separated list of nameservers to query.
       #
-      # Files except for /etc/resolv.conf must be owned by the effective userid 
-      # running the program or they won't be read.  In addition, several environment 
-      # variables can also contain configuration information; see Environment 
+      # Files except for /etc/resolv.conf must be owned by the effective userid
+      # running the program or they won't be read.  In addition, several environment
+      # variables can also contain configuration information; see Environment
       # in the main description for Resolver class.
-      # 
-      # On Windows Systems, an attempt is made to determine the system defaults 
-      # using the registry.  This is still a work in progress; systems with many 
+      #
+      # On Windows Systems, an attempt is made to determine the system defaults
+      # using the registry.  This is still a work in progress; systems with many
       # dynamically configured network interfaces may confuse Net::DNS.
       #
-      # You can include a configuration file of your own when creating a resolver 
+      # You can include a configuration file of your own when creating a resolver
       # object:
       #
       #   # Use my own configuration file
       #   my $res = Net::DNS::Resolver->new(config_file => '/my/dns.conf');
       #
-      # This is supported on both UNIX and Windows.  Values pulled from a custom 
-      # configuration file override the the system's defaults, but can still be 
+      # This is supported on both UNIX and Windows.  Values pulled from a custom
+      # configuration file override the the system's defaults, but can still be
       # overridden by the other arguments to Resolver::new.
       #
-      # Explicit arguments to Resolver::new override both the system's defaults 
+      # Explicit arguments to Resolver::new override both the system's defaults
       # and the values of the custom configuration file, if any.
       #
       # == Parameters
-      # 
+      #
       # The following arguments to Resolver::new are supported:
-      # 
+      #
       # * nameservers: an array reference of nameservers to query.
       # * searchlist:  an array reference of domains.
       # * recurse
@@ -212,16 +229,17 @@ module Net # :nodoc:
       # * persistent_udp
       # * dnssec
       #
-      # For more information on any of these options, please consult the 
+      # For more information on any of these options, please consult the
       # method of the same name.
       #
       # == Disclaimer
-      # 
-      # Part of the above documentation is taken from the one in the 
+      #
+      # Part of the above documentation is taken from the one in the
       # Net::DNS::Resolver Perl module.
       #
       def initialize(config = {})
-        raise ArgumentError, "Argument has to be Hash" unless config.kind_of? Hash
+        raise ArgumentError, "Expected `config' to be a Hash" unless config.is_a?(Hash)
+
         # config.downcase_keys!
         @config = Defaults.merge config
         @raw = false
@@ -229,7 +247,7 @@ module Net # :nodoc:
         # New logger facility
         @logger = Logger.new(@config[:log_file])
         @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
-        
+
         #------------------------------------------------------------
         # Resolver configuration will be set in order from:
         # 1) initialize arguments
@@ -238,18 +256,18 @@ module Net # :nodoc:
         # 4) defaults (and /etc/resolv.conf for config)
         #------------------------------------------------------------
 
-        
-        
+
+
         #------------------------------------------------------------
         # Parsing config file
         #------------------------------------------------------------
         parse_config_file
-        
+
         #------------------------------------------------------------
         # Parsing ENV variables
         #------------------------------------------------------------
         parse_environment_variables
-        
+
         #------------------------------------------------------------
         # Parsing arguments
         #------------------------------------------------------------
@@ -262,7 +280,7 @@ module Net # :nodoc:
           end
         end
       end
-        
+
       # Get the resolver search list, returned as an array of entries.
       #
       #   res.searchlist
@@ -272,7 +290,7 @@ module Net # :nodoc:
         @config[:searchlist].inspect
       end
 
-      # Set the resolver searchlist. 
+      # Set the resolver searchlist.
       # +arg+ can be a single string or an array of strings.
       #
       #   res.searchstring = "example.com"
@@ -293,24 +311,21 @@ module Net # :nodoc:
           @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"
         when Array
           @config[:searchlist] = arg if arg.all? {|x| valid? x}
-          @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"          
+          @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"
         else
           raise ArgumentError, "Wrong argument format, neither String nor Array"
         end
       end
-      
+
       # Get the list of resolver nameservers, in a dotted decimal format-
       #
       #   res.nameservers
       #     #=> ["192.168.0.1","192.168.0.2"]
       #
       def nameservers
-        arr = []
-        @config[:nameservers].each do |x| 
-          arr << x.to_s
-        end
-        arr
+        @config[:nameservers].map(&:to_s)
       end
+
       alias_method :nameserver, :nameservers
 
       # Set the list of resolver nameservers.
@@ -338,7 +353,7 @@ module Net # :nodoc:
           end
         when IPAddr
           @config[:nameservers] = [arg]
-          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"          
+          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
         when Array
           @config[:nameservers] = []
           arg.each do |x|
@@ -356,13 +371,13 @@ module Net # :nodoc:
                                        raise ArgumentError, "Wrong argument format"
                                      end
           end
-          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"          
+          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
         else
           raise ArgumentError, "Wrong argument format, neither String, Array nor IPAddr"
         end
       end
       alias_method("nameserver=","nameservers=")
-      
+
       # Return a string with the default domain.
       def domain
         @config[:domain].inspect
@@ -372,7 +387,7 @@ module Net # :nodoc:
       def domain=(name)
         @config[:domain] = name if valid? name
       end
-      
+
       # Return the defined size of the packet.
       def packet_size
         @config[:packet_size]
@@ -386,8 +401,8 @@ module Net # :nodoc:
         @config[:port]
       end
 
-      # Set the port number to which the resolver sends queries.  This can be useful 
-      # for testing a nameserver running on a non-standard port.  
+      # Set the port number to which the resolver sends queries.  This can be useful
+      # for testing a nameserver running on a non-standard port.
       #
       #   res.port = 10053
       #
@@ -396,7 +411,7 @@ module Net # :nodoc:
       def port=(num)
         if (0..65535).include? num
           @config[:port] = num
-          @logger.info "Port number changed to #{num}"          
+          @logger.info "Port number changed to #{num}"
         else
           raise ArgumentError, "Wrong port number #{num}"
         end
@@ -415,8 +430,8 @@ module Net # :nodoc:
       #
       #   res.source_port = 40000
       #
-      # Note that if you want to set a port you need root priviledges, as 
-      # raw sockets will be used to generate packets. The class will then 
+      # Note that if you want to set a port you need root priviledges, as
+      # raw sockets will be used to generate packets. The class will then
       # generate the exception ResolverPermissionError if you're not root.
       #
       # The default is 0, which means that the port will be chosen by the
@@ -426,14 +441,14 @@ module Net # :nodoc:
         unless root?
           raise ResolverPermissionError, "Are you root?"
         end
-        if (0..65535).include?(num) 
+        if (0..65535).include?(num)
           @config[:source_port] = num
         else
           raise ArgumentError, "Wrong port number #{num}"
         end
       end
-      alias srcport= source_port= 
-      
+      alias srcport= source_port=
+
       # Get the local address from which the resolver sends queries
       #
       #   puts "Sending queries using source address #{res.source_address}"
@@ -441,7 +456,7 @@ module Net # :nodoc:
       def source_address
         @config[:source_address].to_s
       end
-      alias srcaddr source_address 
+      alias srcaddr source_address
 
       # Set the local source address from which the resolver sends its queries.
       #
@@ -452,16 +467,16 @@ module Net # :nodoc:
       # or an instance of IPAddr class.
       #
       # Normally this can be used to force queries out a specific interface
-      # on a multi-homed host. In this case, you should of course need to 
+      # on a multi-homed host. In this case, you should of course need to
       # know the addresses of the interfaces.
       #
       # Another way to use this option is for some kind of spoofing attacks
-      # towards weak nameservers, to probe the security of your network. 
-      # This includes specifing ranged attacks such as DoS and others. For 
+      # towards weak nameservers, to probe the security of your network.
+      # This includes specifing ranged attacks such as DoS and others. For
       # a paper on DNS security, checks http://www.marcoceresa.com/security/
       #
-      # Note that if you want to set a non-binded source address you need 
-      # root priviledges, as raw sockets will be used to generate packets. 
+      # Note that if you want to set a non-binded source address you need
+      # root priviledges, as raw sockets will be used to generate packets.
       # The class will then generate an exception if you're not root.
       #
       # The default is 0.0.0.0, meaning any local address (chosen on routing needs).
@@ -489,37 +504,37 @@ module Net # :nodoc:
         ensure
           a.close
         end
-        
+
         case addr
         when String
           @config[:source_address] = IPAddr.new(string)
           @logger.info "Using new source address: #{@config[:source_address]}"
         when IPAddr
           @config[:source_address] = addr
-          @logger.info "Using new source address: #{@config[:source_address]}"          
+          @logger.info "Using new source address: #{@config[:source_address]}"
         else
           raise ArgumentError, "Unknown dest_address format"
         end
       end
-      alias srcaddr= source_address= 
-      
-      # Return the retrasmission interval (in seconds) the resolvers has 
+      alias srcaddr= source_address=
+
+      # Return the retrasmission interval (in seconds) the resolvers has
       # been set on.
       def retry_interval
         @config[:retry_interval]
       end
-      alias retrans retry_interval 
+      alias retrans retry_interval
 
       # Set the retrasmission interval in seconds. Default 5 seconds.
       def retry_interval=(num)
         if num > 0
           @config[:retry_interval] = num
-          @logger.info "Retransmission interval changed to #{num} seconds"          
+          @logger.info "Retransmission interval changed to #{num} seconds"
         else
           raise ArgumentError, "Interval must be positive"
         end
       end
-      alias retrans= retry_interval= 
+      alias retrans= retry_interval=
 
       # The number of times the resolver will try a query.
       #
@@ -538,10 +553,10 @@ module Net # :nodoc:
         else
           raise ArgumentError, "Retry value must be a positive integer"
         end
-      end        
-      alias_method('retry=', 'retry_number=') 
+      end
+      alias_method('retry=', 'retry_number=')
 
-      # This method will return true if the resolver is configured to 
+      # This method will return true if the resolver is configured to
       # perform recursive queries.
       #
       #   print "The resolver will perform a "
@@ -551,8 +566,8 @@ module Net # :nodoc:
       def recursive?
         @config[:recursive]
       end
-      alias_method :recurse, :recursive? 
-      alias_method :recursive, :recursive? 
+      alias_method :recurse, :recursive?
+      alias_method :recursive, :recursive?
 
       # Sets whether or not the resolver should perform recursive
       # queries. Default is true.
@@ -568,8 +583,8 @@ module Net # :nodoc:
           raise ArgumentError, "Argument must be boolean"
         end
       end
-      alias_method :recurse=, :recursive= 
-      
+      alias_method :recurse=, :recursive=
+
       # Return a string representing the resolver state, suitable
       # for printing on the screen.
       #
@@ -577,7 +592,7 @@ module Net # :nodoc:
       #   puts res.state
       #
       def state
-        str = ";; RESOLVER state:\n;; " 
+        str = ";; RESOLVER state:\n;; "
         i = 1
         @config.each do |key,val|
           if key == :log_file or key == :config_file
@@ -590,17 +605,17 @@ module Net # :nodoc:
         end
         str
       end
-      alias print state 
-      alias inspect state 
-      
+      alias print state
+      alias inspect state
+
       # Checks whether the +defname+ flag has been activate.
       def defname?
         @config[:defname]
       end
-      alias defname defname? 
+      alias defname defname?
 
-      # Set the flag +defname+ in a boolean state. if +defname+ is true, 
-      # calls to Resolver#query will append the default domain to names 
+      # Set the flag +defname+ in a boolean state. if +defname+ is true,
+      # calls to Resolver#query will append the default domain to names
       # that contain no dots.
       # Example:
       #
@@ -615,7 +630,7 @@ module Net # :nodoc:
         case bool
         when TrueClass,FalseClass
           @config[:defname] = bool
-          @logger.info("Defname state changed to #{bool}")          
+          @logger.info("Defname state changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
@@ -625,8 +640,8 @@ module Net # :nodoc:
       def dns_search
         @config[:dns_search]
       end
-      alias_method :dnsrch, :dns_search 
-      
+      alias_method :dnsrch, :dns_search
+
       # Set the flag +dns_search+ in a boolean state. If +dns_search+
       # is true, when using the Resolver#search method will be applied
       # the search list. Default is true.
@@ -634,23 +649,23 @@ module Net # :nodoc:
         case bool
         when TrueClass,FalseClass
           @config[:dns_search] = bool
-          @logger.info("DNS search state changed to #{bool}")          
+          @logger.info("DNS search state changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
       end
       alias_method("dnsrch=","dns_search=")
-      
+
       # Get the state of the use_tcp flag.
       #
       def use_tcp?
         @config[:use_tcp]
       end
-      alias_method :usevc, :use_tcp? 
-      alias_method :use_tcp, :use_tcp? 
+      alias_method :usevc, :use_tcp?
+      alias_method :use_tcp, :use_tcp?
 
-      # If +use_tcp+ is true, the resolver will perform all queries 
-      # using TCP virtual circuits instead of UDP datagrams, which 
+      # If +use_tcp+ is true, the resolver will perform all queries
+      # using TCP virtual circuits instead of UDP datagrams, which
       # is the default for the DNS protocol.
       #
       #   res.use_tcp = true
@@ -663,12 +678,12 @@ module Net # :nodoc:
         case bool
         when TrueClass,FalseClass
           @config[:use_tcp] = bool
-          @logger.info("Use tcp flag changed to #{bool}")          
+          @logger.info("Use tcp flag changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
       end
-      alias usevc= use_tcp= 
+      alias usevc= use_tcp=
 
       def ignore_truncated?
         @config[:ignore_truncated]
@@ -679,20 +694,20 @@ module Net # :nodoc:
         case bool
         when TrueClass,FalseClass
           @config[:ignore_truncated] = bool
-          @logger.info("Ignore truncated flag changed to #{bool}")          
+          @logger.info("Ignore truncated flag changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
       end
-      
-      # Return an object representing the value of the stored TCP 
+
+      # Return an object representing the value of the stored TCP
       # timeout the resolver will use in is queries. This object
       # is an instance of the class +TcpTimeout+, and two methods
       # are available for printing informations: TcpTimeout#to_s
       # and TcpTimeout#pretty_to_s.
       #
       # Here's some example:
-      # 
+      #
       #   puts "Timeout of #{res.tcp_timeout} seconds" # implicit to_s
       #     #=> Timeout of 150 seconds
       #
@@ -715,17 +730,17 @@ module Net # :nodoc:
       #
       def tcp_timeout=(secs)
         @config[:tcp_timeout] = TcpTimeout.new(secs)
-        @logger.info("New TCP timeout value: #{@config[:tcp_timeout]} seconds")        
+        @logger.info("New TCP timeout value: #{@config[:tcp_timeout]} seconds")
       end
 
-      # Return an object representing the value of the stored UDP 
+      # Return an object representing the value of the stored UDP
       # timeout the resolver will use in is queries. This object
       # is an instance of the class +UdpTimeout+, and two methods
       # are available for printing information: UdpTimeout#to_s
       # and UdpTimeout#pretty_to_s.
       #
       # Here's some example:
-      # 
+      #
       #   puts "Timeout of #{res.udp_timeout} seconds" # implicit to_s
       #     #=> Timeout of 150 seconds
       #
@@ -741,9 +756,9 @@ module Net # :nodoc:
 
       # Set the value of UDP timeout for resolver queries that
       # will be performed using UDP. A value of 0 means that
-      # the timeout will not be used, and the resolver will use 
+      # the timeout will not be used, and the resolver will use
       # only +retry_number+ and +retry_interval+ parameters.
-      # 
+      #
       # Default is 5 seconds.
       #
       # The value is stored internally as a +UdpTimeout+ object, see
@@ -751,7 +766,7 @@ module Net # :nodoc:
       #
       def udp_timeout=(secs)
         @config[:udp_timeout] = UdpTimeout.new(secs)
-        @logger.info("New UDP timeout value: #{@config[:udp_timeout]} seconds")                
+        @logger.info("New UDP timeout value: #{@config[:udp_timeout]} seconds")
       end
 
       # Set a new log file for the logger facility of the resolver
@@ -768,11 +783,11 @@ module Net # :nodoc:
         @logger = Logger.new(@config[:log_file])
         @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
       end
-      
+
       # This one permits to have a personal logger facility to handle
       # resolver messages, instead of new built-in one, which is set up
       # for a +$stdout+ (or +$stderr+) use.
-      # 
+      #
       # If you want your own logging facility you can create a new instance
       # of the +Logger+ class:
       #
@@ -798,12 +813,12 @@ module Net # :nodoc:
       # Set the log level for the built-in logging facility.
       #
       # The log level can be one of the following:
-      # 
-      # - +Net::DNS::DEBUG+ 
-      # - +Net::DNS::INFO+ 
-      # - +Net::DNS::WARN+ 
-      # - +Net::DNS::ERROR+ 
-      # - +Net::DNS::FATAL+ 
+      #
+      # - +Net::DNS::DEBUG+
+      # - +Net::DNS::INFO+
+      # - +Net::DNS::WARN+
+      # - +Net::DNS::ERROR+
+      # - +Net::DNS::FATAL+
       #
       # Note that if the global variable $DEBUG is set (like when the
       # -d switch is used at the command line) the logger level is
@@ -815,12 +830,12 @@ module Net # :nodoc:
       def log_level=(level)
         @logger.level = level
       end
-      
-      # Performs a DNS query for the given name, applying the searchlist if 
+
+      # Performs a DNS query for the given name, applying the searchlist if
       # appropriate.  The search algorithm is as follows:
       #
       # 1. If the name contains at least one dot, try it as is.
-      # 2. If the name doesn't end in a dot then append each item in the search 
+      # 2. If the name doesn't end in a dot then append each item in the search
       #    list to the name.  This is only done if +dns_search+ is true.
       # 3. If the name doesn't contain any dots, try it as is.
       #
@@ -831,7 +846,7 @@ module Net # :nodoc:
       #   packet = res.search('example.com', Net::DNS::MX)
       #   packet = res.search('user.passwd.example.com', Net::DNS::TXT, Net::DNS::HS)
       #
-      # If the name is an IP address (Ipv4 or IPv6), in the form of a string 
+      # If the name is an IP address (Ipv4 or IPv6), in the form of a string
       # or a +IPAddr+ object, then an appropriate PTR query will be performed:
       #
       #   ip = IPAddr.new("172.16.100.2")
@@ -839,19 +854,19 @@ module Net # :nodoc:
       #   packet = res.search("192.168.10.254")
       #
       # Returns a Net::DNS::Packet object. If you need to examine the response packet
-      # whether it contains any answers or not, use the send() method instead.
+      # whether it contains any answers or not, use the Resolver#query method instead.
       #
       def search(name,type=Net::DNS::A,cls=Net::DNS::IN)
 
         return query(name,type,cls) if name.class == IPAddr
 
-        # If the name contains at least one dot then try it as is first.        
+        # If the name contains at least one dot then try it as is first.
         if name.include? "."
           @logger.debug "Search(#{name},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
           ans = query(name,type,cls)
           return ans if ans.header.anCount > 0
         end
-        
+
         # If the name doesn't end in a dot then apply the search list.
         if name !~ /\.$/ and @config[:dns_search]
           @config[:searchlist].each do |domain|
@@ -865,15 +880,15 @@ module Net # :nodoc:
         # Finally, if the name has no dots then try it as is.
         @logger.debug "Search(#{name},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
         query(name+".",type,cls)
-        
+
       end
-      
-      # Performs a DNS query for the given name; the search list 
-      # is not applied.  If the name doesn't contain any dots and 
+
+      # Performs a DNS query for the given name; the search list
+      # is not applied.  If the name doesn't contain any dots and
       # +defname+ is true then the default domain will be appended.
       #
-      # The record type and class can be omitted; they default to +A+ 
-      # and +IN+.  If the name looks like an IP address (IPv4 or IPv6), 
+      # The record type and class can be omitted; they default to +A+
+      # and +IN+.  If the name looks like an IP address (IPv4 or IPv6),
       # then an appropriate PTR query will be performed.
       #
       #   packet = res.query('mailhost')
@@ -881,67 +896,67 @@ module Net # :nodoc:
       #   packet = res.query('example.com', Net::DNS::MX)
       #   packet = res.query('user.passwd.example.com', Net::DNS::TXT, Net::DNS::HS)
       #
-      # If the name is an IP address (Ipv4 or IPv6), in the form of a string 
+      # If the name is an IP address (Ipv4 or IPv6), in the form of a string
       # or a +IPAddr+ object, then an appropriate PTR query will be performed:
       #
       #   ip = IPAddr.new("172.16.100.2")
       #   packet = res.query(ip)
       #   packet = res.query("192.168.10.254")
       #
-      # Returns a Net::DNS::Packet object. If you need to examine the response 
-      # packet whether it contains any answers or not, use the Resolver#send 
+      # Returns a Net::DNS::Packet object. If you need to examine the response
+      # packet whether it contains any answers or not, use the Resolver#query
       # method instead.
       #
       def query(name,type=Net::DNS::A,cls=Net::DNS::IN)
 
         return send(name,type,cls) if name.class == IPAddr
 
-        # If the name doesn't contain any dots then append the default domain.        
-        if name !~ /\./ and name !~ /:/ and @config[:defnames]
+        # If the name doesn't contain any dots then append the default domain.
+        if name !~ /\./ and name !~ /:/ and @config[:defname]
           name += "." + @config[:domain]
         end
-        
+
         @logger.debug "Query(#{name},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
-        
+
         send(name,type,cls)
-        
+
       end
-      
-      # Performs a DNS query for the given name.  Neither the 
+
+      # Performs a DNS query for the given name.  Neither the
       # searchlist nor the default domain will be appended.
       #
-      # The argument list can be either a Net::DNS::Packet object 
-      # or a name string plus optional type and class, which if 
-      # omitted default to +A+ and +IN+.  
+      # The argument list can be either a Net::DNS::Packet object
+      # or a name string plus optional type and class, which if
+      # omitted default to +A+ and +IN+.
       #
       # Returns a Net::DNS::Packet object.
       #
       #   # Executes the query with a +Packet+ object
       #   send_packet = Net::DNS::Packet.new("host.example.com", Net::DNS::NS, Net::DNS::HS)
-      #   packet = res.send(send_packet)
+      #   packet = res.query(send_packet)
       #
       #   # Executes the query with a host, type and cls
-      #   packet = res.send("host.example.com")
-      #   packet = res.send("host.example.com", Net::DNS::NS)
-      #   packet = res.send("host.example.com", Net::DNS::NS, Net::DNS::HS)
+      #   packet = res.query("host.example.com")
+      #   packet = res.query("host.example.com", Net::DNS::NS)
+      #   packet = res.query("host.example.com", Net::DNS::NS, Net::DNS::HS)
       #
-      # If the name is an IP address (Ipv4 or IPv6), in the form of a string 
+      # If the name is an IP address (Ipv4 or IPv6), in the form of a string
       # or a IPAddr object, then an appropriate PTR query will be performed:
       #
       #   ip = IPAddr.new("172.16.100.2")
-      #   packet = res.send(ip)
+      #   packet = res.query(ip)
       #   
-      #   packet = res.send("172.16.100.2")
+      #   packet = res.query("172.16.100.2")
       #
-      # Use +packet.header.ancount+ or +packet.answer+ to find out if there 
+      # Use +packet.header.ancount+ or +packet.answer+ to find out if there
       # were any records in the answer section.
       #
-      def send(argument, type = Net::DNS::A, cls = Net::DNS::IN)
+      def query(argument, type = Net::DNS::A, cls = Net::DNS::IN)
         if @config[:nameservers].size == 0
-          raise ResolverError, "No nameservers specified!"
+          raise Resolver::Error, "No nameservers specified!"
         end
 
-        method = :send_udp
+        method = :query_udp
         packet = if argument.kind_of? Net::DNS::Packet
           argument
         else
@@ -959,33 +974,33 @@ module Net # :nodoc:
             @logger.info "Sending #{packet_size} bytes using TCP over RAW socket"
             method = :send_raw_tcp
           else
-            @logger.info "Sending #{packet_size} bytes using TCP"            
-            method = :send_tcp
+            @logger.info "Sending #{packet_size} bytes using TCP"
+            method = :query_tcp
           end
         else # Packet size is inside the boundaries
           if @raw # Use raw sockets?
-            @logger.info "Sending #{packet_size} bytes using UDP over RAW socket"            
+            @logger.info "Sending #{packet_size} bytes using UDP over RAW socket"
             method = :send_raw_udp
           elsif use_tcp? # User requested TCP
-            @logger.info "Sending #{packet_size} bytes using TCP"            
-            method = :send_tcp
+            @logger.info "Sending #{packet_size} bytes using TCP"
+            method = :query_tcp
           else # Finally use UDP
-            @logger.info "Sending #{packet_size} bytes using UDP"            
+            @logger.info "Sending #{packet_size} bytes using UDP"
           end
         end
 
-        if type == Net::DNS::AXFR     
+        if type == Net::DNS::AXFR
           if @raw
             @logger.warn "AXFR query, switching to TCP over RAW socket"
             method = :send_raw_tcp
           else
-            @logger.warn "AXFR query, switching to TCP"            
-            method = :send_tcp
+            @logger.warn "AXFR query, switching to TCP"
+            method = :query_tcp
           end
         end
-        
-        ans = self.old_send(method,packet,packet_data)
-        
+
+        ans = self.send(method, packet, packet_data)
+
         unless ans
           message = "No response from nameservers list"
           @logger.fatal(message)
@@ -994,12 +1009,12 @@ module Net # :nodoc:
 
         @logger.info "Received #{ans[0].size} bytes from #{ans[1][2]+":"+ans[1][1].to_s}"
         response = Net::DNS::Packet.parse(ans[0],ans[1])
-        
+
         if response.header.truncated? and not ignore_truncated?
           @logger.warn "Packet truncated, retrying using TCP"
           self.use_tcp = true
           begin
-            return send(argument,type,cls)
+            return query(argument,type,cls)
           ensure
             self.use_tcp = false
           end
@@ -1008,52 +1023,41 @@ module Net # :nodoc:
         return response
       end
 
-      #
       # Performs a zone transfer for the zone passed as a parameter.
       #
       # It is actually only a wrapper to a send with type set as Net::DNS::AXFR,
       # since it is using the same infrastucture.
       #
-      def axfr(name,cls=Net::DNS::IN)
+      def axfr(name, cls = Net::DNS::IN)
         @logger.info "Requested AXFR transfer, zone #{name} class #{cls}"
-        send(name,Net::DNS::AXFR,cls)
+        query(name, Net::DNS::AXFR, cls)
       end
 
+      # Performs an MX query for the domain name passed as parameter.
       #
-      # Performs an MX query for the domain name passed as parameter. 
-      #
-      # It actually uses the same methods a normal Resolver query would 
-      # use, but automatically sort the results based on preferences 
+      # It actually uses the same methods a normal Resolver query would
+      # use, but automatically sort the results based on preferences
       # and returns an ordered array.
       #
       #   res = Net::DNS::Resolver.new
       #   res.mx("google.com")
       #
-      def mx(name,cls=Net::DNS::IN)
+      def mx(name, cls = Net::DNS::IN)
         arr = []
-        send(name, Net::DNS::MX, cls).answer.each do |entry|
+        query(name, Net::DNS::MX, cls).answer.each do |entry|
           arr << entry if entry.type == 'MX'
         end
-        return arr.sort_by {|a| a.preference}
-      end
-
-      # Quick resolver method. Bypass the configuration using
-      # the defaults.
-      #
-      #   Net::DNS::Resolver.start "www.google.com"
-      #
-      def self.start(*params)
-        self.new.search(*params)
+        arr.sort_by { |a| a.preference }
       end
 
       private
-      
+
       # Parses a configuration file specified as the argument.
       def parse_config_file
         if self.class.platform_windows?
           require 'win32/resolv'
           arr = Win32::Resolv.get_resolv_info
-          self.domain = arr[0]
+          self.domain = arr[0].to_s
           self.nameservers = arr[1]
         else
           IO.foreach(@config[:config_file]) do |line|
@@ -1070,7 +1074,7 @@ module Net # :nodoc:
           end
         end
       end
-      
+
       # Parses environment variables.
       def parse_environment_variables
         if ENV['RES_NAMESERVERS']
@@ -1114,7 +1118,7 @@ module Net # :nodoc:
           begin
             name = IPAddr.new(string.chomp(".")).reverse
             type = Net::DNS::PTR
-          rescue ::ArgumentError
+          rescue ArgumentError
             name = string if valid? string
           end
         else
@@ -1127,34 +1131,34 @@ module Net # :nodoc:
         if packet.query?
           packet.header.recursive = @config[:recursive] ? 1 : 0
         end
-        
+
         # DNSSEC and TSIG stuff to be inserted here
-        
+
         packet
       end
 
-      def send_tcp(packet, packet_data)
+      def query_tcp(packet, packet_data)
 
         ans = nil
         length = [packet_data.size].pack("n")
-        
+
         @config[:nameservers].each do |ns|
           begin
             buffer = ""
             socket = Socket.new(Socket::AF_INET,Socket::SOCK_STREAM,0)
             socket.bind(Socket.pack_sockaddr_in(@config[:source_port],@config[:source_address].to_s))
-            
+
             sockaddr = Socket.pack_sockaddr_in(@config[:port],ns.to_s)
-            
+
             @config[:tcp_timeout].timeout do
-              socket.connect(sockaddr)              
+              socket.connect(sockaddr)
               @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"
               socket.write(length+packet_data)
               ans = socket.recv(Net::DNS::INT16SZ)
               len = ans.unpack("n")[0]
 
               @logger.info "Receiving #{len} bytes..."
-              
+
               if len == 0
                 @logger.warn "Receiving 0 lenght packet from nameserver #{ns}, trying next."
                 next
@@ -1165,7 +1169,7 @@ module Net # :nodoc:
                 temp,from = socket.recvfrom(left)
                 buffer += temp
               end
-              
+
               unless buffer.size == len
                 @logger.warn "Malformed packet from nameserver #{ns}, trying next."
                 next
@@ -1173,26 +1177,33 @@ module Net # :nodoc:
             end
             return [buffer,["",@config[:port],ns.to_s,ns.to_s]]
           rescue TimeoutError
-            @logger.warn "Nameserver #{ns} not responding within TCP timeout, trying next one"            
+            @logger.warn "Nameserver #{ns} not responding within TCP timeout, trying next one"
             next
           ensure
-            socket.close 
+            socket.close
           end
         end
       end
-      
-      def send_udp(packet, packet_data)
-        socket = UDPSocket.new
-        socket.bind(@config[:source_address].to_s,@config[:source_port])
-        
+
+      def query_udp(packet, packet_data)
+        socket4 = UDPSocket.new
+        socket4.bind(@config[:source_address].to_s,@config[:source_port])
+        socket6 = UDPSocket.new(Socket::AF_INET6)
+        socket6.bind(@config[:source_address_inet6].to_s,@config[:source_port])
+
         ans = nil
         response = ""
         @config[:nameservers].each do |ns|
           begin
             @config[:udp_timeout].timeout do
-              @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"              
-              socket.send(packet_data,0,ns.to_s,@config[:port])
-              ans = socket.recvfrom(@config[:packet_size])
+              @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"
+              ans = if ns.ipv6?
+                socket6.send(packet_data, 0, ns.to_s, @config[:port])
+                socket6.recvfrom(@config[:packet_size])
+              else
+                socket4.send(packet_data, 0, ns.to_s, @config[:port])
+                socket4.recvfrom(@config[:packet_size])
+              end
             end
             break if ans
           rescue TimeoutError
@@ -1203,6 +1214,7 @@ module Net # :nodoc:
         ans
       end
 
+      # FIXME: a ? method should never raise.
       def valid?(name)
         if name =~ /[^-\w\.]/
           raise ArgumentError, "Invalid domain name #{name}"
@@ -1211,20 +1223,6 @@ module Net # :nodoc:
         end
       end
 
-
-      class << self
-
-        # Returns true if running on a Windows platform.
-        #
-        # Note. This method doesn't rely on the RUBY_PLATFORM constant
-        # because the comparison will fail when running on JRuby.
-        # On JRuby RUBY_PLATFORM == 'java'.
-        def platform_windows?
-          !!(Config::CONFIG["host_os"] =~ /msdos|mswin|djgpp|mingw/i)
-        end
-
-      end
-
     end
   end
 end