tftpplus 0.2 → 0.3

data/ChangeLog

@@ -1,47 +1,163 @@
-2006-12-08 msoulier
-	* Fixed handling of remote TID.
-	* Added tar task to Rakefile.
+2007-03-15 00:00  msoulier
 
-2006-10-10 msoulier
-	* Added site, and Rakefile entry to push site.
+	* ChangeLog: Updated ChangeLog
+
+2007-03-14 01:32  msoulier
+
+	* lib/net/tftp+.rb, test/test.rb: Added testcases.
+
+2007-03-13 16:27  msoulier
+
+	* test/test.rb: Updated some testcases.
+
+2007-03-10 23:42  msoulier
+
+	* bin/tftp_server.rb, lib/net/tftp+.rb: First working downloads
+	  from server. Woohoo!
+
+2007-03-09 05:04  msoulier
+
+	* lib/net/tftp+.rb: Fixed lots of silly little runtime errors in
+	  testing.
+	  Still not transferring properly, but we're much closer.
+
+2007-03-07 03:22  msoulier
+
+	* lib/net/tftp+.rb: Filled-out the timeout implementation. Server
+	  still fails to start a download
+	  at this point.
+
+2007-03-06 10:16  msoulier
+
+	* lib/net/tftp+.rb: Added check of file path in download request.
+
+2006-12-22 23:43  msoulier
+
+	* lib/net/tftp+.rb: Redefined TftpErrorType
+
+2006-12-22 04:41  msoulier
+
+	* bin/tftp_server.rb, lib/net/tftp+.rb: Starting sample server
+	  implementation.
+
+2006-12-22 04:27  msoulier
+
+	* bin/tftp_client.rb, lib/net/tftp+.rb: First pass at adding server
+	  implementation.
+
+2006-12-21 05:39  msoulier
+
+	* Rakefile, lib/net/tftp+.rb: Added a little more server. Cleaned
+	  up client.
+
+2006-12-19 04:35  msoulier
+
+	* lib/net/tftp+.rb: Fleshing out some of the server and handler
+	  code.
+
+2006-12-19 01:07  msoulier
+
+	* bin/tftp_client.rb, lib/net/tftp+.rb: Cleaned up the client a
+	  bit.
+
+2006-12-09 03:38  msoulier
+
+	* ChangeLog: Updated ChangeLog
+
+2006-12-09 03:34  msoulier
+
+	* Rakefile, doc, doc/rfc1350.txt, doc/rfc2347.txt, doc/rfc2348.txt:
+	  Added tar task to rakefile
+
+2006-12-09 03:23  msoulier
+
+	* ChangeLog, README: Updated ChangeLog and README
+
+2006-12-09 03:18  msoulier
+
+	* Rakefile: Updated version
+
+2006-12-09 03:17  msoulier
+
+	* lib/net/tftp+.rb: Fixing remote TID RFC compliance.
+
+2006-12-08 23:41  msoulier
+
+	* lib/net/tftp+.rb: Updated log messages
+
+2006-10-17 02:33  msoulier
+
+	* lib/net/tftp+.rb: Fix calls to tftpassert.
+
+2006-10-16 00:48  msoulier
+
+	* lib/net/tftp+.rb: Added some rdoc
+
+2006-10-15 23:58  msoulier
+
+	* bin/tftp_client.rb, lib/net/tftp+.rb: Moved the logger to the
+	  client, and put in a nil logger in the library.
+
+2006-10-15 20:53  msoulier
+
+	* lib/net/tftp+.rb, test/test.rb: Added a stdlib logger
+
+2006-10-10 02:52  msoulier
+
+	* ChangeLog, Rakefile, site, site/index.html: Added site directory
+	  with Rakefile entry to push it public
+
+2006-10-10 02:10  msoulier
+
+	* Rakefile: Refactored Rakefile
+
+2006-10-10 02:08  msoulier
+
+	* ChangeLog, README, Rakefile: Added Rakefile for project
+	  management.
 
 2006-10-10 01:46  msoulier
 
-	* trunk/ChangeLog, trunk/README, trunk/doc,
-	  trunk/lib/net/tftp+.rb: Adding Rakefile
+	* ChangeLog, README, doc, lib/net/tftp+.rb: Adding Rakefile
 
 2006-10-06 01:35  msoulier
 
-	* trunk/lib/net/tftp+.rb: Optimizing Tftp object dispatch
+	* lib/net/tftp+.rb: Optimizing Tftp object dispatch
 
 2006-10-04 01:27  msoulier
 
-	* trunk/lib/net/tftp+.rb: minor method rename
+	* lib/net/tftp+.rb: minor method rename
 
 2006-09-25 02:11  msoulier
 
-	* trunk/lib/net/tftp+.rb: Added timeouts on recvfrom
+	* lib/net/tftp+.rb: Added timeouts on recvfrom
 
 2006-09-24 02:39  msoulier
 
-	* trunk/lib/net/tftp+.rb: Updated debugging output
+	* lib/net/tftp+.rb: Updated debugging output
+
+2006-09-24 02:34  msoulier
+
+	* bin/tftp_client.rb: Making client executable
+
+2006-09-24 02:32  msoulier
+
+	* bin, share: Renaming share to bin
 
 2006-09-24 02:31  msoulier
 
-	* trunk/lib/net/tftp+.rb, trunk/share, trunk/share/tftp_client.rb,
-	  trunk/test/test.rb: Moved client code into its own sample client.
+	* lib/net/tftp+.rb, share, share/tftp_client.rb, test/test.rb:
+	  Moved client code into its own sample client.
 
 2006-09-22 16:48  msoulier
 
-	* trunk/lib/net/tftp+.rb: Pulling hardcoded test
+	* lib/net/tftp+.rb: Pulling hardcoded test
 
 2006-09-22 16:44  msoulier
 
-	* doc, lib, test, trunk/doc, trunk/lib, trunk/test: Setting up
-	  branch structure.
+	* doc, lib, test, doc, lib, test: Setting up branch structure.
 
