dns-zone2 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f75671d72916d9ca1b4905cd91300b37126d716
+  data.tar.gz: b5a7f7f754bc0c3145efd379c29812dcee7f365f
+SHA512:
+  metadata.gz: 7b05d6fcc4b0209db6c000e7febc9cec4c55fa6d3d5caae968a34540f8ece38546f04ca4bf130fdebbbd4c9008fe7f636b554d53002966124e062304656a9b8e
+  data.tar.gz: 3f3f32885b598a05e9bdc64d34264c85e4fe55a173038380e7f8292e20a332d479d34a302212917faeaf04272e0c11a9c7a5bc36ec449dbc90dc70de185bec26

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/HISTORY.md

@@ -0,0 +1,45 @@
+## HEAD
+
+## 0.3.1 (2015-12-23)
+
+* Fix edge case when zone file has multiple `ORIGIN` directives.
+
+## 0.3.0 (2015-12-23)
+
+* Requires Ruby version >= 2.0
+* Ability to parse zone file with multiple `ORIGIN` directives.
+
+## 0.2.0 (2015-10-20)
+
+Development sponsored by Peter J. Philipp [centroid.eu](http://centroid.eu)
+
+* Add support for DNSSEC focused RR Types:
+    - RFC 3403: NAPTR
+    - RFC 4255: SSHFP
+    - RFC 4034: DNSKEY, DS, RRSIG, NSEC
+    - RFC 7344: CDNSKEY, CDS
+    - RFC 4431: DLV
+    - RFC 5155: NSEC3, NSEC3PARAM
+* Allow unqualified `domain-name` labels.
+* Allow `ORIGIN` to be specified as an optional parameter when loading a zone, e.g. `zone = DNS::Zone.load(zone_as_string, 'example.com.')`
+
+# 0.1.4 (no gem release)
+
+* Add helper method to quickly access (or create) SOA.
+* Add `dump_pretty` method to `DNS::Zone`.
+
+## 0.1.3 (2014-10-21)
+
+* Fix TXT record parsing bug, when quote enclosed RDATA contained semicolons.
+
+## 0.1.1 (2014-03-30)
+
+* Remove `required_ruby_version` from gemspec.
+
+## 0.1.0 (2014-03-30)
+
+* Initial non-alpha release with support for common resource records.
+
+## 0.0.0 (2014-02-16)
+
+* Initial development/hacking initiated.

data/README.md

@@ -0,0 +1,151 @@
+dns-zone
+========
+
+[![Build Status](https://secure.travis-ci.org/lantins/dns-zone.png?branch=master)](http://travis-ci.org/lantins/dns-zone)
+[![Gem Version](https://badge.fury.io/rb/dns-zone.png)](http://badge.fury.io/rb/dns-zone)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/lantins/dns-zone/blob/master/LICENSE)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/lantins/dns-zone/master/frames)
+
+A Ruby library for building, parsing and manipulating DNS zone files.
+
+## Installation
+
+Add this line to your Gemfile:
+
+    gem 'dns-zone'
+
+And then execute:
+
+    bundle install
+
+Require the gem in your code:
+
+    require 'dns/zone'
+
+## Usage
+
+### Loading a zone file
+
+    zone = DNS::Zone.load(zone_as_string)
+
+### Loading a zone file, without an `$ORIGIN` directive
+
+    zone = DNS::Zone.load(zone_as_string, "example.com.")
+
+### Creating a new zone programmatically
+
+    zone = DNS::Zone.new
+    zone.origin = 'example.com.'
+    zone.ttl = '1d'
+    
+    # quick access to SOA RR
+    zone.soa.nameserver = 'ns0.lividpenguin.com.'
+    zone.soa.email = 'hostmaster.lividpenguin.com.'
+    
+    # add an A RR
+    rec = DNS::Zone::RR::A.new
+    rec.address = '127.0.0.1'
+    zone.records << rec
+    
+    # output using dns zone file format
+    zone.dump
+
+# Development
+
+## Development Commands
+
+    # install external gem dependencies first
+    bundle install
+
+    # run all tests and build code coverage
+    bundle exec rake test
+
+    # hints where to improve docs
+    bundle exec inch
+
+    # watch for changes and run development commands (tests, documentation, etc)
+    bundle exec guard
+
+# Acknowledgement
+
+Special thanks to Peter J. Philipp [centroid.eu](http://centroid.eu) for sponsoring the 0.2.0 release of dns-zone.
+
+---
+
+# TODO
+
+## Must have
+
+    [x] Ability to load a zone made of multiple RR's
+    [x] Add support for RR Type: SOA
+    [x] Add support for RR Type: NS
+    [x] Add support for RR Type: MX
+    [x] Add support for RR Type: AAAA
+    [x] Add support for RR Type: A
+    [x] Add support for RR Type: CNAME
+    [x] Add support for RR Type: TXT
+    [x] Add support for RR Type: SRV
+    [x] Add support for RR Type: PTR
+    [x] Add support for RR Type: SPF
+    [x] Add support for RR Type: HINFO
+    [x] Support loading zone where some records have an empty label
+
+    [x] Add support for RR Type: NAPTR (RFC 3403)
+    [x] Add support for RR Type: SSHFP (RFC 4255)
+
+    [ ] Add test using real bind zone file, with DNSSEC RR's.
+    [ ] Add support for DNSSEC (RFC 4034) RR Types:
+        [x] DNSKEY
+            [ ] Algorithm may be integer or mnemonic.
+        [x] RRSIG
+            [ ] Algorithm may be integer or mnemonic.
+        [x] NSEC
+            [ ] Handle "Type Bit Maps" better, much better...
+        [x] DS
+    [ ] Add support for DNSSEC (RFC 5155) RR Types:
+        [x] NSEC3
+        [x] NSEC3PARAM
+        [ ] Correctly handle "Presentation Format" as defined in RFC.
+
+    [x] Add support for DNSSEC (RFC 4431 & RFC 7344) RR Types:
+        [x] CDNSKEY (identical to DNSKEY)
+        [x] CDS (identical to DS)
+        [x] DLV (identical to DS)
+
+    [ ] Look at newly added DNSSEC RR's and rename fields to be more appropriate, where required.
+
+## Would be nice
+
+    [ ] Basic validation, error checking:
+        [ ] Only one SOA per zone.
+        [ ] CNAMEs can't use a label of `@`.
+        [ ] PTR zones have some extra conditions:
+            [ ] labels cant be repeated
+            [ ] names should end in a dot, otherwise they are invalid after expansion
+            [ ] IPv4 and IPv6 cant be mixed
+
+    [ ] Ability to 'include' defaults/records into a zone.
+        This may or may not mean supporting the `$INCLUDE` directive.
+
+## At some point; low priority
+
+    [ ] Configuration options:
+        [ ] spaces/tabs used between RR params in zone file output
+        [ ] time format used in output (should parse both formats, seconds or bind time format (e.g. 1d))
+            [ ] add comments to explain TTL's that are in seconds
+    [ ] Ability to add comment to RR (n.b. currently we strip comments when parsing)
+    [ ] Add support for RR Type: LOC (RFC 1876)
+    [ ] Add support for RR Type: DNAME (RFC 2672)
+    [ ] Add support for RR Type: KEY
+    [ ] Add support for RR Type: RP
+    [ ] Add support for RR Type: RT
+
+# Misc. Development Notes
+
+- RR Format: `[<TTL>] [<class>] <type> <RDATA>`
+- A DNS zone is built from RR's and a couple of other special directives.
+- If zone file does not include $ORIGIN, it will be inferred by the `zone "<zone-name>" {}` clause from bind.conf
+  In general we should always explicitly define an $ORIGIN directive unless there is a very good reason not to.
+- [RFC 1035 - Domain Names - Implementation and Specification](http://www.ietf.org/rfc/rfc1035.txt)
+- [RFC 2308 - Negative Caching of DNS Queries (DNS NCACHE)](http://www.ietf.org/rfc/rfc2308.txt)
+- [RFC 3596 - DNS Extensions to Support IP Version 6](http://www.ietf.org/rfc/rfc3596.txt)

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+
+# by default run unit tests.
+task :default => 'test'
+
+desc 'Run full test suite and generate code coverage -- COVERAGE=false to disable code coverage'
+Rake::TestTask.new(:test) do |task|
+  ENV['COVERAGE'] ||= 'yes'
+  task.libs << 'test'
+  task.pattern = 'test/**/*_test.rb'
+  task.verbose = true
+end

data/dns-zone2.gemspec

@@ -0,0 +1,41 @@
+require './lib/dns/zone/version'
+
+spec = Gem::Specification.new do |s|
+  # gem information/details
+  s.name                = 'dns-zone2'
+  s.version             = DNS::Zone::Version
+  s.date                = Time.now.strftime('%Y-%m-%d')
+  s.summary             = 'A Ruby library for building and parsing DNS zone files.'
+  s.license             = 'MIT'
+  s.homepage            = 'https://github.com/hetznerZA/dns-zone2'
+  s.authors             = ['Hetzner']
+  s.email               = ['seals@hetzner.co.za ']
+
+  # gem settings for what files to include.
+  s.files               = %w(Rakefile README.md HISTORY.md Gemfile dns-zone2.gemspec)
+  s.files              += Dir.glob('{test/**/*,lib/**/*}')
+  s.require_paths       = ['lib']
+  #s.executables         = ['dns-zone']
+  #s.default_executable  = 'dns-zone'
+
+  # min ruby version
+  s.required_ruby_version = ::Gem::Requirement.new(">= 2.0")
+
+  # cross platform gem dependencies
+  #s.add_dependency('gli')
+  #s.add_dependency('paint')
+  s.add_development_dependency('bundler',        '~> 1.0')
+  s.add_development_dependency('rake',           '>= 9.0')
+  s.add_development_dependency('minitest',       '~> 5.0')
+  s.add_development_dependency('simplecov',      '~> 0.7.1')
+  s.add_development_dependency('yard',           '~> 0.8')
+  s.add_development_dependency('inch',           '~> 0.6')
+  s.add_development_dependency('guard-minitest', '~> 2.0')
+  s.add_development_dependency('guard-bundler',  '~> 2.0')
+
+  # long description.
+  s.description       = <<-EOL
+A Ruby library for building and parsing DNS zone files for use with
+Bind and PowerDNS (with Bind backend) DNS servers.
+  EOL
+end

data/lib/dns/zone.rb

@@ -0,0 +1,207 @@
+require 'dns/zone/rr'
+require 'dns/zone/version'
+
+# :nodoc:
+module DNS
+
+  # Represents a 'whole' zone of many resource records (RRs).
+  #
+  # This is also the primary namespace for the `dns-zone` gem.
+  class Zone
+
+    # The default $TTL (directive) of the zone.
+    attr_accessor :ttl
+    # The primary $ORIGIN (directive) of the zone.
+    attr_accessor :origin
+    # Array of all the zones RRs (including the SOA).
+    attr_accessor :records
+
+    # Create an empty instance of a DNS zone that you can drive programmatically.
+    #
+    # @api public
+    def initialize
+      @records = []
+      soa = DNS::Zone::RR::SOA.new
+      # set a couple of defaults on the SOA
+      soa.serial = Time.now.utc.strftime("%Y%m%d01")    
+      soa.refresh_ttl = '3h'
+      soa.retry_ttl = '15m'
+      soa.expiry_ttl = '4w'
+      soa.minimum_ttl = '30m'
+    end
+
+    # Helper method to access the zones SOA RR.
+    #
+    # @api public
+    def soa
+      # return the first SOA we find in the records array.
+      rr = @records.find { |rr| rr.type == "SOA" }
+      return rr if rr
+      # otherwise create a new SOA
+      rr = DNS::Zone::RR::SOA.new
+      rr.serial = Time.now.utc.strftime("%Y%m%d01")    
+      rr.refresh_ttl = '3h'
+      rr.retry_ttl = '15m'
+      rr.expiry_ttl = '4w'
+      rr.minimum_ttl = '30m'
+      # store and return new SOA
+      @records << rr
+      return rr
+    end
+
+    # Generates output of the zone and its records.
+    #
+    # @api public
+    def dump
+      content = []
+
+      @records.each do |rr|
+        content << rr.dump
+      end
+
+      content.join("\n") << "\n"
+    end
+
+    # Generates pretty output of the zone and its records.
+    #
+    # @api public
+    def dump_pretty
+      content = []
+
+      last_type = "SOA"
+      sorted_records.each do |rr|
+        content << '' if last_type != rr.type
+        content << rr.dump
+        last_type = rr.type
+      end
+
+      content.join("\n") << "\n"
+    end
+
+    # Load the provided zone file data into a new DNS::Zone object.
+    #
+    # @api public
+    def self.load(string, default_origin = "")
+      # get entries
+      entries = self.extract_entries(string)
+
+      instance = self.new
+
+      options = {}
+      entries.each do |entry|
+        # read in special statments like $TTL and $ORIGIN
+        if entry =~ /\$(ORIGIN|TTL)\s+(.+)/
+          instance.ttl    = $2 if $1 == 'TTL'
+          if $1 == 'ORIGIN'
+            instance.origin ||= $2
+            options[:origin] ||= $2
+            options[:last_origin] = $2
+          end
+          next
+        end
+
+        # parse each RR and create a Ruby object for it
+        if entry =~ DNS::Zone::RR::REGEX_RR
+          rec = DNS::Zone::RR.load(entry, options)
+          next unless rec
+          instance.records << rec
+          options[:last_label] = rec.label
+        end
+      end
+
+      # use default_origin if we didn't see a ORIGIN directive in the zone
+      if instance.origin.to_s.empty? && !default_origin.empty?
+        instance.origin = default_origin
+      end
+
+      return instance
+    end
+
+    # Extract entries from a zone file that will be later parsed as RRs.
+    #
+    # @api private
+    def self.extract_entries(string)
+      # FROM RFC:
+      #     The format of these files is a sequence of entries.  Entries are
+      #     predominantly line-oriented, though parentheses can be used to continue
+      #     a list of items across a line boundary, and text literals can contain
+      #     CRLF within the text.  Any combination of tabs and spaces act as a
+      #     delimiter between the separate items that make up an entry.  The end of
+      #     any line in the master file can end with a comment.  The comment starts
+      #     with a ";" (semicolon). 
+
+      entries = []
+      mode = :line
+      entry = ''
+
+      parentheses_ref_count = 0
+
+      string.lines.each do |line|
+        # strip comments unless escaped
+        # strip comments, unless its escaped.
+        # skip semicolons within "quote segments" (TXT records)
+        line = line.gsub(/((?<!\\);)(?=(?:[^"]|"[^"]*")*$).*/o, "").chomp
+
+        next if line.gsub(/\s+/, '').empty?
+
+        # append to entry line
+        entry << line
+
+        quotes = entry.count('"')
+        has_quotes = quotes > 0
+
+        parentheses = entry.count('()')
+        has_parentheses = parentheses > 0
+
+        if has_quotes
+          character_strings = entry.scan(/("(?:[^"\\]+|\\.)*")/).join(' ')
+          without = entry.gsub(/"((?:[^"\\]+|\\.)*)"/, '')
+          parentheses_ref_count = without.count('(') - without.count(')')
+        else
+          parentheses_ref_count = entry.count('(') - entry.count(')')
+        end
+
+        # are parentheses balanced?
+        if parentheses_ref_count == 0
+          if has_quotes
+            without.gsub!(/[()]/, '')
+            without.gsub!(/[ ]{2,}/, '  ')
+            #entries << (without + character_strings)
+            entry = (without + character_strings)
+          else
+            entry.gsub!(/[()]/, '')
+            entry.gsub!(/[ ]{2,}/, '  ')
+            entry.gsub!(/[ ]+$/, '')
+            #entries << entry
+          end
+          entries << entry
+          entry = ''
+        end
+
+      end
+
+      return entries
+    end
+
+    private
+
+    # Records sorted with more important types being at the top.
+    #
+    # @api private
+    def sorted_records
+      # pull out RRs we want to stick near the top
+      top_rrs = {}
+      top = %w{SOA NS MX SPF TXT}
+      top.each { |t| top_rrs[t] = @records.select { |rr| rr.type == t } }
+
+      remaining = @records.reject { |rr| top.include?(rr.type) }
+
+      # sort remaining RRs by type, alphabeticly
+      remaining.sort! { |a,b| a.type <=> b.type }
+
+      top_rrs.values.flatten + remaining
+    end
+
+
+  end
+end