Dnsruby 0.5.0

data/lib/Dnsruby/update.rb

@@ -0,0 +1,263 @@
+#--
+#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::Update is a subclass of Dnsruby::Packet,
+  #to be used for making DNS dynamic updates.  Programmers
+  #should refer to RFC 2136 for the semantics of dynamic updates.
+  
+  #The first example below shows a complete program; subsequent examples
+  #show only the creation of the update packet.
+  #
+  #== Add a new host
+  #
+  # require 'Dnsruby'
+  # 
+  # # Create the update packet.
+  # update = Dnsruby::Update.new('example.com')
+  # 
+  # # Prerequisite is that no A records exist for the name.
+  # update.absent('foo.example.com. A')
+  # 
+  # # Add two A records for the name.
+  # update.add('foo.example.com.', 'A', 86400, '192.168.1.2')
+  # update.add('foo.example.com.', 'A', 86400, '172.16.3.4')
+  # 
+  # # Send the update to the zone's primary master.
+  # res = Dnsruby::Resolver.new({:nameserver => 'primary-master.example.com'})
+  # 
+  # begin
+  #     reply = res.send_message(update)
+  #     print "Update succeeded\n"
+  #  rescue Exception => e
+  #     print 'Update failed: #{e}\n'
+  #  end
+  #
+  #== Add an MX record for a name that already exists
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('example.com')
+  #    update.add('example.com', Dnsruby::Types.MX, 10, 'mailhost.example.com')
+  #
+  #== Add a TXT record for a name that doesn't exist
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.absent('info.example.com')
+  #    update.add('info.example.com', Types.TXT, 86400, "yabba dabba doo"')
+  #
+  #== Delete all A records for a name
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('foo.example.com A')
+  #    update.delete('foo.example.com', 'A')
+  #
+  #== Delete all RRs for a name
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.present('byebye.example.com')
+  #    update.delete('byebye.example.com')
+  #
+  #== Perform a signed update
+  #
+  #    key_name = 'tsig-key'
+  #    key      = 'awwLOtRfpGE+rRKF2+DEiw=='
+  #
+  #    update = Dnsruby::Update.new('example.com')
+  #    update.add('foo.example.com', 'A', 86400, 10.1.2.3'))
+  #    update.add('bar.example.com', 'A', 86400, 10.4.5.6'))
+  #    res.tsig_key=key
+  #
+  class Update < Message
+    #Returns a Dnsruby::Update object suitable for performing a DNS
+    #dynamic update.  Specifically, it creates a message with the header
+    #opcode set to UPDATE and the zone record type to SOA (per RFC 2136,
+    #Section 2.3).
+    #
+    #Programs must use the push method to add RRs to the prerequisite,
+    #update, and additional sections before performing the update.
+    #
+    #Arguments are the zone name and the class.  If the zone is omitted,
+    #the default domain will be taken from the resolver configuration.
+    #If the class is omitted, it defaults to IN.
+    #    packet = Dnsruby::Update.new
+    #    packet = Dnsruby::Update.new('example.com')
+    #    packet = Dnsruby::Update.new('example.com', 'HS')
+    #
+    def initialize(zone=nil, klass=nil)
+      
+      # sort out the zone section (RFC2136, section 2.3)
+      if (zone==nil)
+        config = Config.new
+        zone = (config.search)[0]
+        return unless zone
+      end
+      
+      type  = 'SOA'
+      klass  ||= 'IN'
+      
+      super(zone, type, klass) || return
+      
+      @header.opcode=('UPDATE')
+      @header.rd=(0)
+    end
+    
+    #Ways to create the prerequisite records (exists, notexists, inuse, etc. - RFC2136, section 2.4)
+    #
+    #      (1)  RRset exists (value independent).  At least one RR with a
+    #           specified NAME and TYPE (in the zone and class specified by
+    #           the Zone Section) must exist.
+    #           
+    #           update.present(name, type)
+    #
+    #      (2)  RRset exists (value dependent).  A set of RRs with a
+    #           specified NAME and TYPE exists and has the same members
+    #           with the same RDATAs as the RRset specified here in this
+    #           Section.
+    #           
+    #           update.present(name, type, rdata)
+    #
+    #      (4)  Name is in use.  At least one RR with a specified NAME (in
+    #           the zone and class specified by the Zone Section) must exist.
+    #           Note that this prerequisite is NOT satisfied by empty
+    #           nonterminals.
+    #           
+    #           update.present(name)
+    def present(*args)
+      ttl = 0
+      rdata = []
+      klass = Classes.ANY
+      if (args.length>=1) # domain (RFC2136, Section 2.4.4)
+        # @TODO@ Could also be an actual RR object?
+        name = args[0]
+        type = Types.ANY
+        if (args.length>=2) # RRSET (RFC2136, Section 2.4.1)
+          type = args[1]
+        end
+        if (args.length > 2) # RRSET (RFC2136, Section 2.4.2)
+          klass = zone()[0].zclass
+          rdata=args[2]
+        end
+        rec = RR.create("#{name} #{ttl} #{klass} #{type} #{rdata}")
+        add_pre(rec)
+        return rec
+      else
+        raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1 or 2) for Update#absent")
+      end
+    end
+    
+    #Ways to create the prerequisite records (exists, notexists, inuse, etc. - RFC2136, section 2.4)
+    #Can be called with one arg : 
+    #
+    #   update.absent(name)
+    #      (5)  Name is not in use.  No RR of any type is owned by a
+    #           specified NAME.  Note that this prerequisite IS satisfied by
+    #           empty nonterminals.
+    #
+    #Or with two :
+    #
+    #   update.absent(name, type)
+    #      (3)  RRset does not exist.  No RRs with a specified NAME and TYPE
+    #          (in the zone and class denoted by the Zone Section) can exist.
+    #
+    def absent(*args)
+      ttl = 0
+      rdata = []
+      klass = Classes.NONE
+      if (args.length>=1) # domain (RFC2136, Section 2.4.5)
+        name = args[0]
+        type = Types.ANY
+        if (args.length==2) # RRSET (RFC2136, Section 2.4.3)
+          type = args[1]
+        end
+        rec = RR.create("#{name} #{ttl} #{klass} #{type} #{rdata}")
+        add_pre(rec)
+        return rec
+      else
+        raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1 or 2) for Update#absent")
+      end
+    end
+    
+    #Ways to create the update records (add, delete, RFC2136, section 2.5)
+    #  " 2.5.1 - Add To An RRset
+    #
+    #   RRs are added to the Update Section whose NAME, TYPE, TTL, RDLENGTH
+    #   and RDATA are those being added, and CLASS is the same as the zone
+    #   class.  Any duplicate RRs will be silently ignored by the primary
+    #   master."
+    #   
+    #   update.add(rr)
+    #   update.add([rr1, rr2])
+    #   update.add(name, type, ttl, rdata)
+    #
+    def add(*args)
+      zoneclass=zone()[0].zclass
+      case args[0]
+      when Array
+        args[0].each do |resource|
+          add(resource)
+        end
+      when RR
+        # Make sure that the Class is the same as the zone
+        resource = args[0]
+        if (resource.klass != zoneclass)
+          raise ArgumentError.new("Wrong class #{resource.klass} for update (should be #{zoneclass})!")
+        end
+        add_update(resource)
+        return resource
+      else
+        name=args[0]
+        type=args[1]
+        ttl=args[2]
+        rdata=args[3]
+        resource = RR.create("#{name} #{ttl} #{zoneclass} #{type} #{rdata}")
+        add_update(resource)
+        return resource
+      end
+      # @TODO@ Should be able to take RRSet!
+    end
+    
+    #Ways to create the update records (add, delete, RFC2136, section 2.5)
+    #
+    #2.5.2 - Delete An RRset
+    #   update.delete(name, type)
+    #   
+    #
+    #2.5.3 - Delete All RRsets From A Name
+    #   update.delete(name)
+    #   
+    #2.5.4 - Delete An RR From An RRset
+    #  update.delete(name, type, rdata)
+    #  
+    def delete(*args)
+      ttl = 0
+      klass = Classes.ANY
+      rdata=[]
+      resource = nil
+      case args.length
+      when 1 # name
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{Types.ANY} #{rdata}")
+        add_update(resource)      
+      when 2 # name, type
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{args[1]} #{rdata}")
+        add_update(resource)      
+      when 3 # name, type, rdata
+        klass = Classes.NONE
+        resource = RR.create("#{args[0]} #{ttl} #{klass} #{args[1]} #{args[2]}")
+        add_update(resource)      
+      end
+      return resource
+    end
+  end
+end

