net-dns 0.8.0 → 0.20.0

data/lib/net/dns/resolver.rb

@@ -16,7 +16,7 @@ require 'net/dns/resolver/timeouts'
 #   Resolver("www.google.com") { |packet| puts packet.size + " bytes" }
 #   # => 484 bytes
 #
-def Resolver(name, type = Net::DNS::A, cls = Net::DNS::IN, &block)
+def Resolver(name, type = Net::DNS::A, cls = Net::DNS::IN)
   resolver = Net::DNS::Resolver.start(name, type, cls)
   if block_given?
     yield resolver
@@ -27,7 +27,6 @@ end
 
 module Net
   module DNS
-
     include Logger::Severity
 
     # = Net::DNS::Resolver - DNS resolver class
@@ -87,7 +86,6 @@ module Net
     #      % setenv RES_OPTIONS "retrans:3 retry:2 debug"
     #
     class Resolver
-
       class Error < StandardError
       end
 
@@ -99,30 +97,28 @@ module Net
       # the description for each parameter to have an
       # explanation of its usage.
       Defaults = {
-        :config_file => "/etc/resolv.conf",
-        :log_file => $stdout,
-        :port => 53,
-        :searchlist => [],
-        :nameservers => [IPAddr.new("127.0.0.1")],
-        :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,
-        :defname => true,
-        :dns_search => true,
-        :use_tcp => false,
-        :ignore_truncated => false,
-        :packet_size => 512,
-        :tcp_timeout => TcpTimeout.new(5),
-        :udp_timeout => UdpTimeout.new(5),
-      }
-
+        config_file: "/etc/resolv.conf",
+        log_file: $stdout,
+        port: 53,
+        searchlist: [],
+        nameservers: [IPAddr.new("127.0.0.1")],
+        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,
+        defname: true,
+        dns_search: true,
+        use_tcp: false,
+        ignore_truncated: false,
+        packet_size: 512,
+        tcp_timeout: TcpTimeout.new(5),
+        udp_timeout: UdpTimeout.new(5),
+      }.freeze
 
       class << self
-
         C = Object.const_get(defined?(RbConfig) ? :RbConfig : :Config)::CONFIG
 
         # Quick resolver method. Bypass the configuration using
@@ -142,10 +138,8 @@ module Net
         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
@@ -237,9 +231,9 @@ module Net
       # Net::DNS::Resolver Perl module.
       #
       def initialize(config = {})
-        raise ArgumentError, "Expected `config' to be a Hash" unless config.is_a?(Hash)
+        config.is_a?(Hash) or
+            raise(ArgumentError, "Expected `config' to be a Hash")
 
-        # config.downcase_keys!
         @config = Defaults.merge config
         @raw = false
 
@@ -255,8 +249,6 @@ module Net
         # 4) defaults (and /etc/resolv.conf for config)
         #------------------------------------------------------------
 
-
-
         #------------------------------------------------------------
         # Parsing config file
         #------------------------------------------------------------
@@ -270,10 +262,11 @@ module Net
         #------------------------------------------------------------
         # Parsing arguments
         #------------------------------------------------------------
-        config.each do |key,val|
-          next if key == :log_file or key == :config_file
+        config.each do |key, val|
+          next if (key == :log_file) || (key == :config_file)
+
           begin
-            eval "self.#{key.to_s} = val"
+            eval "self.#{key} = val"
           rescue NoMethodError
             raise ArgumentError, "Option #{key} not valid"
           end
@@ -309,7 +302,7 @@ module Net
           @config[:searchlist] = [arg] if valid? arg
           @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"
         when Array
-          @config[:searchlist] = arg if arg.all? {|x| valid? x}
+          @config[:searchlist] = arg if arg.all? { |x| valid? x }
           @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"
         else
           raise ArgumentError, "Wrong argument format, neither String nor Array"
@@ -325,7 +318,7 @@ module Net
         @config[:nameservers].map(&:to_s)
       end
 
