dnsruby 1.26 → 1.30

data/test/tc_queue.rb

@@ -5,13 +5,15 @@ class TestQueue < Test::Unit::TestCase
   def test_queue
     q = Queue.new
     r = Dnsruby::Resolver.new
-    timeout = 5
-    num_queries = 1000
+#    Dnsruby::TheLog.level=Logger::DEBUG
+    timeout = 15
+    num_queries = 100
     r.query_timeout = timeout
-    num_queries.times do |i| 
-      r.send_async(Dnsruby::Message.new("example#{i}.com"), q, i)
+    num_queries.times do |i|
+      r.send_async(Dnsruby::Message.new("example.com"), q, i)
+#      print "Sent #{i}\n"
     end
-    sleep(timeout * 1.5)
+    sleep(timeout * 2)
     assert(q.size == num_queries, "#{num_queries} expected, but got #{q.size}")
   end
 end

data/test/tc_recur.rb

@@ -3,8 +3,13 @@ require 'test/unit'
 
 class TestRecur < Test::Unit::TestCase
   def test_recur
+    Dnsruby::PacketSender.clear_caches
     r = Dnsruby::Recursor.new
-    ret = r.query_dorecursion("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
+#    Dnsruby::TheLog.level = Logger::DEBUG
+    ret = r.query("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
+#    print ret
     assert(ret.answer.length > 0)
+#    ret = r.query_dorecursion("aaa.bigzone.uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
+#    ret = r.query_dorecursion("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
   end
 end

data/test/tc_res_config.rb

@@ -30,8 +30,6 @@ class TestResolverConfig < Test::Unit::TestCase
 	"ignore_truncation"          => true,
 	"recurse"        => false,
 	"packet_timeout"    => 5,
-	"persistent_tcp" => true,
-	"persistent_udp" => true,
     #	"dnssec"         => 1,
     #	"force_v4"       => 1,
   };
@@ -54,7 +52,7 @@ class TestResolverConfig < Test::Unit::TestCase
     assert(res, "new returned something");
     assert_instance_of(Dnsruby::Resolver, res, "new() returns an object of the correct class.");
     
-    assert(res.config.nameserver,       'nameserver() works');
+#    assert(res.config.nameserver,       'nameserver() works');
     
     searchlist = ["t.dnsruby.validation-test-servers.nominet.org.uk", "t2.dnsruby.validation-test-servers.nominet.org.uk"];
     assert_equal(res.config.search=searchlist, searchlist, 'setting searchlist returns correctly.');

data/test/tc_res_opt.rb

@@ -64,7 +64,7 @@ class TestResOpt < Test::Unit::TestCase
   
   def test_config_hash_singleresolver
     # Resolver interface gives us : port, TCP, IgnoreTruncation, TSIGkey, timeout
-    # SR : server, local_address, persistent_tcp, persistent_udp, udp_size
+    # SR : server, local_address, udp_size
     test_config = {
       :server	   => '10.0.0.1',
       :port		   => 54, # SingleResolver and Multi-Resolver
@@ -74,8 +74,6 @@ class TestResOpt < Test::Unit::TestCase
       :ignore_truncation          => true, # SingleResolver and Multi-Resolver
       :recurse        => false,
       :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
-      :persistent_tcp => true, # SingleResolver and Multi-Resolver
-      :persistent_udp => true, # SingleResolver and Multi-Resolver
       :dnssec         => true,
     }
     
@@ -101,8 +99,6 @@ class TestResOpt < Test::Unit::TestCase
       :recurse        => false, 
       :packet_timeout    => 60, # SingleResolver and Multi-Resolver # Only have one timeout for both UDP and TCP
       :query_timeout    => 60, # Multi-Resolver only
-      :persistent_tcp => true, # SingleResolver and Multi-Resolver
-      :persistent_udp => true, # SingleResolver and Multi-Resolver
       :dnssec         => true,
     }
     

data/test/tc_resolver.rb

@@ -9,7 +9,7 @@
 #
 #Unless required by applicable law or agreed to in writing, software 
 #distributed under the License is distributed on an "AS IS" BASIS, 
-#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either tmexpress or implied. 
 #See the License for the specific language governing permissions and 
 #limitations under the License.
 #++
