dnstraverse 0.1.0 → 0.1.1

data/bin/dnstraverse

@@ -113,7 +113,7 @@ options[:domainname] = nil
 options[:follow_aaaa] = false
 options[:root_aaaa] = false
 options[:always_tcp] = false
-options[:allow_tcp] = false
+options[:allow_tcp] = true
 options[:allstats] = false
 options[:saveobjects] = false
 options[:fast] = true
@@ -121,6 +121,7 @@ options[:udpsize] = 2048
 options[:maxdepth] = 24
 options[:retries] = 2
 options[:results] = true
+options[:quiet] = false
 
 opts = OptionParser.new
 opts.banner = "Usage: #{File.basename($0)} [options] DOMAIN"  
@@ -146,6 +147,7 @@ opts.on("--[no-]show-results", "Display the results (default true)") { |o| optio
 opts.on("--save-objects") { |o| options[:saveobjects] = o }
 opts.on("--[no-]fast", "Fast mode (default true) turn off to be more accurate" ) { |o| options[:fast] = o }
 opts.on_tail("-h", "--help", "Show full help") { puts opts; exit }
+opts.on_tail("-q", "--quiet", "Supress supplementary information") { options[:quiet] = true }
 opts.on_tail("-V", "--version", "Show version") { puts DNSTraverse::Version::STRING; exit }
 begin
   opts.parse!
@@ -169,8 +171,15 @@ args[:loglevel] = options[:debug] >= 1 ? Logger::DEBUG : Logger::UNKNOWN
 args[:libloglevel] = options[:debug] >= 2 ? Logger::DEBUG : Logger::UNKNOWN
 args[:always_tcp] = true if options[:always_tcp]
 args[:allow_tcp] = true if options[:allow_tcp]
-args[:fast] = true if options[:fast]
+args[:fast] = options[:fast]
 begin
+  unless options[:quiet] then
+    puts "# Using fast mode" if options[:fast]
+    puts "# Limiting traverse to one root" unless options[:allroots]
+    puts "# UDP size #{options[:udpsize]} (EDNS0 is #{options[:udpsize == 512] ? "off" : "on"})"
+    puts "# Retries #{options[:retries]}, max depth #{options[:maxdepth]}"
+    puts "# Allow TCP is #{options[:allow_tcp]}, always TCP is #{options[:always_tcp]}"
+  end
   traverser = DNSTraverse::Traverser.new(args)
   if options[:root] then
     root = options[:root]

data/lib/dnstraverse/decoded_query.rb

@@ -51,6 +51,7 @@ module DNSTraverse
       @warnings = nil # Warnings if there are any (array)
       query unless @message
       process
+      Log.debug { "Query to #{@ip} for #{@qname}/#{@qclass}/#{@qtype} decoded status=#{@status}" }
       return self
     end
     
@@ -155,9 +156,9 @@ module DNSTraverse
         @error_message = "Server failure (SERVFAIL)"
         when Dnsruby::RCode::NXDOMAIN
         @error_message = "No such domain (NXDOMAIN)"
-        when NOTIMP
+        when Dnsruby::RCode.NOTIMP
         @error_message = "Not implemented (NOTIMP)"
-        when REFUSED
+        when Dnsruby::RCode.REFUSED
         @error_message = "Refused"
       else
         @error_message = @message.rcode.to_s

data/lib/dnstraverse/referral.rb

@@ -15,6 +15,7 @@
 
 require 'dnstraverse/response'
 require 'dnstraverse/response_noglue'
+require 'dnstraverse/response_loop'
 require 'dnstraverse/info_cache'
 require 'dnstraverse/decoded_query_cache'
 require 'dnstraverse/summary_stats'
@@ -164,6 +165,26 @@ module DNSTraverse
       return true
     end
     
+    # look out for endless loops
+    # e.g. while looking for a.b we get b NS c.d
+    # and while looking for c.d we get d NS a.b
+    # which would take us back to b NS c.d
+    def loop?
+      return false if @serverips
+      parent = @parent
+      until parent.nil? do
+        if parent.qname.to_s == @qname.to_s and
+          parent.qclass.to_s == @qclass.to_s and
+          parent.qtype.to_s == @qtype.to_s and
+          parent.server == @server and
+          parent.serverips.nil?
+            return true
+        end
+        parent = parent.parent
+      end
+      return false
+    end
+    
     # resolve server to serverips, return list of Referral objects to process
     def resolve(*args)
       raise "This Referral object has already been resolved" if resolved?
@@ -173,6 +194,11 @@ module DNSTraverse
                     " of #{bailiwick} - no glue record provided" }
         return Array.new
       end
