bluemonk-net-dns 0.5.0

data/lib/net/dns/question.rb

@@ -0,0 +1,195 @@
+#---
+# $Id: Question.rb,v 1.8 2006/07/28 19:00:03 bluemonk Exp $     
+#+++
+
+require 'net/dns/dns'
+require 'net/dns/names/names'
+require 'net/dns/rr/types'
+require 'net/dns/rr/classes'
+
+module Net # :nodoc:
+  module DNS 
+
+    #
+    # =Name
+    #
+    # Net::DNS::Question - DNS packet question class
+    #
+    # =Synopsis
+    # 
+    #   require 'net/dns/question'
+    #
+    # =Description
+    #
+    # This class represent the Question portion of a DNS packet. The number
+    # of question entries is stored in the +qdCount+ variable of an Header
+    # object. 
+    #
+    # A new object can be created passing the name of the query and the type
+    # of answer desired, plus an optional argument containing the class:
+    #
+    #   question = Net::DNS::Question.new("google.com.", Net::DNS::A)
+    #      #=> "google.com.                   A       IN"
+    #
+    # Alternatevly, a new object is created when processing a binary
+    # packet, as when an answer is received.
+    # To obtain the binary data from a question object you can use
+    # the method Question#data:
+    # 
+    #   question.data
+    #      #=> "\006google\003com\000\000\001\000\001"
+    #
+    # A lot of methods were written to keep a compatibility layer with
+    # the Perl version of the library, as long as methods name which are
+    # more or less the same. 
+    #
+    # =Error classes
+    #
+    # Some error classes has been defined for the Net::DNS::Header class,
+    # which are listed here to keep a light and browsable main documentation.
+    # We have:
+    #
+    # * QuestionArgumentError: generic argument error
+    # * QuestionNameError:     an error in the +name+ part of a Question entry
+    #
+    # =Copyright
+    # 
+    # Copyright (c) 2006 Marco Ceresa
+    #
+    # All rights reserved. This program is free software; you may redistribute 
+    # it and/or modify it under the same terms as Ruby itself.
+    #
+    class Question
+      
+      include Net::DNS::Names
+      
+      # +name+ part of a Question entry
+      attr_reader :qName 
+      # +type+ part of a Question entry
+      attr_reader :qType 
+      # +class+ part of a Question entry
+      attr_reader :qClass 
+      
+      # Creates a new Net::DNS::Question object:
+      #
+      #   question = Net::DNS::Question.new("example.com")
+      #      #=> "example.com                   A       IN"
+      #   question = Net::DNS::Question.new("example.com", Net::DNS::MX)
+      #      #=> "example.com                   MX      IN"
+      #   question = Net::DNS::Question.new("example.com", Net::DNS::TXT, Net::DNS::HS)
+      #      #=> "example.com                   TXT     HS"
+      
+      # If not specified, +type+ and +cls+ arguments defaults 
+      # to Net::DNS::A and Net::DNS::IN respectively.
+      #
+      def initialize(name,type=Net::DNS::A,cls=Net::DNS::IN)
+        @qName = check_name name
+        @qType = Net::DNS::RR::Types.new type
+        @qClass = Net::DNS::RR::Classes.new cls
+      end
+
+      # Return a new Net::DNS::Question object created by
+      # parsing binary data, such as an answer from the
+      # nameserver.
+      #
+      #   question = Net::DNS::Question.parse(data)
+      #   puts "Queried for #{question.qName} type #{question.qType.to_s}"
+      #     #=> Queried for example.com type A
+      #
+      def self.parse(arg)
+        if arg.kind_of? String
+          o = allocate
+          o.send(:new_from_binary,arg)
+          o
+        else
+          raise QuestionArgumentError, "Wrong argument format, must be a String"
+        end
+      end
+
+      # Known inspect method with nice formatting
+      def inspect
+        if @qName.size > 29 then 
+          len = @qName.size + 1 
+        else
+          len = 29
+        end
+        [@qName,@qClass.to_s,@qType.to_s].pack("A#{len} A8 A8")
+      end
+      
+      # Outputs binary data from a Question object
+      #
+      #   question.data
+      #      #=> "\006google\003com\000\000\001\000\001"
+      #
+      def data
+        [pack_name(@qName),@qType.to_i,@qClass.to_i].pack("a*nn")
+      end
+      
+      # Return the binary data of the objects, plus an offset
+      # and an Hash with references to compressed names. For use in 
+      # Net::DNS::Packet compressed packet creation.
+      #
+      def comp_data
+        arr = @qName.split(".")
+        str = pack_name(@qName)
+        string = ""
+        names = {}
+        offset = Net::DNS::HFIXEDSZ
+        arr.size.times do |i|
+          x = i+1
+          elem = arr[-x]
+          len = elem.size
+          string = ((string.reverse)+([len,elem].pack("Ca*")).reverse).reverse
+          names[string] = offset
+          offset += len
+        end
+        offset += 2 * Net::DNS::INT16SZ
+        str += "\000"
+        [[str,@qType.to_i,@qClass.to_i].pack("a*nn"),offset,names]
+      end
+      
+      private
+      
+      def build_qName(str)
+        result = ""
+        offset = 0
+        loop do
+          len = str.unpack("@#{offset} C")[0]
+          break if len == 0
+          offset += 1
+          result += str[offset..offset+len-1]
+          result += "."
+          offset += len
+        end
+        result
+      end
+      
+      def check_name(name)
+        name.strip!
+        if name =~ /[^\w\.\-_]/
+          raise QuestionNameError, "Question name #{name.inspect} not valid"          
+        else
+          name
+        end
+      rescue
+        raise QuestionNameError, "Question name #{name.inspect} not valid"                  
+      end
+      
+      def new_from_binary(data)
+        str,type,cls = data.unpack("a#{data.size-4}nn")
+        @qName = build_qName(str)
+        @qType = Net::DNS::RR::Types.new type
+        @qClass = Net::DNS::RR::Classes.new cls
+      rescue StandardError => e
+        raise QuestionArgumentError, "Invalid data: #{data.inspect}\n{e.backtrace}"
+      end
+
+    end # class Question
+    
+  end # class DNS
+end # module Net
+
+class QuestionArgumentError < ArgumentError # :nodoc:
+end
+class QuestionNameError < StandardError # :nodoc:
+end

