faildns 0.0.1

data/lib/faildns/common.rb

@@ -0,0 +1,52 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of faildns.
+#
+# faildns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# faildns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with faildns. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module DNS
+  Version = '0.0.1'
+
+  def self.debug (argument, options={})
+    if !ENV['DEBUG']
+      return
+    end
+
+    if ENV['DEBUG'].to_i < (options[:level] || 1)
+      return
+    end
+
+    output = "From: #{caller[0, options[:deep] || 1].join("\n")}\n"
+  
+    if argument.is_a?(Exception)
+      output << "#{argument.class}: #{argument.message}\n"
+      output << argument.backtrace.collect {|stack|
+        stack
+      }.join("\n")
+      output << "\n\n"
+    elsif argument.is_a?(String)
+      output << "#{argument}\n"
+    else
+      output << "#{argument.inspect}\n"
+    end
+  
+    if options[:separator]
+      output << options[:separator]
+    end
+
+    puts output
+  end
+end

data/lib/faildns/domainname.rb

@@ -0,0 +1,223 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of faildns.
+#
+# faildns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# faildns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with faildns. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module DNS
+
+#--
+# Domain names in messages are expressed in terms of a sequence of labels.
+# Each label is represented as a one octet length field followed by that
+# number of octets.  Since every domain name ends with the null label of
+# the root, a domain name is terminated by a length byte of zero.  The
+# high order two bits of every length octet must be zero, and the
+# remaining six bits of the length field limit the label to 63 octets or
+# less.
+# 
+# To simplify implementations, the total length of a domain name (i.e.,
+# label octets and label length octets) is restricted to 255 octets or
+# less.
+# 
+# Although labels can contain any 8 bit values in octets that make up a
+# label, it is strongly recommended that labels follow the preferred
+# syntax described elsewhere in this memo, which is compatible with
+# existing host naming conventions.  Name servers and resolvers must
+# compare labels in a case-insensitive manner (i.e., A=a), assuming ASCII
+# with zero parity.  Non-alphabetic codes must match exactly.
+# 
+# In order to reduce the size of messages, the domain system utilizes a
+# compression scheme which eliminates the repetition of domain names in a
+# message.  In this scheme, an entire domain name or a list of labels at
+# the end of a domain name is replaced with a pointer to a prior occurance
+# of the same name.
+# 
+# The pointer takes the form of a two octet sequence:
+# 
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     | 1  1|                OFFSET                   |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+# The first two bits are ones.  This allows a pointer to be distinguished
+# from a label, since the label must begin with two zero bits because
+# labels are restricted to 63 octets or less.  (The 10 and 01 combinations
+# are reserved for future use.)  The OFFSET field specifies an offset from
+# the start of the message (i.e., the first octet of the ID field in the
+# domain header).  A zero offset specifies the first byte of the ID field,
+# etc.
+# 
+# The compression scheme allows a domain name in a message to be
+# represented as either:
+# 
+#    - a sequence of labels ending in a zero octet
+# 
+#    - a pointer
+# 
+#    - a sequence of labels ending with a pointer
+# 
+# Pointers can only be used for occurances of a domain name where the
+# format is not class specific.  If this were not the case, a name server
+# or resolver would be required to know the format of all RRs it handled.
+# As yet, there are no such cases, but they may occur in future RDATA
+# formats.
+# 
+# If a domain name is contained in a part of the message subject to a
+# length field (such as the RDATA section of an RR), and compression is
+# used, the length of the compressed name is used in the length
+# calculation, rather than the length of the expanded name.
+# 
+# Programs are free to avoid using pointers in messages they generate,
+# although this will reduce datagram capacity, and may cause truncation.
+# However all programs are required to understand arriving messages that
+# contain pointers.
+# 
+# For example, a datagram might need to use the domain names F.ISI.ARPA,
+# FOO.F.ISI.ARPA, ARPA, and the root.  Ignoring the other fields of the
+# message, these domain names might be represented as:
+# 
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     20 |           1           |           F           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     22 |           3           |           I           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     24 |           S           |           I           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     26 |           4           |           A           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     28 |           R           |           P           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     30 |           A           |           0           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     40 |           3           |           F           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     42 |           O           |           O           |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     44 | 1  1|                20                       |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     64 | 1  1|                26                       |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     92 |           0           |                       |
+#        +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+# The domain name for F.ISI.ARPA is shown at offset 20.  The domain name
+# FOO.F.ISI.ARPA is shown at offset 40; this definition uses a pointer to
+# concatenate a label for FOO to the previously defined F.ISI.ARPA.  The
+# domain name ARPA is defined at offset 64 using a pointer to the ARPA
+# component of the name F.ISI.ARPA at 20; note that this pointer relies on
+# ARPA being the last label in the string at 20.  The root domain name is
+# defined by a single octet of zeros at 92; the root domain name has no
+# labels.
+#++
+
+class DomainName
+  def self.pointer (string, offset)
+    string.force_encoding 'BINARY'
+
+    return string[offset.unpack('n').first & 0x3FFF, 512]
+  end
+
+  def self.parse (string, whole)
+    string.force_encoding 'BINARY'
+
+    result = ''
+
+    case string.unpack('c').first & 0xC0
+      when 0xC0
+        result       += DomainName.parse(DomainName.pointer(whole, string), whole)
+        string[0, 2]  = ''
+
+      when 0x00
+        while (length = string.unpack('c').first) != 0 && (length & 0xC0) == 0
+          result                += '.' + string[1, length]
+          string[0, length + 1]  = ''
+        end
+
+        if length & 0xC0 == 0xC0
+          result += '.' + DomainName.parse(string, whole)
+
+          string[0, 2] = ''
+        else
+          string[0, 1] = ''
+        end
+
+        result[0, 1] = ''
+    end
+
+    DomainName.new result
+  end
+
+  def self.length (string)
+    string.force_encoding 'BINARY'
+
+    string = string.clone
+    result = 0
+
+    if string.unpack('c').first & 0xC0 == 0xC0
+      return 2
+    else
+      while (length = string.unpack('c').first) != 0 && (length & 0xC0) == 0
+        result                += 1 + length
+        string[0, length + 1]  = ''
+      end
+
+      if length & 0xC0 == 0xC0
+        result += 2
+      else
+        result += 1
+      end
+    end
+
+    return result
+  end
+
+  attr_accessor :domain
+
+  def initialize (domain)
+    if domain.is_a? DomainName
+      domain = domain.domain
+    end
+
+    if !domain.is_a? String
+      raise ArgumentError.new 'The passed value is not a string.'
+    end
+
+    @domain = domain
+  end
+
+  def to_s
+    @domain
+  end
+
+  alias to_str to_s
+
+  def pack (options={})
+    result = ''
+
+    @domain.split('.').each {|part|
+      result += [part.length].pack('c') + part
+    }
+
+    result += [0].pack('c')
+  end
+end
+
+end

