dns-zone2 0.3.2

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

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

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

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

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

@@ -0,0 +1,88 @@
+# Parent class of all RR types, common resource record code lives here.
+# Is responsible for building a Ruby object given a RR string.
+#
+# @abstract Each RR TYPE should subclass and override: {#load} and #{dump} 
+class DNS::Zone::RR::Record
+
+  attr_accessor :label, :ttl
+  attr_reader :klass
+
+  def initialize
+    @label = '@'
+    @klass = 'IN'
+  end
+
+  # FIXME: should we just: `def type; 'SOA'; end` rather then do the class name convension?
+  #
+  # Figures out TYPE of RR using class name.
+  # This means the class name _must_ match the RR ASCII TYPE.
+  #
+  # When called directly on the parent class (that you should never do), it will
+  #   return the string as `<type>`, for use with internal tests.
+  #
+  # @return [String] the RR type
+  def type
+    name = self.class.name.split('::').last
+    return '<type>' if name == 'Record'
+    name
+  end
+
+  # Returns 'general' prefix (in parts) that come before the RDATA.
+  # Used by all RR types, generates: `[<label>] [<ttl>] [<class>] <type>`
+  #
+  # @return [Array<String>] rr prefix parts
+  def general_prefix
+    parts = []
+    parts << label
+    parts << ttl if ttl
+    parts << 'IN'
+    parts << type
+    parts
+  end
+
+  # Build RR zone file output.
+  #
+  # @return [String] RR zone file output
+  def dump
+    general_prefix.join(' ')
+  end
+
+  # @abstract Override to update instance with RR type spesific data.
+  # @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 load(string, options = {})
+    raise NotImplementedError, "#load method must be implemented by subclass (#{self.class})"
+  end
+
+  # Load 'general' RR data/params and return the remaining RDATA for further parsing.
+  #
+  # @param string [String] RR ASCII string data
+  # @param options [Hash] additional data required to correctly parse a 'whole' zone
+  # @return [String] remaining RDATA
+  def load_general_and_get_rdata(string, options = {})
+    # strip comments, unless its escaped.
+    # skip semicolons within "quote segments" (TXT records)
+    string.gsub!(/((?<!\\);)(?=(?:[^"]|"[^"]*")*$).*/o, "")
+
+    captures = string.match(DNS::Zone::RR::REGEX_RR)
+    return nil unless captures
+
+    if [' ', nil].include?(captures[:label])
+      @label = options[:last_label]
+    else
+      @label = captures[:label]
+    end
+
+    # unroll records nested under other origins
+    unrolled_origin = options[:last_origin].sub(options[:origin], '').chomp('.') if options[:last_origin]
+    if unrolled_origin && !unrolled_origin.empty?
+      @label = @label == '@' ? unrolled_origin : "#{@label}.#{unrolled_origin}"
+    end
+
+    @ttl = captures[:ttl]
+    captures[:rdata]
+  end
+
+end

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

@@ -0,0 +1,54 @@
+# `RRSIG` resource record.
+#
+# RFC 4034
+class DNS::Zone::RR::RRSIG < DNS::Zone::RR::Record
+
+  REGEX_RRSIG_RDATA = %r{
+    (?<type_covered>\S+)\s*
+    (?<algorithm>\d+)\s*
+    (?<labels>\d+)\s*
+    (?<original_ttl>#{DNS::Zone::RR::REGEX_TTL})\s*
+    (?<signature_expiration>\d+)\s*
+    (?<signature_inception>\d+)\s*
+    (?<key_tag>\d+)\s*
+    (?<signer>#{DNS::Zone::RR::REGEX_DOMAINNAME})\s*
+    (?<signature>#{DNS::Zone::RR::REGEX_CHARACTER_STRING})\s*
+  }mx
+
+  attr_accessor :type_covered, :algorithm, :labels, :original_ttl, :signature_expiration,
+                :signature_inception, :key_tag, :signer, :signature
+
+  def dump
+    parts = general_prefix
+    parts << type_covered
+    parts << algorithm
+    parts << labels
+    parts << original_ttl
+    parts << signature_expiration
+    parts << signature_inception
+    parts << key_tag
+    parts << signer
+    parts << signature
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_RRSIG_RDATA)
+    return nil unless captures
+
+    @type_covered = captures[:type_covered]
+    @algorithm = captures[:algorithm].to_i
+    @labels = captures[:labels].to_i
+    @original_ttl = captures[:original_ttl].to_i
+    @signature_expiration = captures[:signature_expiration].to_i
+    @signature_inception = captures[:signature_inception].to_i
+    @key_tag = captures[:key_tag].to_i
+    @signer = captures[:signer]
+    @signature = captures[:signature]
+    self
+  end
+
+end

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

@@ -0,0 +1,51 @@
+# `SRV` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::SOA < DNS::Zone::RR::Record
+
+  REGEX_SOA_RDATA = %r{
+    (?<nameserver>#{DNS::Zone::RR::REGEX_DOMAINNAME})\s* # get nameserver domainname
+    (?<email>#{DNS::Zone::RR::REGEX_DOMAINNAME})\s*      # get mailbox domainname
+    (?<serial>\d+)\s*
+    (?<refresh_ttl>#{DNS::Zone::RR::REGEX_TTL})\s*
+    (?<retry_ttl>#{DNS::Zone::RR::REGEX_TTL})\s*
+    (?<expiry_ttl>#{DNS::Zone::RR::REGEX_TTL})\s*
+    (?<minimum_ttl>#{DNS::Zone::RR::REGEX_TTL})\s*
+  }mx
+
+  attr_accessor :nameserver, :email, :serial, :refresh_ttl, :retry_ttl, :expiry_ttl, :minimum_ttl
+
+  def dump
+    parts = general_prefix
+    parts << nameserver
+    parts << email
+
+    parts << '('
+    parts << serial
+    parts << refresh_ttl
+    parts << retry_ttl
+    parts << expiry_ttl
+    parts << minimum_ttl
+    parts << ')'
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_SOA_RDATA)
+    return nil unless captures
+
+    @nameserver = captures[:nameserver]
+    @email = captures[:email]
+    @serial = captures[:serial].to_i
+    @refresh_ttl = captures[:refresh_ttl]
+    @retry_ttl = captures[:retry_ttl]
+    @expiry_ttl = captures[:expiry_ttl]
+    @minimum_ttl = captures[:minimum_ttl]
+
+    self
+  end
+
+end

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

@@ -0,0 +1,5 @@
+# `SPF` resource record.
+#
+# RFC 4408
+class DNS::Zone::RR::SPF < DNS::Zone::RR::TXT
+end

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

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

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

@@ -0,0 +1,35 @@
+# `SSHFP` resource record.
+#
+# RFC 4255
+class DNS::Zone::RR::SSHFP < DNS::Zone::RR::Record
+
+  REGEX_SSHFP_RDATA = %r{
+    (?<algorithm_number>\d+)\s*
+    (?<fingerprint_type>\d+)\s*
+    (?<fingerprint>#{DNS::Zone::RR::REGEX_STRING})\s*
+  }mx
+
+  attr_accessor :algorithm_number, :fingerprint_type, :fingerprint
+
+  def dump
+    parts = general_prefix
+    parts << algorithm_number
+    parts << fingerprint_type
+    parts << fingerprint
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    captures = rdata.match(REGEX_SSHFP_RDATA)
+    return nil unless captures
+
+    @algorithm_number = captures[:algorithm_number].to_i
+    @fingerprint_type = captures[:fingerprint_type].to_i
+    @fingerprint = captures[:fingerprint]
+    self
+  end
+
+end

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

@@ -0,0 +1,24 @@
+# `A` resource record.
+#
+# RFC 1035
+class DNS::Zone::RR::TXT < DNS::Zone::RR::Record
+
+  attr_accessor :text
+
+  def dump
+    parts = general_prefix
+    parts << text
+    parts.join(' ')
+  end
+
+  def load(string, options = {})
+    rdata = load_general_and_get_rdata(string, options)
+    return nil unless rdata
+
+    # extract text from within quotes; allow multiple quoted strings; ignore escaped quotes
+    # @text = rdata.scan(/"#{DNS::Zone::RR::REGEX_STRING}"/).flatten.map { |w| %Q{"#{w}"} }.join
+    @text = rdata.scan(/"#{DNS::Zone::RR::REGEX_STRING}"/).flat_map { |w| %Q{"#{w&.first}"} }.join(' ')
+    self
+  end
+
+end

data/lib/dns/zone/test_case.rb

@@ -0,0 +1,27 @@
+#
+# test_case.rb - A file used to setup the testing enviroment for the library.
+#
+
+require 'rubygems'
+
+# --- code coverage on MRI 1.9 ruby only, but disabled by default --------------
+if RUBY_VERSION >= '1.9' && RUBY_ENGINE == 'ruby' && ENV['COVERAGE']
+  require 'simplecov'
+  #SimpleCov.command_name 'test:unit'
+  SimpleCov.start do
+    # code coverage groups.
+    add_filter 'test/'
+  end
+end
+
+# --- load our dependencies using bundler --------------------------------------
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+# --- Load lib to test ---------------------------------------------------------
+require 'dns/zone'
+
+# --- Extend DNS::Zone::TestCase -------------------------------------------------
+class DNS::Zone::TestCase < Minitest::Test
+end

data/lib/dns/zone/version.rb

@@ -0,0 +1,6 @@
+module DNS
+  class Zone
+    # Version number (major.minor.tiny)
+    Version = '0.3.2'
+  end
+end

data/test/rr/a_test.rb

@@ -0,0 +1,37 @@
+require 'dns/zone/test_case'
+
+class RR_A_Test < DNS::Zone::TestCase
+
+  def test_build_rr__a
+    rr = DNS::Zone::RR::A.new    
+
+    # ensure we can set address parameter
+    rr.address = '10.0.1.1'
+    assert_equal 'A', rr.type
+    assert_equal '@ IN A 10.0.1.1', rr.dump
+    rr.address = '10.0.2.2'
+    assert_equal '@ IN A 10.0.2.2', rr.dump
+
+    # with a label set
+    rr.label = 'labelname'
+    assert_equal 'labelname IN A 10.0.2.2', rr.dump
+
+    # with a ttl
+    rr.ttl = '4w'
+    assert_equal 'labelname 4w IN A 10.0.2.2', rr.dump
+  end
+
+  def test_load_rr__a
+    rr = DNS::Zone::RR::A.new.load('@ IN A 127.0.0.1')
+    assert_equal '@', rr.label
+    assert_equal 'A', rr.type
+    assert_equal '127.0.0.1', rr.address
+
+    rr = DNS::Zone::RR::A.new.load('www IN A 127.0.0.1')
+    assert_equal 'www', rr.label
+    assert_equal 'A', rr.type
+    assert_equal 'IN', rr.klass
+    assert_equal '127.0.0.1', rr.address
+  end
+
+end

data/test/rr/aaaa_test.rb

@@ -0,0 +1,27 @@
+require 'dns/zone/test_case'
+
+class RR_AAAA_Test < DNS::Zone::TestCase
+
+  def test_build_rr__aaaa
+    rr = DNS::Zone::RR::AAAA.new    
+
+    # ensure we can set address parameter
+    rr.address = '2001:db8::3'
+    assert_equal 'AAAA', rr.type
+    assert_equal '@ IN AAAA 2001:db8::3', rr.dump
+  end
+
+  def test_load_rr__aaaa
+    rr = DNS::Zone::RR::AAAA.new.load('@ IN AAAA 2001:db8::6')
+    assert_equal '@', rr.label
+    assert_equal 'AAAA', rr.type
+    assert_equal '2001:db8::6', rr.address
+
+    rr = DNS::Zone::RR::AAAA.new.load('www IN A 2001:db8::6')
+    assert_equal 'www', rr.label
+    assert_equal 'AAAA', rr.type
+    assert_equal 'IN', rr.klass
+    assert_equal '2001:db8::6', rr.address
+  end
+
+end