# File lib/resolv.rb, line 802
802:       def Config.default_config_hash(filename="/etc/resolv.conf")
803:         if File.exist? filename
804:           config_hash = Config.parse_resolv_conf(filename)
805:         else
806:           if /mswin32|cygwin|mingw|bccwin/ =~ RUBY_PLATFORM
807:             require 'win32/resolv'
808:             search, nameserver = Win32::Resolv.get_resolv_info
809:             config_hash = {}
810:             config_hash[:nameserver] = nameserver if nameserver
811:             config_hash[:search] = [search].flatten if search
812:           end
813:         end
814:         config_hash
815:       end

     # File lib/resolv.rb, line 762
762:       def initialize(config_info=nil)
763:         @mutex = Mutex.new
764:         @config_info = config_info
765:         @initialized = nil
766:       end

     # File lib/resolv.rb, line 768
768:       def Config.parse_resolv_conf(filename)
769:         nameserver = []
770:         search = nil
771:         ndots = 1
772:         open(filename) {|f|
773:           f.each {|line|
774:             line.sub!(/[#;].*/, '')
775:             keyword, *args = line.split(/\s+/)
776:             args.each { |arg|
777:               arg.untaint
778:             }
779:             next unless keyword
780:             case keyword
781:             when 'nameserver'
782:               nameserver += args
783:             when 'domain'
784:               next if args.empty?
785:               search = [args[0]]
786:             when 'search'
787:               next if args.empty?
788:               search = args
789:             when 'options'
790:               args.each {|arg|
791:                 case arg
792:                 when /\Andots:(\d+)\z/
793:                   ndots = $1.to_i
794:                 end
795:               }
796:             end
797:           }
798:         }
799:         return { :nameserver => nameserver, :search => search, :ndots => ndots }
800:       end

     # File lib/resolv.rb, line 884
884:       def generate_candidates(name)
885:         candidates = nil
886:         name = Name.create(name)
887:         if name.absolute?
888:           candidates = [name]
889:         else
890:           if @ndots <= name.length - 1
891:             candidates = [Name.new(name.to_a)]
892:           else
893:             candidates = []
894:           end
895:           candidates.concat(@search.map {|domain| Name.new(name.to_a + domain)})
896:         end
897:         return candidates
898:       end

     # File lib/resolv.rb, line 902
902:       def generate_timeouts
903:         ts = [InitialTimeout]
904:         ts << ts[-1] * 2 / @nameserver.length
905:         ts << ts[-1] * 2
906:         ts << ts[-1] * 2
907:         return ts
908:       end

     # File lib/resolv.rb, line 817
817:       def lazy_initialize
818:         @mutex.synchronize {
819:           unless @initialized
820:             @nameserver = []
821:             @search = nil
822:             @ndots = 1
823:             case @config_info
824:             when nil
825:               config_hash = Config.default_config_hash
826:             when String
827:               config_hash = Config.parse_resolv_conf(@config_info)
828:             when Hash
829:               config_hash = @config_info.dup
830:               if String === config_hash[:nameserver]
831:                 config_hash[:nameserver] = [config_hash[:nameserver]]
832:               end
833:               if String === config_hash[:search]
834:                 config_hash[:search] = [config_hash[:search]]
835:               end
836:             else
837:               raise ArgumentError.new("invalid resolv configuration: #{@config_info.inspect}")
838:             end
839:             @nameserver = config_hash[:nameserver] if config_hash.include? :nameserver
840:             @search = config_hash[:search] if config_hash.include? :search
841:             @ndots = config_hash[:ndots] if config_hash.include? :ndots
842: 
843:             @nameserver = ['0.0.0.0'] if @nameserver.empty?
844:             if @search
845:               @search = @search.map {|arg| Label.split(arg) }
846:             else
847:               hostname = Socket.gethostname
848:               if /\./ =~ hostname
849:                 @search = [Label.split($')]
850:               else
851:                 @search = [[]]
852:               end
853:             end
854: 
855:             if !@nameserver.kind_of?(Array) ||
856:                !@nameserver.all? {|ns| String === ns }
857:               raise ArgumentError.new("invalid nameserver config: #{@nameserver.inspect}")
858:             end
859: 
860:             if !@search.kind_of?(Array) ||
861:                !@search.all? {|ls| ls.all? {|l| Label::Str === l } }
862:               raise ArgumentError.new("invalid search config: #{@search.inspect}")
863:             end
864: 
865:             if !@ndots.kind_of?(Integer)
866:               raise ArgumentError.new("invalid ndots config: #{@ndots.inspect}")
867:             end
868: 
869:             @initialized = true
870:           end
871:         }
872:         self
873:       end

     # File lib/resolv.rb, line 910
910:       def resolv(name)
911:         candidates = generate_candidates(name)
912:         timeouts = generate_timeouts
913:         begin
914:           candidates.each {|candidate|
915:             begin
916:               timeouts.each {|tout|
917:                 @nameserver.each {|nameserver|
918:                   begin
919:                     yield candidate, tout, nameserver
920:                   rescue ResolvTimeout
921:                   end
922:                 }
923:               }
924:               raise ResolvError.new("DNS resolv timeout: #{name}")
925:             rescue NXDomain
926:             end
927:           }
928:         rescue ResolvError
929:         end
930:       end

     # File lib/resolv.rb, line 875
875:       def single?
876:         lazy_initialize
877:         if @nameserver.length == 1
878:           return @nameserver[0]
879:         else
880:           return nil
881:         end
882:       end