latte 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in latte.gemspec
+gemspec

data/README.md

@@ -0,0 +1,8 @@
+# Latte
+
+An open DNS platform with an easy to use API.
+
+
+## Authors
+
+Craig R Webster <http://barkingiguana.com/>

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/latte.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "latte/version"
+
+Gem::Specification.new do |s|
+  s.name        = "latte"
+  s.version     = Latte::VERSION
+  s.authors     = ["Craig R Webster"]
+  s.email       = ["craig@barkingiguana.com"]
+  s.homepage    = ""
+  s.summary     = %q{A DNS framework with configurable query resolver}
+  s.description = %q{Talks DNS and passes queries back to a query resolver build by you that just talks Ruby}
+
+  s.rubyforge_project = "latte"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "pethau", ">= 0.0.2"
+  s.add_runtime_dependency "null_logger"
+  s.add_runtime_dependency "bindata"
+end

data/lib/latte.rb

@@ -0,0 +1,17 @@
+require 'null_logger'
+require 'socket'
+require 'bindata'
+require 'pethau'
+
+class Object
+  include Pethau::InitializeWith
+  include Pethau::DefaultValueOf
+  include Pethau::PrivateAttrAccessor
+end
+
+require 'latte/hex_presenter'
+require 'latte/address'
+require 'latte/query'
+require 'latte/response'
+require 'latte/server'
+require 'latte/version'

data/lib/latte/address.rb

@@ -0,0 +1,36 @@
+module Latte
+  class Address
+    def self.default
+      @default ||= new
+    end
+
+    initialize_with :raw_string
+
+    def protocol
+      matches = string.scan /^(udp|tcp):\/\//
+      return matches[0][0] unless matches[0].nil?
+    end
+    default_value_of :protocol, 'udp'
+
+    def ip_address
+      matches = string.scan /(\d+\.\d+\.\d+\.\d+)/
+      return matches[0][0] unless matches[0].nil?
+    end
+    default_value_of :ip_address, '127.0.0.1'
+
+    def port
+      matches = string.scan /:(\d+)$/
+      return matches[0][0].to_i unless matches[0].nil?
+    end
+    default_value_of :port, 53
+
+    def string
+      raw_string.to_s.strip
+    end
+    private :string
+
+    def to_s
+      "#{protocol}://#{ip_address}:#{port}"
+    end
+  end
+end

data/lib/latte/hex_presenter.rb

@@ -0,0 +1,7 @@
+class HexPresenter
+  initialize_with :object
+
+  def to_s
+    object.to_s.unpack('H*')[0].scan(/../).join ' '
+  end
+end

data/lib/latte/query.rb

@@ -0,0 +1,129 @@
+module Latte
+  class Query
+    # QTYPE codes:
+    # A 1 a host address
+    # NS 2 an authoritative name server
+    # MD 3 a mail destination (Obsolete - use MX)
+    # MF 4 a mail forwarder (Obsolete - use MX)
+    # CNAME 5 the canonical name for an alias
+    # SOA 6 marks the start of a zone of authority
+    # MB 7 a mailbox domain name (EXPERIMENTAL)
+    # MG 8 a mail group member (EXPERIMENTAL)
+    # MR 9 a mail rename domain name (EXPERIMENTAL)
+    # NULL 10 a null RR (EXPERIMENTAL)
+    # WKS 11 a well known service description
+    # PTR 12 a domain name pointer
+    # HINFO 13 host information
+    # MINFO 14 mailbox or mail list information
+    # MX 15 mail exchange
+    # TXT 16 text strings
+
+    initialize_with :raw_query
+
+    # DNS MESSAGE FORMAT
+    #
+    # Header
+    # Question
+    # Answer
+    # Authority
+    # Additional
+    #
+    # DNS HEADER FORMAT
+    #
+    # OCTET 1,2             ID
+    # OCTET 3,4             QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) +
+    #                       RD(1 bit)+ RA(1 bit) + Z(3 bit) + RCODE(4 bit)
+    # OCTET 5,6             QDCOUNT
+    # OCTET 7,8             ANCOUNT
+    # OCTET 9,10            NSCOUNT
+    # OCTET 11,12           ARCOUNT
+    #
+    # QUESTION FORMAT
+    #
+    # OCTET 1,2,…n          QNAME
+    # OCTET n+1,n+2         QTYPE
+    # OCTET n+3,n+4         QCLASS
+    #
+    # ANSWER, AUTHORITY, ADDITIONAL FORMAT
+    #
+    # OCTET 1,2,..n         NAME
+    # OCTET n+1,n+2         TYPE
+    # OCTET n+3,n+4         CLASS
+    # OCTET n+5,n+6,n+7,n+8 TTL
+    # OCTET n+9,n+10        RDLENGTH
+    # OCTET n+11,n+12,…..   RDATA
+    class QueryHeader < BinData::Record
+      endian :big
+      uint16 :id
+      bit1   :qr
+      bit4   :opcode
+      bit1   :aa
+      bit1   :tc
+      bit1   :rd
+      bit1   :ra
+      bit3   :z
+      bit4   :rcode
+      uint16 :qdcount
+      uint16 :ancount
+      uint16 :nscount
+      uint16 :arcount
+    end
+
+    class QueryRequest < QueryHeader
+      stringz :qname
+      uint16 :qtype
+      uint16 :qclass
+    end
+
+    def parsed_header
+      @parsed_header ||= build_header
+    end
+    private :parsed_header
+
+    def build_header
+      QueryHeader.read raw_query
+    end
+    private :build_header
+
+    def parsed_record
+      @parsed_record ||= build_record
+    end
+    private :parsed_record
+
+    def build_record
+      case parsed_header.qr.value
+      when 0
+        QueryRequest.read raw_query
+      else
+        raise "Unhandled QR value: #{parsed_header.qr.value}"
+      end
+    end
+
+    def method_missing *args
+      result = parsed_record.send *args
+      return result.value if result.respond_to? :value
+      result
+    end
+
+    def header
+      "ID=#{id} QR=#{qr} TC=#{tc} RD=#{rd} RA=#{ra} Z=#{z} " + \
+      "RCODE=#{rcode} QDCOUNT=#{qdcount} ANCOUNT=#{ancount} " + \
+      "NSCOUNT=#{nscount} ARCOUNT=#{arcount}"
+    end
+
+    def human_qname
+      value = parsed_record.qname.value.dup
+      value.gsub! /^[\x00-\x1f]/, ''
+      value.gsub! /[\x00-\x1f]/, '.'
+      value + '.'
+    end
+
+    def query
+      "QNAME=#{human_qname} QTYPE=#{qtype} QCLASS=#{qclass}"
+    end
+
+    def to_s
+      [ header, query ].join " "
+    end
+  end
+end

