net-dns2 0.8.1

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,75 @@
+require 'timeout'
+
+module Net # :nodoc:
+  module DNS
+    class Resolver
+
+      class DnsTimeout
+
+        attr_reader :seconds
+
+
+        def initialize(seconds)
+          if seconds.is_a?(Numeric) && seconds >= 0
+            @seconds = seconds
+          else
+            raise ArgumentError, "Invalid value for tcp timeout"
+          end
+        end
+
+        # Returns a string representation of the timeout corresponding
+        # to the number of <tt>@seconds</tt>.
+        def to_s
+          @seconds == 0 ? @output.to_s : @seconds.to_s
+        end
+
+        def pretty_to_s
+          transform(@seconds)
+        end
+
+        # Executes the method's block. If the block execution terminates before +sec+
+        # seconds has passed, it returns true. If not, it terminates the execution
+        # and raises Timeout::Error.
+        # If @seconds is 0 or nil, no timeout is set.
+        def timeout(&block)
+          raise LocalJumpError, "no block given" unless block_given?
+          Timeout.timeout(@seconds, &block)
+        end
+
+
+        private
+
+          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 TcpTimeout < DnsTimeout
+        def initialize(seconds)
+          @output = "infinite"
+          super
+        end
+      end
+
+      class UdpTimeout < DnsTimeout
+        def initialize(seconds)
+          @output = "not defined"
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/net/dns/rr.rb