-      alias_method :nameserver, :nameservers
+      alias nameserver nameservers
 
       # Set the list of resolver nameservers.
       # +arg+ can be a single ip address or an array of addresses.
@@ -356,26 +349,27 @@ module Net
         when Array
           @config[:nameservers] = []
           arg.each do |x|
-            @config[:nameservers] << case x
-                                     when String
-                                       begin
-                                         IPAddr.new(x)
-                                       rescue ArgumentError
-                                         nameservers_from_name(arg)
-                                         return
-                                       end
-                                     when IPAddr
-                                       x
-                                     else
-                                       raise ArgumentError, "Wrong argument format"
-                                     end
+            val = case x
+            when String
+              begin
+                IPAddr.new(x)
+              rescue ArgumentError
+                nameservers_from_name(arg)
+                return
+              end
+            when IPAddr
+              x
+            else
+              raise ArgumentError, "Wrong argument format"
+            end
+            @config[:nameservers] << val
           end
           @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=")
+      alias_method("nameserver=", "nameservers=")
 
       # Return a string with the default domain.
       def domain
@@ -408,12 +402,11 @@ module Net
       # The default is port 53.
       #
       def port=(num)
-        if (0..65535).include? num
-          @config[:port] = num
-          @logger.info "Port number changed to #{num}"
-        else
-          raise ArgumentError, "Wrong port number #{num}"
-        end
+        (0..65_535).cover?(num) or
+            raise(ArgumentError, "Wrong port number #{num}")
+
+        @config[:port] = num
+        @logger.info "Port number changed to #{num}"
       end
 
       # Get the value of the source port number.
@@ -437,14 +430,12 @@ module Net
       # underlaying layers.
       #
       def source_port=(num)
-        unless root?
-          raise ResolverPermissionError, "Are you root?"
-        end
-        if (0..65535).include?(num)
-          @config[:source_port] = num
-        else
-          raise ArgumentError, "Wrong port number #{num}"
-        end
+        root? or
+            raise(ResolverPermissionError, "Are you root?")
+        (0..65_535).cover?(num) or
+            raise(ArgumentError, "Wrong port number #{num}")
+
+        @config[:source_port] = num
       end
       alias srcport= source_port=
 
@@ -462,7 +453,7 @@ module Net
       def source_address_inet6
         @config[:source_address_inet6].to_s
       end
-      
+
       # Set the local source address from which the resolver sends its queries.
       #
       #   res.source_address = "172.16.100.1"
@@ -487,14 +478,13 @@ module Net
       # The default is 0.0.0.0, meaning any local address (chosen on routing needs).
       #
       def source_address=(addr)
-        unless addr.respond_to? :to_s
-          raise ArgumentError, "Wrong address argument #{addr}"
-        end
+        addr.respond_to?(:to_s) or
+            raise(ArgumentError, "Wrong address argument #{addr}")
 
         begin
-          port = rand(64000)+1024
-          @logger.warn "Try to determine state of source address #{addr} with port #{port}"
-          a = TCPServer.new(addr.to_s,port)
+          port = rand(1024..65_023)
+          @logger.info "Try to determine state of source address #{addr} with port #{port}"
+          a = TCPServer.new(addr.to_s, port)
         rescue SystemCallError => e
           case e.errno
           when 98 # Port already in use!
@@ -532,12 +522,11 @@ module Net
 
       # 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"
-        else
-          raise ArgumentError, "Interval must be positive"
-        end
+        num.positive? or
+            raise(ArgumentError, "Interval must be positive")
+
+        @config[:retry_interval] = num
+        @logger.info "Retransmission interval changed to #{num} seconds"
       end
       alias retrans= retry_interval=
 
@@ -552,12 +541,11 @@ module Net
       # Set the number of times the resolver will try a query.
       # Default 4 times.
       def retry_number=(num)
