redns 0.0.0

data/lib/redns/record/soa.rb

@@ -0,0 +1,65 @@
+class ReDNS::Record::SOA < ReDNS::Fragment
+  # == Attributes ===========================================================
+  
+  attribute :mname, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
+  attribute :rname, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
+  
+  attribute :serial, :default => 0, :convert => :to_i
+  attribute :refresh, :default => 0, :convert => :to_i
+  attribute :retry, :default => 0, :convert => :to_i
+  attribute :expire, :default => 0, :convert => :to_i
+  attribute :minimum, :default => 0, :convert => :to_i
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+	
+	def to_s
+	  to_a.join(' ')
+	end
+
+	def to_a
+		[
+		  self.mname,
+		  self.rname,
+		  self.serial,
+		  self.refresh,
+		  self.retry,
+		  self.expire,
+		  self.minimum
+		]
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+	  self.mname.serialize(buffer)
+	  self.rname.serialize(buffer)
+
+		buffer.pack(
+		  [
+  			self.serial,
+  			self.refresh,
+  			self.retry,
+  			self.expire,
+  			self.minimum
+		  ],
+		  'NNNNN'
+		)
+		
+		buffer
+	end
+
+	def deserialize(buffer)
+	  self.mname = ReDNS::Name.new(buffer)
+	  self.rname = ReDNS::Name.new(buffer)
+
+		data = buffer.unpack('NNNNN')
+
+		self.serial = data.shift
+		self.refresh = data.shift
+		self.retry = data.shift
+		self.expire = data.shift
+		self.minimum = data.shift
+		
+		self
+	end
+end

data/lib/redns/record.rb

@@ -0,0 +1,7 @@
+class ReDNS::Record < ReDNS::Fragment
+  # == Submodules ===========================================================
+
+  autoload(:MX, 'redns/record/mx')
+  autoload(:Null, 'redns/record/null')
+  autoload(:SOA, 'redns/record/soa')
+end

data/lib/redns/resource.rb

@@ -0,0 +1,86 @@
+class ReDNS::Resource < ReDNS::Fragment
+  # == Constants ============================================================
+
+  # == Attributes ===========================================================
+  
+  attribute :name, :convert => ReDNS::Name, :default => lambda { ReDNS::Name.new }
+  attribute :rclass, :default => :in
+  attribute :rtype, :default => :a
+  attribute :rdata
+  attribute :ttl, :default => 0, :convert => :to_i
+  attribute :additional, :default => lambda { [ ] }
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+  def empty?
+    self.name.empty?
+  end
+
+	def to_s
+		"#{name} #{ttl} #{rclass.to_s.upcase} #{rtype.to_s.upcase} #{rdata}"
+	end
+
+	def to_a
+		[ name, ttl, rclass, rtype, rdata.to_a ].flatten
+	end
+
+	def serialize(buffer = ReDNS::Buffer.new)
+	  self.name.serialize(buffer)
+	  
+	  data_buffer = nil
+	  
+	  if (self.rdata)
+  	  data_buffer = ReDNS::Buffer.new
+  	  self.rdata.serialize(data_buffer)
+	  end
+	  
+	  buffer.pack(
+	    [
+  			ReDNS::RR_TYPE[self.rtype],
+  			ReDNS::RR_CLASS[self.rclass],
+  			self.ttl,
+  			data_buffer ? data_buffer.length : 0
+	    ],
+	    'nnNn'
+	  )
+	  
+	  if (data_buffer)
+	    buffer.append(data_buffer)
+    end
+    
+    buffer
+	end
+	
+	def deserialize(buffer)
+		self.name = ReDNS::Name.new(buffer)
+		
+		raw = buffer.unpack("nnNn")
+		
+		self.rtype = ReDNS::RR_TYPE_LABEL[raw.shift]
+		self.rclass = ReDNS::RR_CLASS_LABEL[raw.shift]
+		self.ttl = raw.shift
+		
+		rdata_length = raw.shift
+
+    self.rdata =
+  		case (self.rtype)
+  		when :a, :aaaa
+  			self.rdata = ReDNS::Address.new(buffer)
+  		when :cname, :ptr, :ns
+  			self.rdata = ReDNS::Name.new(buffer)
+  		when :soa
+  			self.rdata = ReDNS::Record::SOA.new(buffer)
+  		when :txt, :null
+  			self.rdata = ReDNS::Record::Null.new(buffer.read(rdata_length))
+  		when :mx
+  			self.rdata = ReDNS::Record::MX.new(buffer)
+  		else
+        # FUTURE: Throw exception here when trying to decode invalid type
+  		  nil
+  		end
+  		
+  	self
+  end
+end

data/lib/redns/support.rb