-2006-09-22 16:42  msoulier
+2006-09-22 16:44  msoulier
 
-	* doc, doc/rfc1350.txt, doc/rfc2347.txt, doc/rfc2348.txt, lib,
-	  lib/net, lib/net/tftp+.rb, test, test/test.rb: Initial import.
+	* branches, tags, .: Setting up branch structure.
 

data/README

@@ -7,13 +7,17 @@ A new tftp library for clients and servers that supports RFCs 1350, 2347 and
 Release Notes:
 ==============
 
+About version 0.3:
+------------------
+- First working server class.
+
 About version 0.2:
-==================
+------------------
 
 - Fixed handling of remote TID.
 
 About version 0.1:
-==================
+------------------
 
 - Added timeouts on recvfrom
 - Updated debugging output

data/bin/tftp_client.rb

@@ -47,9 +47,9 @@ EOF
                 $log.level = Logger::DEBUG
                 $log.debug('client') { "Debug output requested" }
             end
-            opts.on('-b', '--blksize=', 'Blocksize option: 8-65536 bytes') do |b|
+            opts.on('-b', '--blocksize=', 'Blocksize option: 8-65536 bytes') do |b|
                 options.blksize = b.to_i
-                $log.debug('client') { "blksize is #{b}" }
+                $log.debug('client') { "blocksize is #{b}" }
             end
             opts.on_tail('-h', '--help', 'Show this message') do
                 puts opts
@@ -67,7 +67,7 @@ EOF
         #end
         unless options.blksize >= 8 and options.blksize <= 65536
             raise OptionParser::InvalidOption,
-                "blksize can only be between 8 and 65536 bytes"
+                "blocksize can only be between 8 and 65536 bytes"
         end
         unless options.port > 0 and options.port < 65537
             raise OptionParser::InvalidOption,
@@ -75,7 +75,6 @@ EOF
         end
     rescue Exception => details
         $stderr.puts details.to_s
-        $stderr.puts opts
         exit 1
     end
 
@@ -88,13 +87,25 @@ def main
     size = 0
     start = Time.now
     $log.info('client') { "Starting download of #{options.filename} from #{options.host}" }
-    $log.info('client') { "Options: blksize = #{options.blksize}" }
+    $log.info('client') { "Options: blocksize = #{options.blksize}" }
 
-    client = TftpClient.new(options.host, options.port)
+    begin
+        client = TftpClient.new(options.host, options.port)
+    rescue SocketError => details
+        $stderr.puts "Error looking up host #{options.host}"
+        exit 1
+    end
+    
     tftp_opts = { :blksize => options.blksize.to_i }
-    client.download(options.filename, options.filename, tftp_opts) do |pkt|
-        size += pkt.data.length
-        $log.debug('client') { "Downloaded #{size} bytes" }
+    
+    begin
+        client.download(options.filename, options.filename, tftp_opts) do |pkt|
+            size += pkt.data.length
+            $log.debug('client') { "Downloaded #{size} bytes" }
+        end
+    rescue TftpError => details
+        $stderr.puts "Fatal exception in transfer"
+        $stderr.puts details
     end
 
     finish = Time.now

data/lib/net/tftp+.rb

@@ -20,9 +20,13 @@ MinBlkSize      = 8
 DefBlkSize      = 512
 MaxBlkSize      = 65536
 SockTimeout     = 5
+SendTimeout     = 5
 MaxDups         = 20
 Assertions      = true
 MaxRetry        = 5
+MaxBlockNum     = 65535
+DefRoot         = '/tftpboot'
+MaxBindAttempts = 5
 
 # This class is a Nil logging device. It catches all of the logger calls and
 # does nothing with them. It is up to the client to provide a real logger
@@ -38,9 +42,53 @@ end
 # one.
 $tftplog = TftpNilLogger.new
 
+# Convenience function for debug logging.
+def debug(msg)
+    $tftplog.debug('tftp+') { msg }
+end
+
+# Convenience function for info logging.
+def info(msg)
+    $tftplog.info('tftp+') { msg }
+end
+
+# Convenience function for warn logging.
+def warn(msg)
+    $tftplog.warn('tftp+') { msg }
+end
+
+# Convenience function for error logging.
+def error(msg)
+    $tftplog.error('tftp+') { msg }
+end
+
+# This class is a convenience for defining the common tftp error codes, and
+# making them more readable in the code.
+class TftpErrorType
+    @notDefined  = 0
+    @fileNotFound = 1
+    @accessViolation = 2
+    @diskFull = 3
+    @illegalTftpOp = 4
+    @unknownTID = 5
+    @fileAlreadyExists = 6
+    @noSuchUser = 7
+    @failedNegotiation = 8
+    class <<self
+        attr_reader :notDefined, :fileNotFound, :accessViolation
+        attr_reader :diskFull, :illegalTftpOp, :unknownTID
+        attr_reader :fileAlreadyExists, :noSuchUser, :failedNegotiation
+    end
+end
+
+# This exception is used to signal errors.
 class TftpError < RuntimeError
 end
 
+# This exception is used to signal success to the server instance.
+class TftpSuccess < Exception
+end
+
 # This function is a custom assertion in the library to catch unsupported
 # states and types. If the assertion fails, msg is raised in a TftpError
 # exception.
@@ -80,8 +128,8 @@ class TftpPacket
     def options=(opts)
         myopts = {}
         opts.each do |key, val|
-            $tftplog.debug('tftp+') { "looping on key #{key}, val #{val}" }
-            $tftplog.debug('tftp+') { "class of key is #{key.class}" }
+            debug "looping on key #{key}, val #{val}"
+            debug "class of key is #{key.class}"
             tftpassert("options keys must be symbols") { key.class == Symbol }
             myopts[key.to_s] = val.to_s
         end
@@ -93,7 +141,7 @@ class TftpPacket
         return @options
     end
 