data/lib/latte/response.rb

@@ -0,0 +1,191 @@
+module Latte
+  class Response
+    initialize_with :query
+
+    class BigEndianRecord < BinData::Record
+      endian :big
+    end
+
+    class ResponseHeader < BigEndianRecord
+      uint16 :id
+      bit1   :qr
+      bit4   :opcode
+      bit1   :aa
+      bit1   :tc
+      bit1   :rd
+      bit1   :ra
+      bit3   :z, :value => 0 # Reserved for future use
+      bit4   :rcode
+      uint16 :qdcount
+      uint16 :ancount
+      uint16 :nscount
+      uint16 :arcount
+    end
+
+    class Question < BigEndianRecord
+      stringz :qname
+      uint16 :qtype
+      uint16 :qclass
+    end
+
+    class Answer < BigEndianRecord
+      stringz :qname
+      uint16 :qtype
+      uint16 :qclass
+      uint32 :ttl
+      uint16 :rdlength, :value => lambda { rdata.length }
+      string :rdata
+    end
+
+    def header
+      ResponseHeader.new.tap { |h|
+        h.id = query.id
+        h.qr = 1 # I'm a response
+        h.opcode = 0 # I'm a standard query
+        h.aa = 0 # I'm not authoritative
+        h.tc = 0 # I wasn't truncated
+        h.rd = 0 # Please don't recursively query
+        h.ra = 0 # Recursion isn't welcome here
+        h.rcode = 0 # There are no errors here
+        h.qdcount = 1 # I'm answering one query
+        h.ancount = answers.size # The number of answer records I'm sending
+        h.nscount = 0 # There are 0 NS records in the authority part
+        h.arcount = 0 # How many additional records am I sending?
+      }
+    end
+
+    def question
+      Question.new.tap { |q|
+        q.qname = query.qname
+        q.qtype = query.qtype
+        q.qclass = query.qclass
+      }
+    end
+
+    def answers
+      @answers ||= [ ]
+    end
+
+    class RecordParser
+      initialize_with :record_string
+      private_attr_accessor :record
+      public :record
+
+      # QTYPE codes:
+      # A 1 a host address
+      # NS 2 an authoritative name server
+      # MD 3 a mail destination (Obsolete - use MX)
+      # MF 4 a mail forwarder (Obsolete - use MX)
+      # CNAME 5 the canonical name for an alias
+      # SOA 6 marks the start of a zone of authority
+      # MB 7 a mailbox domain name (EXPERIMENTAL)
+      # MG 8 a mail group member (EXPERIMENTAL)
+      # MR 9 a mail rename domain name (EXPERIMENTAL)
+      # NULL 10 a null RR (EXPERIMENTAL)
+      # WKS 11 a well known service description
+      # PTR 12 a domain name pointer
+      # HINFO 13 host information
+      # MINFO 14 mailbox or mail list information
+      # MX 15 mail exchange
+      # TXT 16 text strings
+
+      def qname
+        parts[0]
+      end
+
+      def qclass
+        parts[1]
+      end
+
+      def encoded_qclass
+        {
+          'IN' => 1,
+          'CH' => 3,
+          'HS' => 4
+        }[qclass]
+      end
+
+      def qtype
+        parts[2]
+      end
+
+      def encoded_qtype
+        {
+          'A'     => 1,
+          'NS'    => 2,
+          'CNAME' => 5,
+          'SOA'   => 6,
+          'PTR'   => 12,
+          'HINFO' => 13,
+          'MINFO' => 14,
+          'MX'    => 15,
+          'TXT'   => 16
+        }[qtype]
+      end
+
+      def ttl
+        parts[3].to_i
+      end
+
+      def rdata
+        parts[4]
+      end
+
+      def encode_name name
+        parts = name.split /\./
+        parts.map! { |p| BinData::Uint8.new(p.length).to_binary_s + p }
+        parts << BinData::Uint8.new(0).to_binary_s
+        parts.join ''
+      end
+
+      def encoded_qname
+        encode_name qname
+      end
+
+      def encoded_rdata
+        # FIXME: Extract this case statment into separate encoders
+        case qtype
+        when 'A', 'PTR'
+          parts = rdata.split /\./
+          parts.map! { |o| BinData::Uint8.new(o.to_i).to_binary_s }
+          parts.join ''
+        when 'NS', 'CNAME'
+          encode_name rdata
+        else
+          raise "I don't know how to encode QTYPE #{qtype.inspect}"
+        end
+      end
+
+      def parts
+        string = record_string.dup
+        string.strip!
+        parts = string.split /\s+/, 5
+        parts.map! { |p| p.strip }
+        parts
+      end
+
+      def execute
+        self.record = Answer.new.tap { |a|
+          a.qname = encoded_qname
+          a.qtype = encoded_qtype
+          a.qclass = encoded_qclass
+          a.ttl = ttl
+          a.rdata = encoded_rdata
+        }
+      end
+    end
+
+    def add record
+      parser = RecordParser.new record
+      parser.execute
+      record = parser.record
+      answers << record
+    end
+
+    def to_s
+      [ header, question, *answers ].map { |part|
+        part.to_binary_s
+      }.join ''
+    end
+  end
+end