data/lib/net/dns/resolver/socks.rb

@@ -0,0 +1,154 @@
+require 'socket'
+require 'ipaddr'
+
+class RawSocket # :nodoc:
+
+  @@id_arr = []
+  
+  def initialize(src_addr,dest_addr)
+    
+    # Define socket
+    begin
+      @socket = Socket.new PF_INET, SOCK_RAW, IPPROTO_RAW
+    rescue SystemCallError => e
+      raise SystemCallError, "You must be root to use raw sockets! #{e}"
+    end
+    
+    @socket.setsockopt IPPROTO_IP, IP_HDRINCL, 1
+
+    # Checks addresses
+    @src_addr  = check_addr src_addr
+    @dest_addr = check_addr dest_addr
+
+    # Source and destination port are zero
+    @src_port  = 0
+    @dest_port = 0
+
+    # Set correct protocol version in the header
+    @version = @dest_addr.ipv4? ? "0100" : "0110"
+    
+    # Total lenght: must be overridden by subclasses
+    @tot_lenght = 20
+
+    # Protocol: must be overridden by subclasses
+    @protocol = 1 # ICMP by default
+
+    # Generate a new id
+    # @id = genID
+    @id = 1234
+
+    # Generate peer sockaddr
+    @to = Socket.pack_sockaddr_in @dest_port, @dest_addr.to_s    
+  end
+
+  def send(payload = '')
+    packet = make_ip_header([[ @version+'0101', 'B8' ],            # version, hlen
+                              [ 0, 'C' ],                          # tos
+                              [ @tot_lenght + payload.size, 'n' ], # total len
+                              [ @id, 'n' ],                        # id
+                              [ 0, 'n' ],                          # flags, offset
+                              [ 64, 'C' ],                         # ttl
+                              [ @protocol, 'C' ],                  # protocol
+                              [ 0, 'n' ],                          # checksum
+                              [ @src_addr.to_i, 'N' ],             # source
+                              [ @dest_addr.to_i, 'N' ],            # destination
+                            ])
+    packet << make_transport_header(payload.size)
+    packet << [payload].pack("a*")
+    @socket.send(packet,0,@to)
+  end 
+
+  private
+  
+  def check_addr addr
+    case addr
+    when String
+      IPAddr.new addr
+    when IPAddr
+      addr
+    else
+      raise ArgumentError, "Wrong address format: #{addr}"
+    end
+  end
+  
+  def check_port port
+    if (1..65535).include? port and port.kind_of? Integer
+      port
+    else
+      raise ArgumentError, "Port #{port} not valid"
+    end
+  end
+  
+  def genID
+    while (@@id_arr.include?(q = rand(65535)))
+    end
+    @@id_arr.push(q)
+    q
+  end
+
+  def ipchecksum(data)
+    checksum = data.unpack("n*").inject(0) { |s, x| s + x }
+    ((checksum >> 16) + (checksum & 0xffff)) ^ 0xffff
+  end
+
+  def make_ip_header(parts)
+    template = ''
+    data = []
+    parts.each do |part|
+      data += part[0..-2]
+      template << part[-1]
+    end
+    data_str = data.pack(template)
+    checksum = ipchecksum(data_str)
+    data[-3] = checksum
+    data.pack(template)
+  end
+  
+  def make_transport_header
+    ""
+  end
+  
+end
+
+class UdpRawSocket < RawSocket # :nodoc:
+
+  def initialize(src_addr,src_port,dest_addr,dest_port)
+    
+    super(src_addr,dest_addr)
+    
+    # Check ports
+    @src_port  = check_port src_port
+    @dest_port = check_port dest_port
+    
+    # Total lenght: must be overridden by subclasses
+    @tot_lenght = 20 + 8 # 8 bytes => UDP Header
+
+    # Protocol: must be overridden by subclasses
+    @protocol = 17 # UDP protocol
+
+    @to = Socket.pack_sockaddr_in @dest_port, @dest_addr.to_s    
+  end
+
+  private
+  
+  def make_udp_header(parts)
+    template = ''
+    data = []
+    parts.each do |part|
+      data += part[0..-2]
+      template << part[-1]
+    end
+    data.pack(template)
+  end 
+  
+  def make_transport_header(pay_size)
+    make_udp_header([
+                      [ @src_port, 'n'],         # source port
+                      [ @dest_port, 'n' ],       # destination port
+                      [ 8 + pay_size, 'n' ],     # len
+                      [ 0, 'n' ]                 # checksum (mandatory)
+                    ]) 
+  end
+  
+end
+

