# File lib/resolv.rb, line 386
386:     def initialize(config_info=nil)
387:       @mutex = Mutex.new
388:       @config = Config.new(config_info)
389:       @initialized = nil
390:     end

     # File lib/resolv.rb, line 376
376:     def self.open(*args)
377:       dns = new(*args)
378:       return dns unless block_given?
379:       begin
380:         yield dns
381:       ensure
382:         dns.close
383:       end
384:     end

     # File lib/resolv.rb, line 402
402:     def close
403:       @mutex.synchronize {
404:         if @initialized
405:           @initialized = false
406:         end
407:       }
408:     end

     # File lib/resolv.rb, line 421
421:     def each_address(name)
422:       each_resource(name, Resource::IN::A) {|resource| yield resource.address}
423:     end

     # File lib/resolv.rb, line 436
436:     def each_name(address)
437:       case address
438:       when Name
439:         ptr = address
440:       when IPv4::Regex
441:         ptr = IPv4.create(address).to_name
442:       when IPv6::Regex
443:         ptr = IPv6.create(address).to_name
444:       else
445:         raise ResolvError.new("cannot interpret as address: #{address}")
446:       end
447:       each_resource(ptr, Resource::IN::PTR) {|resource| yield resource.name}
448:     end

     # File lib/resolv.rb, line 461
461:     def each_resource(name, typeclass, &proc)
462:       lazy_initialize
463:       requester = make_requester
464:       senders = {}
465:       begin
466:         @config.resolv(name) {|candidate, tout, nameserver|
467:           msg = Message.new
468:           msg.rd = 1
469:           msg.add_question(candidate, typeclass)
470:           unless sender = senders[[candidate, nameserver]]
471:             sender = senders[[candidate, nameserver]] =
472:               requester.sender(msg, candidate, nameserver)
473:           end
474:           reply, reply_name = requester.request(sender, tout)
475:           case reply.rcode
476:           when RCode::NoError
477:             extract_resources(reply, reply_name, typeclass, &proc)
478:             return
479:           when RCode::NXDomain
480:             raise Config::NXDomain.new(reply_name.to_s)
481:           else
482:             raise Config::OtherResolvError.new(reply_name.to_s)
483:           end
484:         }
485:       ensure
486:         requester.close
487:       end
488:     end

     # File lib/resolv.rb, line 498
498:     def extract_resources(msg, name, typeclass)
499:       if typeclass < Resource::ANY
500:         n0 = Name.create(name)
501:         msg.each_answer {|n, ttl, data|
502:           yield data if n0 == n
503:         }
504:       end
505:       yielded = false
506:       n0 = Name.create(name)
507:       msg.each_answer {|n, ttl, data|
508:         if n0 == n
509:           case data
510:           when typeclass
511:             yield data
512:             yielded = true
513:           when Resource::CNAME
514:             n0 = data.name
515:           end
516:         end
517:       }
518:       return if yielded
519:       msg.each_answer {|n, ttl, data|
520:         if n0 == n
521:           case data
522:           when typeclass
523:             yield data
524:           end
525:         end
526:       }
527:     end

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

     # File lib/resolv.rb, line 415
415:     def getaddresses(name)
416:       ret = []
417:       each_address(name) {|address| ret << address}
418:       return ret
419:     end

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

     # File lib/resolv.rb, line 430
430:     def getnames(address)
431:       ret = []
432:       each_name(address) {|name| ret << name}
433:       return ret
434:     end

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

     # File lib/resolv.rb, line 455
455:     def getresources(name, typeclass)
456:       ret = []
457:       each_resource(name, typeclass) {|resource| ret << resource}
458:       return ret
459:     end

     # File lib/resolv.rb, line 392
392:     def lazy_initialize
393:       @mutex.synchronize {
394:         unless @initialized
395:           @config.lazy_initialize
396:           @initialized = true
397:         end
398:       }
399:       self
400:     end