dnsruby 1.53 → 1.54

data/lib/Dnsruby/DNS.rb

@@ -77,6 +77,8 @@ module Dnsruby
   #* ftp://ftp.isi.edu/in-notes/iana/assignments/dns-parameters
   #* etc.
   class DNS
+
+    attr_accessor :do_caching
     
     #Creates a new DNS resolver. See Resolv::DNS.new for argument details.
     #
@@ -114,6 +116,7 @@ module Dnsruby
     #                      :search => ['ruby-lang.org'],
     #                      :ndots => 1})
     def initialize(config_info=nil)
+      @do_caching = true
       @config = Config.new()
       @config.set_config_info(config_info)
       @resolver = Resolver.new(@config)
@@ -284,6 +287,7 @@ module Dnsruby
         msg.add_question(candidate, type, klass)
         msg.do_validation = false
         msg.header.cd = false
+        msg.do_caching = do_caching
         @resolver.do_validation = false
         @resolver.send_async(msg, q)
         id, ret, exception = q.pop

data/lib/Dnsruby/PacketSender.rb

@@ -101,22 +101,18 @@ module Dnsruby
     # dnssec defaults to ON
     attr_reader :dnssec
     
+    # Set the source address. If the arg is nil, do nothing
+    def src_address6=(arg)
+      if (not arg.nil?)
+        @src_address6 = arg
+      end
+    end
+
     # Set the source address. If the arg is nil, do nothing
     def src_address=(arg)
       if (not arg.nil?)
         @src_address = arg
       end
-      # Do some verification to make sure that the source address
-      # is of the same type as the server address
-      if (@server.nil?)
-        return
-      else
-        si = IPAddr.new(@src_address)
-        i = IPAddr.new(@server)
-        if (i.ipv4? and si.ipv6?) or (i.ipv6? and si.ipv4?)
-          raise ArgumentError.new("Invalid address specified (address family does not match)")
-        end
-      end
     end
 
     #Sets the TSIG to sign outgoing messages with.
@@ -150,6 +146,7 @@ module Dnsruby
     def server=(server)
       Dnsruby.log.debug{"InternalResolver setting server to #{server}"}
       @server=Config.resolve_server(server)
+      check_ipv6
     end
     
     # Can take a hash with the following optional keys : 
@@ -160,6 +157,7 @@ module Dnsruby
     # * :no_tcp
     # * :ignore_truncation
     # * :src_address
+    # * :src_address6
     # * :src_port
     # * :udp_size
     # * :tsig
@@ -167,6 +165,7 @@ module Dnsruby
     # * :recurse
     def initialize(*args)
       arg=args[0]
+      @ipv6 = false
       @packet_timeout = Resolver::DefaultPacketTimeout
       @port = Resolver::DefaultPort
       @udp_size = Resolver::DefaultUDPSize
@@ -176,6 +175,7 @@ module Dnsruby
       @tsig = nil
       @ignore_truncation = false
       @src_address        = '0.0.0.0'
+      @src_address6        = '::'
       @src_port        = [0]
       @recurse = true
       
@@ -190,7 +190,8 @@ module Dnsruby
       elsif (arg.kind_of?Hash)
         arg.keys.each do |attr|
           begin
-            if ((attr.to_s == "src_address") && ((arg[attr] == nil) || (arg[attr] == "")))
+            if (((attr.to_s == "src_address")||(attr.to_s == "src_address6")) &&
+                  ((arg[attr] == nil) || (arg[attr] == "")))
             else
               send(attr.to_s+"=", arg[attr])
             end
@@ -203,18 +204,24 @@ module Dnsruby
       #Check server is IP
       @server=Config.resolve_server(@server)
 
+      check_ipv6
+      #      ResolverRegister::register_single_resolver(self)
+    end
+
+    def check_ipv6
       begin
         i = IPv4.create(@server)
-        @src_address = '0.0.0.0'
+        #        @src_address = '0.0.0.0'
+        @ipv6=false
       rescue Exception
         begin
           i = IPv6.create(@server)
-          @src_address = '::'
+          #          @src_address6 = '::'
+          @ipv6=true
         rescue Exception
           Dnsruby.log.error{"Server is neither IPv4 or IPv6!\n"}
         end
       end