+      if loop? then
+        # b IN NS c.d, d IN NS a.b
+        Log.debug { "Loop reached at server #{server}" }
+        return Array.new
+      end
       child_refid = 1
       starters, newbailiwick = @infocache.get_startservers(@server)
       Log.debug { "Resolving #{@server} type #{@nsatype} " }
@@ -205,6 +231,15 @@ module DNSTraverse
                                               :bailiwick => @bailiwick)
         @stats_resolve[r.stats_key] = { :prob => 1.0, :response => r,
           :referral => self }
+      elsif loop? then # endless loop, e.g. b. NS c.d, d NS a.b
+        r = DNSTraverse::Response::Loop.new(:qname => @qname,
+                                            :qclass => @qclass,
+                                            :qtype => @qtype,
+                                            :server => @server,
+                                            :ip => @parent_ip,
+                                            :bailiwick => @bailiwick)
+        @stats_resolve[r.stats_key] = { :prob => 1.0, :response => r,
+          :referral => self }
       else
         # normal resolve - combine children's statistics in to @stats_resolve
         stats_calculate_children(@stats_resolve, @resolves, 1.0)
@@ -339,31 +374,8 @@ module DNSTraverse
       end
     end
     
-    def check_loop?(args) # :ip, :qtype, :qname, :qclass
-      parent = @parent
-      until parent.nil? do
-        if parent.qname.to_s == args[:qname].to_s and
-          parent.qclass.to_s == args[:qclass].to_s and
-          parent.qtype.to_s == args[:qtype].to_s and
-          parent.serverips and parent.serverips.include?(args[:ip]) then
-          exit 1 # XXX fix me
-          return RuntimeError.new("Loop detected")
-        end
-        parent = parent.parent
-      end
-      return nil
-    end
-    
     def process_normal(args)
       Log.debug { "process " + self.to_s }
-      #      if l = check_loop?(:ip => ip, :qname => @qname,
-      #                         :qtype => @qtype, :qclass => @qclass) then
-      #        for ip in @serverips do
-      #          @responses[ip] = l
-      #          done
-      #          return
-      #        end
-      #      end
       for ip in @serverips do
         Log.debug { "Process normal #{ip}" }
         next if ip =~ /^key:/ # resolve failed on something
@@ -376,6 +388,7 @@ module DNSTraverse
                                       :qclass => @qclass, :qtype => @qtype,
                                       :bailiwick => @bailiwick,
                                       :infocache => @infocache, :ip => ip,
+                                      :server => @server,
                                       :decoded_query_cache => @decoded_query_cache)
         Log.debug { "Process normal #{ip} - done making response" }
         @responses[ip] = r
@@ -404,7 +417,7 @@ module DNSTraverse
           :server => starter[:name],
           :serverips => starter[:ips],
           :refid => "#{@refid}.#{child_refid}",
-	  :refkey => "#{@refkey}.#{starters.count}"
+          :refkey => "#{@refkey}.#{starters.count}"
         }.merge(args)
         children.push make_referral(refargs)
         child_refid+= 1
@@ -427,6 +440,9 @@ module DNSTraverse
       @children.each_key do | ip |
         @children[ip].map! { |c| c.equal?(before) ? after : c }
       end
