Dnsruby 0.5.0

data/lib/Dnsruby/SingleResolver.rb

@@ -0,0 +1,312 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'Dnsruby/select_thread'
+module Dnsruby
+  #== Dnsruby::SingleResolver
+  #
+  # The SingleResolver class targets a single resolver, and controls the sending of a single 
+  # packet with a packet timeout. It performs no retries. Only two threads are used - the client 
+  # thread and a select thread (which is reused across all queries).
+  # 
+  #== Methods
+  # 
+  #=== Synchronous
+  #These methods raise an exception or return a response message with rcode==NOERROR
+  #
+  #*  Dnsruby::SingleResolver#send_message(msg [, use_tcp]))
+  #*  Dnsruby::SingleResolver#query(name [, type [, klass]])
+  #
+  #=== Asynchronous
+  #These methods use a response queue to return the response and the error
+  #
+  #*  Dnsruby::SingleResolver#send_async(msg, query_id, response_queue [, use_tcp])
+  #
+  class SingleResolver
+    attr_accessor :packet_timeout
+    
+    # The port on the resolver to send queries to.
+    # 
+    # Defaults to 53
+    attr_accessor :port
+    
+    # Use TCP rather than UDP as the transport.
+    # 
+    # Defaults to false
+    attr_accessor :use_tcp
+    
+    attr_accessor :tsig_key
+    
+    # Don't worry if the response is truncated - return it anyway.
+    # 
+    # Defaults to false
+    attr_accessor :ignore_truncation
+    
+    # The source address to send queries from
+    # 
+    # Defaults to localhost
+    attr_accessor :src_address
+    # The source port to send queries from
+    # 
+    # Defaults to 0 - random port
+    attr_accessor :src_port
+    
+    # Should the TCP socket persist between queries?
+    # 
+    # Defaults to false
+    attr_accessor :persistent_tcp
+    
+    # Should the UDP socket persist between queries?
+    # 
+    # Defaults to false
+    attr_accessor :persistent_udp
+    
+    # should the Recursion Desired bit be set on queries?
+    # 
+    # Defaults to true
+    attr_accessor :recurse
+    
+    # The max UDP packet size
+    # 
+    # Defaults to 512
+    attr_accessor :udp_size
+    
+    # The address of the resolver to send queries to
+    attr_reader :server
+    
+    def udp_size=(size)
+      @udp_size = size
+    end
+    
+    def server=(server)
+      TheLog.debug("SingleResolver setting server to #{server}")
+      @server=Config.resolve_server(server)
+    end
+    
+    # Can take a hash with the following optional keys : 
+    # 
+    # * :server
+    # * :port
+    # * :use_tcp
+    # * :ignore_truncation
+    # * :src_addr
+    # * :src_port
+    # * :udp_size
+    # * :persistent_tcp
+    # * :persistent_udp
+    # * :tsig_key
+    # * :packet_timeout
+    # * :recurse
+    def initialize(*args)
+      arg=args[0]
+      @packet_timeout = Resolver::DefaultPacketTimeout
+      @port = Resolver::DefaultPort
+      @udp_size = Resolver::DefaultUDPSize
+      @use_tcp = false
+      @tsig_key = nil
+      @ignore_truncation = false
+      @src_addr        = '0.0.0.0'
+      @src_port        = 0
+      @recurse = true
+      @persistent_udp = false
+      @persistent_tcp = false
+      
+      if (arg==nil)
+        # Get default config
+        config = Config.new
+        @server = config.nameserver[0]
+      elsif (arg.kind_of?String)
+        @server=arg
+      elsif (arg.kind_of?Hash)
+        arg.keys.each do |attr|
+          begin
+            send(attr.to_s+"=", arg[attr])
+          rescue Exception
+            TheLog.error("Argument #{attr} not valid\n")
+          end
+          #        end
+        end
+      end
+      #Check server is IP
+      @server=Config.resolve_server(@server)
+      
+    end
+    
+    def close
+      # @TODO@ What about closing?
+    end
+    
+    # Synchronously send a query for the given name. The type will default to A, 
+    # and the class to IN.
+    def query(name, type=Types.A, klass=Classes.IN)
+      msg = Message.new
+      msg.header.rd = 1
+      msg.add_question(name, type, klass)
+      return send_message(msg)
+    end
+    
+    
+    # Synchronously send a Message to the server. If a valid response is returned, 
+    # then that is returned to the client. Otherwise a ResolvError or ResolvTimeout 
+    # will be thrown. 
+    # 
+    # Takes the message to send, and an optional use_tcp parameter which defaults to
+    # SingleResolver.use_tcp
+    def send_message(msg, use_tcp=@use_tcp)
+      q = Queue.new
+      send_async(msg, q, q, use_tcp)
+      id, msg, error = q.pop
+      if (error != nil)
+        raise error
+      else
+        return msg
+      end
+    end
+    
+    
+    # Asynchronously send a Message to the server. A client_queue is supplied by the client, 
+    # along with a client_query_id to identify the response. When the response is known, the tuple
+    # (query_id, response_message, response_exception) is put in the queue for the client to process. 
+    # 
+    # The query is sent synchronously in the caller's thread. The select thread is then used to 
+    # listen for and process the response (up to pushing it to the client_queue). The client thread 
+    # is then used to retrieve the response and deal with it.
+    # 
+    # Takes :
+    # 
+    # * msg - the message to send
+    # * client_query_id - an ID to identify the query to the client
+    # * client_queue - a Queue to push the response to, when it arrives
+    # * use_tcp - whether to use TCP (defaults to SingleResolver.use_tcp)
+    def send_async(msg, client_query_id, client_queue, use_tcp=@use_tcp)
+      st = SelectThread.instance
+      if (msg.kind_of?String)
+        msg = Message.new(msg)
+      end
+      query_packet = make_query_packet(msg)
+      if (udp_packet_size < query_packet.length)
+        use_tcp = true
+      end
+      # First send the query (synchronously)
+      # @TODO@ persisent sockets
+      endtime = Time.now + @packet_timeout
+      socket = nil
+      begin
+        #@TODO@ Different OSes have different interpretations of "random port" here.
+        #Apparently, Linux will just give you the same port as last time, unless it is still
+        #open, in which case you get n+1.
+        #We need to determine an actual (random) number here, then ask the OS for it, and
+        #continue until we get one.
+        if (use_tcp) 
+          print "Setting src_port to #{@src_port}"
+          socket = TCPSocket.new(@server, @port, @src_addr, @src_port)
+        else
+          socket = UDPSocket.new()
+          socket.bind(@src_addr, @src_port)
+          socket.connect(@server, @port)
+        end
+      rescue Exception => e
+        if (socket!=nil)
+          socket.close
+        end
+        err=IOError.new("dnsruby can't connect to #{@server}:#{@port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}, exception = #{e.class}, #{e}")
+        TheLog.error("#{err}")
+        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        return
+      end
+      if (socket==nil)
+        err=IOError.new("dnsruby can't connect to #{@server}:#{port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}")
+        TheLog.error("#{err}")
+        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        return
+      end
+      TheLog.debug("Sending packet to #{@server}:#{@port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}")
+      begin
+        if (use_tcp)
+          lenmsg = [query_packet.length].pack('n')
+          socket.send(lenmsg, 0)
+        end
+        socket.send(query_packet, 0)
+      rescue Exception => e
+        socket.close
+        err=IOError.new("Send failed to #{@server}:#{@port} from #{@src_addr}:#{@src_port}, use_tcp=#{use_tcp}, exception : #{e}")
+        TheLog.error("#{err}")
+        st.push_exception_to_select(client_query_id, client_queue, err, nil)
+        return
+      end
+      
+      # Then listen for the response
+      query_settings = SelectThread::QuerySettings.new(query_packet, msg.header.id, @tsig_key, @ignore_truncation, client_queue, client_query_id, socket, @server, @port, endtime)
+      # The select thread will now wait for the response and send that or a timeout
+      # back to the client_queue
+      st.add_to_select(query_settings)
+    end
+    
+    # Prepare the packet for sending
+    def make_query_packet(packet) #:nodoc: all
+      if (packet.header.opcode == OpCode.QUERY || @recurse)
+        packet.header.rd=true
+      end
+      
+      if (@dnssec)
+        # RFC 3225
+        TheLog.debug(";; Adding EDNS extention with UDP packetsize #{udp_packet_size} and DNS OK bit set\n")
+        
+        optrr = Resource.create({
+            :type         => 'OPT',
+            :name         => '',
+            :rrclass        => udp_packet_size,  # Decimal UDPpayload
+            :ednsflags    => 0x8000, # first bit set see RFC 3225 
+          })
+        
+        packet.add_additional(optrr)
+        
+      elsif (udp_packet_size > Resolver::DefaultUDPSize)
+        TheLog.debug(";; Adding EDNS extention with UDP packetsize  #{udp_packet_size}.\n")
+        # RFC 3225
+        optrr = Resource.create( {
+            :type         => 'OPT',
+            :name         => '',
+            :rrclass        => udp_packet_size,  # Decimal UDPpayload
+            :ttl          => 0x0000 # RCODE 32bit Hex
+          })
+        
+        packet.add_additional(optrr)
+      end
+      
+      if (@tsig_key)
+        @tsig_key.apply(packet)
+      end
+      # @TODO@ TSIG!!!      
+      #      if (@tsig_rr != nil && @tsig_rr.length > 0)
+      #        #          if (!grep { $_.type == 'TSIG' } packet.additional)
+      #        if (packet.additional.select { |i| i.type == 'TSIG' }.length > 0)
+      #          packet.push('additional', @tsig_rr)
+      #        end
+      #      end
+      
+      #      TheLog.debug("#{packet}")
+      return packet.encode
+    end
+    
+    # Return the packet size to use for UDP
+    def udp_packet_size
+      # if @udp_size > DefaultUDPSize then we use EDNS and 
+      # @udp_size should be taken as the maximum packet_data length
+      ret = (@udp_size > Resolver::DefaultUDPSize ? @udp_size : Resolver::DefaultUDPSize) 
+      return ret
+    end
+  end
+end