@@ -0,0 +1,19 @@
+module ReDNS::Support
+  def addr_to_arpa(ip)
+		ip and (ip.split(/\./).reverse.join('.') + '.in-addr.arpa.')
+	end
+	
+	def inet_ntoa(addr)
+		addr.unpack("C4")[0, 4].collect do |v|
+		  v or 0
+		end.join('.')
+	end
+	
+	def inet_aton(s)
+		s.split(/\./).map do |c|
+		  c.to_i
+		end.pack("C*")
+	end
+	
+	extend(self)
+end

data/lib/redns.rb

@@ -0,0 +1,84 @@
+module ReDNS
+  # == Constants ============================================================
+
+  # RFC1035 Resource Record Type Constants
+
+  RR_TYPE = {
+    :a => 1,
+    :ns => 2,
+    :md => 3,
+    :mf => 4,
+    :cname => 5,
+    :soa => 6,
+    :mb => 7,
+    :mg => 8,
+    :mr => 9,
+    :null => 10,
+    :wks => 11,
+    :ptr => 12,
+    :hinfo => 13,
+    :minfo => 14,
+    :mx => 15,
+    :txt => 16,
+    :axfr => 252,
+    :mailb => 253,
+    :maila => 254,
+    :any => 255
+  }.freeze
+  
+  RR_TYPE_LABEL = RR_TYPE.invert.freeze
+  
+  # RFC1035 Network Class Constants
+  
+  # NOTE: Other classes are defined but are irrelevant in a contemporary
+  #       context. This library is entirely IN(internet)-bound.
+  
+  RR_CLASS = {
+    :in => 1
+  }.freeze
+  
+  RR_CLASS_LABEL = RR_CLASS.invert.freeze
+  
+  OPCODE = {
+    :query => 0,
+    :iquery => 1,
+    :status => 2,
+    :unknown => 15
+  }.freeze
+  
+  OPCODE_LABEL = OPCODE.invert.freeze
+
+  RCODE = {
+    :noerror => 0,
+    :format_error => 1,
+    :server_failure => 2,
+    :name_error => 3,
+    :not_implemented => 4,
+    :refused => 5,
+    :unknown => 15
+  }.freeze
+  
+  RCODE_LABEL = RCODE.invert.freeze
+  
+  # == Submodules ===========================================================
+
+  autoload(:Address, 'redns/address')
+  autoload(:Buffer, 'redns/buffer')
+  autoload(:Fragment, 'redns/fragment')
+  autoload(:Message, 'redns/message')
+  autoload(:Name, 'redns/name')
+  autoload(:Question, 'redns/question')
+  autoload(:Record, 'redns/record')
+  autoload(:Resource, 'redns/resource')
+  autoload(:Support, 'redns/support')
+
+  # == Exceptions ===========================================================
+
+  class Exception < ::Exception
+    class BufferUnderrun < Exception
+    end
+
+    class InvalidPacket < Exception
+    end
+  end
+end

