Class: ReDNS::Resolver

Inherits:
Object
  • Object
show all
Defined in:
lib/redns/resolver.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = { }) {|_self| ... } ⇒ Resolver

Instance Methods =====================================================

Yields:

  • (_self)

Yield Parameters:



48
49
50
51
52
53
54
55
56
 
# File 'lib/redns/resolver.rb', line 48

def initialize(options = { }, &block)
  @servers = self.class.servers.dup
  @responses = { }
  
  @socket = UDPSocket.new
  ReDNS::Support.io_set_nonblock(@socket)
  
  yield(self) if (block)
end

Class Method Details

.in_resolv_conf ⇒ Object

Class Methods ========================================================



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/redns/resolver.rb', line 14

def self.in_resolv_conf
  list = [ ]
  
  File.open("/etc/resolv.conf") do |fh|
    list = fh.readlines.collect { |l| l.chomp }.collect { |l| l.sub(/#.*/, '') }
    
    list.reject!{ |l| !l.sub!(/^\s*nameserver\s+/, '') }
  end
  
  list

rescue Errno::ENOENT
  # /etc/resolv.conf may not be present on misconfigured or offline systems
  [ ]
end

.servers ⇒ Object 



30
31
32
 
# File 'lib/redns/resolver.rb', line 30

def self.servers
  @servers ||= in_resolv_conf
end

.servers=(list) ⇒ Object 



34
35
36
 
# File 'lib/redns/resolver.rb', line 34

def self.servers=(list)
  @servers = list
end

.timeout ⇒ Object 



38
39
40
 
# File 'lib/redns/resolver.rb', line 38

def self.timeout
  @timeout
end

.timeout=(secs) ⇒ Object 



42
43
44
 
# File 'lib/redns/resolver.rb', line 42

def self.timeout=(secs)
  @timeout = secs
end

Instance Method Details

#a_for(name) ⇒ Object 



94
95
96
 
# File 'lib/redns/resolver.rb', line 94

def a_for(name)
  simple_query(:a, name)
end

#bulk_query(type, names) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/redns/resolver.rb', line 67

def bulk_query(type, names)
  results = { }
  ids = [ ]
  
  message ||= ReDNS::Message.new
  q = (message.questions[0] ||= ReDNS::Question.new)
  q.qtype = type
  
  names.each do |name|
    q.name = name.to_s
    message.increment_id!
    ids.push(message.id)
    
    send_message(message)
  end
  
  wait_for_responses do |response, addr|
    results[response.questions[0].name.to_s] = response

    ids.delete(response.id)
      
    return results if (ids.empty?)
  end
  
  results
end

#mx_for(name) ⇒ Object 



106
107
108
 
# File 'lib/redns/resolver.rb', line 106

def mx_for(name)
  simple_query(:mx, name)
end

#ns_for(name) ⇒ Object 



98
99
100
101
102
103
104
 
# File 'lib/redns/resolver.rb', line 98

def ns_for(name)
  if (name.match(/^(\d+\.\d+\.\d+)\.\d+$/))
    return simple_query(:ns, ReDNS::Support.addr_to_arpa($1))
  end
  
  simple_query(:ns, name)
end

#ptr_for(name) ⇒ Object 



110
111
112
 
# File 'lib/redns/resolver.rb', line 110

def ptr_for(name)
  simple_query(:ptr, ReDNS::Support.addr_to_arpa(name))
end

#ptr_for_list(name) ⇒ Object 



114
115
116
117
118
 
# File 'lib/redns/resolver.rb', line 114

def ptr_for_list(name)
  ips = [ ips ].flatten
  
  bulk_query(:ptr, ips.collect { |ip| ReDNS::Support.addr_to_arpa(ip) })
end

#query(message = nil, server = nil, async = false) {|| ... } ⇒ Object

Yields:

  • () 


157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/redns/resolver.rb', line 157

def query(message = nil, server = nil, async = false, &block)
  # FUTURE: Fix the duplication here and in query_async

  message ||= ReDNS::Message.new
  message.questions[0] ||= ReDNS::Question.new
  
  yield(message.questions[0]) if (block)
  
  send_message(message, server)
  
  unless (async)
    wait_for_responses do |r, addr|
      return r if (r.id == message.id)
    end
  end
end

#random_server ⇒ Object 



149
150
151
 
# File 'lib/redns/resolver.rb', line 149

def random_server
  @servers[rand(@servers.length)]
end

#response_for(id) ⇒ Object 



174
175
176
 
# File 'lib/redns/resolver.rb', line 174

def response_for(id)
  @responses[id]
end

#responses ⇒ Object 



178
179
180
 
# File 'lib/redns/resolver.rb', line 178

def responses
  @responses
end

#reverse_addresses(ips) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/redns/resolver.rb', line 124

def reverse_addresses(ips)
  map = ips.inject({ }) do |h, ip|
    h[ReDNS::Support.addr_to_arpa(ip)] = ip
    h
  end
  
  list = bulk_query(:ptr, map.keys)
  
  list.values.inject({ }) do |h, r|
    if (ip = map[r.questions[0].name.to_s])
      h[ip] = (r.answers[0] and r.answers[0].rdata.to_s)
    end
    
    h
  end
end

#send_message(message, server = nil) ⇒ Object 



153
154
155
 
# File 'lib/redns/resolver.rb', line 153

def send_message(message, server = nil)
  @socket.send(message.serialize.to_s, 0, (server or random_server), 53)
end

#servers ⇒ Object 



141
142
143
 
# File 'lib/redns/resolver.rb', line 141

def servers
  @servers
end

#servers=(list) ⇒ Object 



145
146
147
 
# File 'lib/redns/resolver.rb', line 145

def servers=(list)
  @servers = list
end

#simple_query(type, name) ⇒ Object 



58
59
60
61
62
63
64
65
 
# File 'lib/redns/resolver.rb', line 58

def simple_query(type, name)
  r = query do |q|
    q.qtype = type
    q.name = name.to_s
  end
  
  expand_answers(r)
end

#soa_for(name) ⇒ Object 



120
121
122
 
# File 'lib/redns/resolver.rb', line 120

def soa_for(name)
  simple_query(:soa, name)
end

#timeout ⇒ Object 



182
183
184
 
# File 'lib/redns/resolver.rb', line 182

def timeout
  @timeout or self.class.timeout
end

#timeout=(secs) ⇒ Object 



186
187
188
 
# File 'lib/redns/resolver.rb', line 186

def timeout=(secs)
  @timeout = secs
end

#wait(_timeout = nil, &block) ⇒ Object 



190
191
192
 
# File 'lib/redns/resolver.rb', line 190

def wait(_timeout = nil, &block)
  wait_for_response(nil, _timeout, &block)
end

#wait_for_responses(_timeout = nil, &block) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/redns/resolver.rb', line 194

def wait_for_responses(_timeout = nil, &block)
  start = Time.now

  _timeout ||= timeout
  left = _timeout - Time.now.to_f + start.to_f

  while (left > 0)
    if (ready = IO.select([ @socket ], nil, nil, left))
      ready[0].each do |socket|
        data = socket.recvfrom(1524)
    
        r = ReDNS::Message.new(ReDNS::Buffer.new(data[0]))
        
        yield(r, data[1]) if (block)

        @responses[r.id] = [ r, data[1] ]
      end
    end

    left = _timeout - Time.now.to_f + start.to_f
  end
end