redns 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+*.gem
+
+*.tmproj
+tmtags
+
+*~
+\#*
+.\#*
+
+*.swp
+
+coverage
+rdoc
+pkg
+

data/README.rdoc

@@ -0,0 +1,10 @@
+= redns
+
+Reactor-Ready DNS Library
+
+This library includes native Ruby encoder/decoder classes for typical
+DNS records that are specified in RFC1035.
+
+== References
+
+[RFC1035](http://www.faqs.org/rfcs/rfc1035.html)

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "redns"
+    gem.summary = %Q{Ruby Reactor-Ready DNS Library}
+    gem.description = %Q{ReDNS is a pure Ruby DNS library with drivers for reactor-model engines such as EventMachine}
+    gem.email = "github@tadman.ca"
+    gem.homepage = "http://github.com/tadman/redns"
+    gem.authors = %w[ tadman ]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redns #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/redns/address.rb

@@ -0,0 +1,44 @@
+class ReDNS::Address < ReDNS::Fragment
+  # == Attributes ===========================================================
+  
+  attribute :address, :default => '0.0.0.0'
+  
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+
+  def initialize(contents = nil)
+    case (contents)
+    when ReDNS::Buffer
+      # Ensure that this String subclass is handled using the default
+      # method, not intercepted and treated as an actual String
+      super(contents)
+    when String
+      super(:address => contents)
+    else
+      super(contents)
+    end
+  end
+  
+  def empty?
+    self.address == '0.0.0.0'
+  end
+  
+	def to_s
+	  self.address
+	end
+	
+	def to_a
+		[ to_s ]
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+	  buffer.append(inet_aton(self.address))
+	  buffer
+	end
+	
+	def deserialize(buffer)
+	  self.address = inet_ntoa(buffer)
+	  self
+	end	
+end

data/lib/redns/buffer.rb

@@ -0,0 +1,138 @@
+class ReDNS::Buffer < String
+  # == Constants ============================================================
+
+  # == Properties ===========================================================
+  
+  alias_method :total_length, :length
+  alias_method :total_size, :size
+
+  attr_reader :offset
+  attr_reader :size
+  alias_method :length, :size
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+  # Create a buffer with arbitrary String contents. The offset parameter
+  # indicates where to start reading, which defaults to character 0 at the
+  # start of the string. The size parameter is used to limit how much of
+  # the content is used
+
+  def initialize(contents = nil, offset = nil, size = nil)
+    if (contents.respond_to?(:serialize))
+      super('')
+      
+      @offset = 0
+      @size = total_length
+      
+      contents.serialize(self)
+    else
+      super(contents || '')
+
+      @offset = offset ? offset.to_i : 0
+      @size = size ? size.to_i : nil
+    end
+    
+    advance(0)
+  end
+  
+  def unpack(format)
+    return [ ] if (@size <= 0)
+    
+    raise ReDNS::Exception::BufferUnderrun if (@offset > total_length)
+
+    data = to_s.unpack(format)
+    advance(data.pack(format).length)
+    data
+  end
+  
+  def pack(contents, format)
+    append(contents.pack(format))
+  end
+  
+  def read(chars = 1)
+    raise ReDNS::Exception::BufferUnderrun if (@offset + chars > total_length)
+
+    result = to_str[@offset, chars]
+    advance(chars)
+    result
+  end
+  
+  def write(contents, length = nil)
+    insertion = length ? contents[0, length] : contents
+    
+    self[@offset, 0] = insertion
+
+    advance(insertion.length)
+  end
+
+  def append(contents, length = nil)
+    insertion = length ? contents[0, length] : contents
+    
+    self << insertion
+    
+    @size += insertion.length
+    
+    self
+  end
+  
+  def advance(chars = 1)
+    if (chars < 0)
+      rewind(-chars)
+    else
+      @offset += chars
+
+      if (@offset > total_length)
+        @offset = total_length
+      end
+
+      max_length = (total_length - @offset)
+
+      if (!@size or @size > max_length)
+        @size = max_length
+      end
+    end
+    
+    @size ||= total_length - @offset
+    
+    self
+  end
+
+  def rewind(chars = nil)
+    if (chars)
+      if (chars < 0)
+        advance(-chars)
+      else
+        @offset -= chars
+        @size += chars
+      
+        if (@offset < 0)
+          @size += @offset
+          @offset = 0
+        end
+      end
+    else
+      @size += @offset
+      @offset = 0
+    end
+    
+    self
+  end
+  
+  def restore_state
+    offset = @offset
+    size = @size
+    yield(self) if (block_given?)
+    @offset = offset
+    @size = size
+  end
+  
+  def to_s
+    to_str[@offset, @size]
+  end
+  
+  def inspect
+    "\#<#{self.class} #{to_s.inspect}>"
+  end
+end

data/lib/redns/fragment.rb

@@ -0,0 +1,105 @@
+class ReDNS::Fragment
+  # This represents a piece of data serialized in a particular DNS format,
+  # which includes both queries, responses, and the individual records that
+  # they contain.
+
+  # == Properties ===========================================================
+  
+  attr_reader :attributes
+
+  # == Extensions ===========================================================
+  
+  include ReDNS::Support
+
+  # == Class Methods ========================================================
+  
+  # Declares an attribute of this fragment.
+  # Options:
+  # * :default = The default value to use if the attribute is not assigned
+  # * :convert = The conversion method to call on incoming values, which can
+  #              be a Symbol, a Class, or a Proc.
+  # * :boolean = Converted to a boolean value, also introduces name? method
+  # * :primary = Indicates this is the primary attribute to be assigned when
+  #              onstructed with only a String.
+  
+  def self.attribute(name, options = nil)
+    name = name.to_sym
+
+    attribute_config = options || { }
+
+    default = attribute_config[:default]
+
+    if (attribute_config[:boolean])
+      default ||= false
+      
+      attribute_config[:convert] ||= lambda { |v| !!v }
+    end
+
+    convert = attribute_config[:convert] || attribute_config[:class]
+    
+    define_method(name) do
+      case (@attributes[name])
+      when nil
+        new_default = default.respond_to?(:call) ? default.call : default
+        
+        @attributes[name] = convert ? convert.call(new_default) : new_default
+      else
+        @attributes[name]
+      end
+    end
+
+    if (attribute_config[:boolean])
+      alias_method :"#{name}?", name
+    end
+    
+    case (convert)
+    when Symbol
+      convert_sym = convert
+      convert = lambda { |o| o.send(convert_sym) }
+    when Class
+      convert_class = convert
+      convert = lambda { |o| o.is_a?(convert_class) ? o : convert_class.new(o) }
+    end
+    
+    define_method(:"#{name}=") do |value|
+      if (convert)
+        value = convert.call(value)
+      end
+      
+      @attributes[name] = value
+    end
+
+    if (attribute_config[:primary])
+      alias_method :primary_attribute=, :"#{name}="
+    end
+  end
+
+  # == Instance Methods =====================================================
+  
+	def initialize(contents = nil)
+	  @attributes = { }
+
+	  case (contents)
+    when Hash
+      assign(contents)
+    when ReDNS::Buffer
+      deserialize(contents)
+    when String
+      if (respond_to?(:primary_attribute=))
+        self.primary_attribute = contents
+      end
+    else
+      # FUTURE: Raise exception on invalid or unexpected type, but for now
+      #         allow the subclass to try.
+    end
+    
+    yield(self) if (block_given?)
+	end
+	
+protected
+  def assign(attributes)
+    attributes.each do |k, v|
+      send(:"#{k}=", v)
+    end
+  end
+end

data/lib/redns/message.rb

@@ -0,0 +1,144 @@
+class ReDNS::Message < ReDNS::Fragment
+  # == Constants ============================================================
+  
+  SECTIONS = [ :questions, :answers, :nameservers, :additional_records ]
+
+  # == Attributes ===========================================================
+  
+	attribute :random_id, :default => lambda { rand(0x10000) }
+
+  attribute :id, :convert => lambda { |v| v.to_i % 0x10000 }, :default => 1
+	attribute :query, :boolean => true, :default => true
+	attribute :opcode, :default => :query
+	attribute :authorative, :boolean => true, :default => false
+	attribute :truncated, :boolean => true, :default => false
+	attribute :recursion_desired, :boolean => true, :default => false
+	attribute :recursion_available, :boolean => true, :default => false
+	attribute :response_code, :default => :noerror
+	
+	attribute :questions_count, :convert => :to_i, :default => 0
+	attribute :answers_count, :convert => :to_i, :default => 0
+	attribute :nameservers_count, :convert => :to_i, :default => 0
+	attribute :additional_records_count, :convert => :to_i, :default => 0
+	
+	attribute :questions, :default => lambda { [ ] }
+	attribute :answers, :default => lambda { [ ] }
+	attribute :nameservers, :default => lambda { [ ] }
+	attribute :additional_records, :default => lambda { [ ] }
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+	def increment_id!
+	  @attributes[:id] += 1
+	end
+
+	def response?
+	  !self.query?
+	end
+	
+	def to_s
+	  flags = [ ]
+	  flags << 'qr' if (response?)
+	  flags << 'aa' if (authorative?)
+	  flags << 'tc' if (truncated?)
+	  flags << 'rd' if (recursion_desired?)
+	  flags << 'ra' if (recursion_available?)
+	  
+		";; HEADER:\n;; opcode: #{opcode.to_s.upcase} status: #{response_code.to_s.upcase} id: #{id} \n" +
+		";; flags: #{flags.join(' ')}; QUERY: #{questions.length}, ANSWER: #{answers.length}, AUTHORITY: #{nameservers.length}, ADDITIONAL: #{additional_records.length}" +
+		"\n" +
+		";; QUESTION SECTION:\n" +
+		questions.collect(&:to_s).join("\n") + "\n" +
+		";; ANSWER SECTION:\n" +
+		answers.collect(&:to_s).join("\n") + "\n" +
+		";; NAMESERVER SECTION:\n" +
+		nameservers.collect(&:to_s).join("\n") + "\n" +
+		";; ADDITIONAL SECTION:\n" +
+		additional_records.collect(&:to_s).join("\n") + "\n"
+	end
+	
+	def length
+		to_dns.length
+	end
+	
+	def empty?
+		questions.empty? and
+		  answers.empty? and
+		  nameservers.empty? and
+		  additional_records.empty?
+	end
+	
+	def to_yaml
+		@attributes.to_yaml
+	end
+
+	def serialize(buffer = ReDNS::Buffer.new)
+	  buffer.pack(
+  		[
+  			self.id,
+  			(
+    			(self.query? ? 0 : 0x8000) |
+    			(ReDNS::OPCODE[self.opcode] || ReDNS::OPCODE[:unknown]) << 12 |
+    			(self.authorative? ? 0x0400 : 0) |
+    			(self.truncated? ? 0x0200 : 0) |
+    			(self.ecursion_desired? ? 0x0100 : 0) |
+    			(self.recursion_available? ? 0x0080 : 0) |
+    			(ReDNS::RCODE[self.reponse_code] || ReDNS::RCODE[:noerror])
+  			),
+  		  self.questions.length,
+  			self.answers.length,
+  			self.nameservers.length,
+  			self.additional_records.length
+  		],
+  		'nnnnnn'
+  	)
+
+    [ :questions, :answers, :nameservers, :additional_records ].each do |section|
+      @attributes[:group].each do |part|
+        part.serialize(buffer)
+      end
+    end
+    
+    buffer
+	end
+
+	def deserialize(buffer)
+		data = buffer.unpack("nnnnnn")
+		
+		self.id = data.shift
+
+		flags = data.shift
+		self.query = flags & 0x8000
+		self.opcode = (flags & 0x7800) >> 12
+		self.authorative = flags & 0x0400
+		self.truncated = flags & 0x0200
+		self.recursion_desired = flags & 0x0100
+		
+		self.recursion_available = flags & 0x0080
+		self.response_code = flags & 0x000F
+		
+		SECTIONS.each do |section|
+		  @attributes[:"#{section}_count"] = data.shift
+	  end
+		
+		SECTIONS.each do |section|
+		  collection = @attributes[section] = [ ]
+		  
+		  decode_class =
+  		  case (section)
+  	    when :question
+  	      ReDNS::Question
+	      else
+	        ReDNS::Resource
+        end
+        
+		  @attributes[:"#{section}_count"].times do
+		    collection << decode_class.new(buffer)
+	    end
+	  end
+	  
+	  self
+	end
+end

data/lib/redns/name.rb

@@ -0,0 +1,79 @@
+class ReDNS::Name < ReDNS::Fragment
+  # == Attributes ===========================================================
+  
+  attribute :name, :default => '.'
+
+  # == Instance Methods =====================================================
+  
+  def initialize(contents = nil)
+    case (contents)
+    when ReDNS::Buffer
+      # Ensure that this String subclass is handled using the default
+      # method, not intercepted and treated as an actual String
+      super(contents)
+    when String
+      super(:name => contents)
+      self.name << '.' unless (self.name.match(/\.$/))
+    else
+      super(contents)
+    end
+  end
+  
+	def to_s
+	  self.name
+	end
+	
+	def to_a
+		[ self.name ]
+	end
+	
+	def length
+		to_s.length
+	end
+	
+	def empty?
+		name == '.'
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+		buffer.append(
+		  self.name.split(/\./).collect { |l| [ l.length, l ].pack("ca*") }.join('')
+		)
+
+		buffer.append("\0")
+		
+		buffer
+	end
+	
+	def deserialize(buffer)
+		self.name = ''
+		
+		return_to_offset = nil
+
+    while (c = buffer.unpack('C')[0])
+      if (c & 0xC0 == 0xC0)
+        # This is part of a pointer to another section, so advance to that
+        # point and read from there, but preserve the position where the
+        # pointer was found to leave the buffer in that final state.
+
+        pointer = (c & 0x3F << 8) | buffer.unpack('C')[0]
+
+        return_to_offset = buffer.offset
+        buffer.rewind
+        buffer.advance(pointer)
+      elsif (c == 0)
+        break
+      else
+        name << buffer.read(c)
+        name << '.'
+      end
+    end
+    
+    if (return_to_offset)
+      buffer.rewind
+      buffer.advance(return_to_offset)
+    end
+    
+    self
+	end
+end

data/lib/redns/question.rb

@@ -0,0 +1,38 @@
+class ReDNS::Question < ReDNS::Fragment
+  # == Constants ============================================================
+  
+  SECTIONS = [ :questions, :answers, :nameservers, :additional_records ]
+
+  # == Attributes ===========================================================
+  
+	attribute :name, :class => ReDNS::Name, :default => lambda { ReDNS::Name.new }
+	
+	attribute :qclass, :default => :in
+	attribute :qtype, :default => :any
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+
+	def to_s
+		"#{name} #{qclass.to_s.upcase} #{qtype.to_s.upcase}"
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+	  name.serialize(buffer)
+	  buffer.pack([ self.qtype_rfc, self.qclass_rfc ], "nn")
+
+    buffer
+	end
+	
+	def deserialize(buffer)
+	  self.name = DNS::Name.new(buffer)
+	  
+	  data = buffer.unpack('nn')
+	  
+		self.qtype = ReDNS::RR_TYPE_LABEL[data.shift]
+		self.qclass = ReDNS::RR_CLASS_LABEL[data.shift]
+		
+		self
+	end
+end

data/lib/redns/record/mx.rb

@@ -0,0 +1,28 @@
+class ReDNS::Record::MX < ReDNS::Fragment
+  # == Attributes ===========================================================
+  
+  attribute :name, :default => lambda { ReDNS::Name.new }, :class => ReDNS::Name
+  attribute :preference, :default => 0, :convert => :to_i
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+	
+	def to_s
+		"#{preference} #{name}"
+	end
+	
+	def to_a
+		[ name.to_s, preference ]
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+	  buffer.pack([ self.preference ], 'n')
+	  self.name.serialize(buffer)
+	end
+
+	def deserialize(buffer)
+	  self.preference = buffer.unpack('n')[0]
+	  self.name = ReDNS::Name.new(buffer)
+	end
+end

data/lib/redns/record/null.rb

@@ -0,0 +1,30 @@
+class ReDNS::Record::Null < ReDNS::Fragment
+  # == Attributes ===========================================================
+  
+  attribute :contents, :default => '', :primary => true
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+	
+	def to_s
+		"#{self.contents}"
+	end
+	
+	def to_a
+		[ self.contents ]
+	end
+	
+	def serialize(buffer = ReDNS::Buffer.new)
+	  buffer.append(self.contents)
+
+	  buffer
+	end
+
+	def deserialize(buffer)
+	  self.contents = buffer.to_s
+	  buffer.advance(self.contents.length)
+
+	  self
+	end
+end