-    protected
+    private
 
     # This method takes the portion of the buffer containing the options and
     # decodes it, returning a hash of the option name/value pairs, with the
@@ -120,7 +168,7 @@ class TftpPacket
             name  = struct.shift
             value = struct.shift
             options[name.to_sym] = value
-            $tftplog.debug('tftp+') { "decoded option #{name} with value #{value}" }
+            debug "decoded option #{name} with value #{value}"
         end
         return options
     end
@@ -194,7 +242,7 @@ class TftpPacketInitial < TftpPacket
             raise TftpError, "filename is the null string"
         end
         @mode = struct[2]
-        unless valid_mode? @mode
+        unless TftpPacketInitial.valid_mode? @mode
             raise TftpError, "mode #{@mode} is not valid"
         end
 
@@ -219,11 +267,12 @@ class TftpPacketInitial < TftpPacket
         return self
     end
 
-    protected
+    private
 
     # This method is a boolean validator that returns true if the blocksize
     # passed is valid, and false otherwise.
-    def valid_blocksize?(blksize)
+    # FIXME - is anyone calling this?
+    def self.valid_blocksize?(blksize)
         blksize = blksize.to_i
         if blksize >= 8 and blksize <= 65464
             return true
@@ -235,9 +284,11 @@ class TftpPacketInitial < TftpPacket
     # This method is a boolean validator that returns true of the mode passed
     # is valid, and false otherwise. The modes of 'netascii', 'octet' and
     # 'mail' are valid, even though only 'octet' is currently implemented.
-    def valid_mode?(mode)
+    def self.valid_mode?(mode)
         case mode
-        when "netascii", "octet", "mail"
+        # FIXME - implement support for netascii. don't care about mail
+        #when "netascii", "octet", "mail"
+        when "octet"
             return true
         else
             return false
@@ -277,6 +328,9 @@ class TftpPacketDAT < TftpPacket
     end
 
     def encode
+        debug "DAT encode: @opcode is #{@opcode}"
+        debug "DAT encode: @blocknumber is #{@blocknumber}"
+        debug "DAT encode: @data has #{@data.length} bytes in it"
         unless @opcode and @blocknumber and @data
             raise ArgumentError, "Required fields missing!"
         end
@@ -354,6 +408,8 @@ end
 #      7         No such user.
 #      8         Failed negotiation
 class TftpPacketERR < TftpPacket