-        if num.kind_of? Integer and num > 0
-          @config[:retry_number] = num
-          @logger.info "Retrasmissions number changed to #{num}"
-        else
-          raise ArgumentError, "Retry value must be a positive integer"
-        end
+        (num.is_a?(Integer) && (num > 0)) or
+            raise(ArgumentError, "Retry value must be a positive integer")
+
+        @config[:retry_number] = num
+        @logger.info "Retrasmissions number changed to #{num}"
       end
       alias_method('retry=', 'retry_number=')
 
@@ -571,8 +559,8 @@ module Net
       def recursive?
         @config[:recursive]
       end
-      alias_method :recurse, :recursive?
-      alias_method :recursive, :recursive?
+      alias recurse recursive?
+      alias recursive recursive?
 
       # Sets whether or not the resolver should perform recursive
       # queries. Default is true.
@@ -581,14 +569,14 @@ module Net
       #
       def recursive=(bool)
         case bool
-        when TrueClass,FalseClass
+        when TrueClass, FalseClass
           @config[:recursive] = bool
           @logger.info("Recursive state changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
       end
-      alias_method :recurse=, :recursive=
+      alias recurse= recursive=
 
       # Return a string representing the resolver state, suitable
       # for printing on the screen.
@@ -599,13 +587,13 @@ module Net
       def state
         str = ";; RESOLVER state:\n;; "
         i = 1
-        @config.each do |key,val|
-          if key == :log_file or key == :config_file
-            str << "#{key}: #{val} \t"
+        @config.each do |key, val|
+          str << if (key == :log_file) || (key == :config_file)
+            "#{key}: #{val} \t"
           else
-            str << "#{key}: #{eval(key.to_s)} \t"
+            "#{key}: #{eval(key.to_s)} \t"
           end
-          str << "\n;; " if i % 2 == 0
+          str << "\n;; " if i.even?
           i += 1
         end
         str
@@ -633,7 +621,7 @@ module Net
       #
       def defname=(bool)
         case bool
-        when TrueClass,FalseClass
+        when TrueClass, FalseClass
           @config[:defname] = bool
           @logger.info("Defname state changed to #{bool}")
         else
@@ -645,29 +633,29 @@ module Net
       def dns_search
         @config[:dns_search]
       end
-      alias_method :dnsrch, :dns_search
+      alias 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.
       def dns_search=(bool)
         case bool
-        when TrueClass,FalseClass
+        when TrueClass, FalseClass
           @config[:dns_search] = bool
           @logger.info("DNS search state changed to #{bool}")
         else
           raise ArgumentError, "Argument must be boolean"
         end
       end
-      alias_method("dnsrch=","dns_search=")
+      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 usevc use_tcp?
+      alias use_tcp use_tcp?
 
       # If +use_tcp+ is true, the resolver will perform all queries
       # using TCP virtual circuits instead of UDP datagrams, which
@@ -681,7 +669,7 @@ module Net
       #
       def use_tcp=(bool)
         case bool
-        when TrueClass,FalseClass
+        when TrueClass, FalseClass
           @config[:use_tcp] = bool
           @logger.info("Use tcp flag changed to #{bool}")
         else
@@ -693,11 +681,11 @@ module Net
       def ignore_truncated?
         @config[:ignore_truncated]
       end
-      alias_method :ignore_truncated, :ignore_truncated?
+      alias ignore_truncated ignore_truncated?
 
       def ignore_truncated=(bool)
         case bool
-        when TrueClass,FalseClass
+        when TrueClass, FalseClass
           @config[:ignore_truncated] = bool
           @logger.info("Ignore truncated flag changed to #{bool}")
         else
@@ -783,7 +771,6 @@ module Net
       # the old one, which will then be impossibile to recover.
       #
       def log_file=(log)
-        @logger.close
         @config[:log_file] = log
         @logger = Logger.new(@config[:log_file])
         @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
@@ -807,12 +794,10 @@ module Net
       # Note that this will destroy the precedent logger.
       #
       def logger=(logger)
-        if logger.kind_of? Logger
-          @logger.close
-          @logger = logger
-        else
-          raise ArgumentError, "Argument must be an instance of Logger class"
-        end
+        logger.is_a?(Logger) or
+            raise(ArgumentError, "Argument must be an instance of Logger class")
+
+        @logger = logger
       end
 
       # Set the log level for the built-in logging facility.
@@ -861,31 +846,29 @@ module Net
       # 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 search(name,type=Net::DNS::A,cls=Net::DNS::IN)
-
-        return query(name,type,cls) if name.class == IPAddr
+      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 name.include? "."
           @logger.debug "Search(#{name},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
-          ans = query(name,type,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]
+        if name !~ /\.$/ && @config[:dns_search]
           @config[:searchlist].each do |domain|
             newname = name + "." + domain
             @logger.debug "Search(#{newname},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(cls)})"
-            ans = query(newname,type,cls)
+            ans = query(newname, type, cls)
             return ans if ans.header.anCount > 0
           end
         end
 
         # 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)
-
+        query(name + ".", type, cls)
       end
 
       # Performs a DNS query for the given name; the search list
@@ -912,19 +895,17 @@ module Net
       # 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
+      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[:defname]
+        if name !~ /\./ && name !~ /:/ && @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)
-
+        send(name, type, cls)
       end
 
       # Performs a DNS query for the given name.  Neither the
