# File lib/net/dns/resolver.rb, line 203
      def initialize(config = {})
        raise ResolverArgumentError, "Argument has to be Hash" unless config.kind_of? Hash
        # config.key_downcase!
        @config = Defaults.merge config
        @raw = false

        # 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
        # 2) ENV variables
        # 3) config file
        # 4) defaults (and /etc/resolv.conf for config)
        #------------------------------------------------------------

        
        
        #------------------------------------------------------------
        # Parsing config file
        #------------------------------------------------------------
        parse_config_file
        
        #------------------------------------------------------------
        # Parsing ENV variables
        #------------------------------------------------------------
        parse_environment_variables
        
        #------------------------------------------------------------
        # Parsing arguments
        #------------------------------------------------------------
        config.each do |key,val|
          next if key == :log_file or key == :config_file
          begin
            eval "self.#{key.to_s} = val"
          rescue NoMethodError
            raise ResolverArgumentError, "Option #{key} not valid"
          end
        end
      end

# File lib/net/dns/resolver.rb, line 1033
      def self.start(*params)
        self.new.search(*params)
      end

# File lib/net/dns/resolver.rb, line 1000
      def axfr(name,cls=Net::DNS::IN)
        @logger.info "Requested AXFR transfer, zone #{name} class #{cls}"
        send(name,Net::DNS::AXFR,cls)
      end

# File lib/net/dns/resolver.rb, line 602
      def defname=(bool)
        case bool
        when TrueClass,FalseClass
          @config[:defname] = bool
          @logger.info("Defname state changed to #{bool}")          
        else
          raise ResolverArgumentError, "Argument must be boolean"
        end
      end

# File lib/net/dns/resolver.rb, line 585
      def defname?
        @config[:defname]
      end

# File lib/net/dns/resolver.rb, line 613
      def dns_search
        @config[:dns_search]
      end

# File lib/net/dns/resolver.rb, line 622
      def dns_search=(bool)
        case bool
        when TrueClass,FalseClass
          @config[:dns_search] = bool
          @logger.info("DNS search state changed to #{bool}")          
        else
          raise ResolverArgumentError, "Argument must be boolean"
        end
      end

# File lib/net/dns/resolver.rb, line 348
      def domain
        @config[:domain].inspect
      end

# File lib/net/dns/resolver.rb, line 354
      def domain=(name)
        @config[:domain] = name if valid? name
      end

# File lib/net/dns/resolver.rb, line 667
      def ignore_truncated=(bool)
        case bool
        when TrueClass,FalseClass
          @config[:ignore_truncated] = bool
          @logger.info("Ignore truncated flag changed to #{bool}")          
        else
          raise ResolverArgumentError, "Argument must be boolean"
        end
      end

# File lib/net/dns/resolver.rb, line 662
      def ignore_truncated?
        @config[:ignore_truncated]
      end

# File lib/net/dns/resolver.rb, line 753
      def log_file=(log)
        @logger.close
        @config[:log_file] = log
        @logger = Logger.new(@config[:log_file])
        @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
      end

# File lib/net/dns/resolver.rb, line 803
      def log_level=(level)
        @logger.level = level
      end

# File lib/net/dns/resolver.rb, line 777
      def logger=(logger)
        if logger.kind_of? Logger
          @logger.close
          @logger = logger
        else
          raise ResolverArgumentError, "Argument must be an instance of Logger class"
        end
      end

# File lib/net/dns/resolver.rb, line 1017
      def mx(name,cls=Net::DNS::IN)
        arr = []
        send(name, Net::DNS::MX, cls).answer.each do |entry|
          arr << entry if entry.type == 'MX'
        end
        return arr.sort_by {|a| a.preference}
      end

# File lib/net/dns/resolver.rb, line 287
      def nameservers
        arr = []
        @config[:nameservers].each do |x| 
          arr << x.to_s
        end
        arr
      end

# File lib/net/dns/resolver.rb, line 310
      def nameservers=(arg)
        case arg
        when String
          begin
            @config[:nameservers] = [IPAddr.new(arg)]
            @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"
          rescue ArgumentError # arg is in the name form, not IP
            nameservers_from_name(arg)
          end
        when IPAddr
          @config[:nameservers] = [arg]
          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"          
        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 ResolverArgumentError, "Wrong argument format"
                                     end
          end
          @logger.info "Nameservers list changed to value #{@config[:nameservers].inspect}"          
        else
          raise ResolverArgumentError, "Wrong argument format, neither String, Array nor IPAddr"
        end
      end

# File lib/net/dns/resolver.rb, line 360
      def packet_size
        @config[:packet_size]
      end

# File lib/net/dns/resolver.rb, line 368
      def port
        @config[:port]
      end

# File lib/net/dns/resolver.rb, line 379
      def port=(num)
        if (0..65535).include? num
          @config[:port] = num
          @logger.info "Port number changed to #{num}"          
        else
          raise ResolverArgumentError, "Wrong port number #{num}"
        end
      end

# File lib/net/dns/resolver.rb, line 881
      def query(name,type=Net::DNS::A,cls=Net::DNS::IN)
        
        # If the name doesn't contain any dots then append the default domain.        
        if name !~ /\./ and name !~ /:/ and @config[:defnames]
          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