data/redns.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redns}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["tadman"]
+  s.date = %q{2010-08-13}
+  s.description = %q{ReDNS is a pure Ruby DNS library with drivers for reactor-model engines such as EventMachine}
+  s.email = %q{github@tadman.ca}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/redns.rb",
+     "lib/redns/address.rb",
+     "lib/redns/buffer.rb",
+     "lib/redns/fragment.rb",
+     "lib/redns/message.rb",
+     "lib/redns/name.rb",
+     "lib/redns/question.rb",
+     "lib/redns/record.rb",
+     "lib/redns/record/mx.rb",
+     "lib/redns/record/null.rb",
+     "lib/redns/record/soa.rb",
+     "lib/redns/resource.rb",
+     "lib/redns/support.rb",
+     "redns.gemspec",
+     "test/helper.rb",
+     "test/test_redns.rb",
+     "test/test_redns_address.rb",
+     "test/test_redns_buffer.rb",
+     "test/test_redns_fragment.rb",
+     "test/test_redns_message.rb",
+     "test/test_redns_name.rb",
+     "test/test_redns_question.rb",
+     "test/test_redns_resource.rb",
+     "test/test_redns_support.rb"
+  ]
+  s.homepage = %q{http://github.com/tadman/redns}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby Reactor-Ready DNS Library}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_redns.rb",
+     "test/test_redns_address.rb",
+     "test/test_redns_buffer.rb",
+     "test/test_redns_fragment.rb",
+     "test/test_redns_message.rb",
+     "test/test_redns_name.rb",
+     "test/test_redns_question.rb",
+     "test/test_redns_resource.rb",
+     "test/test_redns_support.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+
+[ %w[ .. lib ], %w[ . ] ].each do |path|
+  $LOAD_PATH.unshift(
+    File.expand_path(File.join(*path), File.dirname(__FILE__))
+  )
+end
+
+require 'redns'
+
+class Test::Unit::TestCase
+end

data/test/test_redns.rb

@@ -0,0 +1,4 @@
+require 'helper'
+
+class TestRedns < Test::Unit::TestCase
+end

data/test/test_redns_address.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class TestReDNSAddress < Test::Unit::TestCase
+  def test_defaults
+    address = ReDNS::Address.new
+    
+    assert_equal '0.0.0.0', address.to_s
+    assert address.empty?
+  end
+
+  def test_serialization
+    address = ReDNS::Address.new('127.0.0.1')
+    
+    assert_equal '127.0.0.1', address.to_s
+    assert !address.empty?
+    
+    buffer = ReDNS::Buffer.new(address)
+    
+    assert_equal 4, buffer.size
+    
+    assert_equal '127.0.0.1', ReDNS::Address.new(buffer).to_s
+  end
+end

data/test/test_redns_buffer.rb

@@ -0,0 +1,180 @@
+require 'helper'
+
+class TestReDNSBuffer < Test::Unit::TestCase
+  def test_default_state
+    buffer = ReDNS::Buffer.new
+    
+    assert_equal 0, buffer.offset
+    assert_equal 0, buffer.length
+    assert_equal '', buffer.to_s
+    
+    assert buffer.empty?
+    assert !buffer.inspect.empty?
+    
+    rescued = nil
+    
+    begin
+      assert '', buffer.read
+    rescue Object => rescued
+    end
+    
+    assert_equal ReDNS::Exception::BufferUnderrun, rescued.class
+  end
+    
+  def test_simple_duplicate
+    buffer = ReDNS::Buffer.new('example'.freeze, 1, 3)
+
+    buffer_copy = buffer.dup
+
+    assert_equal 1, buffer_copy.offset
+    assert_equal 3, buffer_copy.length
+    assert_equal 'xam', buffer_copy.to_s
+    
+    assert !buffer_copy.inspect.empty?
+  end
+  
+  def test_simple_slice
+    data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+    
+    buffer = ReDNS::Buffer.new(data)
+    
+    assert_equal 0, buffer.offset
+    assert_equal 26, buffer.length
+    assert_equal data, buffer.to_s
+    
+    buffer = ReDNS::Buffer.new(data, 5, 10)
+    
+    assert_equal 5, buffer.offset
+    assert_equal 10, buffer.length
+    assert_equal data[5, 10], buffer.to_s
+
+    buffer = ReDNS::Buffer.new(data, 20, 10)
+    
+    assert_equal 20, buffer.offset
+    assert_equal 6, buffer.length
+    assert_equal data[20, 6], buffer.to_s
+  end
+    
+  def test_read_and_rewind
+    data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+
+    buffer = ReDNS::Buffer.new(data)
+    
+    assert_equal 0, buffer.offset
+    assert_equal 26, buffer.length
+    assert_equal data, buffer.to_s
+    
+    assert_equal 'ABCDE', buffer.read(5)
+    assert_equal 21, buffer.length
+
+    assert_equal 'F', buffer.read
+    assert_equal 20, buffer.length
+
+    assert_equal 'GHI', buffer.read(3)
+    assert_equal 17, buffer.length
+    
+    buffer.rewind(4)
+    assert_equal 21, buffer.length
+    
+    assert_equal 'FGHIJ', buffer.read(5)
+    assert_equal 16, buffer.length
+    
+    buffer.rewind
+    assert_equal 26, buffer.length
+
+    assert_equal 'ABCDE', buffer.read(5)
+    assert_equal 21, buffer.length
+    
+    buffer.advance(-1)
+    assert_equal 22, buffer.length
+
+    assert_equal 'EFGHI', buffer.read(5)
+    assert_equal 17, buffer.length
+
+    buffer.rewind(-1)
+    assert_equal 16, buffer.length
+
+    assert_equal 'KLM', buffer.read(3)
+    assert_equal 13, buffer.length
+
+    buffer.rewind(99)
+    assert_equal 26, buffer.length
+    
+    buffer.rewind(-99)
+    assert_equal 0, buffer.length
+
+    buffer.rewind(99)
+    assert_equal 26, buffer.length
+  end
+
+  def test_write_and_append
+    data = 'ABCDEF'.freeze
+    
+    buffer = ReDNS::Buffer.new(data)
+    
+    buffer.write('XY')
+    buffer.write('Z')
+    
+    assert_equal 'ABCDEF', buffer.to_s
+    
+    buffer.advance(2)
+    buffer.write('QRST', 1)
+    
+    buffer.rewind
+    assert_equal 'XYZABQCDEF', buffer.to_s
+    
+    buffer.advance(2)
+    assert_equal 'ZABQCDEF', buffer.to_s
+    
+    buffer.append('RST')
+    assert_equal 'ZABQCDEFRST', buffer.to_s
+  end
+  
+  def test_unpack
+    buffer = ReDNS::Buffer.new([ 127, 0, 0, 255 ].pack('CCCC'))
+    
+    assert_equal [ 127, 0, 0, 255 ], buffer.unpack('CCCC')
+    
+    assert_equal 4, buffer.offset
+    assert_equal 0, buffer.length
+    
+    buffer.rewind
+    
+    assert_equal [ (127 << 24 | 255) ], buffer.unpack('N')
+  end
+
+  def test_pack
+    buffer = ReDNS::Buffer.new
+    
+    buffer.pack([ 127, 0, 0, 255 ], 'CCCC')
+    buffer.pack([ 1, 2, 3, 4 ], 'CCCC')
+    
+    assert_equal 0, buffer.offset
+    assert_equal 8, buffer.length
+    
+    assert_equal [ 127, 0, 0, 255 ], buffer.unpack('CCCC')
+
+    assert_equal 4, buffer.offset
+    assert_equal 4, buffer.length
+
+    assert_equal [ 1, 2, 3, 4 ], buffer.unpack('CCCC')
+    
+    assert_equal 8, buffer.offset
+    assert_equal 0, buffer.length
+
+    assert_equal [ ], buffer.unpack('N')
+    
+    buffer.rewind(4)
+    
+    assert_equal [ (1 << 24 | 2 << 16 | 3 << 8 | 4) ], buffer.unpack('N')
+
+    buffer.rewind(8)
+    
+    assert_equal [ (127 << 24 | 255) ], buffer.unpack('N')
+    
+    assert_equal [ 1 ], buffer.unpack('C')
+    assert_equal [ 2 ], buffer.unpack('C')
+    assert_equal [ 3 ], buffer.unpack('C')
+    assert_equal [ 4 ], buffer.unpack('C')
+  end
+end

data/test/test_redns_fragment.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class ExampleFragment < ReDNS::Fragment
+  attribute :sample
+  attribute :sample_int, :convert => :to_i, :default => 0
+  attribute :sample_proc, :convert => lambda { |v| v.to_i * 2 }
+  attribute :sample_class, :convert => ReDNS::Buffer
+  attribute :sample_default, :default => lambda { 5 }
+  attribute :sample_boolean, :boolean => true
+end
+
+class TestReDNSFragment < Test::Unit::TestCase
+  def test_base_class
+    fragment = ReDNS::Fragment.new
+    
+    empty_state = { }
+    
+    assert_equal empty_state, fragment.attributes
+  end
+  
+  def test_example_class
+    fragment = ExampleFragment.new
+    
+    assert_equal nil, fragment.sample
+    assert_equal 0, fragment.sample_int
+    assert_equal ReDNS::Buffer, fragment.sample_class.class
+    assert_equal false, fragment.sample_boolean
+    
+    fragment.sample = 'foo'
+    assert_equal 'foo', fragment.sample
+    
+    fragment.sample_int = '290'
+    assert_equal 290, fragment.sample_int
+
+    fragment.sample_proc = '100'
+    assert_equal 200, fragment.sample_proc
+    
+    fragment.sample_class = 'EXAMPLE'
+    assert_equal 'EXAMPLE', fragment.sample_class
+    assert_equal ReDNS::Buffer, fragment.sample_class.class
+    
+    assert_equal 5, fragment.sample_default
+    
+    fragment.sample_boolean = 0
+    assert_equal true, fragment.sample_boolean
+  end
+
+  def test_initialize_with_block
+    fragment = ExampleFragment.new do |fragment|
+      fragment.sample = "Example"
+    end
+    
+    assert_equal "Example", fragment.sample
+  end
+end

data/test/test_redns_message.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestReDNSMessage < Test::Unit::TestCase
+  def test_empty_message
+    message = ReDNS::Message.new
+    
+    assert_equal true, message.query?
+    
+    assert_equal 1, message.id
+    assert_equal 0, message.questions_count
+    assert_equal 0, message.answers_count
+    assert_equal 0, message.nameservers_count
+    assert_equal 0, message.additional_records_count
+    
+    assert_equal [ ], message.questions
+    assert_equal [ ], message.answers
+    assert_equal [ ], message.nameservers
+    assert_equal [ ], message.additional_records
+    
+    assert_equal ";; HEADER:\n;; opcode: QUERY status: NOERROR id: 1 \n;; flags: ; QUERY: 0, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0\n;; QUESTION SECTION:\n\n;; ANSWER SECTION:\n\n;; NAMESERVER SECTION:\n\n;; ADDITIONAL SECTION:\n\n", message.to_s
+  end
+
+  def test_simple_query
+    message = ReDNS::Message.new
+    
+    question = ReDNS::Question.new do |question|
+      question.name = 'example.com'
+      question.qtype = :a
+    end
+    
+    message.questions << question
+    
+    assert_equal 1, message.questions.length
+  end
+end