In Files

  • resolv.rb

Resolv::DNS

Resolv::DNS is a DNS stub resolver.

Information taken from the following places:

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 = senders[[candidate, nameserver, port]] =
          requester.sender(msg, candidate, nameserver, port)
      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:

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
            

Commenting is here to help enhance the documentation. For example, sample code, or clarification of the documentation.

If you are posting code samples in your comments, please wrap them in "<pre><code class="ruby" > ... </code></pre>" markup in order to get syntax highlighting.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file a bug report so that it can be corrected for the next release. Thank you.

blog comments powered by Disqus