@@ -950,19 +931,18 @@ module Net
       #
       #   ip = IPAddr.new("172.16.100.2")
       #   packet = res.query(ip)
-      #   
+      #
       #   packet = res.query("172.16.100.2")
       #
       # Use +packet.header.ancount+ or +packet.answer+ to find out if there
       # were any records in the answer section.
       #
       def query(argument, type = Net::DNS::A, cls = Net::DNS::IN)
-        if @config[:nameservers].size == 0
-          raise Resolver::Error, "No nameservers specified!"
-        end
+        !@config[:nameservers].empty? or
+            raise(Resolver::Error, "No nameservers specified!")
 
         method = :query_udp
-        packet = if argument.kind_of? Net::DNS::Packet
+        packet = if argument.is_a? Net::DNS::Packet
           argument
         else
           make_query_packet(argument, type, cls)
@@ -996,15 +976,15 @@ module Net
 
         if type == Net::DNS::AXFR
           if @raw
-            @logger.warn "AXFR query, switching to TCP over RAW socket"
+            @logger.info "AXFR query, switching to TCP over RAW socket"
             method = :send_raw_tcp
           else
-            @logger.warn "AXFR query, switching to TCP"
+            @logger.info "AXFR query, switching to TCP"
             method = :query_tcp
           end
         end
 
-        ans = self.send(method, packet, packet_data)
+        ans = send(method, packet, packet_data)
 
         unless ans
           message = "No response from nameservers list"
@@ -1012,20 +992,20 @@ module Net
           raise NoResponseError, message
         end
 
-        @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])
+        @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?
+        if response.header.truncated? && !ignore_truncated?
           @logger.warn "Packet truncated, retrying using TCP"
           self.use_tcp = true
           begin
-            return query(argument,type,cls)
+            return query(argument, type, cls)
           ensure
             self.use_tcp = false
           end
         end
 
-        return response
+        response
       end
 
       # Performs a zone transfer for the zone passed as a parameter.
@@ -1052,7 +1032,7 @@ module Net
         query(name, Net::DNS::MX, cls).answer.each do |entry|
           arr << entry if entry.type == 'MX'
         end
-        arr.sort_by { |a| a.preference }
+        arr.sort_by(&:preference)
       end
 
       private
@@ -1062,20 +1042,21 @@ module Net
         if self.class.platform_windows?
           require 'win32/resolv'
           arr = Win32::Resolv.get_resolv_info
-          self.domain = arr[0].to_s
+          self.domain = arr[0][0]
           self.nameservers = arr[1]
         else
           nameservers = []
           IO.foreach(@config[:config_file]) do |line|