@@ -36,13 +36,28 @@ class TestResolver < Test::Unit::TestCase
     ret = res.send_message(Message.new("example.com", Types.A))
     assert(ret.kind_of?(Message))
   end
-  
+
+  def test_send_plain_message
+    res = Resolver.new
+    response, error = res.send_plain_message(Message.new("example.com"))
+    assert(response.kind_of?(Message))
+    assert(!error)
+    m = Message.new("fgjkhsklfjedfiuaufewriuf.com")
+    m.header.rd = true
+    response, error = res.send_plain_message(m)
+#    print "Response : #{response}\n"
+#    print "Error : #{error}\n"
+    assert(response.kind_of?(Message))
+    assert(error)
+    assert(error.kind_of?(NXDomain))
+  end
+
   def test_query
     res = Resolver.new
     ret = res.query("example.com")
     assert(ret.kind_of?(Message))
   end
-  
+
   def test_query_async
     res = Resolver.new
     q = Queue.new
@@ -52,7 +67,7 @@ class TestResolver < Test::Unit::TestCase
     assert(ret.kind_of?(Message), "Ret wrong!")
     assert(error==nil)
   end
-  
+
   def test_query_one_duff_server_one_good
     res = Resolver.new({:nameserver => ["localhost", "128.8.10.90"]})
     res.retry_delay=1
@@ -142,7 +157,7 @@ class TestResolver < Test::Unit::TestCase
       res = Resolver.new({:nameserver => "10.0.1.128"})
       start=stop=0
       retry_times = retry_delay = packet_timeout= 10
-      query_timeout=1
+      query_timeout=2
       begin
         res.packet_timeout=packet_timeout
         res.retry_times=retry_times
@@ -164,9 +179,9 @@ class TestResolver < Test::Unit::TestCase
   def test_queue_packet_timeout
     if (!RUBY_PLATFORM=~/darwin/)
       res = Resolver.new({:nameserver => "10.0.1.128"})
-      bad = SingleResolver.new("localhost")
-      res.add_resolver(bad)
-      expected = 1
+#      bad = SingleResolver.new("localhost")
+      res.add_server("localhost")
+      expected = 2
       res.query_timeout=expected    
       q = Queue.new
       start = Time.now
@@ -223,4 +238,8 @@ class TestResolver < Test::Unit::TestCase
     assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
     assert(res.single_resolvers[0].src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])    
   end
+
+  def test_eventtype_api
+    # @TODO@ TEST THE Resolver::EventType interface!
+  end
 end

data/test/tc_rr-opt.rb

@@ -43,6 +43,7 @@ class TestRrOpt < Test::Unit::TestCase
     # Set up a server running on localhost. Get the resolver to send a
     # query to it with the UDP size set to 4096. Make sure that it is received
     # correctly.
+    Dnsruby::PacketSender.clear_caches
     socket = UDPSocket.new
     socket.bind("127.0.0.1", 0)
     port = socket.addr[1]

data/test/tc_rr.rb

@@ -259,4 +259,10 @@ class TestRR < Test::Unit::TestCase
       assert_equal(rr.to_s,   rr2.to_s, "#{type} - Parsing from string works")
     end
   end
+
+  def test_naptr
+    update = Update.new
+    update.add('example.com.','NAPTR', 3600, '1 0 "s" "SIP+D2T" "" _sip._tcp.example.com.')
+    update.encode
+  end
 end

data/test/tc_rrset.rb

@@ -55,4 +55,64 @@ class RrsetTest < Test::Unit::TestCase
     assert(rrset.num_sigs == 1)
     assert(rrset.rrs.length == 3)
   end