+      if @resolves then
+        @resolves.map! { |c| c.equal?(before) ? after : c }
+      end
     end
     
     def stats_display(args)
@@ -448,7 +464,11 @@ module DNSTraverse
           puts "#{response.exception_message} at #{where}"
           when :noglue
           puts "No glue at #{referral.parent.server} " + 
-            "(#{response.ip}) for #{response.server}"
+            "(#{response.ip}) for #{referral.server}"
+          when :referral_lame
+          puts "Lame referral from #{where}"
+          when :loop
+          puts "Loop encountered at #{response.server} "
           when :error
           puts "#{response.error_message} at #{where}"
           when :nodata

data/lib/dnstraverse/response.rb

@@ -26,6 +26,7 @@ module DNSTraverse
     attr_reader :status # our status, expanding on DecodedQuery status
     attr_reader :starters, :starters_bailiwick # :referral/:restart only
     attr_reader :stats_key
+    attr_reader :server
     
     # :qname, :qclass, :qtype, :ip, :bailiwick, optional :message
     def initialize(args)
@@ -33,6 +34,7 @@ module DNSTraverse
         :qtype => args[:qtype], :ip => args[:ip],
         :bailiwick => args[:bailiwick], :message => args[:message] }
       @decoded_query = args[:decoded_query_cache].query(dqc_args)
+      @server = args[:server]
       @infocache = InfoCache.new(args[:infocache]) # our infocache
       @starters = nil # initial servers for :referral/:restart
       @starters_bailiwick = nil # for initial servers for :referral/:restart
@@ -50,7 +52,7 @@ module DNSTraverse
     
     def update_stats_key
       r = @decoded_query
-      @stats_key = "key:#{r.ip}:#{@status}:#{r.qname}:#{r.qclass}:#{r.qtype}"
+      @stats_key = "key:#{r.ip}:#{@server}:#{@status}:#{r.qname}:#{r.qclass}:#{r.qtype}"
     end
     
     # clean up the workings

data/lib/dnstraverse/response_loop.rb

@@ -0,0 +1,54 @@
+#    DNSTraverse traverses the DNS to show statistics and information
+#    Copyright (C) 2008 James Ponder
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, version 3 of the License.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module DNSTraverse
+  
+  class Response::Loop < Response
+    
+    attr_reader :qname, :qclass, :qtype, :ip, :bailiwick, :server
+    
+    def initialize(args)
+      # we queried @ip about @qname/@qclass/@qtype and received @server as a
+      # referral in bailiwick @bailiwick but without any glue
+      @qname = args[:qname]
+      @qclass = args[:qclass]
+      @qtype = args[:qtype]
+      @bailiwick = args[:bailiwick]
+      @ip = args[:ip]
+      @server = args[:server]
+      @decoded_query = nil
+      @infocache = nil
+      @starters = nil
+      @starters_bailiwick = nil
+      @status = :loop
+      update_stats_key
+      return self
+    end
+    
+    def method_missing(key, *args, &block)
+      super # there are no missing methods, we answer directly
+    end
+    
+    def update_stats_key
+      @stats_key = "key:#{@ip}:#{@status}:#{@qname}:#{@qclass}:#{@qtype}:#{@server}:#{@bailiwick}"
+    end
+    
+    def to_s
+      return "Loop encountered resolving #{@server}"
+    end
+    
+  end
+  
+end

data/lib/dnstraverse/traverser.rb

@@ -158,8 +158,7 @@ module DNSTraverse
           r.cleanup(cleanup)
           if @fast then
             # store away in @answered hash so we can lookup later
-            key = "#{r.qname}:#{r.qclass}:#{r.qtype}:#{r.server}:#{r.txt_ips_verbose}"
-            key.downcase!
+            key = "#{r.qname}:#{r.qclass}:#{r.qtype}:#{r.server}:#{r.txt_ips_verbose}".downcase!
             Log.debug { "Fast mode cache store: #{key}" }
             @answered[key] = r
           end
