dnsruby 1.2 → 1.23

data/test/tc_header.rb

@@ -58,9 +58,9 @@ class TestHeader < Test::Unit::TestCase
     assert_equal(header.qr, true, "qr() works")
     
     header.rcode="NOERROR"
-    assert_equal(header.rcode, RCode::NOERROR, "rcode() works")
+    assert_equal(header.get_header_rcode, RCode::NOERROR, "rcode() works")
     header.rcode=RCode.NOERROR
-    assert_equal(header.rcode.string, "NOERROR", "rcode() works")
+    assert_equal(header.get_header_rcode.string, "NOERROR", "rcode() works")
     
     header.qdcount=1
     header.ancount=2

data/test/tc_inet6.rb

@@ -0,0 +1,170 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#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. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'Net/DNS'
+require 'socket'
+class TestInet6 < Test::Unit::TestCase
+  def ip6ok?
+    if (@checkedip6)
+      if !@ip6ok
+        return false
+      end
+    end
+    @checkedip6 = true
+    @ip6ok = true
+    # First use the local resolver to query for the AAAA record of a 
+    # well known nameserver, than use v6 transport to get to that record.
+    puts ""
+    puts ""
+    puts "\tTesting for global IPv6 connectivity...\n"
+    puts "\t\t preparing..."
+    
+    tstsock = UDPSocket.new() 
+    begin
+      tstsock.bind("::1", 8765)
+    rescue Exception
+      #      raise RuntimeError, "\n\n\t\tFailed to bind to ::1\n\t\t#{$!}\n\n\t\tWe assume there is no IPv6 connectivity and skip the tests\n\n"
+      puts "\n\n\t\tFailed to bind to ::1\n\t\t#{$!}\n\n\t\tWe assume there is no IPv6 connectivity and skip the tests\n\n"
+      @ip6ok=false
+      return false
+    ensure
+      tstsock.close
+    end
+    return true
+  end
+  
+  def test_inet6
+    if (!ip6ok?)
+      return
+    end
+    res=Net::DNS::Resolver.new
+    #	res.debug(1)
+    nsanswer=res.send("ripe.net",'NS','IN')
+    assert_instance_of(Net::DNS::RR::NS, (nsanswer.answer)[0], "Preparing  for v6 transport, got NS records for ripe.net")
+    
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns| 
+      next if ns.nsdname !~ /ripe\.net/ # User ripe.net only
+      a_answer=res.send(ns.nsdname, 'A','IN')
+      next if (a_answer.header.ancount == 0)
+      assert_instance_of(Net::DNS::RR::A, (a_answer.answer)[0], "Preparing  for v4 transport, got A records for " + ns.nsdname)
+      a_address=(a_answer.answer)[0].address
+      
+      
+      puts("\n\t\t Will try to connect to  " + ns.nsdname + " (#{a_address})")
+      break
+    end
+    
+    
+    aaaa_address=""
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns| 
+      next if ns.nsdname !~ /ripe\.net/ # User ripe.net only
+      aaaa_answer=res.send(ns.nsdname,'AAAA','IN')
+      next if (aaaa_answer.header.ancount == 0)
+      assert_equal((aaaa_answer.answer)[0].type,"AAAA", "Preparing  for v6 transport, got AAAA records for " + ns.nsdname)
+      aaaa_address=(aaaa_answer.answer)[0].address
+      
+      
+      puts("\n\t\t Will try to connect to  #{ns.nsdname} (#{aaaa_address})")
+      break
+    end
+    
+    res.nameservers=(aaaa_address)
+    # res.print
+    answer=res.send("ripe.net",'SOA','IN')
+    if(res.errorstring =~ /Send error: /)
+      puts "\n\t\t Connection failed: " + res.errorstring 
+      puts "\n\t\t It seems you do not have global IPv6 connectivity' \n" 
+      puts "\t\t This is not an error in Net::DNS \n"
+      
+      puts "\t\t You can confirm this by trying 'ping6 " + aaaa_address + "' \n\n"
+    end
+    
+    
+    
+    # answer.print
+    assert_equal((answer.answer)[0].type, "SOA","Query over udp6 succeeded")
+    
+    res.usevc(1)
+    res.force_v4(1)
+    # res.print
+    # res.debug(1)
+    answer=res.send("ripe.net",'SOA','IN')
+    assert_equal(res.errorstring,"no nameservers","Correct errorstring when forcing v4")
+    
+    
+    res.force_v4(0)
+    answer=res.send("ripe.net",'NS','IN')
+    if (answer)
+      assert_equal((answer.answer)[0].type, "NS","Query over tcp6  succeeded")
+    else
+      puts "You can safely ignore the following message:"
+      puts(res.errorstring) if (res.errorstring != "connection failed(IPv6 socket failure)")
+      puts("configuring " + aaaa_address + " " +  a_address + " as nameservers")
+      res.nameservers(aaaa_address,a_address)
+      answer = nil
+      #	res.print
+      answer=res.send("ripe.net",'NS','IN')
+      assert_equal((answer.answer)[0].type, "NS","Fallback to V4 succeeded")
+      
+      
+    end
+    
+  end 
+  
+  
+  
+  
+  def test_axfr
+    if (!ip6ok?)
+      return
+    end
+    #  
+    # Now test AXFR functionality.
+    #
+    #
+    # First use the local resolver to query for the AAAA record of a 
+    
+    aaaa_address=""
+    res2=Net::DNS::Resolver.new
+    # res2.debug(1)
+    nsanswer=res2.send("net-dns.org",'NS','IN')
+    assert_equal((nsanswer.answer)[0].type, "NS","Preparing  for v6 transport, got NS records for net-dns.org")
+    #	foreach ns (nsanswer.answer){
+    nsanswer.answer.each do |ns|
+      #	    next if ns.nsdname !~ /ripe\.net/ # User rupe.net only
+      aaaa_answer=res2.send(ns.nsdname,'AAAA','IN')
+      next if (aaaa_answer.header.ancount == 0)
+      assert_equal((aaaa_answer.answer)[0].type,"AAAA", "Preparing  for v6 transport, got AAAA records for " + ns.nsdname)
+      aaaa_address=(aaaa_answer.answer)[0].address
+      
+      puts("\n\t\t Trying to connect to  " + ns.nsdname + " (#{aaaa_address})")
+      break
+    end
+    
+    res2.nameservers=(aaaa_address)
+    # res2.print
+    
+    socket=res2.axfr_start('example.com')
+            
+    assert_instance_of(Socket, socket,"axfr_start returns IPv6 Socket")
+     (rr,err)=res2.axfr_next
+    assert_equal(res2.errorstring,'Response code from server: NOTAUTH',"Transfer is not authorized (but our connection worked)")
+    
+  end
+end

