# File lib/resolv.rb, line 757
757:       def Config.default_config_hash(filename="/etc/resolv.conf")
758:         if File.exist? filename
759:           config_hash = Config.parse_resolv_conf(filename)
760:         else
761:           if /mswin32|cygwin|mingw|bccwin/ =~ RUBY_PLATFORM
762:             search, nameserver = Win32::Resolv.get_resolv_info
763:             config_hash = {}
764:             config_hash[:nameserver] = nameserver if nameserver
765:             config_hash[:search] = [search].flatten if search
766:           end
767:         end
768:         config_hash
769:       end

     # File lib/resolv.rb, line 717
717:       def initialize(config_info=nil)
718:         @mutex = Mutex.new
719:         @config_info = config_info
720:         @initialized = nil
721:       end

     # File lib/resolv.rb, line 723
723:       def Config.parse_resolv_conf(filename)
724:         nameserver = []
725:         search = nil
726:         ndots = 1
727:         open(filename) {|f|
728:           f.each {|line|
729:             line.sub!(/[#;].*/, '')
730:             keyword, *args = line.split(/\s+/)
731:             args.each { |arg|
732:               arg.untaint
733:             }
734:             next unless keyword
735:             case keyword
736:             when 'nameserver'
737:               nameserver += args
738:             when 'domain'
739:               next if args.empty?
740:               search = [args[0]]
741:             when 'search'
742:               next if args.empty?
743:               search = args
744:             when 'options'
745:               args.each {|arg|
746:                 case arg
747:                 when /\Andots:(\d+)\z/
748:                   ndots = $1.to_i
749:                 end
750:               }
751:             end
752:           }
753:         }
754:         return { :nameserver => nameserver, :search => search, :ndots => ndots }
755:       end

     # File lib/resolv.rb, line 838
838:       def generate_candidates(name)
839:         candidates = nil
840:         name = Name.create(name)
841:         if name.absolute?
842:           candidates = [name]
843:         else
844:           if @ndots <= name.length - 1
845:             candidates = [Name.new(name.to_a)]
846:           else
847:             candidates = []
848:           end
849:           candidates.concat(@search.map {|domain| Name.new(name.to_a + domain)})
850:         end
851:         return candidates
852:       end

     # File lib/resolv.rb, line 856
856:       def generate_timeouts
857:         ts = [InitialTimeout]
858:         ts << ts[-1] * 2 / @nameserver.length
859:         ts << ts[-1] * 2
860:         ts << ts[-1] * 2
861:         return ts
862:       end

     # File lib/resolv.rb, line 771
771:       def lazy_initialize
772:         @mutex.synchronize {
773:           unless @initialized
774:             @nameserver = []
775:             @search = nil
776:             @ndots = 1
777:             case @config_info
778:             when nil
779:               config_hash = Config.default_config_hash
780:             when String
781:               config_hash = Config.parse_resolv_conf(@config_info)
782:             when Hash
783:               config_hash = @config_info.dup
784:               if String === config_hash[:nameserver]
785:                 config_hash[:nameserver] = [config_hash[:nameserver]]
786:               end
787:               if String === config_hash[:search]
788:                 config_hash[:search] = [config_hash[:search]]
789:               end
790:             else
791:               raise ArgumentError.new("invalid resolv configuration: #{@config_info.inspect}")
792:             end
793:             @nameserver = config_hash[:nameserver] if config_hash.include? :nameserver
794:             @search = config_hash[:search] if config_hash.include? :search
795:             @ndots = config_hash[:ndots] if config_hash.include? :ndots
796: 
797:             @nameserver = ['0.0.0.0'] if @nameserver.empty?
798:             if @search
799:               @search = @search.map {|arg| Label.split(arg) }
800:             else
801:               hostname = Socket.gethostname
802:               if /\./ =~ hostname
803:                 @search = [Label.split($')]
804:               else
805:                 @search = [[]]
806:               end
807:             end
808: 
809:             if !@nameserver.kind_of?(Array) ||
810:                !@nameserver.all? {|ns| String === ns }
811:               raise ArgumentError.new("invalid nameserver config: #{@nameserver.inspect}")
812:             end
813: 
814:             if !@search.kind_of?(Array) ||
815:                !@search.all? {|ls| ls.all? {|l| Label::Str === l } }
816:               raise ArgumentError.new("invalid search config: #{@search.inspect}")
817:             end
818: 
819:             if !@ndots.kind_of?(Integer)
820:               raise ArgumentError.new("invalid ndots config: #{@ndots.inspect}")
821:             end
822: 
823:             @initialized = true
824:           end
825:         }
826:         self
827:       end

     # File lib/resolv.rb, line 864
864:       def resolv(name)
865:         candidates = generate_candidates(name)
866:         timeouts = generate_timeouts
867:         begin
868:           candidates.each {|candidate|
869:             begin
870:               timeouts.each {|tout|
871:                 @nameserver.each {|nameserver|
872:                   begin
873:                     yield candidate, tout, nameserver
874:                   rescue ResolvTimeout
875:                   end
876:                 }
877:               }
878:               raise ResolvError.new("DNS resolv timeout: #{name}")
879:             rescue NXDomain
880:             end
881:           }
882:         rescue ResolvError
883:         end
884:       end

     # File lib/resolv.rb, line 829
829:       def single?
830:         lazy_initialize
831:         if @nameserver.length == 1
832:           return @nameserver[0]
833:         else
834:           return nil
835:         end
836:       end