data/lib/Dnsruby/TheLog.rb

@@ -0,0 +1,61 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'logger'
+require 'singleton'
+require 'thread'
+module Dnsruby
+  #This singleton class holds a reference to the Logger object used by the whole of the Dnsruby project.
+  #
+  #It's Logger (which defaults to STDOUT, level FATAL) can be configured, or a new Logger can be supplied.
+  #
+  # Dnsruby::TheLog.level=Logger::DEBUG
+  # Dnsruby::TheLog.debug("Debug message")
+  # 
+  class TheLog
+    include Singleton
+    def initialize() #:nodoc: all
+      @@mutex=Mutex.new
+      @@logger = Logger.new(STDOUT)
+      @@logger.level = Logger::FATAL
+    end
+    # Set a new Logger for use by Dnsruby
+    def set_logger(logger)
+      @@mutex.synchronize{
+        @@logger = logger
+      }
+    end
+    # Change the Logger level.
+    def level=(level)
+      @@mutex.synchronize{
+        @@logger.level = level
+      }
+    end
+    def level
+      @@mutex.synchronize{
+        return @@logger.level
+      }
+    end
+    
+    def self.method_missing(symbol, *args) #:nodoc: all
+      @@mutex.synchronize{
+        now = Time.now
+        #        p "#{now.hour}:#{now.min}:#{now.sec} - #{args}"
+        @@logger.send(symbol, *args)
+      }
+    end
+    log = TheLog.instance # initialise @@logger
+  end
+end

