class Resolv::DNS

Resolv::DNS ist ein DNS Stub-Resolver.

Informationen aus folgenden Quellen entnommen

STD0013
RFC 1035
ftp.isi.edu/in-notes/iana/assignments/dns-parameters
etc.

Constants

Port: Standard DNS Port
UDPSize: Standard DNS UDP-Paketgröße

Öffentliche Klassenmethoden

Source

# File lib/resolv.rb, line 338
def initialize(config_info=nil)
  @mutex = Thread::Mutex.new
  @config = Config.new(config_info)
  @initialized = nil
end

Erstellt einen neuen DNS Resolver.

config_info kann sein

nil: Verwendet /etc/resolv.conf.
String: Pfad zu einer Datei im Format von /etc/resolv.conf.
Hash: Muss die Schlüssel :nameserver, :search und :ndots enthalten.

:nameserver_port kann verwendet werden, um die Portnummer der Nameserver-Adresse anzugeben. :raise_timeout_errors kann verwendet werden, um Timeout-Fehler als Ausnahmen auszulösen, anstatt sie wie eine NXDOMAIN-Antwort zu behandeln.

Der Wert von :nameserver sollte ein Adressstring oder ein Array von Adressstrings sein.

:nameserver => ‘8.8.8.8’
:nameserver => [‘8.8.8.8’, ‘8.8.4.4’]

Der Wert von :nameserver_port sollte ein Array von Paaren aus Nameserver-Adresse und Portnummer sein.

:nameserver_port => [[‘8.8.8.8’, 53], [‘8.8.4.4’, 53]]

Beispiel

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

open (*args) { |dns| ... }

Source

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

Erstellt einen neuen DNS Resolver. Siehe Resolv::DNS.new für Argumentdetails.

Gibt den erstellten DNS Resolver an den Block weiter, falls vorhanden, andernfalls gibt er ihn zurück.

Öffentliche Instanzmethoden

close ()

Source

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

Schließt den DNS Resolver.

each_address (name) { |address| ... }

Source

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

Iteriert über alle IP-Adressen für name, die vom DNS Resolver abgerufen wurden.

name kann ein Resolv::DNS::Name oder ein String sein. Abgerufene Adressen sind ein Resolv::IPv4 oder Resolv::IPv6

each_name (address) { |name| ... }

Source

# File lib/resolv.rb, line 464
def each_name(address)
  case address
  when Name
    ptr = address
  when IPv4, IPv6
    ptr = address.to_name
  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

Iteriert über alle Hostnamen für address, die vom DNS Resolver abgerufen wurden.

address muss ein Resolv::IPv4, Resolv::IPv6 oder ein String sein. Abgerufene Namen sind Resolv::DNS::Name-Instanzen.

each_resource (name, typeclass, &proc)

Source

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

Iteriert über alle typeclass DNS Ressourcen für name. Siehe getresource für Argumentdetails.

getaddress (name)

Source

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

Ruft die IP-Adresse von name vom DNS Resolver ab.

name kann ein Resolv::DNS::Name oder ein String sein. Abgerufene Adresse ist ein Resolv::IPv4 oder Resolv::IPv6

getaddresses (name)

Source

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

Ruft alle IP-Adressen für name vom DNS Resolver ab.

name kann ein Resolv::DNS::Name oder ein String sein. Abgerufene Adressen sind ein Resolv::IPv4 oder Resolv::IPv6

getname (address)

Source

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

Ruft den Hostnamen für address vom DNS Resolver ab.

address muss ein Resolv::IPv4, Resolv::IPv6 oder ein String sein. Abgerufener Name ist ein Resolv::DNS::Name.

getnames (address)

Source

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

Ruft alle Hostnamen für address vom DNS Resolver ab.

address muss ein Resolv::IPv4, Resolv::IPv6 oder ein String sein. Abgerufene Namen sind Resolv::DNS::Name-Instanzen.

getresource (name, typeclass)

Source

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

Sucht die typeclass DNS Ressource von name.

name muss ein Resolv::DNS::Name oder ein String sein.

typeclass sollte einer der folgenden sein

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

Die zurückgegebene Ressource wird als Resolv::DNS::Resource-Instanz dargestellt, d. h. Resolv::DNS::Resource::IN::A.

getresources (name, typeclass)

Source

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

Sucht alle typeclass DNS Ressourcen für name. Siehe getresource für Argumentdetails.

timeouts= (values)

Source

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

Legt die Resolver-Timeouts fest. Dies kann eine einzelne positive Zahl oder ein Array von positiven Zahlen sein, die Timeouts in Sekunden darstellen. Wenn ein Array angegeben wird, versucht eine DNS-Anfrage und wartet auf jedes aufeinanderfolgende Intervall im Array, bis eine erfolgreiche Antwort empfangen wird. Die Angabe von nil setzt die Standard-Timeouts zurück.

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

Beispiel

dns.timeouts = 3