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
• #timeouts=(values) ⇒ Object
• #use_ipv6? ⇒ Boolean

Constructor Details

#initialize(config_info = nil) ⇒ Config

Returns a new instance of Config.

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

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

Class Method Details

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

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

def Config.default_config_hash(filename="/etc/resolv.conf")
  if File.exist? filename
    Config.parse_resolv_conf(filename)
  elsif defined?(Win32::Resolv)
    search, nameserver = Win32::Resolv.get_resolv_info
    config_hash = {}
    config_hash[:nameserver] = nameserver if nameserver
    config_hash[:search] = [search].flatten if search
    config_hash
  else
    {}
  end
end

.parse_resolv_conf(filename) ⇒ Object

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

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

Instance Method Details

#generate_candidates(name) ⇒ Object

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

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)})
    fname = Name.create("#{name}.")
    if !candidates.include?(fname)
      candidates << fname
    end
  end
  return candidates
end

#generate_timeouts ⇒ Object

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

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

#lazy_initialize ⇒ Object

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

def lazy_initialize
  @mutex.synchronize {
    unless @initialized
      @nameserver_port = []
      @use_ipv6 = nil
      @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
      if config_hash.include? :nameserver
        @nameserver_port = config_hash[:nameserver].map {|ns| [ns, Port] }
      end
      if config_hash.include? :nameserver_port
        @nameserver_port = config_hash[:nameserver_port].map {|ns, port| [ns, (port || Port)] }
      end
      if config_hash.include? :use_ipv6
        @use_ipv6 = config_hash[:use_ipv6]
      end
      @search = config_hash[:search] if config_hash.include? :search
      @ndots = config_hash[:ndots] if config_hash.include? :ndots
      @raise_timeout_errors = config_hash[:raise_timeout_errors]

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

      if !@nameserver_port.kind_of?(Array) ||
         @nameserver_port.any? {|ns_port|
            !(Array === ns_port) ||
            ns_port.length != 2
            !(String === ns_port[0]) ||
            !(Integer === ns_port[1])
         }
        raise ArgumentError.new("invalid nameserver config: #{@nameserver_port.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 1121

def nameserver_port
  @nameserver_port
end

#resolv(name) ⇒ Object

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

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

#single? ⇒ Boolean

Returns:

• (Boolean)

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

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

#timeouts=(values) ⇒ Object

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

def timeouts=(values)
  if values
    values = Array(values)
    values.each do |t|
      Numeric === t or raise ArgumentError, "#{t.inspect} is not numeric"
      t > 0.0 or raise ArgumentError, "timeout=#{t} must be positive"
    end
    @timeouts = values
  else
    @timeouts = nil
  end
end

#use_ipv6? ⇒ Boolean

Returns:

• (Boolean)

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

def use_ipv6?
  @use_ipv6
end