+    # FIXME - Reevaluate the ErrMsg, and whether we encourage senderror to
+    # expect one.
     attr_reader :extended_errmsg
     attr_accessor :errorcode, :errmsg, :buffer
     ErrMsgs = [
@@ -453,14 +509,18 @@ class TftpPacketFactory
     end
 
     def parse(buffer)
-        unless buffer
+        unless buffer and buffer.class == String
             raise ArgumentError, "buffer cannot be empty"
         end
-        opcode = buffer[0..1].unpack('n')[0]
-        packet = create(opcode)
-        packet.buffer = buffer
-        packet.decode
-        return packet
+        begin
+            opcode = buffer[0..1].unpack('n')[0]
+            packet = create(opcode)
+            packet.buffer = buffer
+            packet.decode
+            return packet
+        rescue 
+            raise TftpError, "Parsing errors, packet looks bad."
+        end
     end
 end
 
@@ -471,6 +531,7 @@ class TftpSession
     def initialize
         # Agreed upon session options
         @options = {}
+        # FIXME - should we make the state an object of its own?
         # State of the session, can be one of
         # nil   - No state yet
         # :rrq  - Just sent rrq, waiting for response
@@ -483,79 +544,472 @@ class TftpSession
         @state = nil
         @dups = 0
         @errors = 0
-        @blksize = DefBlkSize
+        @options = { :blksize => DefBlkSize }
+    end
+
+    # This method is used to send an error packet to a given address and port,
+    # with an given error code.
+    def senderror(sock, errorcode, address, port)
+        @errors += 1
+        err = TftpPacketERR.new
+        err.errorcode = errorcode
+        sock.send(err.encode.buffer, 0, address, port)
     end
 end
 
+# This server instance currently listens on a single specified port to
+# initiate a session. From there it waits in a select() loop on all sockets
+# for itself and all handlers, dispatching ready sockets to their handlers and
+# instantiating new handlers as needed.
 class TftpServer < TftpSession
-    def initialize
+    def initialize(root)
         super()
+        @root = root
         @iface = nil
         @port = nil
-        @root = nil
-        @sessions = []
+        @handlers = {}
     end
 
     # This method starts a server listening on a given port, to serve up files
     # at a given path. It takes an optional ip to bind to, which defaults to
-    # localhost (127.0.0.1).
-    def listen(port, path, iface="127.0.0.1")
+    # INADDR_ANY.
+    def listen(port, path, iface="")
         @iface = iface
         @port = port
         @root = path
-        sock = UDPSocket.new
-        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-        #sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, SockTimeout)
-        sock.bind(iface, port)
-        $tftplog.info('tftp+') { "Bound to #{iface} on port #{port}" }
+        main_sock = UDPSocket.new
+        main_sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        main_sock.bind(iface, port)
+        info "Bound to #{@iface} on port #{@port}"
 
         factory = TftpPacketFactory.new
         retry_count = 0
         loop do
-            $tftplog.debug('tftp+') { "Waiting for incoming datagram..." }
-            msg = sender = nil
-            begin
-                status = Timeout::timeout(SockTimeout) {
-                    msg, sender = sock.recvfrom(MaxBlkSize)
-                }
-            rescue Timeout::Error => details
-                retry_count += 1
-                if retry_count > MaxRetry
-                    msg = "Timeout! Max retries exceeded. Giving up."
-                    $tftplog.error('tftp+') { msg }
-                    raise TftpError, msg
+            allsockets = []
+            allsockets << main_sock
+            @handlers.each do |key, val|
+                allsockets << val.sock
+            end
+            debug "Performing select on all sockets"
+            debug "allsockets array is #{allsockets}"
+            selectarr = select(allsockets, nil, nil, SockTimeout)
+            readysocks = selectarr ? selectarr[0] : []
+
+            deletion_list = []
+
+            # FIXME - this loop is really large...
+            readysocks.each do |readysock|
+                if readysock.equal?(main_sock)
+                    debug "Traffic on the main socket"
+                    msg, sender = readysock.recvfrom(MaxBlkSize)
+                    prot, rport, rhost, rip = sender
+
+                    pkt = factory.parse(msg)
+                    debug "pkt is a #{pkt}"
+
+                    if pkt.is_a? TftpPacketRRQ
+                        debug "Handling packet as an RRQ"
+
+                        key = "#{rip}:#{rport}"
+                        handler = nil
+                        unless @handlers.has_key?(key)
+                            handler = TftpServerHandler.new(rhost,
+                                                            rport,
+                                                            key,
+                                                            @root,
+                                                            @iface,
+                                                            factory,
+                                                            :rrq)
+                            @handlers[key] = handler
+                            begin
+                                handler.handle(pkt)
+                            rescue TftpError => details
+                                error "Fatal exception thrown from handler at creation #{key}: #{details}"
+                                deletion_list.push(key)
+                            end
+                            # Note: A TftpSuccess exception isn't possible
+                            # here.
+                        else
+                            senderror(main_sock,
+                                      TftpErrorType.unknownTID,
+                                      rhost,
+                                      rport)
+                            error "Received RRQ for session #{key}, which already exists"
+                            @errors += 1
+                            next
+                        end
+                    elsif pkt.is_a? TftpPacketWRQ
+                        debug "Handling packet as a WRQ"
+
+                        senderror(main_sock,
+                                  TftpErrorType.illegalTftpOp,
+                                  rhost,
+                                  rport)
+                        warn "Support for uploads not yet implemented."
+                        next
+                    else
+                        debug "Handling packet as a non-RRQ/WRQ"
+                        # FIXME - this will prevent symmetric udp from working
+                        # if I ever care to implement it.
+                        senderror(main_sock,
+                                  TftpErrorType.illegalTftpOp,
+                                  rhost,
+                                  rport)
+                        error "Only RRQ and WRQ operations are valid on the main socket."
+                        @errors += 1
+                        next
+                    end
                 else
-                    $tftplog.warn('tftp+') { "Timeout! Lets try again." }
-                    next
+
+                    debug "Not the main socket. Hunting for the right socket to match socket #{readysock}"
+                    found = false
+                    @handlers.each do |key, handler|
+                        if readysock.equal?(handler.sock)
+                            debug "Found it. Handler is #{handler.key}"
+                            found = true
+                            begin
+                                handler.handle
+                            rescue TftpSuccess => details
+                                info "Successful transfer for handler #{key}: #{details}"
+                                deletion_list.push(key)
+                            rescue Exception => details
+                                error "Fatal exception thrown from handler #{key}: #{details}"
+                                deletion_list.push(key)
+                            ensure
+                                debug "Breaking out of handler iteration"
+                                break
+                            end
+                        end
+                    end
+
+                    debug "About to process deletion list"
+                    deletion_list.each do |key|
+                        debug "Deleting handler #{key}"
+                        @handlers.delete(key)
+                    end
+                
+                    unless found
+                        # FIXME - should I do more here?
+                        error "Hey, I didn't find the handler for this packet!"
+                        @errors += 1
+                    end
                 end
             end
-            prot, rport, rhost, rip = sender
-
-            pkt = factory.parse(msg)
-            $tftplog.debug('tftp+') { "pkt is #{pkt}" }
 
-            key = "#{rip}-#{rport}"
-            handler = nil
-            unless @sessions.has_key? key
-                handler = TftpServerHandler.new(rhost, rport, key, root)
-            else
-                handler = @sessions[key]
+            # Loop on each handler and see if they've timed-out.
+            now = Time.now
+            @handlers.each do |key, handler|
+                if now - handler.timesent > SendTimeout
+                    info "Handler #{key} has timed-out"
+                    handler.timeout()
+                end
             end
-            handler.handle(pkt)
         end
     end
 end
 
+# The server handler class is responsible for handling a single tftp session.
+# One of these will be instantiated per client.
 class TftpServerHandler < TftpSession
-    def initialize(rhost, rport, key, root)
+    attr_reader :timesent, :sock, :key
+
+    def initialize(rhost, rport, key, root, listen_ip, factory, state)
+        debug "Instantiating a new handler:"
+        debug "   rhost     = #{rhost}"
+        debug "   rport     = #{rport}"
+        debug "   key       = #{key}"
+        debug "   root      = #{root}"
+        debug "   listen_ip = #{listen_ip}"
+        debug "   state     = #{state}"
         super()
         @host = rhost
         @port = rport
         @key = key
         @root = root
+        @listen_ip = listen_ip
+        @factory = factory
+        @state = state
+        @filename = nil
+        @file = nil
+        @mode = nil
+        @blocknumber = 0
+        @buffer = ""
+        @timesent = 0
+
+        @sock = get_socket()
+    end
+
+    # This method returns a UDP socket bound to a random, hopefully unused
+    # port.
+    def get_socket
+        sock = UDPSocket.new
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+
+        count = 0
+        bound = false
+        begin
+            port = rand(2 ** 16 - 1024) + 1024
+            debug "Attempting to bind to #{@listen_ip}:#{port}"
+            sock.bind(@listen_ip, port)
+            bound = true
+        rescue 
+            warn "Failed to bind to #{@listen_ip}:#{port}"
+            if count < MaxBindAttempts
+                count += 1
+                redo
+            end
+        end
+
+        if bound
+            info "Handler #{@key} bound to #{@listen_ip} on port #{port}"
+        else
+            raise TftpError, "Can't seem to find a spare port to bind to."
+        end
+
+        return sock
+    end
+
+    # This method "informs" the handler that it has data waiting on its socket
+    # that it must read. Optionally, an already read packet can be passed to
+    # this method, in which case the handler will assume that the source of
+    # the packet has already been validated.
+    #
+    # To shut down a handler, the handler raises an exception to the server
+    # instance. TftpError is used to signal errors, while TftpSuccess is used
+    # to signal success.
+    # FIXME - this method is too big
+    def handle(*pkt)
+        recvpkt = nil
+        if pkt.length > 0
+            # handle passed data - we're trusting the Server to validate the
+            # client here.
+            recvpkt = pkt.shift
+        else
+            # need to read from our socket - UDP should ensure full reads
+            msg, sender = @sock.recvfrom(MaxBlkSize)
+            prot, rport, rhost, rip = sender
+            if rport != @port or rhost != @host
+                senderror(@sock,
+                          TftpErrorType.unknownTID,
+                          rhost,
+                          rport)
+                error "Handler #{@key} received traffic from #{rhost}:#{rport} " +
+                      "but we're talking to client #{@host}:#{@port}"
+                return
+            end
+
+            recvpkt = @factory.parse(msg)
+        end
+
+        # Process the packet based on its type and our state.
+        if recvpkt.is_a? TftpPacketRRQ
+            info "Received an RRQ from #{@host}:#{@port}"
+            # If we're starting a download, we should be in state rrq.
+            if @state == :rrq
+                # Store the filename and mode.
+                @filename = recvpkt.filename
+                info "Requested filename is #{@filename}"
+
+                @mode = recvpkt.mode
+                info "Requested mode is #{@mode}"
+
+                # FIXME - We only support octet mode for now.
+                if @mode != 'octet'
+                    senderror(@sock,
+                              TftpErrorType.illegalTftpOp,
+                              @host,
+                              @port)
+                    @errors += 1
+                    raise TftpError, "Unsupported mode: #{@mode}"
+                end
+
+                # If there are options, negotiate.
+                if recvpkt.options.length > 0
+                    debug "There are options in the RRQ: #{recvpkt.options}"
+                    # The only option we support is blksize.
+                    if recvpkt.options.key?(:blksize)
+                        # Note, we only consider ourselves in oack state if
+                        # there were supported options.
+                        debug "Client requested blksize #{@options[:blksize]}"
+                        if TftpPacketRRQ.valid_blocksize?(recvpkt.options[:blksize])
+                            @state = :oack
+                            @options[:blksize] = recvpkt.options[:blksize]
+                        else
+                            error "Invalid blocksize #{recvpkt.options[:blksize]}"
+                            @errors += 1
+                            senderror(@sock,
+                                      TftpErrorType.illegalTftpOp,
+                                      @host,
+                                      @port)
+                        end
+                    end
+                end
+
+                # Do we need to send an oack? If we're in oack state, and
+                # we've set any supported options, then yes, we do.
+                if @state == :oack
+                    oack = TftpPacketOACK.new
+                    oack.options = @options
+                    @sock.send(oack.encode.buffer, 0, @host, @port)
+                    @timesent = Time.now
+                else
+                    start_download()
+                end
+
+            else
+                senderror(@sock,
+                          TftpErrorType.illegalTftpOp,
+                          @host,
+                          @port)
+                error "Received an rrq from #{@host}:#{@port}, but we're in state #{@state}"
+                @errors += 1
+                return
+            end
+
+        elsif recvpkt.is_a? TftpPacketWRQ
+            # FIXME - check state here
+            senderror(@sock, TftpErrorType.illegalTftpOp, @host, @port)
+            @errors += 1
+            raise TftpError, "WRQ not yet supported"
+
+        elsif recvpkt.is_a? TftpPacketACK
+            # If we're in state oack and the blocknumber is 0, it's an ACK to
+            # the OACK. Otherwise, it's an ACK to a DAT packet...hopefully.
+            if @state == :oack and recvpkt.blocknumber == 0
+                info "OACK acknowledged by client. Starting download."
+                start_download()
+            elsif @state == :dat or @state == :fin
+                debug "Received ACK to block #{recvpkt.blocknumber}"
+                if recvpkt.blocknumber == @blocknumber
+                    if @state == :fin
+                        raise TftpSuccess, "Successful transfer."
+                    else
+                        debug "Received valid ACK. Sending next DAT."
+                        send_dat()
+                    end
+                elsif recvpkt.blocknumber < @blocknumber
+                    warn "Received duplicate ACK for block #{recvpkt.blocknumber}"
+                    @dups += 1
+                    return
+                else
+                    error "Received ACK from the future, block #{recvpkt.blocknumber}"
+                    @errors += 1
+                    return
+                end
+            else
+                senderror(@sock,
+                          TftpErrorType.illegalTftpOp,
+                          @host,
+                          @port)
+                @errors += 1
+                raise TftpError, "Received invalid ACK from client"
+            end
+
+        elsif recvpkt.is_a? TftpPacketERR
+            @errors += 1
+            raise TftpError, "Received error packet from client: #{recvpkt}"
+        else
+            # Unsupported packet type
+            senderror(@sock,
+                      TftpErrorType.illegalTftpOp,
+                      @host,
+                      @port)
+            @errors += 1
+            raise TftpError, "Unsupported packet type in server: #{recvpkt}"
+        end
+    end
+
+    # This method validates the current filename requested, and initiates the
+    # download if everything is ok.
+    def start_download
+        @state = :dat
+        # Only check if there are any slashes in the filename.
+        if @filename =~ %r{^/}
+            senderror(main_sock,
+                      TftpErrorType.illegalTftpOp,
+                      rhost,
+                      rport)
+            raise TftpError, "Absolute paths in filenames not permitted"
+        elsif @filename =~ %r{../}
+            senderror(main_sock,
+                      TftpErrorType.illegalTftpOp,
+                      rhost,
+                      rport)
+            raise TftpError, ".. not permitted in filenames"
+        elsif @filename =~ %r{/}
+            # Make sure it's in our root.
+            @filename = File.expand_path(@filename)
+            unless @filename =~ /^@root/
+                # It's not in our root. Send an error.
+                senderror(main_sock,
+                          TftpErrorType.illegalTftpOp,
+                          rhost,
+                          rport)
+                raise TftpError, "File request for #{@filename} outside of root"
+            end
+        end
+
+        # If it's ok, open the file and send the first DAT.
+        path = @root + '/' + @filename
+        if File.exists?(path)
+            debug "Opening file #{path} for reading"
+            @file = File.new(path, "r")
+            debug "File open: #{@file.inspect}"
+            send_dat()
+        else
+            senderror(sock,
+                        TftpErrorType.fileNotFound,
+                        @host,
+                        @port)
+            raise TftpError, "File does not exist"
+        end
     end
 
-    def handle(pkt)
+    # This method sends a single DAT packet, the next one in the series.
+    # It takes an optional :resend parameter, in which case it resends the
+    # last DAT instead of sending the next one.
+    def send_dat(*args)
+        debug "send_dat: args is #{args}"
+        opts = {}
+        if args.length > 0 and args[0].class == 'Hash'
+            opts = args[0]
+        end
+
+        unless opts.key?(:resend) and opts[:resend]
+            blksize = @options[:blksize].to_i
+            debug "Reading #{blksize} bytes from file #{@filename}"
+            rv = @file.read(blksize, @buffer)
+            debug "@buffer is now #{@buffer.class}"
+            debug "Read #{@buffer.length} bytes into buffer"
+            unless rv
+                info "End of file #{@filename} detected."
+                @file.close
+                @state = :fin
+            end
+
+            @blocknumber += 1
+            if @blocknumber > MaxBlockNum
+                debug "Blocknumber rolled over to zero"
+                @blocknumber = 0
+            end
+        else
+            warn "Resending block number #{@blocknumber}"
+        end
+
+        dat = TftpPacketDAT.new
+        dat.data = @buffer
+        dat.blocknumber = @blocknumber
+        debug "Sending DAT packet #{@blocknumber}"
+        @sock.send(dat.encode.buffer, 0, @host, @port)
+        @timesent = Time.now
+    end
+
+    # This method handles the timeout case, where the handler has send a
+    # packet to the client and not received a response.
+    def timeout
+        @dups += 1
+        send_dat(:resend => true)
+        # FIXME - need to give up eventually!
     end
 end
 
@@ -574,16 +1028,19 @@ class TftpClient < TftpSession
             @address = Resolv::IPv4.create(@host)
         rescue ArgumentError => details
             # So, @host doesn't look like an IP. Resolve it.
-            # A Resolv::ResolvError exception could be raised here, let it
-            # filter up.
-            @address = Resolv::DNS.new.getaddress(@host)
+            begin
+                @address = Resolv::IPv4.create(TCPSocket.gethostbyname(@host)[3])
+            rescue SocketError => details
+                # Reraise the exception for now.
+                raise
+            end
         end
     end
 
     # FIXME - this method is too big
     def download(filename, output, options={})
-        @blksize = options[:blksize] if options.has_key? :blksize
-        $tftplog.debug('tftp+') { "Opening output file #{output}" }
+        @options[:blksize] = options[:blksize] if options.has_key?(:blksize)
+        debug "Opening output file #{output}"
         fout = File.open(output, "w")
         sock = UDPSocket.new
        
@@ -591,8 +1048,8 @@ class TftpClient < TftpSession
         pkt.filename = filename
         pkt.mode = 'octet' # FIXME - shouldn't hardcode this
         pkt.options = options
-        $tftplog.info('tftp+') { "Sending download request for #{filename}" }
-        $tftplog.info('tftp+') { "host = #{@host}, port = #{@iport}" }
+        info "Sending download request for #{filename}"
+        info "host = #{@host}, port = #{@iport}"
         sock.send(pkt.encode.buffer, 0, @host, @iport)
         @state = :rrq
 
@@ -601,7 +1058,7 @@ class TftpClient < TftpSession
         blocknumber = 1
         retry_count = 0
         loop do
-            $tftplog.debug('tftp+') { "Waiting for incoming datagram..." }
+            debug "Waiting for incoming datagram..."
             msg = sender = nil
             begin
                 status = Timeout::timeout(SockTimeout) {
@@ -611,60 +1068,64 @@ class TftpClient < TftpSession
                 retry_count += 1
                 if retry_count > MaxRetry
                     msg = "Timeout! Max retries exceeded. Giving up."
-                    $tftplog.error('tftp+') { msg }
+                    error msg
                     raise TftpError, msg
                 else
-                    $tftplog.debug('tftp+') { "Timeout! Lets try again." }
+                    debug "Timeout! Lets try again."
                     next
                 end
             end
             prot, rport, rhost, rip = sender
-            $tftplog.info('tftp+') { "Received #{msg.length} byte packet" }
-            $tftplog.debug('tftp+') { "Remote port is #{rport} and remote host is #{rhost}" }
+            info "Received #{msg.length} byte packet"
+            debug "Remote port is #{rport} and remote host is #{rhost}"
 
             if @address.to_s != rip
                 # Skip it
                 @errors += 1
-                $stderr.write "It is a rogue packet! #{sender[1]} #{sender[2]}\n"
+                error "It is a rogue packet! #{sender[1]} #{sender[2]}"
                 next
             elsif @port and @port != rport.to_s
                 # Skip it
                 @errors += 1
-                $stderr.write "It is a rogue packet! #{sender[1]} #{sender[2]}\n"
+                error "It is a rogue packet! #{sender[1]} #{sender[2]}"
                 next
             else not @port
                 # Set this as our TID
-                $tftplog.info('tftp+') { "Set remote TID to #{@port}" }
+                debug "@port was #{@port}"
                 @port = rport.to_s
+                info "Set remote TID to #{@port}"
             end
 
             pkt = factory.parse(msg)
-            $tftplog.debug('tftp+') { "pkt is #{pkt}" }
+            debug "pkt is #{pkt}"
 
             # FIXME - Refactor this into separate methods to handle each case.
             if pkt.is_a? TftpPacketRRQ
                 # Skip it, but info('tftp+')rm the sender.
-                err = TftpPacketERR.new
-                err.errorcode = 4 # illegal op
-                sock.send(err.encode.buffer, 0, @host, @port)
+                senderror(sock,
+                          TftpErrorType.illegalTftpOp,
+                          @host,
+                          @port)
                 @errors += 1
-                $stderr.write "It is a RRQ packet in download, state #{@state}\n"
+                debug "It is a RRQ packet in download, state #{@state}"
 
             elsif pkt.is_a? TftpPacketWRQ
                 # Skip it, but info('tftp+')rm the sender.
-                err = TftpPacketERR.new
-                err.errorcode = 4 # illegal op
-                sock.send(err.encode.buffer, 0, @host, @port)
+                senderror(sock,
+                          TftpErrorType.illegalTftpOp,
+                          @host,
+                          @port)
                 @errors += 1
-                $stderr.write "It is a WRQ packet in download, state #{@state}\n"
+                debug "It is a WRQ packet in download, state #{@state}"
 
             elsif pkt.is_a? TftpPacketACK
                 # Skip it, but info('tftp+')rm the sender.
-                err = TftpPacketERR.new
-                err.errorcode = 4 # illegal op
-                sock.send(err.encode.buffer, 0, @host, @port)
+                senderror(sock,
+                          TftpErrorType.illegalTftpOp,
+                          @host,
+                          @port)
                 @errors += 1
-                $stderr.write "It is a ACK packet in download, state #{@state}\n"
+                debug "It is a ACK packet in download, state #{@state}"
 
             elsif pkt.is_a? TftpPacketERR
                 @errors += 1
@@ -672,8 +1133,12 @@ class TftpClient < TftpSession
 
             elsif pkt.is_a? TftpPacketOACK
                 unless @state == :rrq
+                    senderror(sock,
+                              TftpErrorType.illegalTftpOp,
+                              @host,
+                              @port)
                     @errors += 1
-                    $stderr.write "It is a OACK in state #{@state}"
+                    debug "It is an OACK in state #{@state}"
                     next
                 end
 
@@ -685,11 +1150,12 @@ class TftpClient < TftpSession
                         case optname
                         when :blksize
                             # The blocksize can be <= what we proposed.
-                            unless options.has_key? :blksize
+                            unless options.has_key?(:blksize)
                                 # Hey, we didn't ask for a blocksize option...
-                                err = TftpPacketERR.new
-                                err.errorcode = 8 # failed negotiation
-                                sock.send(err.encode.buffer, 0, @host, @port)
+                                senderror(sock,
+                                          TftpErrorType.failedNegotiation,
+                                          @host,
+                                          @port)
                                 raise TftpError, "It is a OACK with blocksize when we didn't ask for one."
                             end
 
@@ -701,9 +1167,10 @@ class TftpClient < TftpSession
                             # FIXME - refactor err packet handling from above...
                             # Nothing that we don't know of should be in the
                             # oack packet.
-                            err = TftpPacketERR.new
-                            err.errorcode = 8 # failed negotiation
-                            sock.send(err.encode.buffer, 0, @host, @port)
+                            senderror(sock,
+                                      TftpErrorType.failedNegotiation,
+                                      @host,
+                                      @port)
                             raise TftpError, "Failed to negotiate options: #{pkt.options}"
                         end
                     end
@@ -717,9 +1184,10 @@ class TftpClient < TftpSession
                     @state = :ack
                 else
                     # OACK with no options?
-                    err = TftpPacketERR.new
-                    err.errorcode = 8 # failed negotiation
-                    sock.send(err.encode.buffer, 0, @host, @port)
+                    senderror(sock,
+                              TftpErrorType.failedNegotiation,
+                              @host,
+                              @port)
                     raise TftpError, "OACK with no options"
                 end
 
@@ -727,7 +1195,7 @@ class TftpClient < TftpSession
                 # to send an ACK to the server, with block number 0.
                 ack = TftpPacketACK.new
                 ack.blocknumber = 0
-                $tftplog.info('tftp+') { "Sending ACK to OACK" }
+                info "Sending ACK to OACK"
                 sock.send(ack.encode.buffer, 0, @host, @port)
                 @state = :ack
 
@@ -736,34 +1204,35 @@ class TftpClient < TftpSession
                 # server didn't send us an oack, and the options were refused.
                 # FIXME - we need to handle all possible options and set them
                 # back to their defaults here, not just blocksize.
-                if @state == :rrq and options.has_key? :blksize
-                    @blksize = DefBlkSize
+                if @state == :rrq and options.has_key?(:blksize)
+                    @options[:blksize] = DefBlkSize
                 end
 
                 @state = :dat
-                $tftplog.info('tftp+') { "It is a DAT packet, block #{pkt.blocknumber}" }
-                $tftplog.debug('tftp+') { "DAT size is #{pkt.data.length}" }
+                info "It is a DAT packet, block #{pkt.blocknumber}"
+                debug "DAT size is #{pkt.data.length}"
 
                 ack = TftpPacketACK.new
                 ack.blocknumber = pkt.blocknumber
 
-                $tftplog.info('tftp+') { "Sending ACK to block #{ack.blocknumber}" }
+                info "Sending ACK to block #{ack.blocknumber}"
                 sock.send(ack.encode.buffer, 0, @host, @port)
 
                 # Check for dups
                 if pkt.blocknumber <= blocknumber
-                    $tftplog.warn('tftp+') { "It is a DUP for block #{blocknumber}" }
+                    warn "It is a DUP for block #{blocknumber}"
                     @dups += 1
                 elsif pkt.blocknumber = blocknumber+1
-                    $tftplog.debug('tftp+') { "It is a properly ordered DAT packet" }
+                    debug "It is a properly ordered DAT packet"
                     blocknumber += 1
                 else
                     # Skip it, but info('tftp+')rm the sender.
-                    err = TftpPacketERR.new
-                    err.errorcode = 4 # illegal op
-                    sock.send(err.encode.buffer, 0, @host, @port)
+                    senderror(sock,
+                              TftpErrorType.illegalTftpOp,
+                              @host,
+                              @port)
                     @errors += 1
-                    $stderr.write "It is a future packet!\n"
+                    debug "It is a future packet!"
                 end
 
                 # Call any block passed.
@@ -774,16 +1243,16 @@ class TftpClient < TftpSession
                 # Write the data to the file.
                 fout.print pkt.data
                 # If the size is less than our blocksize, we're done.
-                $tftplog.debug('tftp+') { "pkt.data.length is #{pkt.data.length}" }
-                if pkt.data.length < @blksize
-                    $tftplog.info('tftp+') { "It is a last packet." }
+                debug "pkt.data.length is #{pkt.data.length}"
+                if pkt.data.length < @options[:blksize]
+                    info "It is a last packet."
                     fout.close
                     @state = :done
                     break
                 end
             else
                 msg = "It is an unknown packet: #{pkt}"
-                $tftplog.error('tftp+') { msg }
+                error msg
                 raise TftpError, msg
             end
         end

data/test/test.rb

@@ -4,8 +4,19 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'net/tftp+'
 require 'test/unit'
 
+# Mock socket class
+# FIXME - it should probably do more than this
+class MockSock
+    def send(*args)
+        return true
+    end
+end
+
 class TestTftp < Test::Unit::TestCase
-    def test_simple
+    def test_setup
+    end
+    
+    def test_rrq
         rrq = TftpPacketRRQ.new
         rrq.filename = 'myfilename'
         rrq.mode = 'octet'
@@ -15,7 +26,9 @@ class TestTftp < Test::Unit::TestCase
         rrq.decode
         assert_equal('myfilename', rrq.filename)
         assert_equal('octet', rrq.mode)
-
+    end
+    
+    def test_wrq
         wrq = TftpPacketWRQ.new
         wrq.buffer = "\000\002myfilename\000octet\000"
         wrq.decode
@@ -26,7 +39,9 @@ class TestTftp < Test::Unit::TestCase
         assert_equal('myfilename', wrq.filename)
         assert_equal('octet', wrq.mode)
         assert_equal(2, wrq.opcode)
-
+    end
+    
+    def test_dat
         dat = TftpPacketDAT.new
         sampledat = "\000\001\002\003\004\005"
         dat.data = sampledat
@@ -34,18 +49,24 @@ class TestTftp < Test::Unit::TestCase
         assert_equal(sampledat, dat.data)
         assert_equal(6, dat.data.length)
         assert_equal(3, dat.opcode)
-
+    end
+    
+    def test_ack
         ack = TftpPacketACK.new
         ack.blocknumber = 5
         assert_equal(4, ack.opcode)
         assert_equal(5, ack.encode.decode.blocknumber)
-
+    end
+    
+    def test_err
         err = TftpPacketERR.new
         err.errorcode = 3
         assert_equal('Disk full or allocation exceeded.',
                      err.encode.decode.errmsg)
         assert_equal(5, err.opcode)
-
+    end
+    
+    def test_oack
         oack = TftpPacketOACK.new
         oack_options = {
             :blksize => 4096
@@ -55,4 +76,48 @@ class TestTftp < Test::Unit::TestCase
         assert_equal('4096', oack.options[:blksize])
         assert_equal(6, oack.opcode)
     end
+    
+    def test_errortype
+        assert_equal(0, TftpErrorType.notDefined)
+        assert_equal(1, TftpErrorType.fileNotFound)
+        assert_equal(2, TftpErrorType.accessViolation)
+        assert_equal(3, TftpErrorType.diskFull)
+        assert_equal(4, TftpErrorType.illegalTftpOp)
+        assert_equal(5, TftpErrorType.unknownTID)
+        assert_equal(6, TftpErrorType.fileAlreadyExists)
+        assert_equal(7, TftpErrorType.noSuchUser)
+        assert_equal(8, TftpErrorType.failedNegotiation)
+    end
+    
+    def test_packetfactory
+        factory = TftpPacketFactory.new
+        rrq = factory.create(1)
+        wrq = factory.create(2)
+        dat = factory.create(3)
+        ack = factory.create(4)
+        err = factory.create(5)
+        oack = factory.create(6)
+        assert_equal(true, rrq.is_a?(TftpPacketRRQ))
+        assert_equal(true, wrq.is_a?(TftpPacketWRQ))
+        assert_equal(true, dat.is_a?(TftpPacketDAT))
+        assert_equal(true, ack.is_a?(TftpPacketACK))
+        assert_equal(true, err.is_a?(TftpPacketERR))
+        assert_equal(true, oack.is_a?(TftpPacketOACK))
+        assert_raise(ArgumentError) { factory.create(0) }
+        assert_raise(ArgumentError) { factory.create(7) }
+        assert_raise(ArgumentError) { factory.parse(TftpPacketRRQ.new) }
+        assert_raise(ArgumentError) { factory.parse(TftpPacketRRQ.new.buffer) }
+        assert_raise(TftpError) { factory.parse("foobar") }
+    end
+
+    def test_session
+        session = TftpSession.new
+        assert_equal(512, session.options[:blksize])
+        assert_equal(nil, session.state)
+        assert_equal(0, session.dups)
+        assert_equal(0, session.errors)
+
+        sock = MockSock.new
+        assert_equal(true, session.senderror(sock, 1, '192.168.0.1', '69'))
+    end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.2
 specification_version: 1
 name: tftpplus
 version: !ruby/object:Gem::Version 
-  version: "0.2"
-date: 2006-12-08 00:00:00 -05:00
+  version: "0.3"
+date: 2007-03-19 00:00:00 -04:00
 summary: A pure tftp implementation with support for variable block sizes
 require_paths: 
 - lib