+
+  def test_real_rrset
+        uuencodedPacket = %w{
+7c 7d 81 80 00 01 00 02  00 0b 00 0d 03 6e 73 31
+03 6e 69 63 02 75 6b 00  00 ff 00 01 c0 0c 00 01
+00 01 00 02 a2 cc 00 04  c3 42 f0 82 c0 0c 00 1c
+00 01 00 02 88 93 00 10  2a 01 00 40 10 01 00 35
+00 00 00 00 00 00 00 02  c0 10 00 02 00 01 00 02
+a2 cc 00 06 03 6e 73 33  c0 10 c0 10 00 02 00 01
+00 02 a2 cc 00 06 03 6e  73 35 c0 10 c0 10 00 02
+00 01 00 02 a2 cc 00 02  c0 0c c0 10 00 02 00 01
+00 02 a2 cc 00 06 03 6e  73 32 c0 10 c0 10 00 02
+00 01 00 02 a2 cc 00 06  03 6e 73 62 c0 10 c0 10
+00 02 00 01 00 02 a2 cc  00 06 03 6e 73 64 c0 10
+c0 10 00 02 00 01 00 02  a2 cc 00 06 03 6e 73 34
+c0 10 c0 10 00 02 00 01  00 02 a2 cc 00 06 03 6e
+73 36 c0 10 c0 10 00 02  00 01 00 02 a2 cc 00 06
+03 6e 73 61 c0 10 c0 10  00 02 00 01 00 02 a2 cc
+00 06 03 6e 73 37 c0 10  c0 10 00 02 00 01 00 02
+a2 cc 00 06 03 6e 73 63  c0 10 c0 86 00 01 00 01
+00 02 96 62 00 04 d9 4f  a4 83 c0 54 00 01 00 01
+00 02 96 8e 00 04 d5 db  0d 83 c0 bc 00 01 00 01
+00 02 97 08 00 04 c2 53  f4 83 c0 bc 00 1c 00 01
+00 02 96 62 00 10 20 01  06 30 01 81 00 35 00 00
+00 00 00 00 00 83 c0 66  00 01 00 01 00 02 96 85
+00 04 d5 f6 a7 83 c0 ce  00 01 00 01 00 02 96 85
+00 04 d5 f8 fe 82 c0 f2  00 01 00 01 00 02 96 85
+00 04 d4 79 28 82 c0 e0  00 01 00 01 00 02 97 08
+00 04 cc 4a 70 2c c0 e0  00 1c 00 01 00 02 96 62
+00 10 20 01 05 02 d3 99  00 00 00 00 00 00 00 00
+00 44 c0 98 00 01 00 01  00 02 96 8e 00 04 cc 4a
+71 2c c1 04 00 01 00 01  00 02 96 9b 00 04 c7 07
+42 2c c0 aa 00 01 00 01  00 02 96 71 00 04 c7 07
+43 2c c0 aa 00 1c 00 01  00 02 96 62 00 10 20 01
+05 02 10 0e 00 00 00 00  00 00 00 00 00 44
+    }
+    uuencodedPacket.map!{|e| e.hex}
+    packetdata = uuencodedPacket.pack('c*')
+
+    message = Dnsruby::Message.decode(packetdata)
+#      message.additional.rrsets.each {|rr| print "RRSet : #{rr}\n"}
+        sec_hash = message.section_rrsets(nil, true) # include the OPT record
+        sec_hash.each {|section, rrsets|
+          rrsets.each {|rrset|
+#              print "#{section} rrset : #{rrset}\n"
+            rrset.each { |rr|
+            }
+          }
+        }
+
+
+        sec_hash = message.section_rrsets(nil, true) # include the OPT record
+        sec_hash.each {|section, rrsets|
+          rrsets.each {|rrset|
+#              print "#{section} rrset : #{rrset}\n"
+            rrset.each { |rr|
+            }
+          }
+        }
+  end
 end

data/test/tc_single_resolver.rb

@@ -59,7 +59,7 @@ class TestSingleResolver < Test::Unit::TestCase
       # Run a query which will not respond, and check that the timeout works
       begin
         res = SingleResolver.new("10.0.1.128")
-        res.port = port
+        res.port = 12345
         res.packet_timeout=1
         m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
         fail
@@ -155,13 +155,14 @@ class TestSingleResolver < Test::Unit::TestCase
   
   def test_truncated_response
     res = SingleResolver.new
+    #    print "Dnssec = #{res.dnssec}\n"
     res.server=('ns0.validation-test-servers.nominet.org.uk')
     res.packet_timeout = 15
     m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
     assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
     assert(!m.header.tc, "Message was truncated!")
   end
-  
+
   def test_illegal_src_port
     # Try to set src_port to an illegal value - make sure error raised, and port OK
     res = SingleResolver.new
@@ -199,4 +200,56 @@ class TestSingleResolver < Test::Unit::TestCase
     end
     assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
   end