data/lib/latte/server.rb

@@ -0,0 +1,81 @@
+module Latte
+  class Server
+    CHECK_ALIVE_INTERVAL = 5
+
+    initialize_with :resolver, :logger
+    default_value_of :resolver, lambda { |*| }
+    default_value_of :logger    do NullLogger.instance end
+    private_attr_accessor :children
+    default_value_of :children, {}
+    private_attr_accessor :addresses
+    default_value_of :addresses do [ Address.default ] end
+
+    def listen_on *addresses
+      return if addresses.empty?
+      self.addresses = addresses
+    end
+
+    def run
+      logger.debug "I will listen on #{addresses.map(&:to_s).join(',')}"
+      listen
+    end
+
+    def listen
+      loop do
+        addresses.each do |address|
+          next if running_server? address
+          run_server address
+        end
+        sleep CHECK_ALIVE_INTERVAL
+      end
+    end
+    private :listen
+
+    def running_server? address
+      return false unless server_exists_for? address
+      server = server_for address
+      server.alive?
+    end
+
+    def server_for address
+      children[address]
+    end
+
+    def server_exists_for? address
+      !server_for(address).nil?
+    end
+
+    def run_server address
+      if server_exists_for? address
+        logger.warn "Restarting server for #{address}"
+      end
+      logger.debug "Preparing server for #{address}"
+      server_loop = "#{address.protocol}_server_loop"
+      children[address] = Thread.new do
+        begin
+          logger.debug "Server starting on #{address}"
+          Socket.send server_loop, address.ip_address, address.port do |data, client|
+            Thread.new do
+              begin
+                query = Query.new data
+                client_name = client.remote_address.ip_unpack.join ':'
+                logger.debug "#{client_name} > #{address}: #{HexPresenter.new(data)}"
+                response = Response.new query
+                resolver.call query, response
+                logger.debug "#{client_name} < #{address}: #{HexPresenter.new(response)}"
+                client.reply response.to_s
+              rescue => e
+                logger.error [ e.message, e.backtrace ].flatten.join("\n")
+              end
+            end
+          end
+          logger.warn "Server loop terminated"
+        rescue => e
+          logger.error [ e.message, e.backtrace ].flatten.join("\n")
+        end
+      end
+      logger.debug "Server started for #{address}"
+    end
+    private :run_server
+  end
+end

data/lib/latte/version.rb

@@ -0,0 +1,3 @@
+module Latte
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: latte
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Craig R Webster
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pethau
+  requirement: &70282543179020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282543179020
+- !ruby/object:Gem::Dependency
+  name: null_logger
+  requirement: &70282539604060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282539604060
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &70282539603600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282539603600
+description: Talks DNS and passes queries back to a query resolver build by you that
+  just talks Ruby
+email:
+- craig@barkingiguana.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- latte.gemspec
+- lib/latte.rb
+- lib/latte/address.rb
+- lib/latte/hex_presenter.rb
+- lib/latte/query.rb
+- lib/latte/response.rb
+- lib/latte/server.rb
+- lib/latte/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: latte
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A DNS framework with configurable query resolver
+test_files: []