data/lib/faildns/header.rb

@@ -0,0 +1,254 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of faildns.
+#
+# faildns is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# faildns is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with faildns. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'faildns/header/type'
+require 'faildns/header/opcode'
+require 'faildns/header/status'
+
+module DNS
+
+#--
+# The header contains the following fields:
+# 
+#                                     1  1  1  1  1  1
+#       0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |                      ID                       |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |                    QDCOUNT                    |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |                    ANCOUNT                    |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |                    NSCOUNT                    |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+#     |                    ARCOUNT                    |
+#     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+# 
+# where:
+# 
+# ID              A 16 bit identifier assigned by the program that
+#                 generates any kind of query.  This identifier is copied
+#                 the corresponding reply and can be used by the requester
+#                 to match up replies to outstanding queries.
+# 
+# QR              A one bit field that specifies whether this message is a
+#                 query (0), or a response (1).
+# 
+# OPCODE          A four bit field that specifies kind of query in this
+#                 message.  This value is set by the originator of a query
+#                 and copied into the response.  The values are:
+# 
+#                 0               a standard query (QUERY)
+# 
+#                 1               an inverse query (IQUERY)
+# 
+#                 2               a server status request (STATUS)
+# 
+#                 3-15            reserved for future use
+# 
+# AA              Authoritative Answer - this bit is valid in responses,
+#                 and specifies that the responding name server is an
+#                 authority for the domain name in question section.
+# 
+#                 Note that the contents of the answer section may have
+#                 multiple owner names because of aliases.  The AA bit
+#                 corresponds to the name which matches the query name, or
+#                 the first owner name in the answer section.
+# 
+# TC              TrunCation - specifies that this message was truncated
+#                 due to length greater than that permitted on the
+#                 transmission channel.
+# 
+# RD              Recursion Desired - this bit may be set in a query and
+#                 is copied into the response.  If RD is set, it directs
+#                 the name server to pursue the query recursively.
+#                 Recursive query support is optional.
+# 
+# RA              Recursion Available - this be is set or cleared in a
+#                 response, and denotes whether recursive query support is
+#                 available in the name server.
+# 
+# Z               Reserved for future use.  Must be zero in all queries
+#                 and responses.
+# 
+# RCODE           Response code - this 4 bit field is set as part of
+#                 responses.  The values have the following
+#                 interpretation:
+# 
+#                 0               No error condition
+# 
+#                 1               Format error - The name server was
+#                                 unable to interpret the query.
+# 
+#                 2               Server failure - The name server was
+#                                 unable to process this query due to a
+#                                 problem with the name server.
+# 
+#                 3               Name Error - Meaningful only for
+#                                 responses from an authoritative name
+#                                 server, this code signifies that the
+#                                 domain name referenced in the query does
+#                                 not exist.
+# 
+#                 4               Not Implemented - The name server does
+#                                 not support the requested kind of query.
+# 
+#                 5               Refused - The name server refuses to
+#                                 perform the specified operation for
+#                                 policy reasons.  For example, a name
+#                                 server may not wish to provide the
+#                                 information to the particular requester,
+#                                 or a name server may not wish to perform
+#                                 a particular operation (e.g., zone
+#                                 transfer) for particular data.
+# 
+#                 6-15            Reserved for future use.
+# 
+# QDCOUNT         an unsigned 16 bit integer specifying the number of
+#                 entries in the question section.
+# 
+# ANCOUNT         an unsigned 16 bit integer specifying the number of
+#                 resource records in the answer section.
+# 
+# NSCOUNT         an unsigned 16 bit integer specifying the number of name
+#                 server resource records in the authority records
+#                 section.
+# 
+# ARCOUNT         an unsigned 16 bit integer specifying the number of
+#                 resource records in the additional records section.
+#++
+
+class Header
+  @@default = {
+    :AA => false, :TC => false, :RD => false, :RA => false, :AD => false, :CD => true,
+
+    :RCODE => Status.new(:NOERROR),
+
+    :QDCOUNT => 0,
+    :ANCOUNT => 0,
+    :NSCOUNT => 0,
+    :ARCOUNT => 0
+  }
+
+  def self.parse (string)
+    data = string.unpack('nnnnnn')
+
+    string[0, Header.length] = ''
+
+    return Header.new(
+      :ID => data[0],
+
+      :QR => Type.new((data[1] & 0x8000) >> 15),
+
+      :OPCODE => Opcode.new((data[1] & 0x7800) >> 11),
+
+      :AA => (data[1] & 0x400 != 0),
+      :TC => (data[1] & 0x200 != 0),
+      :RD => (data[1] & 0x100 != 0),
+      :RA => (data[1] & 0x80  != 0),
+      :AD => (data[1] & 0x40  != 0),
+      :CD => (data[1] & 0x20  != 0),
+
+      :RCODE  => Status.new(data[1] & 0xf),
+
+      :QDCOUNT => data[2],
+
+      :ANCOUNT => data[3],
+
+      :NSCOUNT => data[4],
+
+      :ARCOUNT => data[5]
+    )
+  end
+
+  def self.length (string=nil)
+    12
+  end
+
+  def initialize (what={})
+    if !what.is_a? Hash
+      raise ArgumentError.new('You have to pass a Hash.')
+    end
+
+    @data = @@default.merge(what)
+
+    if block_given?
+      yield self
+    end
+  end
+
+  def id;             @data[:ID]      end
+  def type;           @data[:QR]      end
+  def class;          @data[:OPCODE]  end
+  def authoritative?; @data[:AA]      end
+  def truncated?;     @data[:TC]      end
+  def recursive?;     @data[:RD]      end
+  def recursivable?;  @data[:RA]      end
+  def authentic?;     @data[:AD]      end
+  def checking?;      @data[:CD]      end
+  def status;         @data[:RCODE]   end
+  def questions;      @data[:QDCOUNT] end
+  def answers;        @data[:ANCOUNT] end
+  def authorities;    @data[:NSCOUNT] end
+  def additionals;    @data[:ARCOUNT] end
+
+  def id= (val);          @data[:ID]      = val             end
+  def type= (val);        @data[:QR]      = Type.new(val)   end
+  def class= (val);       @data[:OPCODE]  = Opcode.new(val) end
+  def authoritative!;     @data[:AA]      = true            end
+  def truncated!;         @data[:TC]      = true            end
+  def recursive!;         @data[:RD]      = true            end
+  def recursivable!;      @data[:RA]      = true            end
+  def authentic!;         @data[:AD]      = true            end
+  def checking!;          @data[:CD]      = true            end
+  def not_authoritative!; @data[:AA]      = false           end
+  def not_truncated!;     @data[:TC]      = false           end
+  def not_recursive!;     @data[:RD]      = false           end
+  def not_recursivable!;  @data[:RA]      = false           end
+  def not_authentic!;     @data[:AD]      = false           end
+  def not_checking!;      @data[:CD]      = false           end
+  def status= (val);      @data[:RCODE]   = Status.new(val) end
+  def questions= (val);   @data[:QDCOUNT] = val             end
+  def answers= (val);     @data[:ANCOUNT] = val             end
+  def authorities= (val); @data[:NSCOUNT] = val             end
+  def additionals= (val); @data[:ARCOUNT] = val             end
+
+  def pack
+    [
+      self.id,
+
+      ( (self.type.value << 15) \
+      | (self.class.value << 14) \
+      | ((self.authoritative?) ? (1 << 10) : 0) \
+      | ((self.truncated?) ? (1 << 9) : 0) \
+      | ((self.recursive?) ? (1 << 8) : 0) \
+      | ((self.recursivable?) ? (1 << 7) : 0) \
+      | (self.status.value)),
+
+      self.questions,
+      self.answers,
+      self.authorities,
+      self.additionals
+    ].pack('nnnnnn')
+  end
+end
+
+end