@@ -0,0 +1,366 @@
+require 'ipaddr'
+require 'net/dns/names'
+require 'net/dns/rr/types'
+require 'net/dns/rr/classes'
+
+%w(a aaaa cname hinfo mr mx ns ptr soa srv txt).each do |file|
+  require "net/dns/rr/#{file}"
+end
+
+module Net
+  module DNS
+
+    #
+    # = Net::DNS::RR - DNS Resource Record class
+    #
+    # The Net::DNS::RR is the base class for DNS Resource
+    # Record (RR) objects. A RR is a pack of data that represents
+    # resources for a DNS zone. The form in which this data is
+    # shows can be drawed as follow:
+    #
+    #   "name  ttl  class  type  data"
+    #
+    # The +name+ is the name of the resource, like an canonical
+    # name for an +A+ record (internet ip address). The +ttl+ is the
+    # time to live, expressed in seconds. +type+ and +class+ are
+    # respectively the type of resource (+A+ for ip addresses, +NS+
+    # for nameservers, and so on) and the class, which is almost
+    # always +IN+, the Internet class. At the end, +data+ is the
+    # value associated to the name for that particular type of
+    # resource record. An example:
+    #
+    #   # A record for IP address
+    #   "www.example.com  86400  IN  A  172.16.100.1"
+    #
+    #   # NS record for name server
+    #   "www.example.com  86400  IN  NS  ns.example.com"
+    #
+    # A new RR object can be created in 2 ways: passing a string
+    # such the ones above, or specifying each field as the pair
+    # of an hash. See the Net::DNS::RR.new method for details.
+    #
+    class RR
+      include Names
+
+
+      # Base error class.
+      class Error < StandardError
+      end
+
+      # Error in parsing binary data, maybe from a malformed packet.
+      class DataError < Error
+      end
+
+
+      # Regexp matching an RR string
+      RR_REGEXP = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s+(" +
+                               Net::DNS::RR::Classes.regexp +
+                               "|CLASS\\d+)?\\s*(" +
+                               Net::DNS::RR::Types.regexp +
+                               "|TYPE\\d+)?\\s*(.*)$", Regexp::IGNORECASE)
+
+      # Dimension of the sum of class, type, TTL and rdlength fields in a
+      # RR portion of the packet, in bytes
+      RRFIXEDSZ = 10
+
+
+      # Create a new instance of Net::DNS::RR class, or an instance of
+      # any of the subclass of the appropriate type.
+      #
+      # Argument can be a string or an hash. With a sting, we can pass
+      # a RR resource record in the canonical format:
+      #
+      #   a     = Net::DNS::RR.new("foo.example.com. 86400 A 10.1.2.3")
+      #   mx    = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
+      #   cname = Net::DNS::RR.new("www.example.com 300 IN CNAME www1.example.com")
+      #   txt   = Net::DNS::RR.new('baz.example.com 3600 HS TXT "text record"')
+      #
+      # Incidentally, +a+, +mx+, +cname+ and +txt+ objects will be instances of
+      # respectively Net::DNS::RR::A, Net::DNS::RR::MX, Net::DNS::RR::CNAME and
+      # Net::DNS::RR::TXT classes.
+      #
+      # The name and RR data are required; all other informations are optional.
+      # If omitted, the +TTL+ defaults to 10800, +type+ default to +A+ and the RR class
+      # defaults to +IN+.  Omitting the optional fields is useful for creating the
+      # empty RDATA sections required for certain dynamic update operations.
+      # All names must be fully qualified.  The trailing dot (.) is optional.
+      #
+      # The preferred method is however passing an hash with keys and values:
+      #
+      #   rr = Net::DNS::RR.new(
+      #                 :name    => "foo.example.com",
+      #                 :ttl     => 86400,
+      #                 :cls     => "IN",
+      #                 :type    => "A",
+      #                 :address => "10.1.2.3"
+      #         )
+      #
+      #   rr = Net::DNS::RR.new(
+      #                 :name => "foo.example.com",
+      #                 :rdata => "10.1.2.3"
+      #         )
+      #
+      # Name and data are required; all the others fields are optionals like
+      # we've seen before. The data field can be specified either with the
+      # right name of the resource (+:address+ in the example above) or with
+      # the generic key +:rdata+. Consult documentation to find the exact name
+      # for the resource in each subclass.
+      #
+      def initialize(arg)
+        instance = case arg
+          when String
+            new_from_string(arg)
+          when Hash
+            new_from_hash(arg)
+          else
+            raise ArgumentError, "Invalid argument, must be a RR string or an hash of values"
+        end
+
+        if @type.to_s == "ANY"
+          @cls = Net::DNS::RR::Classes.new("IN")
+        end
+
+        build_pack
+        set_type
+
+        instance
+      end
+
+      # Return a new RR object of the correct type (like Net::DNS::RR::A
+      # if the type is A) from a binary string, usually obtained from
+      # network stream.
+      #
+      # This method is used when parsing a binary packet by the Packet
+      # class.
+      #
+      def RR.parse(data)
+        o = allocate
+        obj, offset = o.send(:new_from_binary, data, 0)
+        obj
+      end
+
+      # Same as RR.parse, but takes an entire packet binary data to
+      # perform name expansion. Default when analizing a packet
+      # just received from a network stream.
+      #
+      # Return an instance of appropriate class and the offset
+      # pointing at the end of the data parsed.
+      #
+      def RR.parse_packet(data, offset)
+        o = allocate
+        o.send(:new_from_binary, data, offset)
+      end
+
+      def name
+        @name
+      end
+
+      def ttl
+        @ttl
+      end
+
+      # Type accessor
+      def type
+        @type.to_s
+      end
+
+      # Class accessor
+      def cls
+        @cls.to_s
+      end
+
+
+      def value
+        get_inspect
+      end
+
+      # Data belonging to that appropriate class,
+      # not to be used (use real accessors instead)
+      def rdata
+        @rdata
+      end
+
+      # Return the RR object in binary data format, suitable
+      # for using in network streams.
+      #
+      #   raw_data = rr.data
+      #   puts "RR is #{raw_data.size} bytes long"
+      #
+      def data
+        str = pack_name(@name)
+        str + [@type.to_i, @cls.to_i, ttl, @rdlength].pack("n2 N n") + get_data
+      end
+
+      # Return the RR object in binary data format, suitable
+      # for using in network streams, with names compressed.
+      # Must pass as arguments the offset inside the packet
+      # and an hash of compressed names.
+      #
+      # This method is to be used in other classes and is
+      # not intended for user space programs.
+      #
+      # TO FIX in one of the future releases
+      #
+      def comp_data(offset,compnames)
+        str, offset, names = dn_comp(@name, offset, compnames)
+        str    += [@type.to_i, @cls.to_i, ttl, @rdlength].pack("n2 N n")
+        offset += Net::DNS::RRFIXEDSZ
+        [str, offset, names]
+      end
+
+
+      # Returns a human readable representation of this record.
+      # The value is always a String.
+      #
+      #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
+      #   #=> example.com.            7200    IN      MX      10 mailhost.example.com.
+      #
+      def inspect
+        to_s
+      end
+
+      # Returns a String representation of this record.
+      #
+      #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
+      #   mx.to_s
+      #   #=> "example.com.            7200    IN      MX      10 mailhost.example.com."
+      #
+      def to_s
+        items = to_a.map { |e| e.to_s }
+        if @name.size < 24
+          items.pack("A24 A8 A8 A8 A*")
+        else
+          items.join("   ")
+        end.to_s
+      end
+
+      # Returns an Array with all the attributes for this record.
+      #
+      #   mx = Net::DNS::RR.new("example.com. 7200 MX 10 mailhost.example.com.")
+      #   mx.to_a
+      #   #=> ["example.com.", 7200, "IN", "MX", "10 mailhost.example.com."]
+      #
+      def to_a
+        [name, ttl, cls.to_s, type.to_s, value]
+      end
+
+
+      private
+
+        def new_from_string(rrstring)
+          unless rrstring =~ RR_REGEXP
+            raise ArgumentError,
+            "Format error for RR string (maybe CLASS and TYPE not valid?)"
+          end
+
+          # Name of RR - mandatory
+          begin
+            @name = $1.downcase
+          rescue NoMethodError
+            raise ArgumentError, "Missing name field in RR string #{rrstring}"
+          end
+
+          # Time to live for RR, default 3 hours
+          @ttl = $2 ? $2.to_i : 10800
+
+          # RR class, default to IN
+          @cls = Net::DNS::RR::Classes.new $3
+
+          # RR type, default to A
+          @type = Net::DNS::RR::Types.new $4
+
+          # All the rest is data
+          @rdata = $5 ? $5.strip : ""
+
+          if self.class == Net::DNS::RR
+            Net::DNS::RR.const_get(@type.to_s).new(rrstring)
+          else
+            subclass_new_from_string(@rdata)
+            self.class
+          end
+        end
+
+        def new_from_hash(args)
+          # Name field is mandatory
+          unless args.has_key? :name
+            raise ArgumentError, ":name field is mandatory"
+          end
+
+          @name  = args[:name].downcase
+          @ttl   = args[:ttl] ? args[:ttl].to_i : 10800 # Default 3 hours
+          @type  = Net::DNS::RR::Types.new args[:type]
+          @cls  = Net::DNS::RR::Classes.new args[:cls]
+
+          @rdata = args[:rdata] ? args[:rdata].strip : ""
+          @rdlength = args[:rdlength] || @rdata.size
+
+          if self.class == Net::DNS::RR
+            Net::DNS::RR.const_get(@type.to_s).new(args)
+          else
+            hash = args - [:name, :ttl, :type, :cls]
+            if hash.has_key? :rdata
+              subclass_new_from_string(hash[:rdata])
+            else
+              subclass_new_from_hash(hash)
+            end
+            self.class
+          end
+        end
+
+        def new_from_binary(data,offset)
+          if self.class == Net::DNS::RR
+            temp = dn_expand(data,offset)[1]
+            type = Net::DNS::RR::Types.new data.unpack("@#{temp} n")[0]
+            (eval "Net::DNS::RR::#{type}").parse_packet(data,offset)
+          else
+            @name,offset = dn_expand(data,offset)
+            rrtype,cls,@ttl,@rdlength = data.unpack("@#{offset} n2 N n")
+            @type = Net::DNS::RR::Types.new rrtype
+            @cls = Net::DNS::RR::Classes.new cls
+            offset += RRFIXEDSZ
+            offset = subclass_new_from_binary(data,offset)
+            build_pack
+            set_type
+            [self, offset]
+          end
+        end
+
+        # Methods to be overridden by subclasses
+        def subclass_new_from_array(arr)
+        end
+        def subclass_new_from_string(str)
+        end
+        def subclass_new_from_hash(hash)
+        end
+        def subclass_new_from_binary(data, offset)
+        end
+        def build_pack
+        end
+        def get_inspect
+          @rdata
+        end
+        def get_data
+          @rdata
+        end
+
+        def set_type
+          # TODO: Here we should probably
+          # raise NotImplementedError
+          # if we want the method to be implemented in any subclass.
+        end
+
+
+      def self.new(*args)
+        o   = allocate
+        obj = o.send(:initialize,*args)
+        if self == Net::DNS::RR
+          obj
+        else
+          o
+        end
+      end
+
+    end
+
+  end
+end