pNet-DNS 0.0.1

data/test/tc_header.rb

@@ -0,0 +1,91 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+class TestHeader < Test::Unit::TestCase
+  def test_header
+    header = Net::DNS::Header.new();
+    assert(header, "new() returned something")
+    
+    header.id=41
+    assert_equal(header.id, 41, "id() works")
+    
+    header.qr=1
+    assert_equal(header.qr, 1, "qr() works")
+    
+    header.opcode="QUERY"
+    assert_equal(header.opcode, "QUERY", "opcode() works")
+    
+    header.aa=1
+    assert_equal(header.aa, 1, "aa() works")
+    
+    header.tc=0
+    assert_equal(header.tc, 0, "tc() works")
+    
+    header.rd=1
+    assert_equal(header.rd, 1, "rd() works")
+    
+    header.ra=1
+    assert_equal(header.ra, 1, "ra() works")
+    
+    header.qr=1
+    assert_equal(header.qr, 1, "qr() works")
+    
+    header.rcode="NOERROR"
+    assert_equal(header.rcode, "NOERROR", "rcode() works")
+    
+    header.qdcount=1
+    header.ancount=2
+    header.nscount=3
+    header.arcount=3
+    
+    
+    # Reenable when support for CD is there
+    #header.cd=0
+    #assert_equal(header.cd, 0, "cd() works")
+    puts(header.inspect)
+    data = header.data;
+    
+    header2 = Net::DNS::Header.new(data);
+    puts(header2.inspect)
+    
+    assert(header==(header2), 'Headers are the same');
+    
+    #
+    #  Is $header->string remotely sane?
+    #
+    assert(header.inspect =~ /opcode = QUERY/, 'string() has opcode correct');
+    assert(header.inspect =~ /ancount = 2/,    'string() has ancount correct');
+    
+    header = Net::DNS::Header.new;
+    
+    #
+    # Check that the aliases work properly.
+    #
+    header.zocount=(0);
+    header.prcount=(1);
+    header.upcount=(2);
+    header.adcount=(3);
+    
+    assert_equal(header.zocount, 0, 'zocount works');
+    assert_equal(header.prcount, 1, 'prcount works');
+    assert_equal(header.upcount, 2, 'upcount works');
+    assert_equal(header.adcount, 3, 'adcount works');
+    
+    
+    
+  end
+end

data/test/tc_inet6.rb

@@ -0,0 +1,169 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+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_misc.rb

