Class Resolv::DNS
In: lib/resolv.rb
Parent: Object

Resolv::DNS is a DNS stub resolver.

Information taken from the following places:

Methods

Classes and Modules

Class Resolv::DNS::DecodeError
Class Resolv::DNS::EncodeError
Class Resolv::DNS::Name
Class Resolv::DNS::Query
Class Resolv::DNS::Resource

Constants

Port = 53   Default DNS Port
UDPSize = 512   Default DNS UDP packet size
DNSThreadGroup = ThreadGroup.new   Group of DNS resolver threads (obsolete)
RequestID = {}
RequestIDMutex = Mutex.new

Public Class methods

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.

Example:

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

[Source]

     # File lib/resolv.rb, line 328
328:     def initialize(config_info=nil)
329:       @mutex = Mutex.new
330:       @config = Config.new(config_info)
331:       @initialized = nil
332:     end

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

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

[Source]

     # File lib/resolv.rb, line 303
303:     def self.open(*args)
304:       dns = new(*args)
305:       return dns unless block_given?
306:       begin
307:         yield dns
308:       ensure
309:         dns.close
310:       end
311:     end

Public Instance methods

Closes the DNS resolver.

[Source]

     # File lib/resolv.rb, line 347
347:     def close
348:       @mutex.synchronize {
349:         if @initialized
350:           @initialized = false
351:         end
352:       }
353:     end

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

[Source]

     # File lib/resolv.rb, line 385
385:     def each_address(name)
386:       each_resource(name, Resource::IN::A) {|resource| yield resource.address}
387:       each_resource(name, Resource::IN::AAAA) {|resource| yield resource.address}
388:     end

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.

[Source]

     # File lib/resolv.rb, line 420
420:     def each_name(address)
421:       case address
422:       when Name
423:         ptr = address
424:       when IPv4::Regex
425:         ptr = IPv4.create(address).to_name
426:       when IPv6::Regex
427:         ptr = IPv6.create(address).to_name
428:       else
429:         raise ResolvError.new("cannot interpret as address: #{address}")
430:       end
431:       each_resource(ptr, Resource::IN::PTR) {|resource| yield resource.name}
432:     end

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

[Source]

     # File lib/resolv.rb, line 476
476:     def each_resource(name, typeclass, &proc)
477:       lazy_initialize
478:       requester = make_requester
479:       senders = {}
480:       begin
481:         @config.resolv(name) {|candidate, tout, nameserver|
482:           msg = Message.new
483:           msg.rd = 1
484:           msg.add_question(candidate, typeclass)
485:           unless sender = senders[[candidate, nameserver]]
486:             sender = senders[[candidate, nameserver]] =
487:               requester.sender(msg, candidate, nameserver)
488:           end
489:           reply, reply_name = requester.request(sender, tout)
490:           case reply.rcode
491:           when RCode::NoError
492:             extract_resources(reply, reply_name, typeclass, &proc)
493:             return
494:           when RCode::NXDomain
495:             raise Config::NXDomain.new(reply_name.to_s)
496:           else
497:             raise Config::OtherResolvError.new(reply_name.to_s)
498:           end
499:         }
500:       ensure
501:         requester.close
502:       end
503:     end

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

[Source]

     # File lib/resolv.rb, line 361
361:     def getaddress(name)
362:       each_address(name) {|address| return address}
363:       raise ResolvError.new("DNS result has no information for #{name}")
364:     end

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

[Source]

     # File lib/resolv.rb, line 372
372:     def getaddresses(name)
373:       ret = []
374:       each_address(name) {|address| ret << address}
375:       return ret
376:     end

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.

[Source]

     # File lib/resolv.rb, line 396
396:     def getname(address)
397:       each_name(address) {|name| return name}
398:       raise ResolvError.new("DNS result has no information for #{address}")
399:     end

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.

[Source]

     # File lib/resolv.rb, line 407
407:     def getnames(address)
408:       ret = []
409:       each_name(address) {|name| ret << name}
410:       return ret
411:     end

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.

[Source]

     # File lib/resolv.rb, line 457
457:     def getresource(name, typeclass)
458:       each_resource(name, typeclass) {|resource| return resource}
459:       raise ResolvError.new("DNS result has no information for #{name}")
460:     end

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

[Source]

     # File lib/resolv.rb, line 466
466:     def getresources(name, typeclass)
467:       ret = []
468:       each_resource(name, typeclass) {|resource| ret << resource}
469:       return ret
470:     end

[Validate]