data/lib/net/dns/resolver/timeouts.rb

@@ -0,0 +1,73 @@
+require 'timeout'
+
+module SecondsHandle #:nodoc: all
+  def transform(secs)
+    case secs
+    when 0
+      to_s
+    when 1..59
+      "#{secs} seconds"
+    when 60..3559
+      "#{secs/60} minutes and #{secs%60} seconds"
+    else
+      hours = secs/3600
+      secs -= (hours*3600)
+      "#{hours} hours, #{secs/60} minutes and #{secs%60} seconds"
+    end
+  end
+end
+
+class DnsTimeout # :nodoc: all
+
+  include SecondsHandle
+  
+  def initialize(seconds)
+    if seconds.is_a? Numeric and seconds >= 0
+      @timeout = seconds
+    else
+      raise DnsTimeoutArgumentError, "Invalid value for tcp timeout"
+    end    
+  end
+  
+  def to_s
+    if @timeout == 0 
+      @output
+    else
+      @timeout.to_s
+    end
+  end
+  
+  def pretty_to_s
+    transform(@timeout)
+  end
+  
+  def timeout
+    unless block_given?
+      raise DnsTimeoutArgumentError, "Block required but missing"
+    end
+    if @timeout == 0
+      yield
+    else
+      return Timeout.timeout(@timeout) do
+        yield
+      end
+    end
+  end
+end
+
+class TcpTimeout < DnsTimeout # :nodoc: all
+  def initialize(seconds)
+    @output = "infinite"
+    super(seconds)
+  end
+end
+
+class UdpTimeout < DnsTimeout # :nodoc: all
+  def initialize(seconds)
+    @output = "not defined"
+    super(seconds)
+  end
+end
+
+class DnsTimeoutArgumentError < ArgumentError # :nodoc: all
+end