data/lib/Dnsruby/code_mapper.rb

@@ -0,0 +1,164 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+  # CodeMapper superclass looks after String to code mappings (e.g. OpCode, RCode, etc.)
+  # 
+  # Subclasses simply define a mapping of codes to variable names, and CodeMapper provides utility methods.
+  # 
+  # All strings will come out as upper case
+  # 
+  # Example :
+  #   Types::AAAA or Types.AAAA
+  #   rcode.string or rcode.code
+  class CodeMapper
+    include Comparable
+    
+    @@strings = {}
+    @@stringsdown = {}
+    @@values = {}
+    @@maxcode = {}
+    
+    attr_accessor :string, :code
+    alias to_code code
+    alias to_string string
+    alias to_s string
+    
+    def CodeMapper.maxcode
+      return @maxcode
+    end
+    
+    # Creates the CodeMapper from the defined constants
+    def CodeMapper.update
+      
+      @@strings[self] = {}
+      @@stringsdown[self] = {}
+      @@values[self] = {}
+      @@maxcode[self] = 0
+      
+      constants = self.constants - CodeMapper.constants
+      constants.each do |i|
+        @@strings[self].store(i, const_get(i))
+      end 
+      @@maxcode[self] = constants.length
+      @@values[self] = @@strings[self].invert
+      @@stringsdown[self] = Hash.new
+      @@strings[self].keys.each do |s|
+        @@stringsdown[self].store(s.downcase, @@strings[self][s])    
+      end
+    end
+    
+    # Add new a code to the CodeMapper
+    def CodeMapper.add_pair(string, code)
+      @@strings[self].store(string, code)
+      @@values[self]=@@strings[self].invert
+      @@stringsdown[self].store(string.downcase, code)
+      @@maxcode[self]+=1
+    end
+    
+    def unknown_string(arg) #:nodoc: all
+      raise ArgumentError.new("String #{arg} not a member of #{self.class}")
+    end
+    
+    def unknown_code(arg) #:nodoc: all
+      raise ArgumentError.new("Code #{arg} not a member of #{self.class}")
+    end
+    
+    def self.method_missing(methId) #:nodoc: all
+      str = methId.id2name
+      return self.new(str)
+    end
+    
+    def initialize(arg) #:nodoc: all
+      if (arg.kind_of?String)
+        if (@@stringsdown[self.class][arg.downcase] != nil)
+          set_string(arg)
+        else unknown_string(arg)
+        end
+      elsif (arg.kind_of?Fixnum)
+        if (@@values[self.class][arg] != nil)
+          set_code(arg)
+        else unknown_code(arg)
+        end
+      elsif (arg.kind_of?self.class)
+        set_code(arg.code)
+      else
+        raise ArgumentError.new("Unknown argument #{arg} for #{self.class}")
+      end
+    end
+    
+    def set_code(arg)
+      @code = arg
+      @string = @@values[self.class][@code]
+    end
+    
+    def set_string(arg)
+      @code = @@stringsdown[self.class][arg.downcase]
+      @string = @@strings[self.class].invert[@code]
+    end
+    
+    def inspect
+      return @string
+    end    
+    
+    def CodeMapper.to_string(arg)
+      if (arg.kind_of?String) 
+        return arg
+      else
+        return @@values[self][arg]
+      end
+    end
+    
+    def CodeMapper.to_code(arg)
+      if (arg.kind_of?Fixnum)
+        return arg
+      else
+        return @@stringsdown[self][arg.downcase]
+      end
+    end
+    
+    def <=>(other)
+      if (other.class == Fixnum)
+        self.code <=> other
+      else
+        self.code <=> other.code
+      end
+    end
+    
+    def ==(other)
+      if other.kind_of?CodeMapper
+        if other.string == @string && other.code == @code
+          return true 
+        end
+      elsif other.kind_of?String
+        if other == @string
+          return true
+        end
+      elsif other.kind_of?Fixnum
+        if other == @code
+          return true
+        end
+      end
+      return false
+    end
+    
+    # Return a regular expression which matches any codes or strings from the CodeMapper.
+    def self.regexp
+      # Longest ones go first, so the regex engine will match AAAA before A, etc.
+      return @@strings[self].keys.sort { |a, b| b.length <=> a.length }.join('|')
+    end
+    
+  end
+end