data/test/tc_nsec3.rb

@@ -40,11 +40,12 @@ class Nsec3Test < Test::Unit::TestCase
       fail
     rescue DecodeError
     end
-    begin
-      nsec.hash_alg = 8
-      fail
-    rescue DecodeError
-    end
+    # Be liberal in what you accept...
+#    begin
+#      nsec.hash_alg = 8
+#      fail
+#    rescue DecodeError
+#    end
     begin
       nsec.flags = 2
       fail

data/test/tc_packet.rb

@@ -114,21 +114,35 @@ class TestPacket < Test::Unit::TestCase
 00 00 38 40 00 05 46 00 00 00 1c 20 00 00 29 10 
 00 00 00 80 00 00 05 00 00 00 00 30
     }
+    
+    uuencodedPacket = %w{
+ba 91 81 80 00 01 
+00 04 00 00 00 01 07 65 78 61 6d 70 6c 65 03 63 
+6f 6d 00 00 ff 00 01 c0 0c 00 02 00 01 00 02 9f  
+f4 00 14 01 61 0c 69 61 6e 61 2d 73 65 72 76 65 
+72 73 03 6e 65 74 00 c0 0c 00 02 00 01 00 02 9f 
+f4 00 04 01 62 c0 2b c0 0c 00 01 00 01 00 02 9f  
+7e 00 04 d0 4d bc a6 c0 0c 00 06 00 01 00 02 9f 
+f4 00 31 04 64 6e 73 31 05 69 63 61 6e 6e 03 6f  
+72 67 00 0a 68 6f 73 74 6d 61 73 74 65 72 c0 6e 
+77 a1 2d b7 00 00 1c 20 00 00 0e 10 00 12 75 00
+00 01 51 80 00 00 29 05 00 00 00 00 00 00 00        
+    }
     uuencodedPacket.map!{|e| e.hex}
     packetdata = uuencodedPacket.pack('c*')
 
     packet3 = Message.decode(packetdata)
-    assert(packet3,                                 'new(\data) returned something');         #28
+    assert(packet3,                                 'new data returned something');         #28
       
     assert_equal(packet3.header.qdcount, 1, 'header question count in syntetic packet correct');   #29
-    assert_equal(packet3.header.ancount, 0, 'header answer count in syntetic packet correct');     #30
-    assert_equal(packet3.header.nscount, 1, 'header authority count in syntetic packet  correct'); #31 
+    assert_equal(packet3.header.ancount, 4, 'header answer count in syntetic packet correct');     #30
+    assert_equal(packet3.header.nscount, 0, 'header authority count in syntetic packet  correct'); #31 
     assert_equal(packet3.header.adcount, 1, 'header additional in sytnetic  packet correct');      #32
       
     rr=packet3.additional;
       
     assert_equal(Types.OPT, rr[0].type, "Additional section packet is EDNS0 type");                         #33