-      #      ResolverRegister::register_single_resolver(self)
     end
     
     def close
@@ -346,16 +353,20 @@ module Dnsruby
       socket = nil
       runnextportloop = true
       numtries = 0
+      src_address = @src_address
+      if (@ipv6)
+        src_address = @src_address6
+      end
       while (runnextportloop)do
         begin
           numtries += 1
           src_port = get_next_src_port
           if (use_tcp)
             begin
-              socket = TCPSocket.new(@server, @port, @src_address, src_port)
+              socket = TCPSocket.new(@server, @port, src_address, src_port)
             rescue Errno::EBADF, Errno::ENETUNREACH => e
               # Can't create a connection
-              err=IOError.new("TCP connection error to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
+              err=IOError.new("TCP connection error to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
               Dnsruby.log.error{"#{err}"}
               st.push_exception_to_select(client_query_id, client_queue, err, nil)
               return
@@ -366,10 +377,10 @@ module Dnsruby
             if (/java/ =~ RUBY_PLATFORM )
               socket = UDPSocket.new()
             else
-              ipv6 = @src_address =~ /:/
-              socket = UDPSocket.new(ipv6.nil? ? Socket::AF_INET : Socket::AF_INET6)
+              #              ipv6 = @src_address =~ /:/
+              socket = UDPSocket.new(@ipv6 ? Socket::AF_INET6 : Socket::AF_INET)
             end
-            socket.bind(@src_address, src_port)
+            socket.bind(src_address, src_port)
             socket.connect(@server, @port)
           end
           runnextportloop = false
@@ -384,7 +395,7 @@ module Dnsruby
           # Maybe try a max number of times?
           if ((e.class != Errno::EADDRINUSE) || (numtries > 50) ||
                 ((e.class == Errno::EADDRINUSE) && (src_port == @src_port[0])))
-            err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
+            err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
             Dnsruby.log.error{"#{err}"}
             st.push_exception_to_select(client_query_id, client_queue, err, nil)
             return
@@ -392,27 +403,26 @@ module Dnsruby
         end
       end
       if (socket==nil)
-        err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}")
+        err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}")
         Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil) 
         return
       end
-      Dnsruby.log.debug{"Sending packet to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp} : #{query.question()[0].qname}, #{query.question()[0].qtype}"}
+      Dnsruby.log.debug{"Sending packet to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp} : #{query.question()[0].qname}, #{query.question()[0].qtype}"}
       #            print "#{Time.now} : Sending packet to #{@server} : #{query.question()[0].qname}, #{query.question()[0].qtype}\n"
       # Listen for the response before we send the packet (to avoid any race conditions)
       query_settings = SelectThread::QuerySettings.new(query_bytes, query, @ignore_truncation, client_queue, client_query_id, socket, @server, @port, endtime, udp_packet_size, self)
-      # The select thread will now wait for the response and send that or a timeout
-      # back to the client_queue.
-      st.add_to_select(query_settings)
-      # Now that we're listening for the response, send the query!
       begin
         if (use_tcp)
           lenmsg = [query_bytes.length].pack('n')
           socket.send(lenmsg, 0)
         end
         socket.send(query_bytes, 0)
+        # The select thread will now wait for the response and send that or a timeout
+        # back to the client_queue.
+        st.add_to_select(query_settings)
       rescue Exception => e
