Class: Resolv::DNS::Config

Inherits:

Object

• Object
• Resolv::DNS::Config

Defined in:

lib/resolv.rb

Overview

:nodoc:

Defined Under Namespace

Classes: NXDomain, OtherResolvError

Constant Summary

InitialTimeout =

5

Class Method Summary

• .default_config_hash(filename = "/etc/resolv.conf")) ⇒ Object
• .parse_resolv_conf(filename) ⇒ Object

Instance Method Summary

• #generate_candidates(name) ⇒ Object
• #generate_timeouts ⇒ Object
• #initialize(config_info = nil) ⇒ Config constructor

  A new instance of Config.

• #lazy_initialize ⇒ Object
• #nameserver_port ⇒ Object
• #resolv(name) ⇒ Object
• #single? ⇒ Boolean

Constructor Details

#initialize(config_info = nil) ⇒ Config

Returns a new instance of Config.

# File 'lib/resolv.rb', line 808

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

Class Method Details

.default_config_hash(filename = "/etc/resolv.conf")) ⇒ Object

# File 'lib/resolv.rb', line 848

def Config.default_config_hash(filename="/etc/resolv.conf")
  if File.exist? filename
    config_hash = Config.parse_resolv_conf(filename)
  else
    if /mswin32|cygwin|mingw|bccwin/ =~ RUBY_PLATFORM
      require 'win32/resolv'
      search, nameserver = Win32::Resolv.get_resolv_info
      config_hash = {}
      config_hash[:nameserver] = nameserver if nameserver
      config_hash[:search] = [search].flatten if search
    end
  end
  config_hash
end

.parse_resolv_conf(filename) ⇒ Object

# File 'lib/resolv.rb', line 814

def Config.parse_resolv_conf(filename)
  nameserver = []
  search = nil
  ndots = 1
  open(filename) {|f|
    f.each {|line|
      line.sub!(/[#;].*/, '')
      keyword, *args = line.split(/\s+/)
      args.each { |arg|
        arg.untaint
      }
      next unless keyword
      case keyword
      when 'nameserver'
        nameserver += args
      when 'domain'
        next if args.empty?
        search = [args[0]]
      when 'search'
        next if args.empty?
        search = args
      when 'options'
        args.each {|arg|
          case arg
          when /\Andots:(\d+)\z/
            ndots = $1.to_i
          end
        }
      end
    }
  }
  return { :nameserver => nameserver, :search => search, :ndots => ndots }
end

Instance Method Details

#generate_candidates(name) ⇒ Object

# File 'lib/resolv.rb', line 936

def generate_candidates(name)
  candidates = nil
  name = Name.create(name)
  if name.absolute?
    candidates = [name]
  else
    if @ndots <= name.length - 1
      candidates = [Name.new(name.to_a)]
    else
      candidates = []
    end
    candidates.concat(@search.map {|domain| Name.new(name.to_a + domain)})
  end
  return candidates
end

#generate_timeouts ⇒ Object

# File 'lib/resolv.rb', line 954

def generate_timeouts
  ts = [InitialTimeout]
  ts << ts[-1] * 2 / @nameserver.length
  ts << ts[-1] * 2
  ts << ts[-1] * 2
  return ts
end

#lazy_initialize ⇒ Object

# File 'lib/resolv.rb', line 863

def lazy_initialize
  @mutex.synchronize {
    unless @initialized
      @nameserver = []
      @search = nil
      @ndots = 1
      case @config_info
      when nil
        config_hash = Config.default_config_hash
      when String
        config_hash = Config.parse_resolv_conf(@config_info)
      when Hash
        config_hash = @config_info.dup
        if String === config_hash[:nameserver]
          config_hash[:nameserver] = [config_hash[:nameserver]]
        end
        if String === config_hash[:search]
          config_hash[:search] = [config_hash[:search]]
        end
      else
        raise ArgumentError.new("invalid resolv configuration: #{@config_info.inspect}")
      end
      @nameserver = config_hash[:nameserver] if config_hash.include? :nameserver
      @search = config_hash[:search] if config_hash.include? :search
      @ndots = config_hash[:ndots] if config_hash.include? :ndots

      @nameserver = ['0.0.0.0'] if @nameserver.empty?
      if @search
        @search = @search.map {|arg| Label.split(arg) }
      else
        hostname = Socket.gethostname
        if /\./ =~ hostname
          @search = [Label.split($')]
        else
          @search = [[]]
        end
      end

      if !@nameserver.kind_of?(Array) ||
         !@nameserver.all? {|ns| String === ns }
        raise ArgumentError.new("invalid nameserver config: #{@nameserver.inspect}")
      end

      if !@search.kind_of?(Array) ||
         !@search.all? {|ls| ls.all? {|l| Label::Str === l } }
        raise ArgumentError.new("invalid search config: #{@search.inspect}")
      end

      if !@ndots.kind_of?(Integer)
        raise ArgumentError.new("invalid ndots config: #{@ndots.inspect}")
      end

      @initialized = true
    end
  }
  self
end

#nameserver_port ⇒ Object

# File 'lib/resolv.rb', line 930

def nameserver_port
  lazy_initialize
  @nameserver_port ||= @nameserver.map {|i| [i, Port] }
  @nameserver_port
end

#resolv(name) ⇒ Object

# File 'lib/resolv.rb', line 962

def resolv(name)
  candidates = generate_candidates(name)
  timeouts = generate_timeouts
  begin
    candidates.each {|candidate|
      begin
        timeouts.each {|tout|
          @nameserver.each {|nameserver|
            begin
              yield candidate, tout, nameserver
            rescue ResolvTimeout
            end
          }
        }
        raise ResolvError.new("DNS resolv timeout: #{name}")
      rescue NXDomain
      end
    }
  rescue ResolvError
  end
end

#single? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/resolv.rb', line 921

def single?
  lazy_initialize
  if @nameserver.length == 1
    return @nameserver[0]
  else
    return nil
  end
end