-    assert_equal(4096, rr[0].klass.code, "EDNS0 packet size correct");                                     #34
+    assert_equal(1280, rr[0].klass.code, "EDNS0 packet size correct");                                     #34
       
     # In theory its valid to have multiple questions in the question section.
     # Not many servers digest it though.

data/test/tc_queue.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'dnsruby'
+
+class TestQueue < Test::Unit::TestCase
+  def test_queue
+    q = Queue.new
+    r = Dnsruby::Resolver.new
+    timeout = 5
+    num_queries = 1000
+    r.query_timeout = timeout
+    num_queries.times do |i| 
+      r.send_async(Dnsruby::Message.new("example#{i}.com"), q, i)
+    end
+    sleep(timeout * 1.5)
+    assert(q.size == num_queries, "#{num_queries} expected, but got #{q.size}")
+  end
+end

data/test/tc_resolver.rb

@@ -86,26 +86,26 @@ class TestResolver < Test::Unit::TestCase
     assert(!no_pointer)
   end
   
-  def test_bad_host
-    res = Resolver.new({:nameserver => "localhost"})
-    res.retry_times=1
-    res.retry_delay=0
-    res.query_timeout = 1
-    q = Queue.new
-    res.send_async(Message.new("example.com", Types.A), q, q)
-    id, m, err = q.pop
-    assert(id==q)
-    assert(m == nil)
-    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
-  end
-  
+#  def test_bad_host
+#    res = Resolver.new({:nameserver => "localhost"})
+#    res.retry_times=1
+#    res.retry_delay=0
+#    res.query_timeout = 1
+#    q = Queue.new
+#    res.send_async(Message.new("example.com", Types.A), q, q)
+#    id, m, err = q.pop
+#    assert(id==q)
+#    assert(m == nil)
+#    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
+#  end
+#  
   def test_nxdomain
     res=Resolver.new
     q = Queue.new
     res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), q, 1)
     id, m, err = q.pop
     assert(id==1)
-    assert(m.header.rcode == RCode.NXDOMAIN)
+    assert(m.rcode == RCode.NXDOMAIN)
     assert(err.kind_of?(NXDomain))
   end
   

data/test/tc_rr-opt.rb

