net-dns 0.1

data/lib/net/dns/rr/a.rb

@@ -0,0 +1,121 @@
+##
+#
+# Net::DNS::RR::A
+#
+# $id$
+#
+##
+
+require 'ipaddr'
+
+module Net # :nodoc:
+  module DNS 
+    
+    class RR 
+
+      # =Name
+      #
+      # Net::DNS::RR::A   DNS A resource record
+      #
+      # =Synopsis
+      #
+      # require "net/dns/rr"
+      #
+      # =Description
+      #
+      # Net::DNS::RR::A is the class to handle resource records of type A, the
+      # most common in a DNS query. Its resource data is an IPv4 (i.e. 32 bit
+      # long) address, hold in the instance variable +address+.  
+      #    a = Net::DNS::RR::A.new("localhost.movie.edu. 360 IN A 127.0.0.1")
+      #
+      #    a = Net::DNS::RR::A.new(:name    => "localhost.movie.edu.",
+      #                            :ttl     => 360,
+      #                            :cls     => Net::DNS::IN,
+      #                            :type    => Net::DNS::A,
+      #                            :address => "127.0.0.1")
+      #
+      # When computing binary data to trasmit the RR, the RDATA section is an
+      # Internet address expressed as four decimal numbers separated by dots
+      # without any imbedded spaces (e.g.,"10.2.0.52" or "192.0.5.6").
+      #
+      class A < RR
+        attr_reader :address
+
+        # Assign to the RR::A object a new IPv4 address, which can be in the
+        # form of a string or an IPAddr object
+        #
+        #   a.address = "192.168.0.1"
+        #   a.address = IPAddr.new("10.0.0.1")
+        #
+        def address=(addr)
+          @address = check_address addr
+          build_pack
+        end # address=
+        
+        private
+        
+        def check_address(addr)
+          address = ""
+          case addr
+          when String 
+            address = IPAddr.new addr
+          when Integer # Address in numeric form
+            tempAddr = [(addr>>24),(addr>>16)&0xFF,(addr>>8)&0xFF,addr&0xFF]
+            tempAddr = tempAddr.collect {|x| x.to_s}.join(".")
+            address = IPAddr.new tempAddr
+          when IPAddr
+            address = addr
+          else
+            raise RRArgumentError, "Unknown address type: #{addr}"
+          end
+          raise RRArgumentError, "Must specify an IPv4 address" unless address.ipv4?
+          address
+        rescue ArgumentError
+          raise RRArgumentError, "Invalid address #{addr}"
+        end
+          
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
+        
+        def set_type
+          @type = Net::DNS::RR::Types.new("A")
+        end
+        
+        def get_data
+          @address_pack
+        end
+
+        def get_inspect
+          "#@address"
+        end
+        
+        def subclass_new_from_hash(args)
+          if args.has_key? :address 
+            @address = check_address args[:address]
+          elsif args.has_key? :rdata
+            @address = check_address args[:rdata]
+          else
+            # Address field is mandatory
+            raise RRArgumentError, ":address field is mandatory but missing"
+          end
+        end
+        
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
+        
+        def subclass_new_from_binary(data,offset)
+          a,b,c,d = data.unpack("@#{offset} CCCC")
+          @address = IPAddr.new "#{a}.#{b}.#{c}.#{d}"
+          return offset + 4
+        end
+        
+      end # class A
+      
+    end # class RR
+  end # module DNS
+end # module Net
+
+

data/lib/net/dns/rr/aaaa.rb