+
+  def test_options_preserved_on_tcp_resend
+    # Send a very small EDNS message to trigger tcp resend.
+    # Can we do that without using send_raw and avoiding the case we want to test?
+    # Sure - just knock up a little server here, which simply returns the response with the
+    # TC bit set, and records both packets sent to it
+    # Need to listen once on UDP and once on TCP
+    udpPacket = nil
+    tcpPacket = nil
+    port = 59821
+    thread = Thread.new {
+      u = UDPSocket.new()
+      u.bind("127.0.0.1", port)
+
+      s = u.recvfrom(15000)
+      received_query = s[0]
+      udpPacket = Message.decode(received_query)
+      u.connect(s[1][2], s[1][1])
+      udpPacket.header.tc = true
+      u.send(udpPacket.encode(),0)
+      u.close
+
+      ts = TCPServer.new(port)
+      t = ts.accept
+      packet = t.recvfrom(2)[0]
+
+      len = (packet[0]<<8)+packet[1]
+      if (RUBY_VERSION >= "1.9")
+        len = (packet[0].getbyte(0)<<8)+packet[1].getbyte(0)# Ruby 1.9
+      end
+      packet = t.recvfrom(len)[0]
+      tcpPacket = Message.decode(packet)
+      tcpPacket.header.tc = true
+      lenmsg = [tcpPacket.encode.length].pack('n')
+      t.send(lenmsg, 0)
+      t.write(tcpPacket.encode)
+      t.close
+      ts.close
+    }
+    ret = nil
+    thread2 = Thread.new {
+    r = SingleResolver.new("127.0.0.1")
+    r.port = port
+    ret = r.query("example.com")
+    }
+    thread.join
+    thread2.join
+    assert(tcpPacket && udpPacket)
+    assert(tcpPacket.header == udpPacket.header)
+    assert(tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl == udpPacket.additional.rrsets('OPT', true)[0].rrs()[0].ttl, "UDP : #{udpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}, TCP #{tcpPacket.additional.rrsets('OPT', true)[0].rrs()[0]}")
+
+  end
 end

data/test/tc_tsig.rb

@@ -17,6 +17,7 @@ require 'rubygems'
 require 'test/unit'
 require 'dnsruby'
 require "digest/md5"
+include Dnsruby
 class TestTSig < Test::Unit::TestCase
   KEY_NAME="rubytsig"
   KEY = "8n6gugn4aJ7MazyNlMccGKH1WxD2B3UvN/O/RA6iBupO2/03u9CTa3Ewz3gBWTSBCH3crY4Kk+tigNdeJBAvrw=="
@@ -24,21 +25,21 @@ class TestTSig < Test::Unit::TestCase
     return (string == "; no data" || string == "; rdlength = 0")
   end
   def test_signed_update
-    Dnsruby::Resolver::use_eventmachine(false)
+    #    Dnsruby::Resolver::use_eventmachine(false)
     run_test_client_signs
     run_test_resolver_signs
   end
-  def test_signed_update_em
-    begin
-      Dnsruby::Resolver::use_eventmachine(true)
-    rescue RuntimeError
-      Dnsruby.log.error("EventMachine not installed - not running tsig EM tests")
-      return 
-    end
-    run_test_client_signs
-    run_test_resolver_signs
-    Dnsruby::Resolver::use_eventmachine(false)
-  end
+  #  def test_signed_update_em
+  #    begin
+  #      Dnsruby::Resolver::use_eventmachine(true)
+  #    rescue RuntimeError
+  #      Dnsruby.log.error("EventMachine not installed - not running tsig EM tests")
+  #      return
+  #    end
+  #    run_test_client_signs
+  #    run_test_resolver_signs
+  #    Dnsruby::Resolver::use_eventmachine(false)
+  #  end
   
   def run_test_client_signs
     # NOTE - client signing is only appropriate if DNSSEC and EDNS are switched
@@ -88,6 +89,8 @@ class TestTSig < Test::Unit::TestCase
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record does not exist
+    Dnsruby::PacketSender.clear_caches
+    # Or else the cache will tell us it still deos!
     begin
       rr = res.query(update_name, 'TXT')
       assert(false)
@@ -142,6 +145,8 @@ class TestTSig < Test::Unit::TestCase
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record does not exist
+    Dnsruby::PacketSender.clear_caches
+    # Make sure the cache doesn't have an old copy!
     begin
       rr = res.query(update_name, 'TXT')
       assert(false)