@@ -49,7 +49,6 @@ class TestRrOpt < Test::Unit::TestCase
     q = Queue.new
     Thread.new {
       s = socket.recvfrom(65536)
-      print s.length
       received_query = s[0]
       socket.connect(s[1][2], s[1][1])
       q.push(Message.decode(received_query))
@@ -77,6 +76,26 @@ class TestRrOpt < Test::Unit::TestCase
     res = SingleResolver.new
     res.udp_size = 4096
     ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
-    assert(ret.header.rcode == RCode.NoError)
+    assert(ret.rcode == RCode.NoError)
+  end
+  
+  def test_decode_opt
+    # Create an OPT RR
+    size=2048;
+    ednsflags=0x9e22;
+    optrr = RR::OPT.new(size, ednsflags)
+    
+    # Add it to a message
+    m = Message.new
+    m.add_additional(optrr)
+    
+    # Encode the message
+    data = m.encode
+   
+    # Decode it
+    m2 = Message.decode(data)
+    
+    # Make sure there is an OPT RR there
+    assert(m2.rcode == RCode.NOERROR  )
   end
 end

data/test/tc_rr.rb

@@ -215,6 +215,8 @@ class TestRR < Test::Unit::TestCase
         x = ret_rr.send(key)
         if (ret_rr.kind_of?RR::CERT and (key == :alg or key == :certtype))
           assert_equal(value.to_s, x.code.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
+        elsif (ret_rr.kind_of?RR::TXT and (key == :strings)) 
+          assert_equal(value.to_s.downcase, x[0].to_s.downcase, "TXT strings wrong")
         else
           if (key == :type)
             assert_equal(Types.new(value).to_s.downcase, x.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
@@ -242,6 +244,8 @@ class TestRR < Test::Unit::TestCase
         ret = rr.send(meth)
         if (rr.kind_of?RR::CERT and (meth == :alg or meth == :certtype))
           assert_equal(data[meth].to_s, ret.code.to_s.downcase, "#{type} - #{meth}() correct")
+        elsif (rr.kind_of?RR::TXT and (meth == :strings)) 
+          assert_equal(data[meth].to_s, ret[0].to_s.downcase, "TXT strings wrong")
         else
           if (meth == :type)
             assert_equal(Types.new(data[meth]).to_s.downcase, ret.to_s.downcase, "#{type} - #{meth}() correct");

data/test/tc_rrset.rb

@@ -36,8 +36,8 @@ class RrsetTest < Test::Unit::TestCase
         :original_ttl => 3600,
         :algorithm => Dnsruby::Algorithms::RSASHA1,
         :labels => 3,
-        :expiration => Time.mktime(2003,03,22,17,31, 03).to_i,
-        :inception => Time.mktime(2003,02,20,17,31,03).to_i,
+        :expiration => Time.mktime(2003,03,22,17,31, 03),
+        :inception => Time.mktime(2003,02,20,17,31,03),
         :key_tag => 2642
       })
     assert(!rrset.add(sig))

data/test/tc_rrsig.rb

@@ -16,8 +16,8 @@ class RrsigTest < Test::Unit::TestCase
     assert_equal(Dnsruby::Algorithms::RSASHA1, rrsig.algorithm)
     assert_equal(3, rrsig.labels)
     assert_equal(86400, rrsig.original_ttl)
-    assert_equal(Time.mktime(2003,03,22,17,31, 03).to_i, rrsig.expiration)
-    assert_equal(Time.mktime(2003,02,20,17,31,03).to_i, rrsig.inception)
+    assert_equal(Time.mktime(2003,03,22,17,31, 03), rrsig.expiration)
+    assert_equal(Time.mktime(2003,02,20,17,31,03), rrsig.inception)
     assert_equal(2642, rrsig.key_tag)
     assert_equal(Dnsruby::Name.create("example.com."), rrsig.signers_name)
     assert_equal("oJB1W6WNGv+ldvQ3WDG0MQkg5IEhjRip8WTr" +

data/test/tc_tcp.rb

@@ -27,7 +27,7 @@ class TestTcp < Test::Unit::TestCase
     #@TODO@ Need a test server so we can tell what port this message was actually sent on!
     res = Dnsruby::Resolver.new()
     res.use_tcp = true
-    res.src_port=5379
+    res.src_port=rand(65535-1024) + 1024
     ret=res.query("example.com")
     assert(ret.is_a?(Dnsruby::Message))
   end

data/test/tc_tsig.rb

@@ -70,7 +70,7 @@ class TestTSig < Test::Unit::TestCase
     res.query_timeout = 20
     response = res.send_message(update)
     
-    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert_equal( Dnsruby::RCode.NOERROR, response.rcode)
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record exists
@@ -84,7 +84,7 @@ class TestTSig < Test::Unit::TestCase
     tsig.apply(update)
     assert(update.signed?, "Update has not been signed")
     response = res.send_message(update)
-    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert_equal( Dnsruby::RCode.NOERROR, response.rcode)
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record does not exist
@@ -117,7 +117,7 @@ class TestTSig < Test::Unit::TestCase
     
     response = res.send_message(update)
     
-    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert_equal( Dnsruby::RCode.NOERROR, response.rcode)
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record exists
@@ -138,7 +138,7 @@ class TestTSig < Test::Unit::TestCase
     res.dnssec=false # Or else we needed to add OPT record already
     res.udp_size = 512
     response = res.send_message(update)
-    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert_equal( Dnsruby::RCode.NOERROR, response.rcode)
     assert(response.verified?, "Response has not been verified")
     
     # Now check the record does not exist
@@ -204,7 +204,7 @@ class TestTSig < Test::Unit::TestCase
     assert(!update.signed?, "Update has been signed")
     
     response = res.send_message(update)
-    assert(response.header.rcode == Dnsruby::RCode.NOERROR)
+    assert(response.rcode == Dnsruby::RCode.NOERROR)
     
     end_soa_serial = get_soa_serial("validation-test-servers.nominet.org.uk")
     
@@ -223,7 +223,7 @@ class TestTSig < Test::Unit::TestCase
     update.present(update_name, 'TXT')
     update.delete(update_name)
     response = res.send_message(update)
-    assert_equal( Dnsruby::RCode.NOERROR, response.header.rcode)
+    assert_equal( Dnsruby::RCode.NOERROR, response.rcode)
   end
   
   def get_soa_serial(name)

data/test/ts_offline.rb

@@ -36,7 +36,22 @@ require "test/tc_update.rb"
 require "test/tc_escapedchars.rb"
 require "test/tc_dnskey.rb"
 require "test/tc_rrsig.rb"
-require "test/tc_ds.rb"
 require "test/tc_nsec.rb"
 require "test/tc_nsec3.rb"
-require "test/tc_nsec3param.rb"
+require "test/tc_nsec3param.rb"
+
+begin
+  require "openssl"
+  OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, "key", "data")
+  key = OpenSSL::PKey::RSA.new
+  key.e = 111
+      
+  have_openssl=true
+rescue Exception => e
+    puts "-----------------------------------------------------------------------"
+    puts "OpenSSL not present (with full functionality) - skipping DS digest test"
+    puts "-----------------------------------------------------------------------"
+end
+if (have_openssl)
+    require "test/tc_ds.rb"
+end