-            line.gsub!(/\s*[;#].*/,"")
+            line.gsub!(/\s*[;#].*/, "")
             next unless line =~ /\S/
+
             case line
             when /^\s*domain\s+(\S+)/
-              self.domain = $1
+              self.domain = Regexp.last_match(1)
             when /^\s*search\s+(.*)/
-              self.searchlist = $1.split(" ")
+              self.searchlist = Regexp.last_match(1).split(" ")
             when /^\s*nameserver\s+(.*)/
-              nameservers << $1.split(" ")
+              nameservers << Regexp.last_match(1).split(" ")
             end
           end
           self.nameservers = nameservers.flatten
@@ -1093,14 +1074,14 @@ module Net
         if ENV['LOCALDOMAIN']
           self.domain = ENV['LOCALDOMAIN']
         end
-        if ENV['RES_OPTIONS']
-          ENV['RES_OPTIONS'].split(" ").each do |opt|
-            name,val = opt.split(":")
-            begin
-              eval("self.#{name} = #{val}")
-            rescue NoMethodError
-              raise ArgumentError, "Invalid ENV option #{name}"
-            end
+        return unless ENV['RES_OPTIONS']
+
+        ENV['RES_OPTIONS'].split(" ").each do |opt|
+          name, val = opt.split(":")
+          begin
+            eval("self.#{name} = #{val}")
+          rescue NoMethodError
+            raise ArgumentError, "Invalid ENV option #{name}"
           end
         end
       end
@@ -1144,36 +1125,34 @@ module Net
         packet
       end
 
-      def query_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))
+            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)
+            sockaddr = Socket.pack_sockaddr_in(@config[:port], ns.to_s)
 
             @config[:tcp_timeout].timeout do
               socket.connect(sockaddr)
               @logger.info "Contacting nameserver #{ns} port #{@config[:port]}"
-              socket.write(length+packet_data)
+              socket.write(length + packet_data)
               ans = socket.recv(Net::DNS::INT16SZ)
-              len = ans.unpack("n")[0]
+              len = ans.unpack1("n")
 
               @logger.info "Receiving #{len} bytes..."
 
               if len == 0
-                @logger.warn "Receiving 0 lenght packet from nameserver #{ns}, trying next."
+                @logger.warn "Receiving 0 length packet from nameserver #{ns}, trying next."
                 next
               end
 
-              while (buffer.size < len)
+              while buffer.size < len
                 left = len - buffer.size
-                temp,from = socket.recvfrom(left)
+                temp, from = socket.recvfrom(left)
                 buffer += temp
               end
 
@@ -1182,26 +1161,25 @@ module Net
                 next
               end
             end
-            return [buffer,["",@config[:port],ns.to_s,ns.to_s]]
-          rescue TimeoutError
+            return [buffer, ["", @config[:port], ns.to_s, ns.to_s]]
+        rescue Timeout::Error
             @logger.warn "Nameserver #{ns} not responding within TCP timeout, trying next one"
             next
-          ensure
+        ensure
             socket.close
-          end
         end
+        ans
       end
 
-      def query_udp(packet, packet_data)
+      def query_udp(_packet, packet_data)
         socket4 = UDPSocket.new
-        socket4.bind(@config[:source_address].to_s,@config[:source_port])
+        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])
+        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]}"
               ans = if ns.ipv6?
@@ -1213,23 +1191,20 @@ module Net
               end
             end
             break if ans
-          rescue TimeoutError
+        rescue Timeout::Error
             @logger.warn "Nameserver #{ns} not responding within UDP timeout, trying next one"
             next
-          end
         end
         ans
       end
 
       # FIXME: a ? method should never raise.
       def valid?(name)
-        if name =~ /[^-\w\.]/
-          raise ArgumentError, "Invalid domain name #{name}"
-        else
-          true
-        end
-      end
+        name !~ /[^-\w\.\*]/ or
+            raise(ArgumentError, "Invalid domain name #{name}")
 
+        true
+      end
     end
   end
 end