Dnsruby 0.5.0

data/lib/Dnsruby/resource/IN.rb

@@ -0,0 +1,69 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    ClassInsensitiveTypes = [
+    NS, CNAME, DNAME, SOA, PTR, HINFO, MINFO, MX, TXT,
+    ISDN, MB, MG, MR, NAPTR, NSAP, OPT, RP, RT, X25,
+    SPF, CERT, LOC, TSIG, TKEY, ANY
+    ] #:nodoc: all
+    
+    # ARPA Internet specific RRs
+    module IN
+      ClassValue = Classes.IN.code
+      
+      ClassInsensitiveTypes::each {|s|
+        c = Class.new(s)
+        #          c < Record
+        c.const_set(:TypeValue, s::TypeValue)
+        c.const_set(:ClassValue, ClassValue)
+        ClassHash[[s::TypeValue, ClassValue]] = c
+        self.const_set(s.name.sub(/.*::/, ''), c)
+      }
+      
+# RFC 1035, Section 3.4.2 (deprecated)
+      class WKS < RR
+        ClassHash[[TypeValue = Types::WKS, ClassValue = ClassValue]] = self  #:nodoc: all
+        
+        def initialize(address, protocol, bitmap)
+          @address = IPv4.create(address)
+          @protocol = protocol
+          @bitmap = bitmap
+        end
+        attr_reader :address, :protocol, :bitmap
+        
+        def encode_rdata(msg) #:nodoc: all
+          msg.put_bytes(@address.address)
+          msg.put_pack("n", @protocol)
+          msg.put_bytes(@bitmap)
+        end
+        
+        def self.decode_rdata(msg) #:nodoc: all
+          address = IPv4.new(msg.get_bytes(4))
+          protocol, = msg.get_unpack("n")
+          bitmap = msg.get_bytes
+          return self.new(address, protocol, bitmap)
+        end
+      end
+      
+    end
+  end
+end
+require 'Dnsruby/resource/A'
+require 'Dnsruby/resource/AAAA'
+require 'Dnsruby/resource/AFSDB'
+require 'Dnsruby/resource/PX'
+require 'Dnsruby/resource/SRV'

data/lib/Dnsruby/resource/ISDN.rb

@@ -0,0 +1,54 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    #Net::DNS::RR::ISDN - DNS ISDN resource record
+    #RFC 1183 Section 3.2
+    class ISDN < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::ISDN #:nodoc: all
+      
+      #The RR's address field.
+      attr_accessor :address
+      
+      #The RR's sub-address field.
+      attr_accessor :subaddress
+      
+      def from_data(data) #:nodoc: all
+        @address, @subaddress= data
+      end
+      
+      def from_string(input) #:nodoc: all
+        @address, @subaddress = input.split(" ")
+      end
+      
+      def rdata_to_string #:nodoc: all
+        return "#{@address} #{@subaddress}"
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_string(@address)
+        msg.put_string(@subaddress)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        address = msg.get_string
+        subaddress = msg.get_string
+        return self.new([address, subaddress])
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/LOC.rb