@@ -169,48 +168,46 @@ module DNSTraverse
             @seen[r.server.downcase].uniq!
           end
           next
-        else
-          report_progress r, :stage => :start
         end
+        # ok time to process a new item
+        if @fast then
+          Log.debug { "Checking #{r} for already completed earlier" }
+          key = "#{r.qname}:#{r.qclass}:#{r.qtype}:#{r.server}:#{r.txt_ips_verbose}".downcase!
+          Log.debug { "Fast mode cache lookup: #{key}" }
+          # check for previously stored answer
+          # special case noglue situation, don't use previous answer
+          # because attributes are complicated for stats collection and
+          # we don't want to merge them together - creating the noglue
+          # response object is fast anyway
+          if @answered.key?(key) and (not r.noglue?) then
+            Log.debug { "Fast method - completed #{r}" }
+            r.parent.replace_child(r, @answered[key])
+            report_progress r, :stage => :answer_fast
+            next
+          end
+        end
+        report_progress r, :stage => :start
         unless r.resolved? then
           # get resolve Referral objects, place on stack with placeholder
           stack << r << :calc_resolve
           referrals = r.resolve({})
           referrals.each { |c| report_progress c, :stage => :new }
-          stack.push(*referrals.reverse) # XXX
+          stack.push(*referrals.reverse)
           next
         end
-        unless r.processed? then
-          # get Referral objects, place on stack with placeholder
-          stack << r << :calc_answer
-          children = r.process({})
-          if @fast then
-            Log.debug { "Checking #{r} for already completed children" }
-            newchildren = []
-            for c in children do
-              key = "#{c.qname}:#{c.qclass}:#{c.qtype}:#{c.server}:#{c.txt_ips_verbose}"
-              key.downcase!
-              Log.debug { "Fast mode cache lookup: #{key}" }
-              # check for previously stored answer
-              # special case noglue situation, don't use previous answer
-              # because attributes are complicated for stats collection and
-              # we don't want to merge them together - creating the noglue
-              # response object is fast anyway
-              if @answered.key?(key) and (not c.noglue?) then
-                Log.debug { "Fast method - completed #{c}" }
-                r.replace_child(c, @answered[key])
-                report_progress c, :stage => :answer_fast
-              else
-                newchildren << c
-              end
-            end
-            children = newchildren
+        # get Referral objects, place on stack with placeholder
+        stack << r << :calc_answer
+        children = r.process({})
+        children.each do |c|
+          if @fast
+            key = "#{c.qname}:#{c.qclass}:#{c.qtype}:#{c.server}:#{c.txt_ips_verbose}".downcase!
+            stage = @answered.key?(key) ? :new_fast : :new
+          else
+            stage = :new
           end
-          children.each { |c| report_progress c, :stage => :new }
-          stack.push(*children.reverse)
-          next
+          report_progress c, :stage => stage
         end
-        raise "Fatal stack error at #{r} - size still #{stack.size}"
+        stack.push(*children.reverse)
       end
     end
     

data/lib/dnstraverse/version.rb

@@ -2,7 +2,7 @@ module DNSTraverse
   module Version
     MAJOR = 0
     MINOR = 1
-    PATCH = 0
+    PATCH = 1
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dnstraverse
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - James Ponder
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-03 00:00:00 +01:00
+date: 2011-06-10 00:00:00 +01:00
 default_executable: dnstraverse
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -106,6 +106,7 @@ files:
 - lib/dnstraverse/message_utility.rb
 - lib/dnstraverse/referral.rb
 - lib/dnstraverse/response.rb
+- lib/dnstraverse/response_loop.rb
 - lib/dnstraverse/response_noglue.rb
 - lib/dnstraverse/summary_stats.rb
 - lib/dnstraverse/traverser.rb