net-dns 0.8.0 → 0.9.0

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

@@ -2,18 +2,16 @@ require 'socket'
 require 'ipaddr'
 
 class RawSocket # :nodoc:
-
   @@id_arr = []
-  
-  def initialize(src_addr,dest_addr)
-    
+
+  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
@@ -26,7 +24,7 @@ class RawSocket # :nodoc:
 
     # Set correct protocol version in the header
     @version = @dest_addr.ipv4? ? "0100" : "0110"
-    
+
     # Total lenght: must be overridden by subclasses
     @tot_lenght = 20
 
@@ -38,49 +36,50 @@ class RawSocket # :nodoc:
     @id = 1234
 
     # Generate peer sockaddr
-    @to = Socket.pack_sockaddr_in @dest_port, @dest_addr.to_s    
+    @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_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 
+    @socket.send(packet, 0, @to)
+  end
 
   private
-  
-  def check_addr addr
+
+  def check_addr(addr)
     case addr
-      when String
-        IPAddr.new(addr)
-      when IPAddr
-        addr
-      else
-        raise ArgumentError, "Wrong address format: #{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
+
+  def check_port(port)
+    if (1..65_535).cover?(port) && port.is_a?(Integer)
       port
     else
       raise ArgumentError, "Port #{port} not valid"
     end
   end
-  
+
   def genID
-    while (@@id_arr.include?(q = rand(65535)))
+    while @@id_arr.include?(q = rand(65_535))
     end
     @@id_arr.push(q)
     q
@@ -103,34 +102,31 @@ class RawSocket # :nodoc:
     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)
 
-  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    
+    @to = Socket.pack_sockaddr_in @dest_port, @dest_addr.to_s
   end
 
   private
-  
+
   def make_udp_header(parts)
     template = ''
     data = []
@@ -139,16 +135,14 @@ class UdpRawSocket < RawSocket # :nodoc:
       template << part[-1]
     end
     data.pack(template)
-  end 
-  
+  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)
-                    ]) 
+      [@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

@@ -3,14 +3,11 @@ require 'timeout'
 module Net # :nodoc:
   module DNS
     class Resolver
-
       class DnsTimeout
-
         attr_reader :seconds
 
-
         def initialize(seconds)
-          if seconds.is_a? Numeric and seconds >= 0
+          if seconds.is_a?(Numeric) && seconds >= 0
             @seconds = seconds
           else
             raise ArgumentError, "Invalid value for tcp timeout"
@@ -20,11 +17,7 @@ module Net # :nodoc:
         # Returns a string representation of the timeout corresponding
         # to the number of <tt>@seconds</tt>.
         def to_s
-          if @seconds == 0
-            @output.to_s
-          else
-            @seconds.to_s
-          end
+          @seconds == 0 ? @output.to_s : @seconds.to_s
         end
 
         def pretty_to_s
@@ -37,27 +30,26 @@ module Net # :nodoc:
         # 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
+        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
@@ -73,7 +65,6 @@ module Net # :nodoc:
           super
         end
       end
-
     end
   end
-end
+end

data/lib/net/dns/rr.rb

@@ -1,15 +1,14 @@
 require 'ipaddr'
-require 'net/dns/names'
-require 'net/dns/rr/types'
-require 'net/dns/rr/classes'
+require_relative 'names'
+require_relative 'rr/types'
+require_relative 'rr/classes'
 
-%w(a aaaa cname hinfo mr mx ns ptr soa srv txt).each do |file|
-  require "net/dns/rr/#{file}"
+%w[a aaaa cname hinfo mr mx ns ptr soa srv txt].each do |file|
+  require_relative "rr/#{file}"
 end
 
 module Net
   module DNS
-
     #
     # = Net::DNS::RR - DNS Resource Record class
     #
@@ -42,7 +41,6 @@ module Net
     class RR
       include Names
 
-
       # Base error class.
       class Error < StandardError
       end
@@ -51,7 +49,6 @@ module Net
       class DataError < Error
       end
 
-
       # Regexp matching an RR string
       RR_REGEXP = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s+(" +
                                Net::DNS::RR::Classes.regexp +
@@ -63,7 +60,6 @@ module Net
       # 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.
       #
@@ -108,12 +104,12 @@ module Net
       #
       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"
+        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"
@@ -133,7 +129,7 @@ module Net
       # This method is used when parsing a binary packet by the Packet
       # class.
       #
-      def RR.parse(data)
+      def self.parse(data)
         o = allocate
         obj, offset = o.send(:new_from_binary, data, 0)
         obj
@@ -146,18 +142,14 @@ module Net
       # Return an instance of appropriate class and the offset
       # pointing at the end of the data parsed.
       #
-      def RR.parse_packet(data, offset)
+      def self.parse_packet(data, offset)
         o = allocate
         o.send(:new_from_binary, data, offset)
       end
 
-      def name
-        @name
-      end
+      attr_reader :name
 
-      def ttl
-        @ttl
-      end
+      attr_reader :ttl
 
       # Type accessor
       def type
@@ -169,16 +161,13 @@ module Net
         @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
+      attr_reader :rdata
 
       # Return the RR object in binary data format, suitable
       # for using in network streams.
@@ -201,14 +190,13 @@ module Net
       #
       # TO FIX in one of the future releases
       #
-      def comp_data(offset,compnames)
+      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.
       #
@@ -226,7 +214,7 @@ module Net
       #   #=> "example.com.            7200    IN      MX      10 mailhost.example.com."
       #
       def to_s
-        items = to_a.map { |e| e.to_s }
+        items = to_a.map(&:to_s)
         if @name.size < 24
           items.pack("A24 A8 A8 A8 A*")
         else
@@ -244,123 +232,125 @@ module Net
         [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
+      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
+        # Name of RR - mandatory
+        begin
+          @name = Regexp.last_match(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
+        # Time to live for RR, default 3 hours
+        @ttl = Regexp.last_match(2) ? Regexp.last_match(2).to_i : 10_800
 
-          # RR class, default to IN
-          @cls = Net::DNS::RR::Classes.new $3
+        # RR class, default to IN
+        @cls = Net::DNS::RR::Classes.new Regexp.last_match(3)
 
-          # RR type, default to A
-          @type = Net::DNS::RR::Types.new $4
+        # RR type, default to A
+        @type = Net::DNS::RR::Types.new Regexp.last_match(4)
 
-          # All the rest is data
-          @rdata = $5 ? $5.strip : ""
+        # All the rest is data
+        @rdata = Regexp.last_match(5) ? Regexp.last_match(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
+        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
+      def new_from_hash(args)
+        # Name field is mandatory
+        unless args.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]
+        @name  = args[:name].downcase
+        @ttl   = args[:ttl] ? args[:ttl].to_i : 10_800 # 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
+        @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)
+        if self.class == Net::DNS::RR
+          Net::DNS::RR.const_get(@type.to_s).new(args)
+        else
+          hash = args - %i[name ttl type cls]
+          if hash.key? :rdata
+            subclass_new_from_string(hash[:rdata])
           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
+            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
+      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
+      # Methods to be overridden by subclasses
+      def subclass_new_from_array(arr)
+      end
 
-        def set_type
-          # TODO: Here we should probably
-          # raise NotImplementedError
-          # if we want the method to be implemented in any subclass.
-        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)
+        obj = o.send(:initialize, *args)
         if self == Net::DNS::RR
           obj
         else
           o
         end
       end
-
     end
-
   end
 end