Class: Resolv::DNS

Inherits:
Object
  • Object
show all
Defined in:
lib/rubysl/resolv/resolv.rb

Overview

Resolv::DNS is a DNS stub resolver.

Information taken from the following places:

Defined Under Namespace

Modules: Label, OpCode, RCode Classes: Config, DecodeError, EncodeError, Message, Name, Query, Requester, Resource

Constant Summary collapse

Port =

Default DNS Port

53
UDPSize =

Default DNS UDP packet size

512
DNSThreadGroup =

Group of DNS resolver threads (obsolete)

ThreadGroup.new
RequestID = 
{}
RequestIDMutex = 
Mutex.new

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config_info = nil) ⇒ DNS

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)



328
329
330
331
332
 
# File 'lib/rubysl/resolv/resolv.rb', line 328

def initialize(config_info=nil)
  @mutex = Mutex.new
  @config = Config.new(config_info)
  @initialized = nil
end

Class Method Details

.allocate_request_id(host, port) ⇒ Object

:nodoc:



571
572
573
574
575
576
577
578
579
580
581
 
# File 'lib/rubysl/resolv/resolv.rb', line 571

def self.allocate_request_id(host, port) # :nodoc:
  id = nil
  RequestIDMutex.synchronize {
    h = (RequestID[[host, port]] ||= {})
    begin
      id = rangerand(0x0000..0xffff)
    end while h[id] 
    h[id] = true
  }
  id
end

.bind_random_port(udpsock) ⇒ Object

:nodoc:



595
596
597
598
599
600
601
602
 
# File 'lib/rubysl/resolv/resolv.rb', line 595

def self.bind_random_port(udpsock) # :nodoc:
  begin
    port = rangerand(1024..65535)
    udpsock.bind("", port)
  rescue Errno::EADDRINUSE
    retry
  end
end

.free_request_id(host, port, id) ⇒ Object

:nodoc:



583
584
585
586
587
588
589
590
591
592
593
 
# File 'lib/rubysl/resolv/resolv.rb', line 583

def self.free_request_id(host, port, id) # :nodoc:
  RequestIDMutex.synchronize {
    key = [host, port]
    if h = RequestID[key]
      h.delete id
      if h.empty?
        RequestID.delete key
      end
    end
  }
end

.open(*args) ⇒ Object

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.



303
304
305
306
307
308
309
310
311
 
# File 'lib/rubysl/resolv/resolv.rb', line 303

def self.open(*args)
  dns = new(*args)
  return dns unless block_given?
  begin
    yield dns
  ensure
    dns.close
  end
end

.random(arg) ⇒ Object

:nodoc:



545
546
547
548
549
550
551
 
# File 'lib/rubysl/resolv/resolv.rb', line 545

def self.random(arg) # :nodoc:
  begin
    SecureRandom.random_number(arg)
  rescue NotImplementedError
    rand(arg)
  end
end

.rangerand(range) ⇒ Object

:nodoc:



559
560
561
562
563
564
565
566
 
# File 'lib/rubysl/resolv/resolv.rb', line 559

def self.rangerand(range) # :nodoc:
  base = range.begin
  len = range.end - range.begin
  if !range.exclude_end?
    len += 1
  end
  base + random(len)
end

Instance Method Details

#close ⇒ Object

Closes the DNS resolver.



347
348
349
350
351
352
353
 
# File 'lib/rubysl/resolv/resolv.rb', line 347

def close
  @mutex.synchronize {
    if @initialized
      @initialized = false
    end
  }
end

#each_address(name) ⇒ Object

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



385
386
387
388
 
# File 'lib/rubysl/resolv/resolv.rb', line 385

def each_address(name)
  each_resource(name, Resource::IN::A) {|resource| yield resource.address}
  each_resource(name, Resource::IN::AAAA) {|resource| yield resource.address}
end

#each_name(address) ⇒ Object

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.



420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'lib/rubysl/resolv/resolv.rb', line 420

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) ⇒ Object

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



476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
 
# File 'lib/rubysl/resolv/resolv.rb', line 476

def each_resource(name, typeclass, &proc)
  lazy_initialize
  requester = make_requester
  senders = {}
  begin
    @config.resolv(name) {|candidate, tout, nameserver|
      msg = Message.new
      msg.rd = 1
      msg.add_question(candidate, typeclass)
      unless sender = senders[[candidate, nameserver]]
        sender = senders[[candidate, nameserver]] =
          requester.sender(msg, candidate, nameserver)
      end
      reply, reply_name = requester.request(sender, tout)
      case reply.rcode
      when RCode::NoError
        extract_resources(reply, reply_name, typeclass, &proc)
        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

#extract_resources(msg, name, typeclass) ⇒ Object

:nodoc:



513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
 
# File 'lib/rubysl/resolv/resolv.rb', line 513

def extract_resources(msg, name, typeclass) # :nodoc:
  if typeclass < Resource::ANY
    n0 = Name.create(name)
    msg.each_answer {|n, ttl, data|
      yield data if n0 == n
    }
  end
  yielded = false
  n0 = Name.create(name)
  msg.each_answer {|n, ttl, data|
    if n0 == n
      case data
      when typeclass
        yield data
        yielded = true
      when Resource::CNAME
        n0 = data.name
      end
    end
  }
  return if yielded
  msg.each_answer {|n, ttl, data|
    if n0 == n
      case data
      when typeclass
        yield data
      end
    end
  }
end

#getaddress(name) ⇒ Object

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

Raises:



361
362
363
364
 
# File 'lib/rubysl/resolv/resolv.rb', line 361

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

#getaddresses(name) ⇒ Object

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



372
373
374
375
376
 
# File 'lib/rubysl/resolv/resolv.rb', line 372

def getaddresses(name)
  ret = []
  each_address(name) {|address| ret << address}
  return ret
end

#getname(address) ⇒ Object

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.

Raises:



396
397
398
399
 
# File 'lib/rubysl/resolv/resolv.rb', line 396

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

#getnames(address) ⇒ Object

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.



407
408
409
410
411
 
# File 'lib/rubysl/resolv/resolv.rb', line 407

def getnames(address)
  ret = []
  each_name(address) {|name| ret << name}
  return ret
end

#getresource(name, typeclass) ⇒ Object

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.

Raises:



457
458
459
460
 
# File 'lib/rubysl/resolv/resolv.rb', line 457

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) ⇒ Object

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



466
467
468
469
470
 
# File 'lib/rubysl/resolv/resolv.rb', line 466

def getresources(name, typeclass)
  ret = []
  each_resource(name, typeclass) {|resource| ret << resource}
  return ret
end

#lazy_initialize ⇒ Object

:nodoc:



334
335
336
337
338
339
340
341
342
 
# File 'lib/rubysl/resolv/resolv.rb', line 334

def lazy_initialize # :nodoc:
  @mutex.synchronize {
    unless @initialized
      @config.lazy_initialize
      @initialized = true
    end
  }
  self
end

#make_requester ⇒ Object

:nodoc:



505
506
507
508
509
510
511
 
# File 'lib/rubysl/resolv/resolv.rb', line 505

def make_requester # :nodoc:
  if nameserver = @config.single?
    Requester::ConnectedUDP.new(nameserver)
  else
    Requester::UnconnectedUDP.new
  end
end