data/lib/Dnsruby/ipv4.rb

@@ -0,0 +1,83 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+module Dnsruby
+#== Dnsruby::IPv4 class
+#=== class methods
+#* Dnsruby::IPv4.create(address)
+#
+#=== methods
+#* Dnsruby::IPv4#to_s
+#* Dnsruby::IPv4#to_name
+#
+#=== constants
+#* Dnsruby::IPv4::Regex
+#    regular expression for IPv4 address.
+#
+  class IPv4
+    Regex = /\A(\d+)\.(\d+)\.(\d+)\.(\d+)\z/
+    
+    def self.create(arg)
+      case arg
+      when IPv4
+        return arg
+      when Regex
+        if (0..255) === (a = $1.to_i) &&
+         (0..255) === (b = $2.to_i) &&
+         (0..255) === (c = $3.to_i) &&
+         (0..255) === (d = $4.to_i)
+          return self.new([a, b, c, d].pack("CCCC"))
+        else
+          raise ArgumentError.new("IPv4 address with invalid value: " + arg)
+        end
+      else
+        raise ArgumentError.new("cannot interpret as IPv4 address: #{arg.inspect}")
+      end
+    end
+    
+    def initialize(address)
+      unless address.kind_of?(String) && address.length == 4
+        raise ArgumentError.new('IPv4 address must be 4 bytes')
+      end
+      @address = address
+    end
+    attr_reader :address
+    
+    def to_s
+      return sprintf("%d.%d.%d.%d", *@address.unpack("CCCC"))
+    end
+    
+    def inspect
+      return "#<#{self.class} #{self.to_s}>"
+    end
+    
+    def to_name
+      return Name.create(
+        '%d.%d.%d.%d.in-addr.arpa.' % @address.unpack('CCCC').reverse)
+    end
+    
+    def ==(other)
+      return @address == other.address
+    end
+    
+    def eql?(other)
+      return self == other
+    end
+    
+    def hash
+      return @address.hash
+    end
+  end
+end