Class: Resolv::DNS (Ruby 2.2.2)
Description: Class : Resolv::DNS - Ruby 2.2.2

- Home
- Core 2.2.2
- Std-lib 2.2.2
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- resolv.rb

### Parent

Object

### Namespace

- CLASS Resolv::DNS::Config
- CLASS Resolv::DNS::DecodeError
- CLASS Resolv::DNS::EncodeError
- CLASS Resolv::DNS::Name
- CLASS Resolv::DNS::Query
- CLASS Resolv::DNS::Requester
- CLASS Resolv::DNS::Resource

### Methods

- ::new
- ::open
- #close
- #each_address
- #each_name
- #each_resource
- #fetch_resource
- #getaddress
- #getaddresses
- #getname
- #getnames
- #getresource
- #getresources
- #timeouts=

### Class/Module Index

Quicksearch

- Resolv
- Resolv::DNS
- Resolv::DNS::Config
- Resolv::DNS::Config::NXDomain
- Resolv::DNS::Config::OtherResolvError
- Resolv::DNS::DecodeError
- Resolv::DNS::EncodeError
- Resolv::DNS::Name
- Resolv::DNS::Query
- Resolv::DNS::Requester
- Resolv::DNS::Requester::RequestError
- Resolv::DNS::Resource
- Resolv::DNS::Resource::ANY
- Resolv::DNS::Resource::CNAME
- Resolv::DNS::Resource::DomainName
- Resolv::DNS::Resource::Generic
- Resolv::DNS::Resource::HINFO
- Resolv::DNS::Resource::IN
- Resolv::DNS::Resource::IN::A
- Resolv::DNS::Resource::IN::AAAA
- Resolv::DNS::Resource::IN::SRV
- Resolv::DNS::Resource::IN::WKS
- Resolv::DNS::Resource::LOC
- Resolv::DNS::Resource::MINFO
- Resolv::DNS::Resource::MX
- Resolv::DNS::Resource::NS
- Resolv::DNS::Resource::PTR
- Resolv::DNS::Resource::SOA
- Resolv::DNS::Resource::TXT
- Resolv::Hosts
- Resolv::IPv4
- Resolv::IPv6
- Resolv::LOC
- Resolv::LOC::Alt
- Resolv::LOC::Coord
- Resolv::LOC::Size
- Resolv::MDNS
- Resolv::ResolvError
- Resolv::ResolvTimeout

No matching classes.

# Resolv::DNS

Resolv::DNS is a DNS stub resolver.

Information taken from the following places:

- STD0013

- RFC 1035

- ftp.isi.edu/in-notes/iana/assignments/dns-parameters

- etc.

### Constants

Port

  Default DNS Port

UDPSize

  Default DNS UDP packet size

### Public Class Methods

new(config_info=nil) click to toggle source

Creates a new DNS resolver.

`config_info` can be:

nil

  Uses /etc/resolv.conf.

String

  Path to a file using /etc/resolv.conf's format.

Hash

  Must contain :nameserver, :search and :ndots keys.

:nameserver_port can be used to specify port number of nameserver address.

The value of :nameserver should be an address string or an array of address strings.

- :nameserver => '8.8.8.8'

- :nameserver => ['8.8.8.8', '8.8.4.4']

The value of :nameserver_port should be an array of pair of nameserver address and port number.

- :nameserver_port => [['8.8.8.8', 53], ['8.8.4.4', 53]]

Example:

    Resolv::DNS.new(:nameserver => ['210.251.121.21'],
                    :search => ['ruby-lang.org'],
                    :ndots => 1)

                   # File resolv.rb, line 333
    def initialize(config_info=nil)
      @mutex = Mutex.new
      @config = Config.new(config_info)
      @initialized = nil
    end

open(*args) click to toggle source

Creates a new DNS resolver. See ::new for argument details.

Yields the created DNS resolver to the block, if given, otherwise returns it.

                   # File resolv.rb, line 298
    def self.open(*args)
      dns = new(*args)
      return dns unless block_given?
      begin
        yield dns
      ensure
        dns.close
      end
    end

### Public Instance Methods

close() click to toggle source

Closes the DNS resolver.

                   # File resolv.rb, line 367
    def close
      @mutex.synchronize {
        if @initialized
          @initialized = false
        end
      }
    end

each_address(name) click to toggle source

Iterates over all IP addresses for `name` retrieved from the DNS resolver.

`name` can be a Resolv::DNS::Name or a String. Retrieved addresses will be a Resolv::IPv4 or Resolv::IPv6

                   # File resolv.rb, line 405
    def each_address(name)
      each_resource(name, Resource::IN::A) {|resource| yield resource.address}
      if use_ipv6?
        each_resource(name, Resource::IN::AAAA) {|resource| yield resource.address}
      end
    end

each_name(address) click to toggle source

Iterates over all hostnames for `address` retrieved from the DNS resolver.

`address` must be a Resolv::IPv4, Resolv::IPv6 or a String. Retrieved names will be Resolv::DNS::Name instances.

                   # File resolv.rb, line 452
    def each_name(address)
      case address
      when Name
        ptr = address
      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, Resource::IN::PTR) {|resource| yield resource.name}
    end