data/lib/Dnsruby/zone_transfer.rb

@@ -0,0 +1,296 @@
+module Dnsruby
+  # This class performs zone transfers as per RFC1034 (AXFR) and RFC1995 (IXFR). 
+  class ZoneTransfer
+    # The nameserver to use for the zone transfer - defaults to system config
+    attr_accessor :server
+    # What type of transfer to do (IXFR or AXFR) - defaults to AXFR
+    attr_accessor :transfer_type
+    # The class - defaults to IN
+    attr_accessor :klass
+    # The port to connect to - defaults to 53
+    attr_accessor :port
+    # If using IXFR, this is the SOA serial number to start the incrementals from
+    attr_accessor :serial
+
+    def initialize
+      @server=Config.new.nameserver[0]
+      @transfer_type = Types.AXFR
+      @klass=Classes.IN
+      @port=53
+      @serial=0
+    end
+    
+    # Perform a zone transfer (RFC1995)
+    # If an IXFR query is unsuccessful, then AXFR is tried (and @transfer_type is set
+    # to AXFR)
+    # TCP is used as the only transport
+    # 
+    # If AXFR is performed, then the zone will be returned as a set of records :
+    # 
+    #       zt = Dnsruby::ZoneTransfer.new
+    #       zt.transfer_type = Dnsruby::Types.AXFR
+    #       zt.server = "ns0.validation-test-servers.nominet.org.uk"
+    #       zone = zt.transfer("validation-test-servers.nominet.org.uk")
+    #       soa = zone[0]
+    #       rec1 = zone[1]
+    #       print zone.to_s
+    #
+    #
+    # If IXFR is performed, then the incrementals will be returned as a set of Deltas. 
+    # Each Delta contains the start and end SOA serial number, as well as an array of 
+    # adds and deletes that occurred between the start and end.
+    # 
+    #        zt = Dnsruby::ZoneTransfer.new
+    #        zt.transfer_type = Dnsruby::Types.IXFR
+    #        zt.server = "ns0.validation-test-servers.nominet.org.uk"
+    #        zt.serial = 2007090401
+    #        deltas = zt.transfer("validation-test-servers.nominet.org.uk")
+    #        assert_equal("Should show up in transfer", deltas[0].adds[1].data)
+    def transfer(zone)      
+      servers = @server
+      if (servers.class == String)
+        servers=[servers]
+      end
+      xfr = nil
+      exception = nil
+      servers.each do |server|
+        begin
+          server=Config.resolve_server(server)
+          xfr = do_transfer(zone, server)
+          break
+        rescue Exception => exception
+        end
+      end
+      if (xfr == nil && exception != nil)
+        raise exception
+      end
+      return xfr
+    end
+      
+    def do_transfer(zone, server) #:nodoc: all
+      @transfer_type = Types.new(@transfer_type)
+      @state = :InitialSoa
+      socket = TCPSocket.new(server, @port)
+      begin
+        # Send an initial query
+        msg = Message.new(zone, @transfer_type, @klass)
+        if @transfer_type == Types.IXFR
+          rr = RR.create("#{zone} 0 IN SOA" + '. . %u 0 0 0 0' % @serial)
+          msg.add_authority(rr)
+        end
+        # @TODO@ TSIG?
+        send_message(socket, msg)
+        
+        while (@state != :End)
+          response = receive_message(socket)
+          
+          if (@state == :InitialSoa)
+            rcode = response.header.rcode
+            if (rcode != RCode.NOERROR)
+              if (@transfer_type == Types.IXFR &&
+                    rcode == RCode.NOTIMP)
+                # IXFR didn't work - let's try AXFR
+                TheLog.debug("IXFR DID NOT WORK (rcode = NOTIMP) - TRYING AXFR!!")
+                @state = :InitialSoa
+                @transfer_type=Types.AXFR
+                # Send an initial AXFR query
+                msg = Message.new(zone, @transfer_type, @klass)
+                # @TODO@ TSIG?
+                send_message(socket, msg)
+                next
+              end
+              raise ResolvError.new(rcode.string);
+            end
+            
+            if (response.question[0].qtype != @transfer_type) 
+              raise ResolvError.new("invalid question section")
+            end
+            
+            if (response.header.ancount == 0 && @transfer_type == Types.IXFR) 
+              TheLog.debug("IXFR DID NOT WORK (ancount = 0) - TRYING AXFR!!")
+              # IXFR didn't work - let's try AXFR
+              @transfer_type=Types.AXFR
+              # Send an initial AXFR query
+              @state = :InitialSoa
+              msg = Message.new(zone, @transfer_type, @klass)
+              # @TODO@ TSIG?
+              send_message(socket, msg)
+              next
+            end
+          end
+          
+          response.each_answer { |rr|
+            parseRR(rr)
+          }
+          #        if (state == END &&
+          #            response.tsigState == Message.TSIG_INTERMEDIATE)
+          #          raise ResolvError.new("last message must be signed")
+          #        end
+        end
+        # This could return with an IXFR response, or an AXFR response.
+        # If it fails completely, then try to send an AXFR query.
+        # Once the query has been sent, then enter the main response loop.
+        # Unless we know we're definitely AXFR, we should be prepared for either IXFR or AXFR
+        # AXFR response : The first and the last RR of the response is the SOA record of the zone.
+        #                 The whole zone is returned inbetween.
+        # IXFR response : one or more difference sequences is returned.  The list of difference 
+        #                 sequences is preceded and followed by a copy of the server's current 
+        #                 version of the SOA.
+        #                 Each difference sequence represents one update to the zone (one SOA
+        #                 serial change) consisting of deleted RRs and added RRs.  The first RR
+        #                 of the deleted RRs is the older SOA RR and the first RR of the added
+        #                 RRs is the newer SOA RR.
+        socket.close
+        if (@axfr!=nil)
+          return @axfr
+        end
+        return @ixfr
+      rescue Exception => e
+        socket.close
+        raise e
+      end
+    end
+    
+    # All changes between two versions of a zone in an IXFR response.
+    class Delta
+      
+      # The starting serial number of this delta.
+      attr_accessor :start
+      
+      # The ending serial number of this delta.
+      attr_accessor :end
+      
+      # A list of records added between the start and end versions
+      attr_accessor :adds
+      
+      # A list of records deleted between the start and end versions
+      attr_accessor :deletes
+      
+      def initialize()
+        @adds = []
+        @deletes = []
+      end
+    end
+    
+    def parseRR(rec) #:nodoc: all
+      name = rec.name
+      type = rec.type
+      delta = Delta.new
+      
+      case @state
+      when :InitialSoa
+        if (type != Types.SOA)
+          raise ResolvError.new("missing initial SOA")
+        end
+        @initialsoa = rec
+        # Remember the serial number in the initial SOA; we need it
+        # to recognize the end of an IXFR.
+        @end_serial = rec.serial
+        if (@transfer_type == Types.IXFR && @end_serial <= @serial)
+          TheLog.debug("zone up to date")
+          @state = :End
+        else
+          @state = :FirstData
+        end
+      when :FirstData
+        # If the transfer begins with 1 SOA, it's an AXFR.
+        # If it begins with 2 SOAs, it's an IXFR.
+        if (@transfer_type == Types.IXFR && type == Types.SOA &&
+              rec.serial == @serial)
+          TheLog.debug("IXFR response - using IXFR")
+          @rtype = Types.IXFR
+          @ixfr = []
+          @state = :Ixfr_DelSoa
+        else
+          TheLog.debug("AXFR response - using AXFR")
+          @rtype = Types.AXFR
+          @axfr = []
+          @axfr << @initialsoa
+          @state = :Axfr
+        end
+        parseRR(rec) # Restart...
+        return
+        
+      when :Ixfr_DelSoa
+        delta = Delta.new
+        @ixfr.push(delta);
+        delta.start = rec.serial
+        delta.deletes << rec
+        @state = :Ixfr_Del
+        
+      when :Ixfr_Del
+        if (type == Types.SOA)
+          @current_serial = rec.serial
+          @state = :Ixfr_AddSoa;
+          parseRR(rec); # Restart...
+          return;
+        end
+        delta = @ixfr.get(@ixfr.length - 1);
+        delta.deletes << rec
+        
+      when :Ixfr_AddSoa
+        delta = @ixfr[@ixfr.length - 1]
+        delta.end = rec.serial
+        delta.adds << rec
+        @state = :Ixfr_Add
+        
+      when :Ixfr_Add
+        if (type == Types.SOA)
+          soa_serial = rec.serial
+          if (soa_serial == @end_serial)
+            @state = :End
+            return
+          elsif (soa_serial != @current_serial)
+            raise ResolvError.new("IXFR out of sync: expected serial " +
+                @current_serial + " , got " + soa_serial);
+          else
+            @state = :Ixfr_DelSoa
+            parseRR(rec); # Restart...
+            return;
+          end
+        end
+        delta = @ixfr[@ixfr.length - 1]
+        delta.adds << rec
+        
+      when :Axfr
+        # Old BINDs sent cross class A records for non IN classes.
+        if (type == Types.A && rec.klass() != @klass)
+        else
+          @axfr << rec
+          if (type == Types.SOA)
+            @state = :End
+          end
+        end
+      when :End
+        raise ResolvError.new("extra data in zone transfer")
+        
+      else
+        raise ResolvError.new("invalid state for zone transfer")
+      end
+    end
+    
+    def send_message(socket, msg) #:nodoc: all
+      query_packet = msg.encode
+      lenmsg = [query_packet.length].pack('n')
+      socket.send(lenmsg, 0)
+      socket.send(query_packet, 0)        
+    end  
+    
+    def tcp_read(socket, len) #:nodoc: all
+      buf=""
+      while (buf.length < len) do
+        buf += socket.recv(len-buf.length)
+      end
+      return buf
+    end
+    
+    def receive_message(socket) #:nodoc: all
+      buf = tcp_read(socket, 2)
+      answersize = buf.unpack('n')[0]
+      buf = tcp_read(socket, answersize)
+      msg = Message.decode(buf)
+      
+      return msg
+    end  
+  end
+end