@@ -0,0 +1,92 @@
+##
+#
+# Net::DNS::RR::AAAA
+#
+# $id$
+#
+##
+
+require 'ipaddr'
+
+module Net 
+  module DNS 
+    
+    class RR 
+
+      #
+      # RR type AAAA
+      #
+      class AAAA < RR
+        attr_reader :address
+
+        # Assign to the RR::AAAA object a new IPv6 address, which can be in the
+        # form of a string or an IPAddr object
+        #
+        #   a.address = "::1"
+        #   a.address = IPAddr.new("::1")
+        #
+        def address=(addr)
+          @address = check_address addr
+          build_pack
+        end # address=
+        
+        private
+        
+        def check_address(addr)
+          address = ""
+          case addr
+          when String 
+            address = IPAddr.new addr
+          when IPAddr
+            address = addr
+          else
+            raise RRArgumentError, "Unknown address type: #{addr.inspect}"
+          end
+          raise RRArgumentError, "Must specify an IPv6 address" unless address.ipv6?
+          address
+        rescue ArgumentError
+          raise RRArgumentError, "Invalid address #{addr.inspect}"
+        end
+          
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
+        
+        def set_type
+          @type = Net::DNS::RR::Types.new("AAAA")
+        end
+        
+        def get_data
+          @address_pack
+        end
+
+        def get_inspect
+          "#@address"
+        end
+        
+        def subclass_new_from_hash(args)
+          if args.has_key? :address 
+            @address = check_address args[:address]
+          else
+            raise RRArgumentError, ":address field is mandatory but missing"
+          end
+        end
+        
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
+        
+        def subclass_new_from_binary(data,offset)
+          arr = data.unpack("@#{offset} n8")
+          @address = IPAddr.new sprintf("%x:%x:%x:%x:%x:%x:%x:%x",*arr)
+          return offset + 16
+        end
+        
+      end # class AAAA
+      
+    end # class RR
+  end # module DNS
+end # module Net
+
+

data/lib/net/dns/rr/classes.rb

@@ -0,0 +1,148 @@
+module Net # :nodoc:
+  module DNS 
+    
+    class RR
+      
+      #
+      # This is an auxiliary class to hadle RR class field in a DNS packet. 
+      #
+      class Classes
+        
+        # An hash with the values of each RR class stored with the 
+        # respective id number
+        Classes = {
+          'IN'        => 1,       # RFC 1035
+          'CH'        => 3,       # RFC 1035
+          'HS'        => 4,       # RFC 1035
+          'NONE'      => 254,     # RFC 2136
+          'ANY'       => 255,     # RFC 1035
+        }
+        
+        # The default value when class is nil in Resource Records
+        @@default = Classes["IN"]
+
+        # Be able to control the default class to assign when
+        # cls argument is +nil+. Default to +IN+
+        def self.default=(str)
+          if Classes.has_key? str
+            @@default = Classes[str]
+          else
+            raise ClassArgumentError, "Unknown class #{str}"
+          end
+        end
+
+        # Checks whether +cls+ is a valid RR class.  
+        def self.valid?(cls)
+          case cls
+          when String
+            return Classes.has_key?(cls)
+          when Fixnum
+            return Classes.invert.has_key?(cls)
+          else
+            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
+          end
+        end
+        
+        # Returns the class in string format, as "IN" or "CH",
+        # given the numeric value
+        def self.to_str(cls)
+          case cls
+          when Fixnum
+            if Classes.invert.has_key? cls
+              return Classes.invert[cls]
+            else
+              raise ClassArgumentError, "Unknown class number #{cls}"
+            end
+          else
+            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
+          end
+        end
+
+        # Gives in output the keys from the +Classes+ hash
+        # in a format suited for regexps
+        def self.regexp
+          Classes.keys.join("|")
+        end
+
+        # Creates a new object representing an RR class. Performs some
+        # checks on the argument validity too. Il +cls+ is +nil+, the
+        # default value is +ANY+ or the one set with Classes.default=
+        def initialize(cls)
+          case cls
+          when String
+            # type in the form "A" or "NS"
+            new_from_string(cls.upcase) 
+          when Fixnum
+            # type in numeric form
+            new_from_num(cls) 
+          when nil
+            # default type, control with Classes.default=
+            @str = Classes.invert[@@default] 
+            @num = @@default
+          else
+            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
+          end
+        end
+
+        # Constructor for string data class,
+        # *PRIVATE* method
+        def new_from_string(cls)
+          case cls
+          when /^CLASS\\d+/
+            # TODO!!!
+          else 
+            # String with name of class
+            if Classes.has_key? cls
+              @str = cls
+              @num = Classes[cls]
+            else
+              raise ClassesArgumentError, "Unknown cls #{cls}"
+            end
+          end
+        end
+
+        # Contructor for numeric data class
+        # *PRIVATE* method
+        def new_from_num(cls)
+          if Classes.invert.has_key? cls
+            @num = cls
+            @str = Classes.invert[cls]
+          else
+            raise ClassesArgumentError, "Unkown cls number #{cls}"
+          end
+        end
+        
+        # Returns the class in number format 
+        # (default for normal use)
+        def inspect
+          @num
+        end
+
+        # Returns the class in string format,
+        # i.d. "IN" or "CH" or such a string.
+        def to_s
+          @str
+        end
+        
+        # Returns the class in numeric format,
+        # usable by the pack methods for data transfers
+        def to_i
+          @num.to_i
+        end
+
+
+        # Should be used only for testing purpouses
+        def to_str
+          @num.to_s
+        end
+
+        private :new_from_num, :new_from_string
+
+      end # class Classes
+    
+    end # class RR
+  end # module DNS
+end # module Net
+
+class ClassArgumentError < ArgumentError # :nodoc:
+end