each_resource(name, typeclass, &proc) click to toggle source

Iterates over all `typeclass` DNS resources for `name`. See getresource for argument details.

                   # File resolv.rb, line 508
    def each_resource(name, typeclass, &proc)
      fetch_resource(name, typeclass) {|reply, reply_name|
        extract_resources(reply, reply_name, typeclass, &proc)
      }
    end

fetch_resource(name, typeclass) click to toggle source

                   # File resolv.rb, line 514
    def fetch_resource(name, typeclass)
      lazy_initialize
      requester = make_udp_requester
      senders = {}
      begin
        @config.resolv(name) {|candidate, tout, nameserver, port|
          msg = Message.new
          msg.rd = 1
          msg.add_question(candidate, typeclass)
          unless sender = senders[[candidate, nameserver, port]]
            sender = requester.sender(msg, candidate, nameserver, port)
            next if !sender
            senders[[candidate, nameserver, port]] = sender
          end
          reply, reply_name = requester.request(sender, tout)
          case reply.rcode
          when RCode::NoError
            if reply.tc == 1 and not Requester::TCP === requester
              requester.close
              # Retry via TCP:
              requester = make_tcp_requester(nameserver, port)
              senders = {}
              # This will use TCP for all remaining candidates (assuming the
              # current candidate does not already respond successfully via
              # TCP).  This makes sense because we already know the full
              # response will not fit in an untruncated UDP packet.
              redo
            else
              yield(reply, reply_name)
            end
            return
          when RCode::NXDomain
            raise Config::NXDomain.new(reply_name.to_s)
          else
            raise Config::OtherResolvError.new(reply_name.to_s)
          end
        }
      ensure
        requester.close
      end
    end

getaddress(name) click to toggle source

Gets the IP address of `name` from the DNS resolver.

`name` can be a Resolv::DNS::Name or a String. Retrieved address will be a Resolv::IPv4 or Resolv::IPv6

                   # File resolv.rb, line 381
    def getaddress(name)
      each_address(name) {|address| return address}
      raise ResolvError.new("DNS result has no information for #{name}")
    end

getaddresses(name) click to toggle source

Gets all IP addresses for `name` from the DNS resolver.

`name` can be a Resolv::DNS::Name or a String. Retrieved addresses will be a Resolv::IPv4 or Resolv::IPv6

                   # File resolv.rb, line 392
    def getaddresses(name)
      ret = []
      each_address(name) {|address| ret << address}
      return ret
    end

getname(address) click to toggle source

Gets the hostname for `address` from the DNS resolver.

`address` must be a Resolv::IPv4, Resolv::IPv6 or a String. Retrieved name will be a Resolv::DNS::Name.

                   # File resolv.rb, line 428
    def getname(address)
      each_name(address) {|name| return name}
      raise ResolvError.new("DNS result has no information for #{address}")
    end

getnames(address) click to toggle source

Gets all hostnames for `address` from the DNS resolver.

`address` must be a Resolv::IPv4, Resolv::IPv6 or a String. Retrieved names will be Resolv::DNS::Name instances.

                   # File resolv.rb, line 439
    def getnames(address)
      ret = []
      each_name(address) {|name| ret << name}
      return ret
    end

getresource(name, typeclass) click to toggle source

Look up the `typeclass` DNS resource of `name`.

`name` must be a Resolv::DNS::Name or a String.

`typeclass` should be one of the following:

- Resolv::DNS::Resource::IN::A

- Resolv::DNS::Resource::IN::AAAA

- Resolv::DNS::Resource::IN::ANY

- Resolv::DNS::Resource::IN::CNAME

- Resolv::DNS::Resource::IN::HINFO

- Resolv::DNS::Resource::IN::MINFO

- Resolv::DNS::Resource::IN::MX

- Resolv::DNS::Resource::IN::NS

- Resolv::DNS::Resource::IN::PTR

- Resolv::DNS::Resource::IN::SOA

- Resolv::DNS::Resource::IN::TXT

- Resolv::DNS::Resource::IN::WKS

Returned resource is represented as a Resolv::DNS::Resource instance, i.e. Resolv::DNS::Resource::IN::A.

                   # File resolv.rb, line 489
    def getresource(name, typeclass)
      each_resource(name, typeclass) {|resource| return resource}
      raise ResolvError.new("DNS result has no information for #{name}")
    end

getresources(name, typeclass) click to toggle source

Looks up all `typeclass` DNS resources for `name`. See getresource for argument details.

                   # File resolv.rb, line 498
    def getresources(name, typeclass)
      ret = []
      each_resource(name, typeclass) {|resource| ret << resource}
      return ret
    end

timeouts=(values) click to toggle source

Sets the resolver timeouts. This may be a single positive number or an array of positive numbers representing timeouts in seconds. If an array is specified, a DNS request will retry and wait for each successive interval in the array until a successful response is received. Specifying `nil` reverts to the default timeouts:

5, second = 5 * 2 / nameserver_count, 2 * second, 4 * second

  Example:

      dns.timeouts = 3

                   # File resolv.rb, line 350
    def timeouts=(values)
      @config.timeouts = values
    end