@@ -232,6 +237,17 @@ class TestTSig < Test::Unit::TestCase
       soa_rr = dns.getresource(name, 'SOA')
       soa_serial = soa_rr.serial
     }
-    return soa_serial    
+    return soa_serial
+  end
+
+  def test_bad_tsig
+    res = Resolver.new
+    res.query_timeout=10
+    res.tsig=KEY_NAME, KEY
+    begin
+      ret = res.query("example.com")
+      assert(false, "Should not have got TSIG response from non-TSIG server!\n #{ret}\n")
+    rescue TsigError => e
+    end
   end
 end

data/test/tc_update.rb

@@ -187,6 +187,12 @@ class TestUpdate < Test::Unit::TestCase
     assert_equal(rdata,                  rr.rdata, 'rr_del - right data');    #60
     
     rr = nil
+
+    data = update.encode
+    header = Header.new_from_data(data)
+    assert(header.opcode == OpCode.Update)
+    new_update = Message.decode(data)
+    assert(new_update.header.opcode == OpCode.Update)
     
     #------------------------------------------------------------------------------
     # Make sure RRs in an update packet have the same class as the zone, unless

data/test/tc_validator.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+
+class TestValidator < Test::Unit::TestCase
+  def test_validation
+#    Dnsruby::TheLog.level = Logger::DEBUG
+    Dnsruby::Dnssec.clear_trusted_keys
+    Dnsruby::Dnssec.clear_trust_anchors
+    res = Dnsruby::Resolver.new("dnssec.nominet.org.uk")
+    res.dnssec=true
+    Dnsruby::Dnssec.do_validation_with_recursor(false)
+    Dnsruby::Dnssec.default_resolver=(res) # This is a closed zone (not reachable by recursion)
+
+    trusted_key = Dnsruby::RR.create({:name => "uk-dnssec.nic.uk.",
+        :type => Dnsruby::Types.DNSKEY,
+        :key=> "AQPJO6LjrCHhzSF9PIVV7YoQ8iE31FXvghx+14E+jsv4uWJR9jLrxMYm sFOGAKWhiis832ISbPTYtF8sxbNVEotgf9eePruAFPIg6ZixG4yMO9XG LXmcKTQ/cVudqkU00V7M0cUzsYrhc4gPH/NKfQJBC5dbBkbIXJkksPLv Fe8lReKYqocYP6Bng1eBTtkA+N+6mSXzCwSApbNysFnm6yfQwtKlr75p m+pd0/Um+uBkR4nJQGYNt0mPuw4QVBu1TfF5mQYIFoDYASLiDQpvNRN3 US0U5DEG9mARulKSSw448urHvOBwT9Gx5qF2NE4H9ySjOdftjpj62kjb Lmc8/v+z"
+      })
+    ret = Dnsruby::Dnssec.add_trust_anchor_with_expiration(trusted_key, Time.now.to_i + 5000)
+
+    r = res.query("aaa.bigzone.uk-dnssec.nic.uk", Dnsruby::Types.A)
+    assert(r.security_level.code == Message::SecurityLevel::SECURE, "Level = #{r.security_level.string}")
+    ret = Dnsruby::Dnssec.validate(r)
+    assert(ret, "Dnssec validation failed")
+
+    # @TODO@ Test other validation policies!!
+  end
+
+  def test_resolver_cd_validation_fails
+    # Should be able to check Nominet test-zone here - no keys point to it
+    res = Resolver.new
+    res.dnssec=true
+    r = res.query("uk-dnssec.nic.uk", Dnsruby::Types.A)
+    assert(r.security_level = Message::SecurityLevel::INSECURE)
+  end
+
+  def test_eventtype_api
+    # @TODO@ TEST THE Resolver::EventType interface!
+    print "Test EventType API!\n"
+  end
+
+  def test_config_api
+    # @TODO@ Test the different configuration options for the validator,
+    # and their defaults
+    #
+    # Should be able to set :
+    #  o Whether or not validation happens
+    #  o The async API queue tuples etc.
+    #  o Whether to use authoritative nameservers for validation
+    #  o Whether to use authoritative nameservers generally
+    #
+    print "Test validation configuration options!\n"
+  end
+
+
+end