-        err=IOError.new("Send failed to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
+        err=IOError.new("Send failed to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp}, exception : #{e}")
         Dnsruby.log.error{"#{err}"}
         st.push_exception_to_select(client_query_id, client_queue, err, nil)
         begin
@@ -422,7 +432,7 @@ module Dnsruby
         return
       end
       
-      Dnsruby.log.debug{"Packet sent to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp} : #{query.question()[0].qname}, #{query.question()[0].qtype}"}
+      Dnsruby.log.debug{"Packet sent to #{@server}:#{@port} from #{src_address}:#{src_port}, use_tcp=#{use_tcp} : #{query.question()[0].qname}, #{query.question()[0].qtype}"}
       #      print "Packet sent to #{@server}:#{@port} from #{@src_address}:#{src_port}, use_tcp=#{use_tcp} : #{query.question()[0].qname}, #{query.question()[0].qtype}\n"
     end
     
@@ -521,6 +531,16 @@ module Dnsruby
           end
         end
       end
+      # IF WE GET FORMERR BACK HERE (and we have EDNS0 on) THEN
+      # TRY AGAIN WITH NO OPT RECORDS! (rfc2671 section 5.3)
+      if ((response.header.get_header_rcode == RCode.FORMERR) &&
+            (query.header.arcount > 0))
+        # try resending the message with no OPT record
+        query.remove_additional
+        query.send_raw = true
+        send_async(query, client_queue, client_query_id, false)
+        return false
+      end
       if (response.header.tc && !tcp && !@ignore_truncation)
         if (@no_tcp)
           Dnsruby.log.debug{"Truncated response - not resending over TCP as no_tcp==true"}

data/lib/Dnsruby/Resolver.rb

@@ -92,9 +92,12 @@ module Dnsruby
     # i.e. the TC bit is ignored and thus the resolver will not requery over TCP if TC is set
     attr_reader :ignore_truncation
     
-    # The source address to send queries from
+    # The source address to send queries from for IPv4
     attr_reader :src_address
     
+    # The source address to send queries from for IPv6
+    attr_reader :src_address6
+
     # Should the Recursion Desired bit be set?
     attr_reader :recurse
     
@@ -360,6 +363,7 @@ module Dnsruby
     # * :tsig
     # * :ignore_truncation
     # * :src_address
+    # * :src_address6
     # * :src_port
     # * :recurse
     # * :udp_size
@@ -374,6 +378,7 @@ module Dnsruby
       # @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
@@ -425,7 +430,7 @@ module Dnsruby
           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_port=>@src_port,
+              :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
@@ -472,6 +477,7 @@ module Dnsruby
       @ignore_truncation = false
       @config = Config.new()
       @src_address        = nil
+      @src_address6        = nil
       @src_port        = [0]
       @recurse = true
       @single_res_mutex.synchronize {
@@ -509,7 +515,7 @@ module Dnsruby
 
     def update_internal_res(res)
       [:port, :use_tcp, :no_tcp, :tsig, :ignore_truncation, :packet_timeout,
-        :src_address, :src_port, :recurse,
+        :src_address, :src_address6, :src_port, :recurse,
         :udp_size, :dnssec].each do |param|
 
         res.send(param.to_s+"=", instance_variable_get("@"+param.to_s))
@@ -695,6 +701,11 @@ module Dnsruby
       update
     end
     
+    def src_address6=(a)
+      @src_address6 = a
+      update
+    end
+
     def port=(a)
       @port = a
       update

data/lib/Dnsruby/SingleResolver.rb

@@ -46,6 +46,7 @@ module Dnsruby
     # * :no_tcp
     # * :ignore_truncation
     # * :src_address
+    # * :src_address6
     # * :src_port
     # * :udp_size
     # * :persistent_tcp
@@ -66,6 +67,7 @@ module Dnsruby
       @tsig = nil
       @ignore_truncation = false
       @src_address        = nil
+      @src_address6        = nil
       @src_port        = [0]
       @recurse = true
       @persistent_udp = false
@@ -115,8 +117,7 @@ module Dnsruby
       isr = PacketSender.new({:server=>@server, :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_port=>@src_port,
-          :do_caching=>@do_caching,
+          :src_address=>@src_address, :src_address6=>@src_address6, :src_port=>@src_port,
           :recurse=>@recurse, :udp_size=>@udp_size})
 
       @single_resolvers = [isr]
@@ -132,8 +133,7 @@ module Dnsruby
       isr = PacketSender.new({:server=>@server, :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_port=>@src_port,
-          :do_caching=>@do_caching,
+          :src_address=>@src_address, :src_address6=>@src_address6, :src_port=>@src_port,
           :recurse=>@recurse, :udp_size=>@udp_size})
 
       @single_res_mutex.synchronize {

data/lib/Dnsruby/dnssec.rb

@@ -281,12 +281,12 @@ module Dnsruby
 
     def self.verify(msg, keys=nil)
       begin
-        return true if @@anchor_verifier.verify(msg, keys=nil)
+        return true if @@anchor_verifier.verify(msg, keys)
       rescue VerifyError
         begin
-          return true if @@root_verifier.verify(msg, keys=nil)
+          return true if @@root_verifier.verify(msg, keys)
         rescue VerifyError
-          return true if @@dlv_verifier.verify(msg, keys=nil) # Will carry error to client
+          return true if @@dlv_verifier.verify(msg, keys) # Will carry error to client
         end
       end
     end

data/lib/Dnsruby/message.rb

@@ -314,6 +314,11 @@ module Dnsruby
       return ret
     end
 
+    def remove_additional
+      @additional = Section.new(self)
+      @header.arcount = 0
+    end
+
     # Return the first rrset of the specified attributes in the message
     def rrset(name, type, klass = Classes::IN)
       [@answer, @authority, @additional].each do |section|

data/lib/Dnsruby/resource/resource.rb

@@ -34,7 +34,12 @@ module Dnsruby
       @num_sigs = 0
       rrs.each {|rr| add(rr)}
     end
-    # The RRSIGs stored with this RRSet
+    def self.new_from_string(string)
+      rr_strings = string.split("\n")
+      rrs = rr_strings.map { |s| Dnsruby::RR.new_from_string(s) }
+
+      Dnsruby::RRSet.new(rrs)
+    end    # The RRSIGs stored with this RRSet
     def sigs
       return @rrs[@rrs.length-@num_sigs, @num_sigs]
     end
@@ -106,10 +111,10 @@ module Dnsruby
     def <=>(other)
       #      return 1 if ((!other) || !(other.name) || !(other.type))
       #      return -1 if (!@name)
-      if (@name.canonical == other.name.canonical)
-        return @type.code <=> other.type.code
+      if (name.canonical == other.name.canonical)
+        return type.code <=> other.type.code
       else
-        return @name <=> other.name
+        return name <=> other.name
       end
     end
 

data/lib/Dnsruby/single_verifier.rb

@@ -680,8 +680,9 @@ module Dnsruby
         end
 
         sigrecs.each {|sig|
+#          print "Looking at #{sig.key_tag} on sig, #{key.key_tag} on key\n"
           if ((key.key_tag == sig.key_tag) && (key.algorithm == sig.algorithm))
-            #                        print "Found key #{key.key_tag}\n"
+#                                    print "Found key #{key.key_tag}\n"
             return key, sig
           end
         }
@@ -695,6 +696,12 @@ module Dnsruby
     # Returns true if the RRSet verified, false otherwise.
     def verify_rrset(rrset, keys = nil)
       #      print "Verify_rrset #{rrset.name}, #{rrset.type}\n"
+#      print "ABOUT TO VERIFY WITH #{keys == nil ? '0' : keys.length} keys\n"
+#      if (keys != nil)
+#        if (keys.length > 0)
+#          print "KEY TAG : #{keys[0].key_tag}\n"
+#        end
+#      end
       sigrecs = rrset.sigs
       if (rrset.rrs.length == 0)
         raise VerifyError.new("No RRSet to verify")
@@ -744,6 +751,9 @@ module Dnsruby
         raise VerifyError.new("DNSKEY with SEP flag set and Zone Key flag not set")
       end
 
+
+#      print "VERIFY KEY FOUND - doing verification\n"
+
       #Any DNS names in the RDATA field of each RR MUST be in
       #canonical form; and
       #The RRset MUST be sorted in canonical order.

data/lib/dnsruby.rb

@@ -104,7 +104,7 @@ require 'Dnsruby/TheLog'
 module Dnsruby
 
   # @TODO@ Remember to update version in dnsruby.gemspec!
-  VERSION = 1.53
+  VERSION = 1.54
   def Dnsruby.version
     return VERSION
   end

data/test/tc_res_config.rb

@@ -14,48 +14,50 @@
 #limitations under the License.
 #++
 begin
-require 'rubygems'
+  require 'rubygems'
 rescue LoadError
 end
 require 'test/unit'
 require 'dnsruby'
 class TestResolverConfig < Test::Unit::TestCase
-  def setup
-    Dnsruby::Config.reset
-  end
   
   GoodInput = {
-	"port"		  => 54,
-	"src_address"        => '10.1.0.1',
-	"src_port"        => 56453,
-	"use_tcp"		   => true,
+    "port"		  => 54,
+    "src_address"        => '10.1.0.1',
+    "src_address6"        => 'fc00::1:2:3',
+    "src_port"        => 56453,
+    "use_tcp"		   => true,
     #	"stayopen"       => 1,
-	"ignore_truncation"          => true,
-	"recurse"        => false,
-	"packet_timeout"    => 5,
+    "ignore_truncation"          => true,
+    "recurse"        => false,
+    "packet_timeout"    => 5,
     #	"dnssec"         => 1,
     #	"force_v4"       => 1,
   };
   
   ExtendedInput={
     "query_timeout"        => 30,
-	"retry_delay"	       => 6,
-	"retry_times"		   => 5,
+    "retry_delay"	       => 6,
+    "retry_times"		   => 5,
   }
   
   LookupInput={
-	"domain"	       => 'dnsruby.rubyforge.org',
-	"apply_search_list"         => false,
-	"ndots"       => 4	,
-	"apply_domain" => false	
+    "domain"	       => 'dnsruby.rubyforge.org',
+    "apply_search_list"         => false,
+    "ndots"       => 4	,
+    "apply_domain" => false
   }
   
+  def setup
+    Dnsruby::Config.reset
+  end
+
   def test_multiple_resolver
-    res = Dnsruby::Resolver.new();
+    res = Dnsruby::Resolver.new({:nameserver => ["127.0.0.1", "::1"]});
     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.');
@@ -64,8 +66,8 @@ class TestResolverConfig < Test::Unit::TestCase
     
     #~ #diag "\n\nIf you do not have Net::DNS::SEC installed you will see a warning.\n";
     #~ #diag "It is safe to ignore this\n";
-    
-     (GoodInput.merge(ExtendedInput)).each do | param, value |
+
+    (GoodInput.merge(ExtendedInput)).each do | param, value |
       #      puts("Setting " + param);
       res.send(param+"=", value)
       assert_equal(res.send(param), value,       "setting #param sticks");
@@ -74,12 +76,14 @@ class TestResolverConfig < Test::Unit::TestCase
   end
   
   def test_single_resolver
-    res = Dnsruby::SingleResolver.new
-    GoodInput.each do | param, value |
-      #      puts("Setting " + param);
-      res.send(param+"=", value)
-      assert_equal(res.send(param), value,       "setting #param sticks");
-    end;
+    [Dnsruby::SingleResolver.new({:nameserver => ["127.0.0.1"]}),
+      Dnsruby::SingleResolver.new({:nameserver => ["::1"]})].each {|res|
+      GoodInput.each do | param, value |
+        #      puts("Setting " + param);
+        res.send(param+"=", value)
+        assert_equal(res.send(param), value,       "setting #param sticks");
+      end;
+    }
   end
   
   def test_dns
@@ -87,7 +91,7 @@ class TestResolverConfig < Test::Unit::TestCase
     LookupInput.each do | param, value |
       res.config.send(param+"=", value)
       assert_equal(res.config.send(param), value,       "setting #param sticks");
-    end;    
+    end;
   end
   
 end

data/test/tc_res_opt.rb

@@ -72,6 +72,7 @@ class TestResOpt < Test::Unit::TestCase
       :server	   => '10.0.0.1',
       :port		   => 54, # SingleResolver and Multi-Resolver
       :src_address        => '10.1.0.1', # SingleResolver and Multi-Resolver
+      :src_address6        => 'fc00::1:2:3', # SingleResolver and Multi-Resolver
       :src_port        => 56353, # SingleResolver and Multi-Resolver
       :use_tcp		   => true, # SingleResolver and Multi-Resolver
       :ignore_truncation          => true, # SingleResolver and Multi-Resolver
@@ -94,6 +95,7 @@ class TestResOpt < Test::Unit::TestCase
       :nameserver	   => ['10.0.0.1', '10.0.0.2'], # for Multi-Resolver & DNS
       :port		   => 54, # SingleResolver and Multi-Resolver
       :src_address        => '10.1.0.1', # SingleResolver and Multi-Resolver
+      :src_address6        => 'fc00::1:2:3', # SingleResolver and Multi-Resolver
       :src_port        => 56753, # SingleResolver and Multi-Resolver
       :retry_delay	       => 6, # DNS and Multi-Resolver
       :retry_times		   => 5, # DNSand Multi-Resolver

data/test/tc_rr-opt.rb

@@ -14,7 +14,7 @@
 #limitations under the License.
 #++
 begin
-require 'rubygems'
+  require 'rubygems'
 rescue LoadError
 end
 require 'test/unit'
@@ -42,7 +42,7 @@ class TestRrOpt < Test::Unit::TestCase
   end
   
   def test_resolver_opt_application
-        return if (/java/ =~ RUBY_PLATFORM) # @TODO@ Check if this is fixed with JRuby yet
+    return if (/java/ =~ RUBY_PLATFORM) # @TODO@ Check if this is fixed with JRuby yet
     # 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.
@@ -102,4 +102,59 @@ class TestRrOpt < Test::Unit::TestCase
     # Make sure there is an OPT RR there
     assert(m2.rcode == RCode.NOERROR  )
   end
+
+  def test_formerr_response
+    # If we get a FORMERR back from the remote resolver, we should retry with no OPT record
+    # So, we need a server which sends back FORMERR for OPT records, and is OK without them.
+    # Then, we need to get a client to send a request to it (by default adorned with EDNS0),
+    # and make sure that the response is returned to the client OK.
+    # We should then check that the server only received one message with EDNS0, and one message
+    # without.
+    return if (/java/ =~ RUBY_PLATFORM) # @TODO@ Check if this is fixed with JRuby yet
+    # 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]
+    q = Queue.new
+    Thread.new {
+      2.times {
+        s = socket.recvfrom(65536)
+        received_query = s[0]
+        m = Message.decode(received_query)
+        q.push(m)
+        if (m.header.arcount > 0)
+          # send back FORMERR
+          m.header.rcode = RCode.FORMERR
+          socket.send(m.encode,0,s[1][2], s[1][1])
+        else
+          socket.send(received_query,0,s[1][2], s[1][1]) # @TODO@ FORMERR if edns
+        end
+      }
+
+    }
+    # Now send query
+    res = Resolver.new("127.0.0.1")
+    res.port = port
+    res.udp_size = 4096
+    assert(res.udp_size == 4096)
+    ret = res.query("example.com")
+    assert(ret.header.get_header_rcode == RCode.NOERROR)
+    assert(ret.header.arcount == 0)
+
+    # Now get received query from the server
+    p = q.pop
+    # Now check the query was what we expected
+    assert(p.header.arcount == 1)
+    assert(p.additional()[0].type = Types.OPT)
+    assert(p.additional()[0].klass.code == 4096)
+
+    # Now check the second message
+    assert (!(q.empty?))
+    p2 = q.pop
+    assert (p2)
+    assert(p2.header.arcount == 0)
+  end
 end

metadata

@@ -1,12 +1,11 @@
 --- !ruby/object:Gem::Specification 
 name: dnsruby
 version: !ruby/object:Gem::Version 
-  hash: 101
-  prerelease: 
+  prerelease: false
   segments: 
   - 1
-  - 53
-  version: "1.53"
+  - 54
+  version: "1.54"
 platform: ruby
 authors: 
 - AlexD
@@ -14,7 +13,8 @@ autorequire: dnsruby
 bindir: bin
 cert_chain: []
 
-date: 2011-11-17 00:00:00 Z
+date: 2013-06-12 00:00:00 +01:00
+default_executable: 
 dependencies: []
 
 description: 
@@ -154,6 +154,7 @@ files:
 - EXAMPLES
 - README
 - EVENTMACHINE
+has_rdoc: true
 homepage: http://rubyforge.org/projects/dnsruby/
 licenses: []
 
@@ -163,27 +164,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: dnsruby
-rubygems_version: 1.8.11
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Ruby DNS(SEC) implementation