@@ -0,0 +1,137 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+class TestMisc < Test::Unit::TestCase
+  def test_wildcard
+    # test to make sure that wildcarding works.
+    #
+    rr = Net::DNS::RR.create('*.t.net-dns.org 60 IN A 10.0.0.1')
+    
+    assert(rr, 'RR got made')
+    
+    assert_equal(rr.name,    '*.t.net-dns.org', 'Name is correct'   )
+    assert_equal(60,      rr.ttl,               'TTL is correct'    )
+    assert_equal('IN',   rr.rrclass,              'CLASS is correct'  )
+    assert_equal('A',    rr.type,               'TYPE is correct'   )
+    assert_equal('10.0.0.1', rr.address,        'Address is correct')
+  end
+  
+  def test_misc
+    
+    #
+    # Make sure the underscore in SRV hostnames work.
+    #
+    srv = Net::DNS::RR.create('_rvp._tcp.t.net-dns.org. 60 IN SRV 0 0 80 im.bastardsinc.biz')
+    
+    assert(!$@,  'No errors')
+    assert(srv, 'SRV got made')
+    
+    
+    #~ # Test that the 5.005 Use of uninitialized value at
+    #~ # /usr/local/lib/perl5/site_perl/5.005/Net/DNS/RR.pm line 639. bug is gone
+    rr = Net::DNS::RR.create('mx.t.net-dns.org 60 IN MX 10 a.t.net-dns.org')
+    assert(rr, 'RR created')
+    
+    assert_equal(rr.preference, 10, 'Preference works')
+    
+    
+    
+    mx = Net::DNS::RR.create('mx.t.net-dns.org 60 IN MX 0 mail.net-dns.org')
+    
+    assert(mx.inspect =~ /0 mail.net-dns.org/) # was 'like'
+    assert_equal(mx.preference, 0)
+    assert_equal(mx.exchange, 'mail.net-dns.org')
+    
+    srv = Net::DNS::RR.create('srv.t.net-dns.org 60 IN SRV 0 2 3 target.net-dns.org')
+    
+    p srv.inspect
+    assert(srv.inspect =~ /0 2 3 target.net-dns.org\./)
+    assert_equal(srv.rdatastr, '0 2 3 target.net-dns.org.')
+    
+    
+    
+  end
+  
+  def test_TXT_RR
+    
+    #
+    #
+    # Below are some thests that have to do with TXT RRs 
+    #
+    #
+    
+    
+    # QUESTION SECTION:
+    #txt2.t.net-dns.org.		IN	TXT
+    
+    # ANSWER SECTION:
+    #txt2.t.net-dns.org.	60	IN	TXT	"Net-DNS\ complicated $tuff" "sort of \" text\ and binary \000 data"
+    
+    # AUTHORITY SECTION:
+    #net-dns.org.		3600	IN	NS	ns1.net-dns.org.
+    #net-dns.org.		3600	IN	NS	ns.ripe.net.
+    #net-dns.org.		3600	IN	NS	ns.hactrn.net.
+    
+    # ADDITIONAL SECTION:
+    #ns1.net-dns.org.	3600	IN	A	193.0.4.49
+    #ns1.net-dns.org.	3600	IN	AAAA
+    
+    uuencodedPacket=%w{
+11 99 85 00 00 01
+00 01 00 03 00 02 04 74  78 74 32 01 74 07 6e 65
+74 2d 64 6e 73 03 6f 72  67 00 00 10 00 01 c0 0c
+00 10 00 01 00 00 00 3c  00 3d 1a 4e 65 74 2d 44
+4e 53 3b 20 63 6f 6d 70  6c 69 63 61 74 65 64 20
+24 74 75 66 66 21 73 6f  72 74 20 6f 66 20 22 20
+74 65 78 74 3b 20 61 6e  64 20 62 69 6e 61 72 79
+20 00 20 64 61 74 61 c0  13 00 02 00 01 00 00 0e
+10 00 06 03 6e 73 31 c0  13 c0 13 00 02 00 01 00
+00 0e 10 00 0d 02 6e 73  04 72 69 70 65 03 6e 65
+74 00 c0 13 00 02 00 01  00 00 0e 10 00 0c 02 6e
+73 06 68 61 63 74 72 6e  c0 93 c0 79 00 01 00 01
+00 00 0e 10 00 04 c1 00  04 31 c0 79 00 1c 00 01
+00 00 0e 10 00 10 20 01  06 10 02 40 00 03 00 00
+12 34 be 21 e3 1e                               
+}
+    
+    uuencodedPacket.map!{|e| e.hex}
+    packetdata = uuencodedPacket.pack('c*')
+    packetdata.gsub!("\s*", "")
+    
+    packet     = Net::DNS::Packet.new_from_binary(packetdata)
+    txtRr=(packet.answer)[0]
+    assert_equal('Net-DNS; complicated $tuff',(txtRr.char_str_list())[0],"First Char string in TXT RR read from wireformat")
+    
+    # Compare the second char_str this contains a NULL byte (space NULL
+    # space=200020 in hex)
+    
+    temp = (txtRr.char_str_list())[1].unpack('H*')[0]
+    #assert_equal(unpack('H*',(TXTrr.char_str_list())[1]),"736f7274206f66202220746578743b20616e642062696e61727920002064617461", "Second Char string in TXT RR read from wireformat")
+    assert_equal("736f7274206f66202220746578743b20616e642062696e61727920002064617461", temp,"Second Char string in TXT RR read from wireformat")
+    
+    
+    txtRr2=Net::DNS::RR.create('txt2.t.net-dns.org.	60	IN	TXT  "Test1 \" \ more stuff"  "Test2"')
+    
+    assert_equal((txtRr2.char_str_list())[0],'Test1 "  more stuff', "First arg string in TXT RR read from zonefileformat")
+    assert_equal((txtRr2.char_str_list())[1],'Test2',"Second Char string in TXT RR read from zonefileformat")
+    
+    
+    txtRr3   = Net::DNS::RR.create("baz.example.com 3600 HS TXT '\"' 'Char Str2'")
+    
+    assert_equal( (txtRr3.char_str_list())[0],'"',"Escaped \" between the  single quotes")
+  end
+end