@@ -0,0 +1,255 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR   
+      #Class for DNS Location (LOC) resource records.  See RFC 1876 for
+      #details.
+    class LOC < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::LOC #:nodoc: all
+      
+      #The version number of the representation; programs should
+      #always check this.  Dnsruby currently supports only version 0.
+      attr_accessor :version
+      @version = 0
+      
+      #The diameter of a sphere enclosing the described entity,
+      #in centimeters.
+      attr_accessor :size
+      #The horizontal precision of the data, in centimeters.
+      attr_accessor :horiz_pre
+      #The vertical precision of the data, in centimeters.
+      attr_accessor :vert_pre
+      #The latitude of the center of the sphere described by
+      #the size method, in thousandths of a second of arc.  2**31
+      #represents the equator; numbers above that are north latitude.
+      attr_accessor :latitude
+      #The longitude of the center of the sphere described by
+      #the size method, in thousandths of a second of arc.  2**31
+      #represents the prime meridian; numbers above that are east
+      #longitude.
+      attr_accessor :longitude
+      #The altitude of the center of the sphere described by
+      #the size method, in centimeters, from a base of 100,000m
+      #below the WGS 84 reference spheroid used by GPS.
+      attr_accessor :altitude
+      # Powers of 10 from 0 to 9 (used to speed up calculations).
+      POWEROFTEN = [1, 10, 100, 1_000, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000, 1_000_000_000]
+      
+      # Reference altitude in centimeters (see RFC 1876).
+      REFERENCE_ALT = 100_000 * 100;
+      
+      # Reference lat/lon (see RFC 1876).
+      REFERENCE_LATLON = 2**31;
+      
+      # Conversions to/from thousandths of a degree.
+      CONV_SEC = 1000;
+      CONV_MIN = 60 * CONV_SEC;
+      CONV_DEG = 60 * CONV_MIN;
+      
+      # Defaults (from RFC 1876, Section 3).
+      DEFAULT_MIN       = 0;
+      DEFAULT_SEC       = 0;
+      DEFAULT_SIZE      = 1;
+      DEFAULT_HORIZ_PRE = 10_000;
+      DEFAULT_VERT_PRE  = 10;
+      
+      
+      def latlon2dms(rawmsec, hems)
+        # Tried to use modulus here, but Perl dumped core if
+        # the value was >= 2**31.
+        
+        abs  = (rawmsec - REFERENCE_LATLON).abs;
+        deg  = (abs / CONV_DEG).round;
+        abs  -= deg * CONV_DEG;
+        min  = (abs / CONV_MIN).round; 
+        abs -= min * CONV_MIN;
+        sec  = (abs / CONV_SEC).round;  # $conv_sec
+        abs -= sec * CONV_SEC;
+        msec = abs;
+        
+        hem = hems[(rawmsec >= REFERENCE_LATLON ? 0 : 1), 1]
+        
+        return sprintf("%d %02d %02d.%03d %s", deg, min, sec, msec, hem);
+      end
+      
+      def dms2latlon(deg, min, sec, hem)
+        retval=0
+        
+        retval = (deg * CONV_DEG) + (min * CONV_MIN) + (sec * CONV_SEC);
+        retval = -retval if ((hem != nil) && ((hem == "S") || (hem == "W")));
+        retval += REFERENCE_LATLON;
+        return retval;
+      end
+      
+      #Returns the latitude and longitude as floating-point degrees.
+      #Positive numbers represent north latitude or east longitude;
+      #negative numbers represent south latitude or west longitude.
+      #
+      #    lat, lon = rr.latlon
+      #    system("xearth", "-pos", "fixed #{lat} #{lon}")
+      #
+      def latlon
+        retlat, retlon = nil
+        
+        if (@version == 0)
+          retlat = latlon2deg(@latitude);
+          retlon = latlon2deg(@longitude);
+        end
+        
+        return retlat, retlon
+      end
+      
+      def latlon2deg(rawmsec)
+        deg=0;
+        
+        deg = (rawmsec - reference_latlon) / CONV_DEG;
+        return deg;
+      end
+      
+      def from_data(data) #:nodoc: all
+        @version, @size, @horiz_pre, @vert_pre, @latitude, @longitude, @altitude = data
+      end
+      
+      def from_string(string) #:nodoc: all
+        if (string && 
+            string =~ /^ (\d+) \s+		# deg lat
+         ((\d+) \s+)?		# min lat
+         (([\d.]+) \s+)?	# sec lat
+         (N|S) \s+		# hem lat
+         (\d+) \s+		# deg lon
+         ((\d+) \s+)?		# min lon
+         (([\d.]+) \s+)?	# sec lon
+         (E|W) \s+		# hem lon
+         (-?[\d.]+) m? 	# altitude
+         (\s+ ([\d.]+) m?)?	# size
+         (\s+ ([\d.]+) m?)?	# horiz precision
+         (\s+ ([\d.]+) m?)? 	# vert precision
+          /ix)  # 
+          
+          # What to do for other versions?
+          version = 0;
+          
+          latdeg, latmin, latsec, lathem = $1.to_i, $3.to_i, $5.to_i, $6;
+          londeg, lonmin, lonsec, lonhem = $7.to_i, $9.to_i, $11.to_i, $12
+          alt, size, horiz_pre, vert_pre = $13.to_i, $15.to_i, $17.to_i, $19.to_i
+          
+          latmin    = DEFAULT_MIN       unless latmin;
+          latsec    = DEFAULT_SEC       unless latsec;
+          lathem    = lathem.upcase;
+          
+          lonmin    = DEFAULT_MIN       unless lonmin;
+          lonsec    = DEFAULT_SEC       unless lonsec;
+          lonhem    = lonhem.upcase
+          
+          size      = DEFAULT_SIZE      unless size;
+          horiz_pre = DEFAULT_HORIZ_PRE unless horiz_pre;
+          vert_pre  = DEFAULT_VERT_PRE  unless vert_pre;
+          
+          @version   = version;
+          @size      = size * 100;
+          @horiz_pre = horiz_pre * 100;
+          @vert_pre  = vert_pre * 100;
+          @latitude  = dms2latlon(latdeg, latmin, latsec, lathem);
+          @longitude = dms2latlon(londeg, lonmin, lonsec, lonhem);
+          @altitude  = alt * 100 + REFERENCE_ALT;
+        end
+      end
+      
+      def from_hash(hash) #:nodoc: all
+        super(hash)
+        if (@size == nil)
+          @size = DEFAULT_SIZE
+        end
+        if @horiz_pre == nil
+          @horiz_pre = DEFAULT_HORIZ_PRE * 100
+        end
+        if @vert_pre == nil
+          @vert_pre = DEFAULT_VERT_PRE * 100
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        rdatastr=""
+        
+        if (defined?@version)
+          if (@version == 0)
+            lat       = @latitude;
+            lon       = @longitude;
+            altitude  = @altitude;
+            size      = @size;
+            horiz_pre = @horiz_pre;
+            vert_pre  = @vert_pre;
+            
+            altitude   = (altitude - REFERENCE_ALT) / 100;
+            size      /= 100;
+            horiz_pre /= 100;
+            vert_pre  /= 100;
+            
+            rdatastr = latlon2dms(lat, "NS") + " " +
+            latlon2dms(lon, "EW") + " " +
+            sprintf("%.2fm", altitude)  + " " +
+            sprintf("%.2fm", size)      + " " +
+            sprintf("%.2fm", horiz_pre) + " " +
+            sprintf("%.2fm", vert_pre);
+          else
+            rdatastr = "; version " + @version + " not supported";
+          end
+        else
+          rdatastr = '';
+        end
+        
+        return rdatastr;
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        version, = msg.get_unpack("C")
+        if (version == 0)
+          size, horiz_pre, vert_pre, latitude, longitude, altitude = msg.get_unpack('CCCNNN')
+          size = precsize_ntoval(size)
+          horiz_pre = precsize_ntoval(horiz_pre)
+          vert_pre = precsize_ntoval(vert_pre)
+          return self.new([version, size, horiz_pre, vert_pre, latitude, longitude, altitude])
+        end
+      end
+      
+      def encode_rdata(msg) #:nodoc: all
+        msg.put_pack('C', @version)
+        if (@version == 0)
+          msg.put_pack('CCCNNN', precsize_valton(@size), 
+          precsize_valton(@horiz_pre), precsize_valton(@vert_pre),
+          @latitude, @longitude, @altitude)
+        end
+      end
+      
+      def self.precsize_ntoval(prec)
+        mantissa = ((prec >> 4) & 0x0f) % 10;
+        exponent = (prec & 0x0f) % 10;
+        return mantissa * POWEROFTEN[exponent];
+      end
+      
+      def precsize_valton(val)
+        exponent = 0;
+        while (val >= 10)
+          val /= 10;
+          exponent+=1
+        end
+        return (val.round << 4) | (exponent & 0x0f);
+      end
+      
+    end
+  end
+end

