dns-zone2 0.3.2

data/lib/dns/zone/rr.rb

@@ -0,0 +1,87 @@
+module DNS
+  class Zone
+
+    # The module containes resource record types supported by this gem.
+    # The #{load} method will convert RR string data into a Ruby class.
+    module RR
+
+      REGEX_TTL = /\d+[wdmhs]?/i
+      REGEX_KLASS = /(?<klass>IN)?/i
+      REGEX_TYPE = /(?<type>A|AAAA|CDNSKEY|CDS|CNAME|DLV|DNSKEY|DS|HINFO|MX|NAPTR|NS|NSEC|NSEC3|NSEC3PARAM|RRSIG|SOA|SPF|SRV|SSHFP|TXT|PTR)\s{1}/i
+      REGEX_RR = /^(?<label>\S+|\s{1})\s*(?<ttl>#{REGEX_TTL})?\s*#{REGEX_KLASS}\s*#{REGEX_TYPE}\s*(?<rdata>[\s\S]*)$/i
+      REGEX_DOMAINNAME = /\S+\.?/i
+      REGEX_STRING = /((?:[^"\\]+|\\.)*)/
+      REGEX_CHARACTER_STRING = %r{
+        "#{DNS::Zone::RR::REGEX_STRING}"|#{DNS::Zone::RR::REGEX_STRING}
+      }mx
+
+      # Load RR string data and return an instance representing the RR.
+      #
+      # @param string [String] RR ASCII string data
+      # @param options [Hash] additional data required to correctly parse a 'whole' zone
+      # @option options [String] :last_label The last label used by the previous RR
+      # @return [Object]
+      def self.load(string, options = {})
+        # strip comments, unless its escaped.
+        # skip semicolons within "quote segments" (TXT records)
+        string.gsub!(/((?<!\\);)(?=(?:[^"]|"[^"]*")*$).*/o, "")
+
+        captures = string.match(REGEX_RR)
+        return nil unless captures
+
+        case captures[:type]
+        when 'A'           then A.new.load(string, options)
+        when 'AAAA'        then AAAA.new.load(string, options)
+        when 'CDNSKEY'     then CDNSKEY.new.load(string, options)
+        when 'CDS'         then CDS.new.load(string, options)
+        when 'CNAME'       then CNAME.new.load(string, options)
+        when 'DLV'         then DLV.new.load(string, options)
+        when 'DNSKEY'      then DNSKEY.new.load(string, options)
+        when 'DS'          then DS.new.load(string, options)
+        when 'HINFO'       then HINFO.new.load(string, options)
+        when 'MX'          then MX.new.load(string, options)
+        when 'NAPTR'       then NAPTR.new.load(string, options)
+        when 'NS'          then NS.new.load(string, options)
+        when 'NSEC'        then NSEC.new.load(string, options)
+        when 'NSEC3'       then NSEC3.new.load(string, options)
+        when 'NSEC3PARAM'  then NSEC3PARAM.new.load(string, options)
+        when 'PTR'         then PTR.new.load(string, options)
+        when 'RRSIG'       then RRSIG.new.load(string, options)
+        when 'SOA'         then SOA.new.load(string, options)
+        when 'SPF'         then SPF.new.load(string, options)
+        when 'SRV'         then SRV.new.load(string, options)
+        when 'SSHFP'       then SSHFP.new.load(string, options)
+        when 'TXT'         then TXT.new.load(string, options)
+        else
+          raise 'Unknown or unsupported RR Type'          
+        end
+      end
+
+      autoload :Record, 'dns/zone/rr/record'
+
+      autoload :A,          'dns/zone/rr/a'
+      autoload :AAAA,       'dns/zone/rr/aaaa'
+      autoload :CDNSKEY,    'dns/zone/rr/cdnskey'
+      autoload :CDS,        'dns/zone/rr/cds'
+      autoload :CNAME,      'dns/zone/rr/cname'
+      autoload :DLV,        'dns/zone/rr/dlv'
+      autoload :DNSKEY,     'dns/zone/rr/dnskey'
+      autoload :DS,         'dns/zone/rr/ds'
+      autoload :HINFO,      'dns/zone/rr/hinfo'
+      autoload :MX,         'dns/zone/rr/mx'
+      autoload :NAPTR,      'dns/zone/rr/naptr'
+      autoload :NS,         'dns/zone/rr/ns'
+      autoload :NSEC,       'dns/zone/rr/nsec'
+      autoload :NSEC3,      'dns/zone/rr/nsec3'
+      autoload :NSEC3PARAM, 'dns/zone/rr/nsec3param'
+      autoload :PTR,        'dns/zone/rr/ptr'
+      autoload :RRSIG,      'dns/zone/rr/rrsig'
+      autoload :SOA,        'dns/zone/rr/soa'
+      autoload :SPF,        'dns/zone/rr/spf'
+      autoload :SRV,        'dns/zone/rr/srv'
+      autoload :SSHFP,      'dns/zone/rr/sshfp'
+      autoload :TXT,        'dns/zone/rr/txt'
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+# `A` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::A < DNS::Zone::RR::Record
+
+  attr_accessor :address
+
+  def dump
+    parts = general_prefix
+    parts << address
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+    @address = rdata
+    self
+  end
+
+end

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

@@ -0,0 +1,5 @@
+# `AAAA` resource record.
+#
+# RFC xxxx
+class DNS::Zone::RR::AAAA < DNS::Zone::RR::A
+end

data/lib/dns/zone/rr/cdnskey.rb

@@ -0,0 +1,5 @@
+# `CDNSKEY` resource record.
+#
+# RFC 7344
+class DNS::Zone::RR::CDNSKEY < DNS::Zone::RR::DNSKEY
+end

data/lib/dns/zone/rr/cds.rb

@@ -0,0 +1,5 @@
+# `CDS` resource record.
+#
+# RFC 7344
+class DNS::Zone::RR::CDS < DNS::Zone::RR::DS
+end

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

@@ -0,0 +1,21 @@
+# `CNAME` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::CNAME < DNS::Zone::RR::Record
+
+  attr_accessor :domainname
+
+  def dump
+    parts = general_prefix
+    parts << domainname
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+    @domainname = rdata
+    self
+  end
+
+end

data/lib/dns/zone/rr/dlv.rb

@@ -0,0 +1,5 @@
+# `DLV` resource record.
+#
+# RFC 4431
+class DNS::Zone::RR::DLV < DNS::Zone::RR::DS
+end

data/lib/dns/zone/rr/dnskey.rb

@@ -0,0 +1,38 @@
+# `DNSKEY` resource record.
+#
+# RFC 4034
+class DNS::Zone::RR::DNSKEY < DNS::Zone::RR::Record
+
+  REGEX_DNSKEY_RDATA = %r{
+    (?<flags>\d+)\s*
+    (?<protocol>\d+)\s*
+    (?<algorithm>\d+)\s*
+    (?<key>#{DNS::Zone::RR::REGEX_STRING})\s*
+  }mx
+
+  attr_accessor :flags, :protocol, :algorithm, :key
+
+  def dump
+    parts = general_prefix
+    parts << flags
+    parts << protocol
+    parts << algorithm
+    parts << key
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_DNSKEY_RDATA)
+    return nil unless captures
+
+    @flags = captures[:flags].to_i
+    @protocol = captures[:protocol].to_i
+    @algorithm = captures[:algorithm].to_i
+    @key = captures[:key].scan(/#{DNS::Zone::RR::REGEX_STRING}/).join
+    self
+  end
+
+end

data/lib/dns/zone/rr/ds.rb

@@ -0,0 +1,38 @@
+# `DS` resource record.
+#
+# RFC 4034
+class DNS::Zone::RR::DS < DNS::Zone::RR::Record
+
+  REGEX_DS_RDATA = %r{
+    (?<key_tag>\d+)\s*
+    (?<algorithm>\d+)\s*
+    (?<digest_type>\d+)\s*
+    (?<digest>#{DNS::Zone::RR::REGEX_STRING})\s*
+  }mx
+
+  attr_accessor :key_tag, :algorithm, :digest_type, :digest
+
+  def dump
+    parts = general_prefix
+    parts << key_tag
+    parts << algorithm
+    parts << digest_type
+    parts << digest
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_DS_RDATA)
+    return nil unless captures
+
+    @key_tag = captures[:key_tag].to_i
+    @algorithm = captures[:algorithm].to_i
+    @digest_type = captures[:digest_type].to_i
+    @digest = captures[:digest].scan(/#{DNS::Zone::RR::REGEX_STRING}/).join
+    self
+  end
+
+end

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

@@ -0,0 +1,31 @@
+# `HINFO` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::HINFO < DNS::Zone::RR::Record
+
+  REGEX_HINFO_RDATA = %r{
+    (?<cpu>(?:#{DNS::Zone::RR::REGEX_CHARACTER_STRING})){1}\s
+    (?<os>(?:#{DNS::Zone::RR::REGEX_CHARACTER_STRING})){1}
+  }mx
+  attr_accessor :cpu
+  attr_accessor :os
+
+  def dump
+    parts = general_prefix
+    parts << %Q{"#{cpu}" "#{os}"}
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_HINFO_RDATA)
+    return nil unless captures
+
+    @cpu = captures[:cpu].scan(/#{DNS::Zone::RR::REGEX_CHARACTER_STRING}/).join
+    @os = captures[:os].scan(/#{DNS::Zone::RR::REGEX_CHARACTER_STRING}/).join
+    self
+  end
+
+end

data/lib/dns/zone/rr/mx.rb

@@ -0,0 +1,33 @@
+# `MX` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::MX < DNS::Zone::RR::Record
+
+  REGEX_MX_RDATA = %r{
+    (?<priority>\d+)\s*
+    (?<exchange>#{DNS::Zone::RR::REGEX_DOMAINNAME})\s*
+  }mx
+
+  attr_accessor :priority
+  attr_accessor :exchange
+
+  def dump
+    parts = general_prefix
+    parts << priority
+    parts << exchange
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_MX_RDATA)
+    return nil unless captures
+
+    @priority = captures[:priority].to_i
+    @exchange = captures[:exchange]
+    self
+  end
+
+end

data/lib/dns/zone/rr/naptr.rb

@@ -0,0 +1,44 @@
+# `NAPTR` resource record.
+#
+# RFC 3403
+class DNS::Zone::RR::NAPTR < DNS::Zone::RR::Record
+
+  REGEX_NAPTR_RDATA = %r{
+    (?<order>\d+)\s*
+    (?<pref>\d+)\s*
+    (?<flags>#{DNS::Zone::RR::REGEX_CHARACTER_STRING})\s*
+    (?<service>#{DNS::Zone::RR::REGEX_CHARACTER_STRING})\s*
+    (?<regexp>#{DNS::Zone::RR::REGEX_CHARACTER_STRING})\s*
+    (?<replacement>#{DNS::Zone::RR::REGEX_DOMAINNAME}|\.{1})\s*
+  }mx
+
+  attr_accessor :order, :pref, :flags, :service, :regexp, :replacement
+
+  def dump
+    parts = general_prefix
+    parts << order
+    parts << pref
+    parts << %Q{"#{flags}"}
+    parts << %Q{"#{service}"}
+    parts << %Q{"#{regexp}"}
+    parts << replacement
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_NAPTR_RDATA)
+    return nil unless captures
+
+    @order = captures[:order].to_i
+    @pref = captures[:pref].to_i
+    @flags = captures[:flags].scan(/#{DNS::Zone::RR::REGEX_CHARACTER_STRING}/).join
+    @service = captures[:service].scan(/#{DNS::Zone::RR::REGEX_CHARACTER_STRING}/).join
+    @regexp = captures[:regexp].scan(/#{DNS::Zone::RR::REGEX_CHARACTER_STRING}/).join
+    @replacement = captures[:replacement]
+    self
+  end
+
+end

data/lib/dns/zone/rr/ns.rb

@@ -0,0 +1,21 @@
+# `NS` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::NS < DNS::Zone::RR::Record
+
+  attr_accessor :nameserver
+
+  def dump
+    parts = general_prefix
+    parts << nameserver
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+    @nameserver = rdata
+    self
+  end
+
+end

data/lib/dns/zone/rr/nsec.rb

@@ -0,0 +1,32 @@
+# `NSEC` resource record.
+#
+# RFC 4034
+class DNS::Zone::RR::NSEC < DNS::Zone::RR::Record
+
+  REGEX_NSEC_RDATA = %r{
+    (?<next_domain>#{DNS::Zone::RR::REGEX_DOMAINNAME})\s*
+    (?<rrset_types>#{DNS::Zone::RR::REGEX_STRING})\s*
+  }mx
+
+  attr_accessor :next_domain, :rrset_types
+
+  def dump
+    parts = general_prefix
+    parts << next_domain
+    parts << rrset_types
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_NSEC_RDATA)
+    return nil unless captures
+
+    @next_domain = captures[:next_domain]
+    @rrset_types = captures[:rrset_types]
+    self
+  end
+
+end

data/lib/dns/zone/rr/nsec3.rb

@@ -0,0 +1,45 @@
+# `NSEC3` resource record.
+#
+# RFC 5155
+class DNS::Zone::RR::NSEC3 < DNS::Zone::RR::Record
+
+  REGEX_NSEC3_RDATA = %r{
+    (?<algorithm>\d+)\s*
+    (?<flags>\d+)\s*
+    (?<iterations>\d+)\s*
+    (?<salt>\S+)\s*
+    (?<next_hashed_owner_name>\S+)\s*
+    (?<rrset_types>#{DNS::Zone::RR::REGEX_STRING})\s*
+  }mx
+
+  attr_accessor :algorithm, :flags, :iterations, :salt,
+                :next_hashed_owner_name, :rrset_types
+
+  def dump
+    parts = general_prefix
+    parts << algorithm
+    parts << flags
+    parts << iterations
+    parts << salt
+    parts << next_hashed_owner_name
+    parts << rrset_types
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_NSEC3_RDATA)
+    return nil unless captures
+
+    @algorithm = captures[:algorithm].to_i
+    @flags = captures[:flags].to_i
+    @iterations = captures[:iterations].to_i
+    @salt = captures[:salt]
+    @next_hashed_owner_name = captures[:next_hashed_owner_name]
+    @rrset_types = captures[:rrset_types]
+    self
+  end
+
+end