# File lib/net/dns/resolver.rb, line 550
      def recursive=(bool)
        case bool
        when TrueClass,FalseClass
          @config[:recursive] = bool
          @logger.info("Recursive state changed to #{bool}")
        else
          raise ResolverArgumentError, "Argument must be boolean"
        end
      end

# File lib/net/dns/resolver.rb, line 539
      def recursive?
        @config[:recursive]
      end

# File lib/net/dns/resolver.rb, line 494
      def retry_interval
        @config[:retry_interval]
      end

# File lib/net/dns/resolver.rb, line 501
      def retry_interval=(num)
        if num > 0
          @config[:retry_interval] = num
          @logger.info "Retransmission interval changed to #{num} seconds"          
        else
          raise ResolverArgumentError, "Interval must be positive"
        end
      end

# File lib/net/dns/resolver.rb, line 515
      def retry_number
        @config[:retry_number]
      end

# File lib/net/dns/resolver.rb, line 522
      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 ResolverArgumentError, "Retry value must be a positive integer"
        end
      end

# File lib/net/dns/resolver.rb, line 832
      def search(name,type=Net::DNS::A,cls=Net::DNS::IN)

        # 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|
            newname = name + "." + domain
            @logger.debug "Search(#{newname},#{Net::DNS::RR::Types.new(type)},#{Net::DNS::RR::Classes.new(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)
        
      end

# File lib/net/dns/resolver.rb, line 251
      def searchlist
        @config[:searchlist].inspect
      end

# File lib/net/dns/resolver.rb, line 269
      def searchlist=(arg)
        case arg
        when String
          @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}
          @logger.info "Searchlist changed to value #{@config[:searchlist].inspect}"          
        else
          raise ResolverArgumentError, "Wrong argument format, neither String nor Array"
        end
      end

# File lib/net/dns/resolver.rb, line 922
      def send(argument,type=Net::DNS::A,cls=Net::DNS::IN)
        if @config[:nameservers].size == 0
          raise ResolverError, "No nameservers specified!"
        end

        method = :send_udp
        
        if argument.kind_of? Net::DNS::Packet
          packet = argument
        else
          packet = make_query_packet(argument,type,cls)
        end
        
        # Store packet_data for performance improvements,
        # so methods don't keep on calling Packet#data
        packet_data = packet.data
        packet_size = packet_data.size

        # Choose whether use TCP, UDP or RAW
        if packet_size > @config[:packet_size] # Must use TCP, either plain or raw
          if @raw # Use raw sockets?
            @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
          end
        else # Packet size is inside the boundaries
          if @raw # Use raw sockets?
            @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
          else # Finally use UDP
            @logger.info "Sending #{packet_size} bytes using UDP"            
          end
        end

        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
          end
        end
        
        ans = self.old_send(method,packet,packet_data)
        
        unless ans
          @logger.fatal "No response from nameservers list: aborting"
          raise NoResponseError
        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])
        
        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)
          ensure
            self.use_tcp = false
          end
        end

        return response
      end

# File lib/net/dns/resolver.rb, line 424
      def source_address
        @config[:source_address].to_s
      end

# File lib/net/dns/resolver.rb, line 454
      def source_address=(addr)
        unless addr.respond_to? :to_s
          raise ResolverArgumentError, "Wrong address argument #{addr}"
        end

        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)
        rescue SystemCallError => e
          case e.errno
          when 98 # Port already in use!
            @logger.warn "Port already in use"
            retry
          when 99 # Address is not valid: raw socket
            @raw = true
            @logger.warn "Using raw sockets"
          else
            raise SystemCallError, e
          end
        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]}"          
        else
          raise ArgumentError, "Unknown dest_address format"
        end
      end

# File lib/net/dns/resolver.rb, line 392
      def source_port
        @config[:source_port]
      end

# File lib/net/dns/resolver.rb, line 408
      def source_port=(num)
        unless root?
          raise ResolverPermissionError, "Are you root?"
        end
        if (0..65535).include?(num) 
          @config[:source_port] = num
        else
          raise ResolverArgumentError, "Wrong port number #{num}"
        end
      end

# File lib/net/dns/resolver.rb, line 567
      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"
            else
            str << "#{key}: #{eval(key.to_s)} \t"
          end
          str << "\n;; " if i % 2 == 0
          i += 1
        end
        str
      end

# File lib/net/dns/resolver.rb, line 694
      def tcp_timeout
        @config[:tcp_timeout].to_s
      end

# File lib/net/dns/resolver.rb, line 705
      def tcp_timeout=(secs)
        @config[:tcp_timeout] = TcpTimeout.new(secs)
        @logger.info("New TCP timeout value: #{@config[:tcp_timeout]} seconds")        
      end

# File lib/net/dns/resolver.rb, line 727
      def udp_timeout
        @config[:udp_timeout].to_s
      end

# File lib/net/dns/resolver.rb, line 740
      def udp_timeout=(secs)
        @config[:udp_timeout] = UdpTimeout.new(secs)
        @logger.info("New UDP timeout value: #{@config[:udp_timeout]} seconds")                
      end

# File lib/net/dns/resolver.rb, line 651
      def use_tcp=(bool)
        case bool
        when TrueClass,FalseClass
          @config[:use_tcp] = bool
          @logger.info("Use tcp flag changed to #{bool}")          
        else
          raise ResolverArgumentError, "Argument must be boolean"
        end
      end

# File lib/net/dns/resolver.rb, line 635
      def use_tcp?
        @config[:use_tcp]
      end