data/lib/Dnsruby/resource/MINFO.rb

@@ -0,0 +1,66 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR   
+    #Class for DNS Mailbox Information (MINFO) resource records.
+    #RFC 1035 Section 3.3.7
+    class MINFO < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue = Types::MINFO #:nodoc: all
+      
+      #The RR's responsible mailbox field.  See RFC 1035.
+      attr_accessor :rmailbx
+      #The RR's error mailbox field.
+      attr_accessor :emailbx
+      
+      def from_hash(hash) #:nodoc: all
+        @rmailbx = Name.create(hash[:rmailbx])
+        @emailbx = Name.create(hash[:emailbx])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @rmailbx, @emailbx = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input.length > 0)
+          names = input.split(" ")
+          @rmailbx = Name.create(names[0])
+          @emailbx = Name.create(names[1])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@rmailbx!=nil)
+          return "#{@rmailbx} #{@emailbx}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_name(@rmailbx, canonical)
+        msg.put_name(@emailbx, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        rmailbx = msg.get_name
+        emailbx = msg.get_name
+        return self.new([rmailbx, emailbx])
+      end
+    end
+  end
+end

data/lib/Dnsruby/resource/MX.rb

@@ -0,0 +1,66 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    #Class for DNS Mail Exchanger (MX) resource records.
+    #RFC 1035 Section 3.3.9
+    class MX < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::MX #:nodoc: all
+      
+      #The preference for this mail exchange.
+      attr_accessor :preference
+      #The name of this mail exchange.
+      attr_accessor :exchange
+      
+      def from_hash(hash) #:nodoc: all
+        @preference = hash[:preference]
+        @exchange = Name.create(hash[:exchange])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @preference, @exchange = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input.length > 0)
+          names = input.split(" ")
+          @preference = names[0].to_i
+          @exchange = Name.create(names[1])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@preference!=nil)
+          return "#{@preference} #{@exchange}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack('n', @preference, canonical)
+        msg.put_name(@exchange, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        preference, = msg.get_unpack('n')
+        exchange = msg.get_name
+        return self.new([preference, exchange])
+      end
+    end 
+  end
+end

data/lib/Dnsruby/resource/NAPTR.rb

@@ -0,0 +1,90 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  class RR
+    #Class for DNS Naming Authority Pointer (NAPTR) resource records.
+    #RFC 2168
+    class NAPTR < RR
+      ClassValue = nil #:nodoc: all
+      TypeValue= Types::NAPTR #:nodoc: all
+      
+      # The NAPTR RR order field      
+      attr_accessor :order
+      # The NAPTR RR preference field      
+      attr_accessor :preference
+      # The NAPTR RR flags field      
+      attr_accessor :flags
+      # The NAPTR RR service field      
+      attr_accessor :service
+      # The NAPTR RR regexp field      
+      attr_accessor :regexp
+      # The NAPTR RR replacement field      
+      attr_accessor :replacement
+      
+      def from_hash(hash) #:nodoc: all
+        @order = hash[:order]
+        @preference = hash[:preference]
+        @flags  = hash[:flags]
+        @service = hash[:service]
+        @regexp = hash[:regexp]
+        @replacement = Name.create(hash[:replacement])
+      end
+      
+      def from_data(data) #:nodoc: all
+        @order,  @preference, @flags, @service, @regexp, @replacement = data
+      end
+      
+      def from_string(input) #:nodoc: all
+        if (input.length > 0)
+          values = input.split(" ")
+          @order = values [0]
+          @preference = values [1]
+          @flags = values [2]
+          @service = values [3]
+          @regexp = values [4]
+          @replacement = Name.create(values[5])
+        end
+      end
+      
+      def rdata_to_string #:nodoc: all
+        if (@order!=nil)
+          return "#{@order} #{@preference} #{@flags} #{@service} #{@regexp} #{@replacement}"
+        else
+          return ""
+        end
+      end
+      
+      def encode_rdata(msg, canonical=false) #:nodoc: all
+        msg.put_pack('n', @order)
+        msg.put_pack('n', @preference)
+        msg.put_string(@flags)
+        msg.put_string(@service)
+        msg.put_string(@regexp)
+        msg.put_name(@replacement, canonical)
+      end
+      
+      def self.decode_rdata(msg) #:nodoc: all
+        order, = msg.get_unpack('n')
+        preference, = msg.get_unpack('n')
+        flags, = msg.get_string
+        service, = msg.get_string
+        regexp, = msg.get_string
+        replacement = msg.get_name
+        return self.new([order, preference, flags, service, regexp, replacement])
+      end
+    end 
+  end
+end