Class: Dnsruby::Resolver
- Inherits:
-
Object
- Object
- Dnsruby::Resolver
- Defined in:
- lib/Dnsruby/Resolver.rb
Overview
Description
Dnsruby::Resolver is a DNS stub resolver. This class performs queries with retries across multiple nameservers. The system configured resolvers are used by default.
The retry policy is a combination of the Net::DNS and dnsjava approach, and has the option of :
-
A total timeout for the query (defaults to 0, meaning “no total timeout”)
-
A retransmission system that targets the namervers concurrently once the first query round is
complete, but in which the total time per query round is split between the number of nameservers
targetted for the first round. and total time for query round is doubled for each query round
Note that, if a total timeout is specified, then that will apply regardless of the retry policy (i.e. it may cut retries short).
Note also that these timeouts are distinct from the SingleResolver’s packet_timeout
Timeouts apply to the initial query and response. If DNSSEC validation is to be performed, then additional queries may be required (these are performed automatically by Dnsruby). Each additional query will be performed with its own timeouts. So, even with a query_timeout of 5 seconds, a response which required extensive validation may take several times that long. (Future versions of Dnsruby may expose finer-grained events for client tracking of responses and validation)
Methods
Synchronous
These methods raise an exception or return a response message with rcode==NOERROR
-
Dnsruby::Resolver#send_message(msg)
-
Dnsruby::Resolver#query(name [, type [, klass]])
Asynchronous
These methods use a response queue to return the response and the error
-
Dnsruby::Resolver#send_async(msg, response_queue, query_id)
Event Loop
Dnsruby runs a pure Ruby event loop to handle I/O in a single thread. Support for EventMachine has been deprecated.
Direct Known Subclasses
Defined Under Namespace
Classes: EventType
Constant Summary collapse
- DefaultQueryTimeout =
0
- DefaultPacketTimeout =
5
- DefaultRetryTimes =
1
- DefaultRetryDelay =
5
- DefaultPort =
53
- DefaultDnssec =
true
- AbsoluteMinDnssecUdpSize =
1220
- MinDnssecUdpSize =
4096
- DefaultUDPSize =
MinDnssecUdpSize
Instance Attribute Summary collapse
-
#config ⇒ Object
readonly
The current Config.
-
#dnssec ⇒ Object
Use DNSSEC for this Resolver.
-
#do_caching ⇒ Object
Defines whether we will cache responses, or pass every request to the upstream resolver.
-
#do_validation ⇒ Object
Defines whether validation is performed by default on this Resolver when the query method is called.
-
#ignore_truncation ⇒ Object
Should truncation be ignored? i.e.
-
#no_tcp ⇒ Object
If no_tcp==true, then ONLY UDP will be used as a transport.
-
#packet_timeout ⇒ Object
The timeout for any individual packet.
-
#port ⇒ Object
The port to send queries to on the resolver.
-
#query_timeout ⇒ Object
Note that this timeout represents the total time a query may run for - multiple packets can be sent to multiple nameservers in this time.
-
#recurse ⇒ Object
Should the Recursion Desired bit be set?.
-
#retry_delay ⇒ Object
The query will be tried across nameservers retry_times times, with a delay of retry_delay seconds between each retry.
-
#retry_times ⇒ Object
The query will be tried across nameservers retry_times times, with a delay of retry_delay seconds between each retry.
-
#src_address ⇒ Object
The source address to send queries from for IPv4.
-
#src_address6 ⇒ Object
The source address to send queries from for IPv6.
-
#tsig ⇒ Object
Returns the value of attribute tsig.
-
#udp_size ⇒ Object
The maximum UDP size to be used.
-
#use_tcp ⇒ Object
Should TCP be used as a transport rather than UDP? If use_tcp==true, then ONLY TCP will be used as a transport.
Class Method Summary collapse
- .check_port(p, src_port = []) ⇒ Object
- .get_ports_from(p) ⇒ Object
- .get_tsig(args) ⇒ Object
- .port_in_range(p) ⇒ Object
Instance Method Summary collapse
-
#add_config_nameservers ⇒ Object
:nodoc: all.
-
#add_server(server) ⇒ Object
# Add a new SingleResolver to the list of resolvers this Resolver object will # query.
-
#add_src_port(p) ⇒ Object
Can be a single Fixnum or a Range or an Array If an invalid port is selected (one reserved by IANA), then an ArgumentError will be raised.
-
#close ⇒ Object
Close the Resolver.
-
#generate_timeouts(base = 0) ⇒ Object
:nodoc: all.
-
#initialize(*args) ⇒ Resolver
constructor
Create a new Resolver object.
- #nameserver=(n) ⇒ Object
- #nameservers=(ns) ⇒ Object
- #persistent_tcp=(on) ⇒ Object
- #persistent_udp=(on) ⇒ Object
-
#query(name, type = Types.A, klass = Classes.IN, set_cd = @dnssec) ⇒ Object
Query for a name.
-
#query_no_validation_or_recursion(name, type = Types.A, klass = Classes.IN) ⇒ Object
:nodoc: all.
-
#reset_attributes ⇒ Object
:nodoc: all.
-
#send_async(msg, client_queue, client_query_id = nil) ⇒ Object
Asynchronously send a Message to the server.
-
#send_message(message) ⇒ Object
Send a message, and wait for the response.
-
#send_plain_message(message) ⇒ Object
This method takes a Message (supplied by the client), and sends it to the configured nameservers.
- #set_config_nameserver(n) ⇒ Object
-
#single_res_mutex ⇒ Object
:nodoc: all.
-
#single_resolvers ⇒ Object
}.
-
#single_resolvers=(s) ⇒ Object
The array of SingleResolvers used for sending query messages attr_accessor :single_resolvers # :nodoc:.
-
#src_port ⇒ Object
The source port to send queries from Returns either a single Fixnum or an Array e.g.
-
#src_port=(p) ⇒ Object
Can be a single Fixnum or a Range or an Array If an invalid port is selected (one reserved by IANA), then an ArgumentError will be raised.
-
#update ⇒ Object
:nodoc: all.
- #update_internal_res(res) ⇒ Object
Constructor Details
#initialize(*args) ⇒ Resolver
Create a new Resolver object. If no parameters are passed in, then the default system configuration will be used. Otherwise, a Hash may be passed in with the following optional elements :
-
:port
-
:use_tcp
-
:tsig
-
:ignore_truncation
-
:src_address
-
:src_address6
-
:src_port
-
:recurse
-
:udp_size
-
:config_info - see Config
-
:nameserver - can be either a String or an array of Strings
-
:packet_timeout
-
:query_timeout
-
:retry_times
-
:retry_delay
-
:do_caching
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 |
# File 'lib/Dnsruby/Resolver.rb', line 377 def initialize(*args) # @TODO@ Should we allow :namesver to be an RRSet of NS records? Would then need to randomly order them? @resolver_ruby = nil @src_address = nil @src_address6 = nil @single_res_mutex = Mutex.new @configured = false @do_caching = true @config = Config.new() reset_attributes # Process args if (args.length==1) if (args[0].class == Hash) args[0].keys.each do |key| begin if (key == :config_info) @config.set_config_info(args[0][:config_info]) elsif (key==:nameserver) set_config_nameserver(args[0][:nameserver]) elsif (key==:nameservers) set_config_nameserver(args[0][:nameservers]) else send(key.to_s+"=", args[0][key]) end rescue Exception => e Dnsruby.log.error{"Argument #{key} not valid : #{e}\n"} end end elsif (args[0].class == String) set_config_nameserver(args[0]) elsif (args[0].class == Config) # also accepts a Config object from Dnsruby::Resolv @config = args[0] end else # Anything to do? end # if (@single_resolvers==[]) # add_config_nameservers # end update # ResolverRegister::register_resolver(self) end |
Instance Attribute Details
#config ⇒ Object (readonly)
The current Config
108 109 110 |
# File 'lib/Dnsruby/Resolver.rb', line 108 def config @config end |
#dnssec ⇒ Object
Use DNSSEC for this Resolver
144 145 146 |
# File 'lib/Dnsruby/Resolver.rb', line 144 def dnssec @dnssec end |
#do_caching ⇒ Object
Defines whether we will cache responses, or pass every request to the upstream resolver. This is only really useful when querying authoritative servers (as the upstream recursive resolver is likely to cache)
111 112 113 |
# File 'lib/Dnsruby/Resolver.rb', line 111 def do_caching @do_caching end |
#do_validation ⇒ Object
Defines whether validation is performed by default on this Resolver when the query method is called. Note that send_message and send_async expect a Message object to be passed in, which is already configured to the callers requirements.
151 152 153 |
# File 'lib/Dnsruby/Resolver.rb', line 151 def do_validation @do_validation end |
#ignore_truncation ⇒ Object
Should truncation be ignored? i.e. the TC bit is ignored and thus the resolver will not requery over TCP if TC is set
93 94 95 |
# File 'lib/Dnsruby/Resolver.rb', line 93 def ignore_truncation @ignore_truncation end |
#no_tcp ⇒ Object
If no_tcp==true, then ONLY UDP will be used as a transport. This should not generally be used, but is provided as a debugging aid.
86 87 88 |
# File 'lib/Dnsruby/Resolver.rb', line 86 def no_tcp @no_tcp end |
#packet_timeout ⇒ Object
The timeout for any individual packet. This is the timeout used by SingleResolver
129 130 131 |
# File 'lib/Dnsruby/Resolver.rb', line 129 def packet_timeout @packet_timeout end |
#port ⇒ Object
The port to send queries to on the resolver
78 79 80 |
# File 'lib/Dnsruby/Resolver.rb', line 78 def port @port end |
#query_timeout ⇒ Object
Note that this timeout represents the total time a query may run for - multiple packets can be sent to multiple nameservers in this time. This is distinct from the SingleResolver per-packet timeout The query_timeout is not required - it will default to 0, which means “do not use query_timeout”. If this is the case then the timeout will be dictated by the retry_times and retry_delay attributes
136 137 138 |
# File 'lib/Dnsruby/Resolver.rb', line 136 def query_timeout @query_timeout end |
#recurse ⇒ Object
Should the Recursion Desired bit be set?
102 103 104 |
# File 'lib/Dnsruby/Resolver.rb', line 102 def recurse @recurse end |
#retry_delay ⇒ Object
The query will be tried across nameservers retry_times times, with a delay of retry_delay seconds between each retry. The first time round, retry_delay will be divided by the number of nameservers being targetted, and a new nameserver will be queried with the resultant delay.
141 142 143 |
# File 'lib/Dnsruby/Resolver.rb', line 141 def retry_delay @retry_delay end |
#retry_times ⇒ Object
The query will be tried across nameservers retry_times times, with a delay of retry_delay seconds between each retry. The first time round, retry_delay will be divided by the number of nameservers being targetted, and a new nameserver will be queried with the resultant delay.
141 142 143 |
# File 'lib/Dnsruby/Resolver.rb', line 141 def retry_times @retry_times end |
#src_address ⇒ Object
The source address to send queries from for IPv4
96 97 98 |
# File 'lib/Dnsruby/Resolver.rb', line 96 def src_address @src_address end |
#src_address6 ⇒ Object
The source address to send queries from for IPv6
99 100 101 |
# File 'lib/Dnsruby/Resolver.rb', line 99 def src_address6 @src_address6 end |
#tsig ⇒ Object
Returns the value of attribute tsig.
89 90 91 |
# File 'lib/Dnsruby/Resolver.rb', line 89 def tsig @tsig end |
#udp_size ⇒ Object
The maximum UDP size to be used
105 106 107 |
# File 'lib/Dnsruby/Resolver.rb', line 105 def udp_size @udp_size end |
#use_tcp ⇒ Object
Should TCP be used as a transport rather than UDP? If use_tcp==true, then ONLY TCP will be used as a transport.
82 83 84 |
# File 'lib/Dnsruby/Resolver.rb', line 82 def use_tcp @use_tcp end |
Class Method Details
.check_port(p, src_port = []) ⇒ Object
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 |
# File 'lib/Dnsruby/Resolver.rb', line 599 def Resolver.check_port(p, src_port=[]) if (p.class != Fixnum) tmp_src_ports = Array.new(src_port) p.each do |x| if (!Resolver.check_port(x, tmp_src_ports)) return false end tmp_src_ports.push(x) end return true end if (Resolver.port_in_range(p)) if ((p == 0) && (src_port.length > 0)) return false end return true else Dnsruby.log.error("Illegal port (#{p})") raise ArgumentError.new("Illegal port #{p}") end end |
.get_ports_from(p) ⇒ Object
631 632 633 634 635 636 637 638 639 640 641 |
# File 'lib/Dnsruby/Resolver.rb', line 631 def Resolver.get_ports_from(p) a = [] if (p.class == Fixnum) a = [p] else p.each do |x| a.push(x) end end return a end |
.get_tsig(args) ⇒ Object
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 |
# File 'lib/Dnsruby/Resolver.rb', line 665 def Resolver.get_tsig(args) tsig = nil if (args.length == 1) if (args[0]) if (args[0].instance_of?RR::TSIG) tsig = args[0] elsif (args[0].instance_of?Array) if (args[0].length > 2) tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0][0], :key => args[0][1], :algorithm => args[0][2]}) else tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0][0], :key => args[0][1]}) end end else # Dnsruby.log.debug{"TSIG signing switched off"} return nil end elsif (args.length ==2) tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0], :key => args[1]}) elsif (args.length ==3) tsig = RR.new_from_hash({:type => Types.TSIG, :klass => Classes.ANY, :name => args[0], :key => args[1], :algorithm => args[2]}) else raise ArgumentError.new("Wrong number of arguments to tsig=") end Dnsruby.log.info{"TSIG signing now using #{tsig.name}, key=#{tsig.key}"} return tsig end |
.port_in_range(p) ⇒ Object
621 622 623 624 625 626 627 628 629 |
# File 'lib/Dnsruby/Resolver.rb', line 621 def Resolver.port_in_range(p) if ((p == 0) || ((p >= 50000) && (p <= 65535))) # @TODO@ IANA port bitmap - use 50000 - 65535 for now # ((Iana::IANA_PORTS.index(p)) == nil && # (p > 1024) && (p < 65535))) return true end return false end |
Instance Method Details
#add_config_nameservers ⇒ Object
:nodoc: all
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 |
# File 'lib/Dnsruby/Resolver.rb', line 422 def add_config_nameservers # :nodoc: all if (!@configured) @config.get_ready end @configured = true @single_res_mutex.synchronize { # Add the Config nameservers @config.nameserver.each do |ns| res = PacketSender.new({:server=>ns, :dnssec=>@dnssec, :use_tcp=>@use_tcp, :no_tcp=>@no_tcp, :packet_timeout=>@packet_timeout, :tsig => @tsig, :ignore_truncation=>@ignore_truncation, :src_address=>@src_address, :src_address6=>@src_address6, :src_port=>@src_port, :recurse=>@recurse, :udp_size=>@udp_size}) @single_resolvers.push(res) if res end } end |
#add_server(server) ⇒ Object
# Add a new SingleResolver to the list of resolvers this Resolver object will
# query.
def add_resolver(internal) # :nodoc:
# @TODO@ Make a new PacketSender from this SingleResolver!!
@single_resolvers.push(internal)
end
506 507 508 509 510 511 512 513 514 |
# File 'lib/Dnsruby/Resolver.rb', line 506 def add_server(server)# :nodoc: @configured = true res = PacketSender.new(server) raise ArgumentError.new("Can't create server #{server}") if !res update_internal_res(res) @single_res_mutex.synchronize { @single_resolvers.push(res) } end |
#add_src_port(p) ⇒ Object
Can be a single Fixnum or a Range or an Array If an invalid port is selected (one reserved by IANA), then an ArgumentError will be raised. “0” means “any valid port” - this is only a viable option if it is the only port in the list. An ArgumentError will be raised if “0” is added to an existing set of source ports.
res.add_src_port(60000)
res.add_src_port([60001,60005,60010])
res.add_src_port(60015..60115)
586 587 588 589 590 591 592 593 594 595 596 597 |
# File 'lib/Dnsruby/Resolver.rb', line 586 def add_src_port(p) if (Resolver.check_port(p, @src_port)) a = Resolver.get_ports_from(p) a.each do |x| if ((@src_port.length > 0) && (x == 0)) raise ArgumentError.new("src_port of 0 only allowed as only src_port value (currently #{@src_port.length} values") end @src_port.push(x) end end update end |
#close ⇒ Object
Close the Resolver. Unfinished queries are terminated with OtherResolvError.
352 353 354 |
# File 'lib/Dnsruby/Resolver.rb', line 352 def close @resolver_ruby.close if @resolver_ruby end |
#generate_timeouts(base = 0) ⇒ Object
:nodoc: all
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 |
# File 'lib/Dnsruby/Resolver.rb', line 754 def generate_timeouts(base=0) #:nodoc: all #These should be be pegged to the single_resolver they are targetting : # e.g. timeouts[timeout1]=nameserver timeouts = {} retry_delay = @retry_delay # @single_res_mutex.synchronize { @retry_times.times do |retry_count| if (retry_count>0) retry_delay *= 2 end @single_resolvers.delete(nil) # Just in case... @single_resolvers.each_index do |i| res= @single_resolvers[i] offset = (i*@retry_delay.to_f/@single_resolvers.length) if (retry_count==0) timeouts[base+offset]=[res, retry_count] else if (timeouts.has_key?(base+retry_delay+offset)) Dnsruby.log.error{"Duplicate timeout key!"} raise RuntimeError.new("Duplicate timeout key!") end timeouts[base+retry_delay+offset]=[res, retry_count] end end end # } return timeouts end |
#nameserver=(n) ⇒ Object
528 529 530 531 532 533 534 535 |
# File 'lib/Dnsruby/Resolver.rb', line 528 def nameserver=(n) @configured = true @single_res_mutex.synchronize { @single_resolvers=[] } set_config_nameserver(n) add_config_nameservers end |
#nameservers=(ns) ⇒ Object
525 526 527 |
# File 'lib/Dnsruby/Resolver.rb', line 525 def nameservers=(ns) self.nameserver=(ns) end |
#persistent_tcp=(on) ⇒ Object
714 715 716 717 |
# File 'lib/Dnsruby/Resolver.rb', line 714 def persistent_tcp=(on) @persistent_tcp = on update end |
#persistent_udp=(on) ⇒ Object
719 720 721 722 |
# File 'lib/Dnsruby/Resolver.rb', line 719 def persistent_udp=(on) @persistent_udp = on update end |
#query(name, type = Types.A, klass = Classes.IN, set_cd = @dnssec) ⇒ Object
Query for a name. If a valid Message is received, then it is returned to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
require 'Dnsruby'
res = Dnsruby::Resolver.new
response = res.query("example.com") # defaults to Types.A, Classes.IN
response = res.query("example.com", Types.MX)
response = res.query("208.77.188.166") # IPv4 address so PTR query will be made
response = res.query("208.77.188.166", Types.PTR)
173 174 175 176 177 178 179 180 181 182 183 |
# File 'lib/Dnsruby/Resolver.rb', line 173 def query(name, type=Types.A, klass=Classes.IN, set_cd=@dnssec) msg = Message.new msg.do_caching = @do_caching msg.header.rd = 1 msg.add_question(name, type, klass) msg.do_validation = @do_validation if (@dnssec) msg.header.cd = set_cd # We do our own validation by default end return (msg) end |
#query_no_validation_or_recursion(name, type = Types.A, klass = Classes.IN) ⇒ Object
:nodoc: all
185 186 187 188 189 190 191 192 193 194 195 |
# File 'lib/Dnsruby/Resolver.rb', line 185 def query_no_validation_or_recursion(name, type=Types.A, klass=Classes.IN) # :nodoc: all msg = Message.new msg.do_caching = @do_caching msg.header.rd = false msg.do_validation = false msg.add_question(name, type, klass) if (@dnssec) msg.header.cd = true # We do our own validation by default end return (msg) end |
#reset_attributes ⇒ Object
:nodoc: all
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 |
# File 'lib/Dnsruby/Resolver.rb', line 454 def reset_attributes #:nodoc: all if (@resolver_ruby) @resolver_ruby.reset_attributes end # Attributes # do_validation tells the Resolver whether to try to validate the response # with DNSSEC. This should work for NSEC-signed domains, but NSEC3 # validation is not currently supported. This attribute now defaults to # false. Please let me know if you require NSEC3 validation. @do_validation = false @query_timeout = DefaultQueryTimeout @retry_delay = DefaultRetryDelay @retry_times = DefaultRetryTimes @packet_timeout = DefaultPacketTimeout @port = DefaultPort @udp_size = DefaultUDPSize @dnssec = DefaultDnssec @do_caching= true @use_tcp = false @no_tcp = false @tsig = nil @ignore_truncation = false @config = Config.new() @src_address = nil @src_address6 = nil @src_port = [0] @recurse = true @single_res_mutex.synchronize { @single_resolvers=[] } @configured = false end |
#send_async(msg, client_queue, client_query_id = nil) ⇒ Object
Asynchronously send a Message to the server. The send can be done using just Dnsruby. Support for EventMachine has been deprecated.
Dnsruby pure Ruby event loop :
A client_queue is supplied by the client, along with an optional client_query_id to identify the response. The client_query_id is generated, if not supplied, and returned to the client. When the response is known, a tuple of (query_id, response_message, exception) will be added to the client_queue.
The query is sent synchronously in the caller’s thread. The select thread is then used to listen for and process the response (up to pushing it to the client_queue). The client thread is then used to retrieve the response and deal with it.
Takes :
-
msg - the message to send
-
client_queue - a Queue to push the response to, when it arrives
-
client_query_id - an optional ID to identify the query to the client
-
use_tcp - whether to use only TCP (defaults to SingleResolver.use_tcp)
Returns :
-
client_query_id - to identify the query response to the client. This ID is
generated if it is not passed in by the client
Example invocations :
id = res.send_async(msg, queue)
NOT SUPPORTED : id = res.send_async(msg, queue, use_tcp)
id = res.send_async(msg, queue, id)
id = res.send_async(msg, queue, id, use_tcp)
Example code :
require 'Dnsruby'
res = Dnsruby::Resolver.newsend
query_id = 10 # can be any object you like
query_queue = Queue.new
res.send_async(Message.new("example.com", Types.MX), query_queue, query_id)
query_id_2 = res.send_async(Message.new("example.com", Types.A), query_queue)
# ...do a load of other stuff here...
2.times do
response_id, response, exception = query_queue.pop
# You can check the ID to see which query has been answered
if (exception == nil)
# deal with good response
else
# deal with problem
end
end
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 |
# File 'lib/Dnsruby/Resolver.rb', line 332 def send_async(msg, client_queue, client_query_id = nil) if (!@configured) add_config_nameservers end # @single_res_mutex.synchronize { if (!@resolver_ruby) # @TODO@ Synchronize this? @resolver_ruby = ResolverRuby.new(self) end # } client_query_id = @resolver_ruby.send_async(msg, client_queue, client_query_id) if (@single_resolvers.length == 0) Thread.start { sleep(@query_timeout == 0 ? 1 : @query_timeout) client_queue.push([client_query_id, nil, ResolvTimeout.new("Query timed out - no nameservers configured")]) } end return client_query_id end |
#send_message(message) ⇒ Object
Send a message, and wait for the response. If a valid Message is received, then it is returned to the caller. Otherwise an exception (a Dnsruby::ResolvError or Dnsruby::ResolvTimeout) is raised.
send_async is called internally.
example :
require 'dnsruby'
include Dnsruby
res = Dnsruby::Resolver.new
begin
response = res.(Message.new("example.com", Types.MX))
rescue ResolvError
# ...
rescue ResolvTimeout
# ...
end
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
# File 'lib/Dnsruby/Resolver.rb', line 214 def () Dnsruby.log.debug{"Resolver : sending message"} q = Queue.new send_async(, q) # # @TODO@ Add new queue tuples, e.g. : # event_type = EventType::RECEIVED # reply = nil # while (event_type == EventType::RECEIVED) # id, event_type, reply, error = q.pop # Dnsruby.log.debug{"Resolver : result received"} # if ((error != nil) && (event_type == EventType::ERROR)) # raise error # end # print "Reply = #{reply}\n" # end # print "Reply = #{reply}\n" # return reply id, result, error = q.pop if (error != nil) raise error else return result end end |
#send_plain_message(message) ⇒ Object
This method takes a Message (supplied by the client), and sends it to the configured nameservers. No changes are made to the Message before it is sent (TSIG signatures will be applied if configured on the Resolver). Retries are handled as the Resolver is configured to do. Incoming responses to the query are not cached or validated (although TCP fallback will be performed if the TC bit is set and the (Single)Resolver has ignore_truncation set to false). Note that the Message is left untouched - this means that no OPT records are added, even if the UDP transport for the server is specified at more than 512 bytes. If it is desired to use EDNS for this packet, then you should call the Dnsruby::PacketSender#prepare_for_dnssec(msg), or Dnsruby::PacketSender#add_opt_rr(msg) The return value from this method is the [response, error] tuple. Either of these values may be nil - it is up to the client to check.
example :
require 'dnsruby'
include Dnsruby
res = Dnsruby::Resolver.new
response, error = res.(Message.new("example.com", Types.MX))
if (error)
print "Error returned : #{error}\n"
else
process_response(response)
end
267 268 269 270 271 272 273 274 275 276 |
# File 'lib/Dnsruby/Resolver.rb', line 267 def () Dnsruby::TheLog.debug("Resolver : send_plain_message") .do_caching = false .do_validation = false .send_raw = true q = Queue.new send_async(, q) id, result, error = q.pop return [result, error] end |
#set_config_nameserver(n) ⇒ Object
440 441 442 443 444 445 446 447 448 449 450 451 452 |
# File 'lib/Dnsruby/Resolver.rb', line 440 def set_config_nameserver(n) # @TODO@ Should we allow NS RRSet here? If so, then .sort_by {rand} if (!@configured) @config.get_ready end @configured = true if (n).kind_of?String @config.nameserver=[n] else @config.nameserver=n end add_config_nameservers end |
#single_res_mutex ⇒ Object
:nodoc: all
750 751 752 |
# File 'lib/Dnsruby/Resolver.rb', line 750 def single_res_mutex # :nodoc: all return @single_res_mutex end |
#single_resolvers ⇒ Object
}
121 122 123 124 125 126 |
# File 'lib/Dnsruby/Resolver.rb', line 121 def single_resolvers # :nodoc: if (!@configured) add_config_nameservers end return @single_resolvers end |
#single_resolvers=(s) ⇒ Object
The array of SingleResolvers used for sending query messages
attr_accessor :single_resolvers # :nodoc:
115 116 117 118 119 120 |
# File 'lib/Dnsruby/Resolver.rb', line 115 def single_resolvers=(s) # :nodoc: @configured = true # @single_res_mutex.synchronize { @single_resolvers = s # } end |
#src_port ⇒ Object
The source port to send queries from Returns either a single Fixnum or an Array e.g. “0”, or “[60001, 60002, 60007]”
Defaults to 0 - random port
552 553 554 555 556 557 |
# File 'lib/Dnsruby/Resolver.rb', line 552 def src_port if (@src_port.length == 1) return @src_port[0] end return @src_port end |
#src_port=(p) ⇒ Object
Can be a single Fixnum or a Range or an Array If an invalid port is selected (one reserved by IANA), then an ArgumentError will be raised.
res.src_port=0
res.src_port=[60001,60005,60010]
res.src_port=60015..60115
567 568 569 570 571 572 |
# File 'lib/Dnsruby/Resolver.rb', line 567 def src_port=(p) if (Resolver.check_port(p)) @src_port = Resolver.get_ports_from(p) update end end |
#update ⇒ Object
:nodoc: all
489 490 491 492 493 494 495 496 497 |
# File 'lib/Dnsruby/Resolver.rb', line 489 def update #:nodoc: all #Update any resolvers we have with the latest config @single_res_mutex.synchronize { @single_resolvers.delete(nil) # Just in case... @single_resolvers.each do |res| update_internal_res(res) end } end |
#update_internal_res(res) ⇒ Object
516 517 518 519 520 521 522 523 |
# File 'lib/Dnsruby/Resolver.rb', line 516 def update_internal_res(res) [:port, :use_tcp, :no_tcp, :tsig, :ignore_truncation, :packet_timeout, :src_address, :src_address6, :src_port, :recurse, :udp_size, :dnssec].each do |param| res.send(param.to_s+"=", instance_variable_get("@"+param.to_s)) end end |