data/test/tc_online.rb

@@ -0,0 +1,236 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+require 'socket'
+class TestOnline < Test::Unit::TestCase
+  def test_online
+    res = Net::DNS::Resolver.new
+    rrs = [
+    {
+      :type   		=> 'A',
+      :name   		=> 'a.t.net-dns.org',
+      :address 	=> '10.0.1.128'
+    },
+    {
+      :type		=> 'MX',
+      :name		=> 'mx.t.net-dns.org',
+      :exchange	=> 'a.t.net-dns.org',
+      :preference 	=> 10
+    },
+    {
+      :type		=> 'CNAME',
+      :name		=> 'cname.t.net-dns.org',
+      :cname		=> 'a.t.net-dns.org'
+    },
+    {
+      :type		=> 'TXT',
+      :name		=> 'txt.t.net-dns.org',
+      :txtdata		=> 'Net-DNS'
+    }		
+    ]		
+    
+     (rrs.each do |data|
+      packet = res.send(data[:name], data[:type], 'IN')
+      
+      assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
+      assert_equal(1, packet.header.qdcount, 'Only one question')
+      assert_equal(1, packet.header.ancount, 'Got single answer')
+      
+      question = (packet.question)[0]
+      answer   = (packet.answer)[0]
+      
+      assert(question,                           'Got question'            )
+      assert_equal(data[:name],  question.qname,  'Question has right name' )
+      assert_equal(data[:type],  question.qtype,  'Question has right type' )
+      assert_equal('IN',             question.qclass, 'Question has right class')
+      
+      assert(answer)
+      assert_equal(answer.rrclass,    'IN',             'Class correct'           )
+      
+      
+      #	foreach meth (keys %{data}) {
+       (data.keys.each do |meth| 
+        assert_equal(answer.send(meth), data[meth], "#{meth} correct (#{data[:name]})") 
+        end)
+        end) # do
+      end # test_online
+      
+      def test_mx
+        # Does the mx() function work.
+        mx = Net::DNS.mx('mx2.t.net-dns.org')
+        
+        wanted_names = ['a.t.net-dns.org', 'a2.t.net-dns.org']
+        names = mx.collect { |i| i.exchange } # $_.exchange)
+        #names        = [ map { $_.exchange } @mx ]
+        
+        assert_equal(names, wanted_names, "mx() seems to be working")
+        
+        # some people seem to use mx() in scalar context
+        assert_equal(2, Net::DNS.mx('mx2.t.net-dns.org').length,  "mx() works in scalar context")
+        
+        #
+        # test that search() and query() DTRT with reverse lookups
+        #
+        tests = [
+        {
+          :ip => '198.41.0.4',
+          :host => 'a.root-servers.net',
+        },
+        {
+          :ip => '2001:500:1::803f:235',
+          :host => 'h.root-servers.net',
+        },
+        ]
+        
+        res = Net::DNS::Resolver.new
+        testWords = ['search', 'query']
+        #	foreach test (@tests) {
+        tests.each do |test| 
+          #		foreach method (qw(search query)) {
+          testWords.each do |method|
+            packet = res.send_method(method, test[:ip])
+            
+            assert_instance_of(Net::DNS::Packet,packet)
+            
+            next unless packet
+            
+            assert_equal((packet.answer)[0].ptrdname, test[:host], "method(#{test[:ip]}) works")
+          end # do
+        end # do
+      end # test_mx
+      
+      def test_search_query
+        res = Net::DNS::Resolver.new(
+                                     :domain     => 't.net-dns.org',
+        :searchlist => ['t.net-dns.org', 'net-dns.org']
+        )
+        
+        
+        #
+        # test the search() and query() append the default domain and 
+        # searchlist correctly.
+        #
+        res.defnames=(1) 
+        res.dnsrch=(1)
+        res.persistent_udp=(0)
+        
+        tests = [
+        {
+          :method => 'search',
+          :name   => 'a'
+        },
+        {
+          :method => 'search',
+          :name   => 'a.t'
+        },
+        {
+          :method => 'query',
+          :name   => 'a'
+        }
+        ]
+        
+        
+        tests.each do |test|
+          method = test[:method]
+          
+          ans = res.send_method(method,test[:name])
+          
+          assert_instance_of(Net::DNS::Packet, ans)
+          
+          assert_equal(ans.header.ancount, 1,"Correct answer count (with method)")
+          a = ans.answer[0]
+          
+          assert_instance_of(Net::DNS::RR::A, a)
+          assert_equal(a.name, 'a.t.net-dns.org',"Correct name (with method)")
+        end
+        socket=res.bgsend('a.t.net-dns.org','A')
+        assert(socket.is_a?(UDPSocket),"Socket returned")
+        
+        # burn a little CPU to get the socket ready.
+        sleep(0.1)
+        res.debug=false
+        
+        assert(res.bgisready(socket),"Socket is ready")
+        if res.bgisready(socket)
+          
+          ans= res.bgread(socket)
+          socket = nil
+          assert_equal(ans.header.ancount, 1,"Correct answer count")	
+          a=ans.answer
+          
+          assert_instance_of(Net::DNS::RR::A,a[0])
+          assert_equal(a[0].name, 'a.t.net-dns.org',"Correct name")
+        else
+          print "No socket to read from"
+        end
+      end
+      
+      
+      def test_searchlist
+        res = Net::DNS::Resolver.new(
+	:domain     => 't.net-dns.org',
+	:searchlist => ["t.net-dns.org", "net-dns.org"]
+        )
+        
+        #
+        # test the search() and query() append the default domain and 
+        # searchlist correctly.
+        #
+        
+        res.defnames=(1) 
+        res.dnsrch=(1)
+        res.persistent_udp=(1)
+        #	res.debug(1)
+        tests = [
+        {
+			:method => 'search',
+			:name   => 'a'
+        },
+        {
+			:method => 'search',
+			:name   => 'a.t'
+        },
+        {
+			:method => 'query',
+			:name   => 'a'
+        }
+        ]
+        
+        #          res.send("a.t.net-dns.org A")
+        res.send("a.t.net-dns.org",  "A")
+        
+        sock_id= res.sockets['AF_INET']["UDP"]
+        assert(sock_id,"Persistent UDP socket identified")
+        
+         (tests.each do |test|
+          method = test[:method]
+          
+          ans = res.send_method(method,test[:name])
+          assert_equal(  res.sockets['AF_INET']["UDP"],sock_id,"Persistent socket matches")
+          
+          assert_instance_of(Net::DNS::Packet, ans)
+          
+          assert_equal(1, ans.header.ancount, "Correct answer count (with persistent socket and method)")
+          
+          a = ans.answer
+          
+          assert_instance_of(Net::DNS::RR::A, a[0])
+          assert_equal(a[0].name, 'a.t.net-dns.org',"Correct name (with persistent socket and method)")
+          end)
+          
+        end
+      end