data/lib/net/dns/rr/cname.rb

@@ -0,0 +1,69 @@
+##
+#
+# Net::DNS::RR::CNAME
+#
+#       $Id: CNAME.rb,v 1.7 2006/07/28 07:33:36 bluemonk Exp $  
+#
+##
+
+module Net
+  module DNS
+
+    class RR
+      
+      #------------------------------------------------------------
+      # RR type CNAME
+      #------------------------------------------------------------
+      class CNAME < RR
+        attr_reader :cname
+
+        private
+        
+        def check_name(name)
+          unless name =~ /(\w\.?)+\s*$/ and name =~ /[a-zA-Z]/
+            raise RRArgumentError, "Canonical Name not valid: #{name}"
+          end
+          name
+        end
+
+        def build_pack
+          @cname_pack = pack_name(@cname)
+          @rdlength = @cname_pack.size
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("CNAME")
+        end
+
+        def get_data
+          @cname_pack
+        end
+
+        def get_inspect
+          "#@cname"
+        end
+
+        def subclass_new_from_hash(args)
+          if args.has_key? :cname
+            @cname = check_name args[:cname]
+          else
+            raise RRArgumentError, ":cname field is mandatory but missing"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @cname = check_name(str)
+        end
+
+        def subclass_new_from_binary(data,offset)
+          @cname,offset = dn_expand(data,offset)
+          return offset
+        end
+        
+      end # class CNAME
+       
+    end # class RR
+  end # module DNS
+end # module Net
+
+

data/lib/net/dns/rr/hinfo.rb

@@ -0,0 +1,74 @@
+##
+#
+# Net::DNS::RR::HINFO
+#
+# $Id: HINFO.rb,v 1.4 2006/07/28 07:33:36 bluemonk Exp $
+#
+##
+
+module Net
+  module DNS
+    class RR
+      
+      #------------------------------------------------------------
+      # RR type HINFO
+      #------------------------------------------------------------
+      class HINFO < RR
+        attr_reader :cpu, :os
+
+        private
+        
+        def check_hinfo(str)
+          if str.strip =~ /^["'](.*?)["']\s+["'](.*?)["']$/
+            return $1,$2
+          else
+            raise RRArgumentError, "HINFO section not valid: #{str.inspect}"
+          end
+        end
+        
+        def build_pack
+          @hinfo_pack = [@cpu.size].pack("C") + @cpu
+          @hinfo_pack += [@os.size].pack("C") + @os
+          @rdlength = @hinfo_pack.size
+        end
+
+        def set_type
+          @type = Net::DNS::RR::Types.new("HINFO")
+        end
+
+        def get_data
+          @hinfo_pack
+        end
+
+        def get_inspect
+          "#@cpu #@os"
+        end
+
+        def subclass_new_from_hash(args)
+          if args.has_key? :cpu and args.has_key? :os
+            @cpu = args[:cpu]
+            @os =  args[:os]
+          else
+            raise RRArgumentError, ":cpu and :os fields are mandatory but missing"
+          end
+        end
+
+        def subclass_new_from_string(str)
+          @cpu,@os = check_hinfo(str)
+        end
+
+        def subclass_new_from_binary(data,offset)
+          len = data.unpack("@#{offset} C")[0]
+          @cpu = data[offset+1..offset+1+len]
+          offset += len+1
+          len = @data.unpack("@#{offset} C")[0]
+          @os = data[offset+1..offset+1+len]
+          return offset += len+1
+        end
+        
+      end # class HINFO
+      
+    end # class RR
+  end # module DNS
+end # module Net
+