[PATCH] tester: Change to a simpler TFTP server

Gedare Bloom gedare at rtems.org
Thu Aug 27 15:44:53 UTC 2020


On Wed, Aug 26, 2020 at 10:56 PM <chrisj at rtems.org> wrote:
>
> From: Chris Johns <chrisj at rtems.org>
>
> - Add a simpler TFTP to allow parallel test hardware
>
> - Remove the imported tftpy server
>
> Closes #4063
> ---
>  tester/rt/tftp.py                    |  37 +-
>  tester/rt/tftpserver.py              | 619 +++++++++++++++++++++++++++
>  tester/rt/tftpy/COPYING              |  21 -
>  tester/rt/tftpy/README               | 115 -----
>  tester/rt/tftpy/TftpClient.py        | 107 -----
>  tester/rt/tftpy/TftpContexts.py      | 429 -------------------
>  tester/rt/tftpy/TftpPacketFactory.py |  47 --
>  tester/rt/tftpy/TftpPacketTypes.py   | 494 ---------------------
>  tester/rt/tftpy/TftpServer.py        | 271 ------------
>  tester/rt/tftpy/TftpShared.py        |  52 ---
>  tester/rt/tftpy/TftpStates.py        | 611 --------------------------
>  tester/rt/tftpy/__init__.py          |  27 --
>  tester/rtems-tftp-server             |  46 ++
>  13 files changed, 685 insertions(+), 2191 deletions(-)
>  create mode 100644 tester/rt/tftpserver.py
>  delete mode 100644 tester/rt/tftpy/COPYING
>  delete mode 100644 tester/rt/tftpy/README
>  delete mode 100644 tester/rt/tftpy/TftpClient.py
>  delete mode 100644 tester/rt/tftpy/TftpContexts.py
>  delete mode 100644 tester/rt/tftpy/TftpPacketFactory.py
>  delete mode 100644 tester/rt/tftpy/TftpPacketTypes.py
>  delete mode 100644 tester/rt/tftpy/TftpServer.py
>  delete mode 100644 tester/rt/tftpy/TftpShared.py
>  delete mode 100644 tester/rt/tftpy/TftpStates.py
>  delete mode 100644 tester/rt/tftpy/__init__.py
>  create mode 100755 tester/rtems-tftp-server
>
> diff --git a/tester/rt/tftp.py b/tester/rt/tftp.py
> index d518036..46a1d11 100644
> --- a/tester/rt/tftp.py
> +++ b/tester/rt/tftp.py
> @@ -43,7 +43,7 @@ import sys
>  from rtemstoolkit import error
>  from rtemstoolkit import reraise
>
> -import tftpy
> +import tftpserver
>
>  class tftp(object):
>      '''RTEMS Testing TFTP base.'''
> @@ -88,7 +88,7 @@ class tftp(object):
>      def _stop(self):
>          try:
>              if self.server:
> -                self.server.stop(now = True)
> +                self.server.stop()
>          except:
>              pass
>
> @@ -101,6 +101,10 @@ class tftp(object):
>
>      def _timeout(self):
>          self._stop()
> +        while self.running or not self.finished:
> +            self._unlock('_timeout')
> +            time.sleep(0.1)
> +            self._lock('_timeout')
>          if self.timeout is not None:
>              self.timeout()
>
> @@ -119,22 +123,21 @@ class tftp(object):
>          return None
>
>      def _listener(self):
> -        tftpy_log = logging.getLogger('tftpy')
> -        tftpy_log.setLevel(100)
> +        self._lock('_listener')
> +        exe = self.exe
> +        self.exe = None
> +        self._unlock('_listener')
> +        self.server = tftpserver.tftp_server(host = 'all',
> +                                             port = self.port,
> +                                             timeout = 1,
> +                                             forced_file = exe,
> +                                             sessions = 1)
>          try:
> -            self.server = tftpy.TftpServer(tftproot = '.',
> -                                           dyn_file_func = self._exe_handle)
> -        except tftpy.TftpException as te:
> -            raise error.general('tftp: %s' % (str(te)))
> -        if self.server is not None:
> -            try:
> -                self.server.listen('0.0.0.0', self.port, 0.5)
> -            except tftpy.TftpException as te:
> -                raise error.general('tftp: %s' % (str(te)))
> -            except IOError as ie:
> -                if ie.errno == errno.EACCES:
> -                    raise error.general('tftp: permissions error: check tftp server port')
> -                raise error.general('tftp: io error: %s' % (str(ie)))
> +            self.server.start()
> +            self.server.run()
> +        except:
> +            self.server.stop()
> +            raise
>
>      def _runner(self):
>          self._lock('_runner')
> diff --git a/tester/rt/tftpserver.py b/tester/rt/tftpserver.py
> new file mode 100644
> index 0000000..b307bd2
> --- /dev/null
> +++ b/tester/rt/tftpserver.py
> @@ -0,0 +1,619 @@
> +#
> +# Copyright 2020 Chris Johns (chris at contemporary.software)
Nice email.

> +# All rights reserved.
> +#
> +# Permission to use, copy, modify, and/or distribute this software for any
> +# purpose with or without fee is hereby granted, provided that the above
> +# copyright notice and this permission notice appear in all copies.
> +#
> +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
> +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
> +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
> +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
> +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
> +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
> +# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
> +
Not the preferred file block:
https://docs.rtems.org/branches/master/eng/coding-file-hdr.html#python-file-template

But, we could add an MIT template.

I don't really have the context to check python code. Please do a pass
over the guidelines to see if you think you got to them.

> +#
> +# The TFTP Server handles a read only TFTP session.
> +#
> +
> +from __future__ import print_function
> +
> +import argparse
> +import os
> +import socket
> +import sys
> +import time
> +import threading
> +
> +try:
> +    import socketserver
> +except:
> +    import SocketServer as socketserver
> +
> +from rtemstoolkit import error
> +from rtemstoolkit import log
> +from rtemstoolkit import version
> +
> +class tftp_session(object):
> +
> +    opcodes = ['nul', 'RRQ', 'WRQ', 'DATA', 'ACK', 'ERROR', 'OACK']
> +
> +    OP_RRQ = 1
> +    OP_WRQ = 2
> +    OP_DATA = 3
> +    OP_ACK = 4
> +    OP_ERROR = 5
> +    OP_OACK = 6
> +
> +    E_NOT_DEFINED = 0
> +    E_FILE_NOT_FOUND = 1
> +    E_ACCESS_VIOLATION = 2
> +    E_DISK_FULL = 3
> +    E_ILLEGAL_TFTP_OP = 4
> +    E_UKNOWN_TID = 5
> +    E_FILE_ALREADY_EXISTS = 6
> +    E_NO_SUCH_USER = 7
> +    E_NO_ERROR = 10
> +
> +
> +    def __init__(self, host, port, base, forced_file, reader = None):
> +        self.host = host
> +        self.port = port
> +        self.base = base
> +        self.forced_file = forced_file
> +        if reader is None:
> +            self.data_reader = self._file_reader
> +        else:
> +            self.data_reader = reader
> +        self.filein = None
> +        self.resends_limit = 5
> +        self._reinit()
> +
> +
> +    def __str__(self):
> +        return os.linesep.join([self.decode(p[0], p[1], p[2]) for p in self.packets])
> +
> +
> +    def _reinit(self):
> +        if self.filein is not None:
> +            self.filein.close()
> +            self.filein = None
> +        self.block = 0
> +        self.block_size = 512
> +        self.timeout = 0
> +        self.resends = 0
> +        self.finished = False
> +
> +
> +    def _file_reader(self, command, **kwargs):
> +        '''The default file reader if the user does not provide one.
> +
> +        The call returns a two element tuple where the first element
> +        is an error code, and the second element is data if the error
> +        code is 0 else it is an error message.
> +        '''
> +        if command == 'open':
> +            if 'filename' not in kwargs:
> +                raise error.general('tftp-reader: invalid open: no filename')
> +            filename = kwargs['filename']
> +            try:
> +                self.filein = open(filename, 'rb')
> +                filesize = os.stat(filename).st_size
> +            except FileNotFoundError:
> +                return self.E_FILE_NOT_FOUND, 'file not found (%s)' % (filename)
> +            except PermissionError:
> +                return self.E_ACCESS_VIOLATION, 'access violation'
> +            except IOError as ie:
> +                return self.E_NOT_DEFINED, str(ie)
> +            return self.E_NO_ERROR, str(filesize)
> +        elif command == 'read':
> +            if self.filein is None:
> +                raise error.general('tftp-reader: read when not open')
> +            if 'blksize' not in kwargs:
> +                raise error.general('tftp-reader: invalid read: no blksize')
> +            try:
> +                return self.E_NO_ERROR, self.filein.read(kwargs['blksize'])
> +            except IOError as ie:
> +                return self.E_NOT_DEFINED, str(ie)
> +            except:
> +                return self.E_NOT_DEFINED, 'unknown error'
> +        elif command == 'close':
> +            if self.filein is not None:
> +                self.filein = None
> +        return self.E_NOT_DEFINED, 'invalid reader state'
> +
> +
> +    def _pack_bytes(self, data = None):
> +        bdata = bytearray()
> +        if data is not None:
> +            if not isinstance(data, list):
> +                data = [data]
> +            for d in data:
> +                if isinstance(d, int):
> +                    bdata.append(d >> 8)
> +                    bdata.append(d & 0xff)
> +                elif isinstance(d, str):
> +                    bdata.extend(d.encode())
> +                    bdata.append(0)
> +                else:
> +                    bdata.extend(d)
> +        return bdata
> +
> +
> +    def _next_data(self, command):
> +        if block == 1:
> +            self.data_reader('open')
> +        self.data = self.data_reader('read')
> +
> +
> +    def _response(self, opcode, data):
> +        code = self.opcodes.index(opcode)
> +        if code == 0 or code >= len(self.opcodes):
> +            raise error.general('invalid opcode: ' + opcode)
> +        bdata = self._pack_bytes([code, data])
> +        #print(''.join(format(x, '02x') for x in bdata))
> +        return bytes(bdata)
> +
> +
> +    def _error_response(self, code, message):
> +        if log.tracing:
> +            log.trace('tftp: error: %s:%d: %d: %s' % (self.host, self.port,
> +                                                      code, message))
> +        self.finished = True;
> +        return self._response('ERROR', self._pack_bytes([code, message, 0]))
> +
> +
> +    def _data_response(self, block, data):
> +        if len(data) < self.block_size:
> +            self.finished = True;
> +        return self._response('DATA', self._pack_bytes([block, data]))
> +
> +
> +    def _oack_response(self, data):
> +        self.resends += 1
> +        if self.resends >= self.resends_limit:
> +            return self._error_response(self.E_NOT_DEFINED, 'resend limit reached')
> +        return self._response('OACK', self._pack_bytes(data))
> +
> +
> +    def _next_block(self, block):
> +        # has the current block been acknowledged?
> +        if block == self.block:
> +            self.resends = 0
> +            self.block += 1
> +            error, self.data = self.data_reader('read', blksize=self.block_size)
> +            if error != self.E_NO_ERROR:
> +                return self._error_response(error, data)
> +            # close if the length of data is less than the block size
> +            if len(self.data) < self.block_size:
> +                self.data_reader('close')
> +        else:
> +            self.resends += 1
> +            if self.resends >= self.resends_limit:
> +                return self._error_response(self.E_NOT_DEFINED, 'resend limit reached')
> +        return self._data_response(self.block, self.data)
> +
> +
> +    def process(self, host, port, data):
> +        '''Process the incoming client data sending a response. If the session
> +        has finished return None.
> +        '''
> +        if host != self.host and port != self.port:
> +            return self._error_response(self.E_UKNOWN_TID,
> +                                        'unkown transfer ID')
> +        if self.finished:
> +            return None
> +        opcode = (data[0] << 8) | data[1]
> +        if opcode == self.OP_RRQ:
> +            # if the last block is not 0 something has gone wrong and
> +            # TID match. Restart the session. It could be the client
> +            # is a simple implementation that does not move the send
> +            # port on each retry.
> +            if self.block != 0:
> +                self.data_reader('close')
> +                self._reinit()
> +            # Get the filename, mode and options
> +            self.filename = self.get_option('filename', data)
> +            if self.filename is None:
> +                return self._error_response(self.E_NOT_DEFINED,
> +                                            'filename not found in request')
> +            elif self.forced_file is not None:
> +                self.filename = self.forced_file
> +            # open the reader
> +            error, message = self.data_reader('open', filename=self.filename)
> +            if error != self.E_NO_ERROR:
> +                return self._error_response(error, message)
> +            # the no error on open message is the file size
> +            try:
> +                tsize = int(message)
> +            except:
> +                tsize = 0
> +            self.mode = self.get_option('mode', data)
> +            if self.mode is None:
> +                return self._error_response(self.E_NOT_DEFINED,
> +                                           'mode not found in request')
> +            self.oack_data = self._pack_bytes()
> +            value = self.get_option('timeout', data)
> +            if value is not None:
> +                self.oack_data += self._pack_bytes(['timeout', value])
> +                self.timeout = int(value)
> +            value = self.get_option('blksize', data)
> +            if value is not None:
> +                self.oack_data += self._pack_bytes(['blksize', value])
> +                self.block_size = int(value)
> +            else:
> +                self.block_size = 512
> +            value = self.get_option('tsize', data)
> +            if value is not None and tsize > 0:
> +                self.oack_data += self._pack_bytes(['tsize', str(tsize)])
> +            # Send the options ack
> +            return self._oack_response(self.oack_data)
> +        elif opcode == self.OP_WRQ or opcode == self.OP_DATA:
> +            # WRQ is not supported
> +            return self._error_response(self.E_ILLEGAL_TFTP_OP,
> +                                        "writes not supported")
> +        elif opcode == self.OP_ACK:
> +            # send the next block of data
> +            block = (data[2] << 8) | data[3]
> +            return self._next_block(block)
> +        return self._error_response(self.E_ILLEGAL_TFTP_OP,
> +                                    "unknown or unsupported opcode")
> +
> +    def decode(self, host, port, data):
> +        s = ''
> +        dlen = len(data)
> +        if dlen > 2:
> +            opcode = (data[0] << 8) | data[1]
> +            if opcode > 0 and opcode < len(self.opcodes):
> +                if opcode == self.OP_RRQ or opcode == self.OP_WRQ:
> +                    s += '  ' + self.opcodes[opcode] + ', '
> +                    i = 2
> +                    while data[i] != 0:
> +                        s += chr(data[i])
> +                        i += 1
> +                    while i < dlen - 1:
> +                        s += ', '
> +                        i += 1
> +                        while data[i] != 0:
> +                            s += chr(data[i])
> +                            i += 1
> +                elif opcode == self.OP_DATA:
> +                    block = (data[2] << 8) | data[3]
> +                    s += '  ' + self.opcodes[opcode] + ', '
> +                    s += '#' + str(block) + ', '
> +                    if dlen > 4:
> +                        s += '%02x%02x..%02x%02x' % (data[4], data[5], data[-2], data[-1])
> +                    else:
> +                        s += '%02x%02x%02x%02x' % (data[4], data[5], data[6], data[6])
> +                    s += ',' + str(dlen - 4)
> +                elif opcode == self.OP_ACK:
> +                    block = (data[2] << 8) | data[3]
> +                    s += '  ' + self.opcodes[opcode] + ' ' + str(block)
> +                elif opcode == self.OP_ERROR:
> +                    s += 'E ' + self.opcodes[opcode] + ', '
> +                    s += str((data[2] << 8) | (data[3]))
> +                    s += ': ' + str(data[4:].decode())
> +                    i = 2
> +                    while data[i] != 0:
> +                        s += chr(data[i])
> +                        i += 1
> +                elif opcode == self.OP_OACK:
> +                    s += '  ' + self.opcodes[opcode]
> +                    i = 1
> +                    while i < dlen - 1:
> +                        s += ', '
> +                        i += 1
> +                        while data[i] != 0:
> +                            s += chr(data[i])
> +                            i += 1
> +            else:
> +                s += 'E INV(%d)' % (opcode)
> +        else:
> +            s += 'E INVALID LENGTH'
> +        return s[:2] + '[%s:%d] (%d) ' % (host, port, len(data)) + s[2:]
> +
> +
> +    def get_option(self, option, data):
> +        dlen = len(data) - 1
> +        opcode = (data[0] << 8) | data[1]
> +        next_option = False
> +        if opcode == 1 or opcode == 2:
> +            count = 0
> +            i = 2
> +            while i < dlen:
> +                o = ''
> +                while data[i] != 0:
> +                    o += chr(data[i])
> +                    i += 1
> +                i += 1
> +                if option == 'filename' and count == 0:
> +                    return o
> +                elif option == 'mode' and count == 1:
> +                    return o
> +                elif o == option and (count % 1) == 0:
> +                    next_option = True
> +                elif next_option:
> +                    return o
> +                count += 1
> +        return None
> +
> +
> +    def get_timeout(self, default_timeout, timeout_guard):
> +        if self.timeout == 0:
> +            return self.timeout + timeout_guard
> +        return default_timeout
> +
> +
> +    def get_block_size(self):
> +        return self.block_size
> +
> +
> +class udp_handler(socketserver.BaseRequestHandler):
> +
> +    def _notice(self, text):
> +        if self.server.tftp.notices:
> +            log.notice(text)
> +        else:
> +            log.trace(text)
> +
> +
> +    def handle_session(self, index):
> +        client_ip = self.client_address[0]
> +        client_port = self.client_address[1]
> +        client = '%s:%i' % (client_ip, client_port)
> +        self._notice('] tftp: %d: start: %s' % (index, client))
> +        try:
> +            session = tftp_session(client_ip, client_port,
> +                                   self.server.tftp.base,
> +                                   self.server.tftp.forced_file,
> +                                   self.server.tftp.reader)
> +            response = session.process(client_ip, client_port, self.request[0])
> +            if response is not None:
> +                if log.tracing and self.server.tftp.packet_trace:
> +                    log.trace(' > ' + session.decode(client_ip,
> +                                                     client_port,
> +                                                     self.request[0]))
> +                timeout = session.get_timeout(self.server.tftp.timeout, 1)
> +                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
> +                sock.bind(('', 0))
> +                host_ip, host_port = sock.getsockname()
> +                sock.settimeout(timeout)
> +                while response is not None:
> +                    if log.tracing and self.server.tftp.packet_trace:
> +                        log.trace(' < ' + session.decode(client_ip,
> +                                                         client_port,
> +                                                         response))
> +                    sock.sendto(response, (client_ip, client_port))
> +                    if session.finished:
> +                        break
> +                    try:
> +                        data, address = sock.recvfrom(2 + 2 + session.get_block_size())
> +                        if log.tracing and self.server.tftp.packet_trace:
> +                            log.trace(' > ' + session.decode(address[0],
> +                                                             address[1],
> +                                                             data))
> +                    except socket.error as se:
> +                        if log.tracing:
> +                            log.trace('] tftp: %d: receive: %s: error: %s' \
> +                                      % (index, client, se))
> +                        return
> +                    except socket.gaierror as se:
> +                        if log.tracing:
> +                            log.trace('] tftp: %d: receive: %s: error: %s' \
> +                                      % (index, client, se))
> +                        return
> +                    response = session.process(address[0], address[1], data)
> +        except error.general as gerr:
> +            self._notice('] tftp: %dd: error: %s' % (index, gerr))
> +        except error.internal as ierr:
> +            self._notice('] tftp: %d: error: %s' % (index, ierr))
> +        except error.exit as eerr:
> +            pass
> +        except KeyboardInterrupt:
> +            pass
> +        except Exception as e:
> +            self._notice('] tftp: %d: error: %s: %s' % (index, type(e), e))
> +        self._notice('] tftp: %d: end: %s' % (index, client))
> +
> +
> +    def handle(self):
> +        if self.server.tftp.sessions is None \
> +           or self.server.tftp.session < self.server.tftp.sessions:
> +            self.handle_session(self.server.tftp.get_session())
> +
> +
> +class udp_server(socketserver.ThreadingMixIn, socketserver.UDPServer):
> +    pass
> +
> +
> +class tftp_server(object):
> +    def __init__(self, host, port, timeout = 10, base = None,
> +                 forced_file = None, sessions = None, reader = None):
> +        self.lock = threading.Lock()
> +        self.notices = False
> +        self.packet_trace = False
> +        self.timeout = timeout
> +        self.host = host
> +        self.port = port
> +        self.server = None
> +        if base is None:
> +            base = os.getcwd()
> +        self.base = base
> +        self.forced_file = forced_file
> +        if sessions is not None and not isinstance(sessions, int):
> +            raise error.general('tftp session count is not a number')
> +        self.sessions = sessions
> +        self.session = 0
> +        self.reader = reader
> +
> +    def __del__(self):
> +        self.stop()
> +
> +    def _lock(self):
> +        self.lock.acquire()
> +
> +    def _unlock(self):
> +        self.lock.release()
> +
> +    def start(self):
> +        if log.tracing:
> +            log.trace('] tftp: server: %s:%i' % (self.host, self.port))
> +        if self.host == 'all':
> +            host = ''
> +        else:
> +            host = self.host
> +        try:
> +            self.server = udp_server((host, self.port), udp_handler)
> +        except Exception as e:
> +            raise error.general('tftp server create: %s' % (e))
> +        self.server.tftp = self
> +        self.server_thread = threading.Thread(target = self.server.serve_forever)
> +        self.server_thread.daemon = True
> +        self.server_thread.start()
> +
> +    def stop(self):
> +        self._lock()
> +        try:
> +            if self.server is not None:
> +                self.server.shutdown()
> +                self.server.server_close()
> +                self.server = None
> +        finally:
> +            self._unlock()
> +
> +    def run(self):
> +        running = True
> +        while running:
> +            period = 1
> +            self._lock()
> +            if self.server is None:
> +                running = False
> +                period = 0
> +            elif self.sessions is not None:
> +                if self.sessions == 0:
> +                    running = False
> +                    period = 0
> +                else:
> +                    period = 0.25
> +            self._unlock()
> +            if period > 0:
> +                time.sleep(period)
> +        self.stop()
> +
> +    def get_session(self):
> +        count = 0
> +        self._lock()
> +        try:
> +            self.session += 1
> +            count = self.session
> +        finally:
> +            self._unlock()
> +        return count
> +
> +    def enable_notices(self):
> +        self._lock()
> +        self.notices = True
> +        self._unlock()
> +
> +    def trace_packets(self):
> +        self._lock()
> +        self.packet_trace = True
> +        self._unlock()
> +
> +
> +def load_log(logfile):
> +    if logfile is None:
> +        log.default = log.log(streams = ['stdout'])
> +    else:
> +        log.default = log.log(streams = [logfile])
> +
> +def run(args = sys.argv, command_path = None):
> +    ec = 0
> +    notice = None
> +    server = None
> +    try:
> +        description  = 'A TFTP Server that supports a read only TFTP session.'
> +
> +        nice_cwd = os.path.relpath(os.getcwd())
> +        if len(nice_cwd) > len(os.path.abspath(nice_cwd)):
> +            nice_cwd = os.path.abspath(nice_cwd)
> +
> +        argsp = argparse.ArgumentParser(prog = 'rtems-tftp-server',
> +                                        description = description)
> +        argsp.add_argument('-l', '--log',
> +                           help = 'log file.',
> +                           type = str, default = None)
> +        argsp.add_argument('-v', '--trace',
> +                           help = 'enable trace logging for debugging.',
> +                           action = 'store_true', default = False)
> +        argsp.add_argument('--trace-packets',
> +                           help = 'enable trace logging of packets.',
> +                           action = 'store_true', default = False)
> +        argsp.add_argument('-B', '--bind',
> +                           help = 'address to bind the server too (default: %(default)s).',
> +                           type = str, default = 'all')
> +        argsp.add_argument('-P', '--port',
> +                           help = 'port to bind the server too (default: %(default)s).',
> +                           type = int, default = '69')
> +        argsp.add_argument('-t', '--timeout',
> +                           help = 'timeout in seconds, client can override ' \
> +                           '(default: %(default)s).',
> +                           type = int, default = '10')
> +        argsp.add_argument('-b', '--base',
> +                           help = 'base path, not checked (default: %(default)s).',
> +                           type = str, default = nice_cwd)
> +        argsp.add_argument('-F', '--force-file',
> +                           help = 'force the file to be downloaded overriding the client.',
> +                           type = str, default = None)
> +        argsp.add_argument('-s', '--sessions',
> +                           help = 'number of TFTP sessions to run before exiting ' \
> +                           '(default: forever.',
> +                           type = int, default = None)
> +
> +        argopts = argsp.parse_args(args[1:])
> +
> +        load_log(argopts.log)
> +        log.notice('RTEMS Tools - TFTP Server, %s' % (version.string()))
> +        log.output(log.info(args))
> +        log.tracing = argopts.trace
> +
> +        server = tftp_server(argopts.bind,
> +                             argopts.port,
> +                             argopts.timeout,
> +                             argopts.base,
> +                             argopts.force_file,
> +                             argopts.sessions)
> +        server.enable_notices()
> +
> +        try:
> +            server.start()
> +            server.run()
> +        except:
> +            server.stop()
> +            raise
> +
> +    except error.general as gerr:
> +        notice = str(gerr)
> +        ec = 1
> +    except error.internal as ierr:
> +        notice = str(ierr)
> +        ec = 1
> +    except error.exit as eerr:
> +        pass
> +    except KeyboardInterrupt:
> +        notice = 'abort: user terminated'
> +        ec = 1
> +    except:
> +        raise
> +        notice = 'abort: unknown error'
> +        ec = 1
> +    if server is not None:
> +        del server
> +    if notice is not None:
> +        log.stderr(notice)
> +    sys.exit(ec)
> +
> +if __name__ == "__main__":
> +    run()
> diff --git a/tester/rt/tftpy/COPYING b/tester/rt/tftpy/COPYING
> deleted file mode 100644
> index c9f2c9c..0000000
> --- a/tester/rt/tftpy/COPYING
> +++ /dev/null
> @@ -1,21 +0,0 @@
> -The MIT License
> -
> -Copyright (c) 2009 Michael P. Soulier
> -
> -Permission is hereby granted, free of charge, to any person obtaining a copy
> -of this software and associated documentation files (the "Software"), to deal
> -in the Software without restriction, including without limitation the rights
> -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
> -copies of the Software, and to permit persons to whom the Software is
> -furnished to do so, subject to the following conditions:
> -
> -The above copyright notice and this permission notice shall be included in
> -all copies or substantial portions of the Software.
> -
> -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
> -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
> -THE SOFTWARE.
> diff --git a/tester/rt/tftpy/README b/tester/rt/tftpy/README
> deleted file mode 100644
> index ad7a871..0000000
> --- a/tester/rt/tftpy/README
> +++ /dev/null
> @@ -1,115 +0,0 @@
> -Copyright, Michael P. Soulier, 2010.
> -
> -About Release 0.6.2:
> -====================
> -Maintenance release to fix a couple of reported issues.
> -
> -About Release 0.6.1:
> -====================
> -Maintenance release to fix several reported problems, including a rollover
> -at 2^16 blocks, and some contributed work on dynamic file objects.
> -
> -About Release 0.6.0:
> -====================
> -Maintenance update to fix several reported issues, including proper
> -retransmits on timeouts, and further expansion of unit tests.
> -
> -About Release 0.5.1:
> -====================
> -Maintenance update to fix a bug in the server, overhaul the documentation for
> -the website, fix a typo in the unit tests, fix a failure to set default
> -blocksize, and a divide by zero error in speed calculations for very short
> -transfers.
> -
> -Also, this release adds support for input/output in client as stdin/stdout
> -
> -About Release 0.5.0:
> -====================
> -Complete rewrite of the state machine.
> -Now fully implements downloading and uploading.
> -
> -About Release 0.4.6:
> -====================
> -Feature release to add the tsize option.
> -Thanks to Kuba Kończyk for the patch.
> -
> -About Release 0.4.5:
> -====================
> -Bugfix release for compatability issues on Win32, among other small issues.
> -
> -About Release 0.4.4:
> -====================
> -Bugfix release for poor tolerance of unsupported options in the server.
> -
> -About Release 0.4.3:
> -====================
> -Bugfix release for an issue with the server's detection of the end of the file
> -during a download.
> -
> -About Release 0.4.2:
> -====================
> -Bugfix release for some small installation issues with earlier Python
> -releases.
> -
> -About Release 0.4.1:
> -====================
> -Bugfix release to fix the installation path, with some restructuring into a
> -tftpy package from the single module used previously.
> -
> -About Release 0.4:
> -==================
> -This release adds a TftpServer class with a sample implementation in bin.
> -The server uses a single thread with multiple handlers and a select() loop to
> -handle multiple clients simultaneously.
> -
> -Only downloads are supported at this time.
> -
> -About Release 0.3:
> -==================
> -This release fixes a major RFC 1350 compliance problem with the remote TID.
> -
> -About Release 0.2:
> -==================
> -This release adds variable block sizes, and general option support,
> -implementing RFCs 2347 and 2348. This is accessible in the TftpClient class
> -via the options dict, or in the sample client via the --blocksize option.
> -
> -About Release 0.1:
> -==================
> -
> -This is an initial release in the spirit of "release early, release often".
> -Currently the sample client works, supporting RFC 1350. The server is not yet
> -implemented, and RFC 2347 and 2348 support (variable block sizes) is underway,
> -planned for 0.2.
> -
> -About Tftpy:
> -============
> -
> -Purpose:
> ---------
> -Tftpy is a TFTP library for the Python programming language. It includes
> -client and server classes, with sample implementations. Hooks are included for
> -easy inclusion in a UI for populating progress indicators. It supports RFCs
> -1350, 2347, 2348 and the tsize option from RFC 2349.
> -
> -Dependencies:
> --------------
> -Python 2.3+, hopefully. Let me know if it fails to work.
> -
> -Trifles:
> ---------
> -Home page: http://tftpy.sf.net/
> -Project page: http://sourceforge.net/projects/tftpy/
> -
> -License is the MIT License
> -
> -See COPYING in this distribution.
> -
> -Limitations:
> -------------
> -- Only 'octet' mode is supported.
> -- The only options supported are blksize and tsize.
> -
> -Author:
> -=======
> -Michael P. Soulier <msoulier at digitaltorque.ca>
> diff --git a/tester/rt/tftpy/TftpClient.py b/tester/rt/tftpy/TftpClient.py
> deleted file mode 100644
> index eb82c05..0000000
> --- a/tester/rt/tftpy/TftpClient.py
> +++ /dev/null
> @@ -1,107 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements the TFTP Client functionality. Instantiate an
> -instance of the client, and then use its upload or download method. Logging is
> -performed via a standard logging object set in TftpShared."""
> -
> -
> -import types
> -import logging
> -from .TftpShared import *
> -from .TftpPacketTypes import *
> -from .TftpContexts import TftpContextClientDownload, TftpContextClientUpload
> -
> -log = logging.getLogger('tftpy.TftpClient')
> -
> -class TftpClient(TftpSession):
> -    """This class is an implementation of a tftp client. Once instantiated, a
> -    download can be initiated via the download() method, or an upload via the
> -    upload() method."""
> -
> -    def __init__(self, host, port=69, options={}, localip = ""):
> -        TftpSession.__init__(self)
> -        self.context = None
> -        self.host = host
> -        self.iport = port
> -        self.filename = None
> -        self.options = options
> -        self.localip = localip
> -        if 'blksize' in self.options:
> -            size = self.options['blksize']
> -            tftpassert(int == type(size), "blksize must be an int")
> -            if size < MIN_BLKSIZE or size > MAX_BLKSIZE:
> -                raise TftpException("Invalid blksize: %d" % size)
> -
> -    def download(self, filename, output, packethook=None, timeout=SOCK_TIMEOUT):
> -        """This method initiates a tftp download from the configured remote
> -        host, requesting the filename passed. It writes the file to output,
> -        which can be a file-like object or a path to a local file. If a
> -        packethook is provided, it must be a function that takes a single
> -        parameter, which will be a copy of each DAT packet received in the
> -        form of a TftpPacketDAT object. The timeout parameter may be used to
> -        override the default SOCK_TIMEOUT setting, which is the amount of time
> -        that the client will wait for a receive packet to arrive.
> -
> -        Note: If output is a hyphen, stdout is used."""
> -        # We're downloading.
> -        log.debug("Creating download context with the following params:")
> -        log.debug("host = %s, port = %s, filename = %s" % (self.host, self.iport, filename))
> -        log.debug("options = %s, packethook = %s, timeout = %s" % (self.options, packethook, timeout))
> -        self.context = TftpContextClientDownload(self.host,
> -                                                 self.iport,
> -                                                 filename,
> -                                                 output,
> -                                                 self.options,
> -                                                 packethook,
> -                                                 timeout,
> -                                                 localip = self.localip)
> -        self.context.start()
> -        # Download happens here
> -        self.context.end()
> -
> -        metrics = self.context.metrics
> -
> -        log.info('')
> -        log.info("Download complete.")
> -        if metrics.duration == 0:
> -            log.info("Duration too short, rate undetermined")
> -        else:
> -            log.info("Downloaded %.2f bytes in %.2f seconds" % (metrics.bytes, metrics.duration))
> -            log.info("Average rate: %.2f kbps" % metrics.kbps)
> -        log.info("%.2f bytes in resent data" % metrics.resent_bytes)
> -        log.info("Received %d duplicate packets" % metrics.dupcount)
> -
> -    def upload(self, filename, input, packethook=None, timeout=SOCK_TIMEOUT):
> -        """This method initiates a tftp upload to the configured remote host,
> -        uploading the filename passed. It reads the file from input, which
> -        can be a file-like object or a path to a local file. If a packethook
> -        is provided, it must be a function that takes a single parameter,
> -        which will be a copy of each DAT packet sent in the form of a
> -        TftpPacketDAT object. The timeout parameter may be used to override
> -        the default SOCK_TIMEOUT setting, which is the amount of time that
> -        the client will wait for a DAT packet to be ACKd by the server.
> -
> -        Note: If input is a hyphen, stdin is used."""
> -        self.context = TftpContextClientUpload(self.host,
> -                                               self.iport,
> -                                               filename,
> -                                               input,
> -                                               self.options,
> -                                               packethook,
> -                                               timeout,
> -                                               localip = self.localip)
> -        self.context.start()
> -        # Upload happens here
> -        self.context.end()
> -
> -        metrics = self.context.metrics
> -
> -        log.info('')
> -        log.info("Upload complete.")
> -        if metrics.duration == 0:
> -            log.info("Duration too short, rate undetermined")
> -        else:
> -            log.info("Uploaded %d bytes in %.2f seconds" % (metrics.bytes, metrics.duration))
> -            log.info("Average rate: %.2f kbps" % metrics.kbps)
> -        log.info("%.2f bytes in resent data" % metrics.resent_bytes)
> -        log.info("Resent %d packets" % metrics.dupcount)
> diff --git a/tester/rt/tftpy/TftpContexts.py b/tester/rt/tftpy/TftpContexts.py
> deleted file mode 100644
> index da85886..0000000
> --- a/tester/rt/tftpy/TftpContexts.py
> +++ /dev/null
> @@ -1,429 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements all contexts for state handling during uploads and
> -downloads, the main interface to which being the TftpContext base class.
> -
> -The concept is simple. Each context object represents a single upload or
> -download, and the state object in the context object represents the current
> -state of that transfer. The state object has a handle() method that expects
> -the next packet in the transfer, and returns a state object until the transfer
> -is complete, at which point it returns None. That is, unless there is a fatal
> -error, in which case a TftpException is returned instead."""
> -
> -
> -from .TftpShared import *
> -from .TftpPacketTypes import *
> -from .TftpPacketFactory import TftpPacketFactory
> -from .TftpStates import *
> -import socket
> -import time
> -import sys
> -import os
> -import logging
> -
> -log = logging.getLogger('tftpy.TftpContext')
> -
> -###############################################################################
> -# Utility classes
> -###############################################################################
> -
> -class TftpMetrics(object):
> -    """A class representing metrics of the transfer."""
> -    def __init__(self):
> -        # Bytes transferred
> -        self.bytes = 0
> -        # Bytes re-sent
> -        self.resent_bytes = 0
> -        # Duplicate packets received
> -        self.dups = {}
> -        self.dupcount = 0
> -        # Times
> -        self.start_time = 0
> -        self.end_time = 0
> -        self.duration = 0
> -        # Rates
> -        self.bps = 0
> -        self.kbps = 0
> -        # Generic errors
> -        self.errors = 0
> -
> -    def compute(self):
> -        # Compute transfer time
> -        self.duration = self.end_time - self.start_time
> -        if self.duration == 0:
> -            self.duration = 1
> -        log.debug("TftpMetrics.compute: duration is %s", self.duration)
> -        self.bps = (self.bytes * 8.0) / self.duration
> -        self.kbps = self.bps / 1024.0
> -        log.debug("TftpMetrics.compute: kbps is %s", self.kbps)
> -        for key in self.dups:
> -            self.dupcount += self.dups[key]
> -
> -    def add_dup(self, pkt):
> -        """This method adds a dup for a packet to the metrics."""
> -        log.debug("Recording a dup of %s", pkt)
> -        s = str(pkt)
> -        if s in self.dups:
> -            self.dups[s] += 1
> -        else:
> -            self.dups[s] = 1
> -        tftpassert(self.dups[s] < MAX_DUPS, "Max duplicates reached")
> -
> -###############################################################################
> -# Context classes
> -###############################################################################
> -
> -class TftpContext(object):
> -    """The base class of the contexts."""
> -
> -    def __init__(self, host, port, timeout, localip = ""):
> -        """Constructor for the base context, setting shared instance
> -        variables."""
> -        self.file_to_transfer = None
> -        self.fileobj = None
> -        self.options = None
> -        self.packethook = None
> -        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
> -        if localip != "":
> -            self.sock.bind((localip, 0))
> -        self.sock.settimeout(timeout)
> -        self.timeout = timeout
> -        self.state = None
> -        self.next_block = 0
> -        self.factory = TftpPacketFactory()
> -        # Note, setting the host will also set self.address, as it's a property.
> -        self.host = host
> -        self.port = port
> -        # The port associated with the TID
> -        self.tidport = None
> -        # Metrics
> -        self.metrics = TftpMetrics()
> -        # Fluag when the transfer is pending completion.
> -        self.pending_complete = False
> -        # Time when this context last received any traffic.
> -        # FIXME: does this belong in metrics?
> -        self.last_update = 0
> -        # The last packet we sent, if applicable, to make resending easy.
> -        self.last_pkt = None
> -        # Count the number of retry attempts.
> -        self.retry_count = 0
> -
> -    def getBlocksize(self):
> -        """Fetch the current blocksize for this session."""
> -        return int(self.options.get('blksize', 512))
> -
> -    def __del__(self):
> -        """Simple destructor to try to call housekeeping in the end method if
> -        not called explicitely. Leaking file descriptors is not a good
> -        thing."""
> -        self.end()
> -
> -    def checkTimeout(self, now):
> -        """Compare current time with last_update time, and raise an exception
> -        if we're over the timeout time."""
> -        log.debug("checking for timeout on session %s", self)
> -        if now - self.last_update > self.timeout:
> -            raise TftpTimeout("Timeout waiting for traffic")
> -
> -    def start(self):
> -        raise NotImplementedError("Abstract method")
> -
> -    def end(self, close_fileobj=True):
> -        """Perform session cleanup, since the end method should always be
> -        called explicitely by the calling code, this works better than the
> -        destructor.
> -        Set close_fileobj to False so fileobj can be returned open."""
> -        log.debug("in TftpContext.end - closing socket")
> -        self.sock.close()
> -        if close_fileobj and self.fileobj is not None and not self.fileobj.closed:
> -            log.debug("self.fileobj is open - closing")
> -            self.fileobj.close()
> -
> -    def gethost(self):
> -        "Simple getter method for use in a property."
> -        return self.__host
> -
> -    def sethost(self, host):
> -        """Setter method that also sets the address property as a result
> -        of the host that is set."""
> -        self.__host = host
> -        self.address = socket.gethostbyname(host)
> -
> -    host = property(gethost, sethost)
> -
> -    def setNextBlock(self, block):
> -        if block >= 2 ** 16:
> -            log.debug("Block number rollover to 0 again")
> -            block = 0
> -        self.__eblock = block
> -
> -    def getNextBlock(self):
> -        return self.__eblock
> -
> -    next_block = property(getNextBlock, setNextBlock)
> -
> -    def cycle(self):
> -        """Here we wait for a response from the server after sending it
> -        something, and dispatch appropriate action to that response."""
> -        try:
> -            (buffer, (raddress, rport)) = self.sock.recvfrom(MAX_BLKSIZE)
> -        except socket.timeout:
> -            log.warning("Timeout waiting for traffic, retrying...")
> -            raise TftpTimeout("Timed-out waiting for traffic")
> -
> -        # Ok, we've received a packet. Log it.
> -        log.debug("Received %d bytes from %s:%s",
> -                        len(buffer), raddress, rport)
> -        # And update our last updated time.
> -        self.last_update = time.time()
> -
> -        # Decode it.
> -        recvpkt = self.factory.parse(buffer)
> -
> -        # Check for known "connection".
> -        if raddress != self.address:
> -            log.warning("Received traffic from %s, expected host %s. Discarding"
> -                        % (raddress, self.host))
> -
> -        if self.tidport and self.tidport != rport:
> -            log.warning("Received traffic from %s:%s but we're "
> -                        "connected to %s:%s. Discarding."
> -                        % (raddress, rport,
> -                        self.host, self.tidport))
> -
> -        # If there is a packethook defined, call it. We unconditionally
> -        # pass all packets, it's up to the client to screen out different
> -        # kinds of packets. This way, the client is privy to things like
> -        # negotiated options.
> -        if self.packethook:
> -            self.packethook(recvpkt)
> -
> -        # And handle it, possibly changing state.
> -        self.state = self.state.handle(recvpkt, raddress, rport)
> -        # If we didn't throw any exceptions here, reset the retry_count to
> -        # zero.
> -        self.retry_count = 0
> -
> -class TftpContextServer(TftpContext):
> -    """The context for the server."""
> -    def __init__(self,
> -                 host,
> -                 port,
> -                 timeout,
> -                 root,
> -                 dyn_file_func=None,
> -                 upload_open=None):
> -        TftpContext.__init__(self,
> -                             host,
> -                             port,
> -                             timeout,
> -                             )
> -        # At this point we have no idea if this is a download or an upload. We
> -        # need to let the start state determine that.
> -        self.state = TftpStateServerStart(self)
> -
> -        self.root = root
> -        self.dyn_file_func = dyn_file_func
> -        self.upload_open = upload_open
> -
> -    def __str__(self):
> -        return "%s:%s %s" % (self.host, self.port, self.state)
> -
> -    def start(self, buffer):
> -        """Start the state cycle. Note that the server context receives an
> -        initial packet in its start method. Also note that the server does not
> -        loop on cycle(), as it expects the TftpServer object to manage
> -        that."""
> -        log.debug("In TftpContextServer.start")
> -        self.metrics.start_time = time.time()
> -        log.debug("Set metrics.start_time to %s", self.metrics.start_time)
> -        # And update our last updated time.
> -        self.last_update = time.time()
> -
> -        pkt = self.factory.parse(buffer)
> -        log.debug("TftpContextServer.start() - factory returned a %s", pkt)
> -
> -        # Call handle once with the initial packet. This should put us into
> -        # the download or the upload state.
> -        self.state = self.state.handle(pkt,
> -                                       self.host,
> -                                       self.port)
> -
> -    def end(self):
> -        """Finish up the context."""
> -        TftpContext.end(self)
> -        self.metrics.end_time = time.time()
> -        log.debug("Set metrics.end_time to %s", self.metrics.end_time)
> -        self.metrics.compute()
> -
> -class TftpContextClientUpload(TftpContext):
> -    """The upload context for the client during an upload.
> -    Note: If input is a hyphen, then we will use stdin."""
> -    def __init__(self,
> -                 host,
> -                 port,
> -                 filename,
> -                 input,
> -                 options,
> -                 packethook,
> -                 timeout,
> -                 localip = ""):
> -        TftpContext.__init__(self,
> -                             host,
> -                             port,
> -                             timeout,
> -                             localip)
> -        self.file_to_transfer = filename
> -        self.options = options
> -        self.packethook = packethook
> -        # If the input object has a read() function,
> -        # assume it is file-like.
> -        if hasattr(input, 'read'):
> -            self.fileobj = input
> -        elif input == '-':
> -            self.fileobj = sys.stdin
> -        else:
> -            self.fileobj = open(input, "rb")
> -
> -        log.debug("TftpContextClientUpload.__init__()")
> -        log.debug("file_to_transfer = %s, options = %s" %
> -            (self.file_to_transfer, self.options))
> -
> -    def __str__(self):
> -        return "%s:%s %s" % (self.host, self.port, self.state)
> -
> -    def start(self):
> -        log.info("Sending tftp upload request to %s" % self.host)
> -        log.info("    filename -> %s" % self.file_to_transfer)
> -        log.info("    options -> %s" % self.options)
> -
> -        self.metrics.start_time = time.time()
> -        log.debug("Set metrics.start_time to %s" % self.metrics.start_time)
> -
> -        # FIXME: put this in a sendWRQ method?
> -        pkt = TftpPacketWRQ()
> -        pkt.filename = self.file_to_transfer
> -        pkt.mode = "octet" # FIXME - shouldn't hardcode this
> -        pkt.options = self.options
> -        self.sock.sendto(pkt.encode().buffer, (self.host, self.port))
> -        self.next_block = 1
> -        self.last_pkt = pkt
> -        # FIXME: should we centralize sendto operations so we can refactor all
> -        # saving of the packet to the last_pkt field?
> -
> -        self.state = TftpStateSentWRQ(self)
> -
> -        while self.state:
> -            try:
> -                log.debug("State is %s" % self.state)
> -                self.cycle()
> -            except TftpTimeout as err:
> -                log.error(str(err))
> -                self.retry_count += 1
> -                if self.retry_count >= TIMEOUT_RETRIES:
> -                    log.debug("hit max retries, giving up")
> -                    raise
> -                else:
> -                    log.warning("resending last packet")
> -                    self.state.resendLast()
> -
> -    def end(self):
> -        """Finish up the context."""
> -        TftpContext.end(self)
> -        self.metrics.end_time = time.time()
> -        log.debug("Set metrics.end_time to %s" % self.metrics.end_time)
> -        self.metrics.compute()
> -
> -
> -class TftpContextClientDownload(TftpContext):
> -    """The download context for the client during a download.
> -    Note: If output is a hyphen, then the output will be sent to stdout."""
> -    def __init__(self,
> -                 host,
> -                 port,
> -                 filename,
> -                 output,
> -                 options,
> -                 packethook,
> -                 timeout,
> -                 localip = ""):
> -        TftpContext.__init__(self,
> -                             host,
> -                             port,
> -                             timeout,
> -                             localip)
> -        # FIXME: should we refactor setting of these params?
> -        self.file_to_transfer = filename
> -        self.options = options
> -        self.packethook = packethook
> -        self.filelike_fileobj = False
> -        # If the output object has a write() function,
> -        # assume it is file-like.
> -        if hasattr(output, 'write'):
> -            self.fileobj = output
> -            self.filelike_fileobj = True
> -        # If the output filename is -, then use stdout
> -        elif output == '-':
> -            self.fileobj = sys.stdout
> -            self.filelike_fileobj = True
> -        else:
> -            self.fileobj = open(output, "wb")
> -
> -        log.debug("TftpContextClientDownload.__init__()")
> -        log.debug("file_to_transfer = %s, options = %s" %
> -            (self.file_to_transfer, self.options))
> -
> -    def __str__(self):
> -        return "%s:%s %s" % (self.host, self.port, self.state)
> -
> -    def start(self):
> -        """Initiate the download."""
> -        log.info("Sending tftp download request to %s" % self.host)
> -        log.info("    filename -> %s" % self.file_to_transfer)
> -        log.info("    options -> %s" % self.options)
> -
> -        self.metrics.start_time = time.time()
> -        log.debug("Set metrics.start_time to %s" % self.metrics.start_time)
> -
> -        # FIXME: put this in a sendRRQ method?
> -        pkt = TftpPacketRRQ()
> -        pkt.filename = self.file_to_transfer
> -        pkt.mode = "octet" # FIXME - shouldn't hardcode this
> -        pkt.options = self.options
> -        self.sock.sendto(pkt.encode().buffer, (self.host, self.port))
> -        self.next_block = 1
> -        self.last_pkt = pkt
> -
> -        self.state = TftpStateSentRRQ(self)
> -
> -        while self.state:
> -            try:
> -                log.debug("State is %s" % self.state)
> -                self.cycle()
> -            except TftpTimeout as err:
> -                log.error(str(err))
> -                self.retry_count += 1
> -                if self.retry_count >= TIMEOUT_RETRIES:
> -                    log.debug("hit max retries, giving up")
> -                    raise
> -                else:
> -                    log.warning("resending last packet")
> -                    self.state.resendLast()
> -            except TftpFileNotFoundError as err:
> -                # If we received file not found, then we should not save the open
> -                # output file or we'll be left with a size zero file. Delete it,
> -                # if it exists.
> -                log.error("Received File not found error")
> -                if self.fileobj is not None and not self.filelike_fileobj:
> -                    if os.path.exists(self.fileobj.name):
> -                        log.debug("unlinking output file of %s", self.fileobj.name)
> -                        os.unlink(self.fileobj.name)
> -
> -                raise
> -
> -    def end(self):
> -        """Finish up the context."""
> -        TftpContext.end(self, not self.filelike_fileobj)
> -        self.metrics.end_time = time.time()
> -        log.debug("Set metrics.end_time to %s" % self.metrics.end_time)
> -        self.metrics.compute()
> diff --git a/tester/rt/tftpy/TftpPacketFactory.py b/tester/rt/tftpy/TftpPacketFactory.py
> deleted file mode 100644
> index 41f39a9..0000000
> --- a/tester/rt/tftpy/TftpPacketFactory.py
> +++ /dev/null
> @@ -1,47 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements the TftpPacketFactory class, which can take a binary
> -buffer, and return the appropriate TftpPacket object to represent it, via the
> -parse() method."""
> -
> -
> -from .TftpShared import *
> -from .TftpPacketTypes import *
> -import logging
> -
> -log = logging.getLogger('tftpy.TftpPacketFactory')
> -
> -class TftpPacketFactory(object):
> -    """This class generates TftpPacket objects. It is responsible for parsing
> -    raw buffers off of the wire and returning objects representing them, via
> -    the parse() method."""
> -    def __init__(self):
> -        self.classes = {
> -            1: TftpPacketRRQ,
> -            2: TftpPacketWRQ,
> -            3: TftpPacketDAT,
> -            4: TftpPacketACK,
> -            5: TftpPacketERR,
> -            6: TftpPacketOACK
> -            }
> -
> -    def parse(self, buffer):
> -        """This method is used to parse an existing datagram into its
> -        corresponding TftpPacket object. The buffer is the raw bytes off of
> -        the network."""
> -        log.debug("parsing a %d byte packet" % len(buffer))
> -        (opcode,) = struct.unpack(str("!H"), buffer[:2])
> -        log.debug("opcode is %d" % opcode)
> -        packet = self.__create(opcode)
> -        packet.buffer = buffer
> -        return packet.decode()
> -
> -    def __create(self, opcode):
> -        """This method returns the appropriate class object corresponding to
> -        the passed opcode."""
> -        tftpassert(opcode in self.classes,
> -                   "Unsupported opcode: %d" % opcode)
> -
> -        packet = self.classes[opcode]()
> -
> -        return packet
> diff --git a/tester/rt/tftpy/TftpPacketTypes.py b/tester/rt/tftpy/TftpPacketTypes.py
> deleted file mode 100644
> index 3d3bdf8..0000000
> --- a/tester/rt/tftpy/TftpPacketTypes.py
> +++ /dev/null
> @@ -1,494 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements the packet types of TFTP itself, and the
> -corresponding encode and decode methods for them."""
> -
> -
> -import struct
> -import sys
> -import logging
> -from .TftpShared import *
> -
> -log = logging.getLogger('tftpy.TftpPacketTypes')
> -
> -class TftpSession(object):
> -    """This class is the base class for the tftp client and server. Any shared
> -    code should be in this class."""
> -    # FIXME: do we need this anymore?
> -    pass
> -
> -class TftpPacketWithOptions(object):
> -    """This class exists to permit some TftpPacket subclasses to share code
> -    regarding options handling. It does not inherit from TftpPacket, as the
> -    goal is just to share code here, and not cause diamond inheritance."""
> -
> -    def __init__(self):
> -        self.options = {}
> -
> -    # Always use unicode strings, except at the encode/decode barrier.
> -    # Simpler to keep things clear.
> -    def setoptions(self, options):
> -        log.debug("in TftpPacketWithOptions.setoptions")
> -        log.debug("options: %s", options)
> -        myoptions = {}
> -        for key in options:
> -            newkey = key
> -            if isinstance(key, bytes):
> -                newkey = newkey.decode('ascii')
> -            newval = options[key]
> -            if isinstance(newval, bytes):
> -                newval = newval.decode('ascii')
> -            myoptions[newkey] = newval
> -            log.debug("populated myoptions with %s = %s", newkey, myoptions[newkey])
> -
> -        log.debug("setting options hash to: %s", myoptions)
> -        self._options = myoptions
> -
> -    def getoptions(self):
> -        log.debug("in TftpPacketWithOptions.getoptions")
> -        return self._options
> -
> -    # Set up getter and setter on options to ensure that they are the proper
> -    # type. They should always be strings, but we don't need to force the
> -    # client to necessarily enter strings if we can avoid it.
> -    options = property(getoptions, setoptions)
> -
> -    def decode_options(self, buffer):
> -        """This method decodes the section of the buffer that contains an
> -        unknown number of options. It returns a dictionary of option names and
> -        values."""
> -        fmt = b"!"
> -        options = {}
> -
> -        log.debug("decode_options: buffer is: %s", repr(buffer))
> -        log.debug("size of buffer is %d bytes", len(buffer))
> -        if len(buffer) == 0:
> -            log.debug("size of buffer is zero, returning empty hash")
> -            return {}
> -
> -        # Count the nulls in the buffer. Each one terminates a string.
> -        log.debug("about to iterate options buffer counting nulls")
> -        length = 0
> -        for i in range(len(buffer)):
> -            if ord(buffer[i:i+1]) == 0:
> -                log.debug("found a null at length %d", length)
> -                if length > 0:
> -                    fmt += b"%dsx" % length
> -                    length = -1
> -                else:
> -                    raise TftpException("Invalid options in buffer")
> -            length += 1
> -
> -        log.debug("about to unpack, fmt is: %s", fmt)
> -        mystruct = struct.unpack(fmt, buffer)
> -
> -        tftpassert(len(mystruct) % 2 == 0,
> -                   "packet with odd number of option/value pairs")
> -
> -        for i in range(0, len(mystruct), 2):
> -            key = mystruct[i].decode('ascii')
> -            val = mystruct[i+1].decode('ascii')
> -            log.debug("setting option %s to %s", key, val)
> -            log.debug("types are %s and %s", type(key), type(val))
> -            options[key] = val
> -
> -        return options
> -
> -class TftpPacket(object):
> -    """This class is the parent class of all tftp packet classes. It is an
> -    abstract class, providing an interface, and should not be instantiated
> -    directly."""
> -    def __init__(self):
> -        self.opcode = 0
> -        self.buffer = None
> -
> -    def encode(self):
> -        """The encode method of a TftpPacket takes keyword arguments specific
> -        to the type of packet, and packs an appropriate buffer in network-byte
> -        order suitable for sending over the wire.
> -
> -        This is an abstract method."""
> -        raise NotImplementedError("Abstract method")
> -
> -    def decode(self):
> -        """The decode method of a TftpPacket takes a buffer off of the wire in
> -        network-byte order, and decodes it, populating internal properties as
> -        appropriate. This can only be done once the first 2-byte opcode has
> -        already been decoded, but the data section does include the entire
> -        datagram.
> -
> -        This is an abstract method."""
> -        raise NotImplementedError("Abstract method")
> -
> -class TftpPacketInitial(TftpPacket, TftpPacketWithOptions):
> -    """This class is a common parent class for the RRQ and WRQ packets, as
> -    they share quite a bit of code."""
> -    def __init__(self):
> -        TftpPacket.__init__(self)
> -        TftpPacketWithOptions.__init__(self)
> -        self.filename = None
> -        self.mode = None
> -
> -    def encode(self):
> -        """Encode the packet's buffer from the instance variables."""
> -        tftpassert(self.filename, "filename required in initial packet")
> -        tftpassert(self.mode, "mode required in initial packet")
> -        # Make sure filename and mode are bytestrings.
> -        filename = self.filename
> -        mode = self.mode
> -        if not isinstance(filename, bytes):
> -            filename = filename.encode('ascii')
> -        if not isinstance(self.mode, bytes):
> -            mode = mode.encode('ascii')
> -
> -        ptype = None
> -        if self.opcode == 1: ptype = "RRQ"
> -        else:                ptype = "WRQ"
> -        log.debug("Encoding %s packet, filename = %s, mode = %s",
> -            ptype, filename, mode)
> -        for key in self.options:
> -            log.debug("    Option %s = %s", key, self.options[key])
> -
> -        fmt = b"!H"
> -        fmt += b"%dsx" % len(filename)
> -        if mode == b"octet":
> -            fmt += b"5sx"
> -        else:
> -            raise AssertionError("Unsupported mode: %s" % mode)
> -        # Add options. Note that the options list must be bytes.
> -        options_list = []
> -        if len(list(self.options.keys())) > 0:
> -            log.debug("there are options to encode")
> -            for key in self.options:
> -                # Populate the option name
> -                name = key
> -                if not isinstance(name, bytes):
> -                    name = name.encode('ascii')
> -                options_list.append(name)
> -                fmt += b"%dsx" % len(name)
> -                # Populate the option value
> -                value = self.options[key]
> -                # Work with all strings.
> -                if isinstance(value, int):
> -                    value = str(value)
> -                if not isinstance(value, bytes):
> -                    value = value.encode('ascii')
> -                options_list.append(value)
> -                fmt += b"%dsx" % len(value)
> -
> -        log.debug("fmt is %s", fmt)
> -        log.debug("options_list is %s", options_list)
> -        log.debug("size of struct is %d", struct.calcsize(fmt))
> -
> -        self.buffer = struct.pack(fmt,
> -                                  self.opcode,
> -                                  filename,
> -                                  mode,
> -                                  *options_list)
> -
> -        log.debug("buffer is %s", repr(self.buffer))
> -        return self
> -
> -    def decode(self):
> -        tftpassert(self.buffer, "Can't decode, buffer is empty")
> -
> -        # FIXME - this shares a lot of code with decode_options
> -        nulls = 0
> -        fmt = b""
> -        nulls = length = tlength = 0
> -        log.debug("in decode: about to iterate buffer counting nulls")
> -        subbuf = self.buffer[2:]
> -        for i in range(len(subbuf)):
> -            if ord(subbuf[i:i+1]) == 0:
> -                nulls += 1
> -                log.debug("found a null at length %d, now have %d", length, nulls)
> -                fmt += b"%dsx" % length
> -                length = -1
> -                # At 2 nulls, we want to mark that position for decoding.
> -                if nulls == 2:
> -                    break
> -            length += 1
> -            tlength += 1
> -
> -        log.debug("hopefully found end of mode at length %d", tlength)
> -        # length should now be the end of the mode.
> -        tftpassert(nulls == 2, "malformed packet")
> -        shortbuf = subbuf[:tlength+1]
> -        log.debug("about to unpack buffer with fmt: %s", fmt)
> -        log.debug("unpacking buffer: %s", repr(shortbuf))
> -        mystruct = struct.unpack(fmt, shortbuf)
> -
> -        tftpassert(len(mystruct) == 2, "malformed packet")
> -        self.filename = mystruct[0].decode('ascii')
> -        self.mode = mystruct[1].decode('ascii').lower() # force lc - bug 17
> -        log.debug("set filename to %s", self.filename)
> -        log.debug("set mode to %s", self.mode)
> -
> -        self.options = self.decode_options(subbuf[tlength+1:])
> -        log.debug("options dict is now %s", self.options)
> -        return self
> -
> -class TftpPacketRRQ(TftpPacketInitial):
> -    """
> -::
> -
> -            2 bytes    string   1 byte     string   1 byte
> -            -----------------------------------------------
> -    RRQ/  | 01/02 |  Filename  |   0  |    Mode    |   0  |
> -    WRQ     -----------------------------------------------
> -    """
> -    def __init__(self):
> -        TftpPacketInitial.__init__(self)
> -        self.opcode = 1
> -
> -    def __str__(self):
> -        s = 'RRQ packet: filename = %s' % self.filename
> -        s += ' mode = %s' % self.mode
> -        if self.options:
> -            s += '\n    options = %s' % self.options
> -        return s
> -
> -class TftpPacketWRQ(TftpPacketInitial):
> -    """
> -::
> -
> -            2 bytes    string   1 byte     string   1 byte
> -            -----------------------------------------------
> -    RRQ/  | 01/02 |  Filename  |   0  |    Mode    |   0  |
> -    WRQ     -----------------------------------------------
> -    """
> -    def __init__(self):
> -        TftpPacketInitial.__init__(self)
> -        self.opcode = 2
> -
> -    def __str__(self):
> -        s = 'WRQ packet: filename = %s' % self.filename
> -        s += ' mode = %s' % self.mode
> -        if self.options:
> -            s += '\n    options = %s' % self.options
> -        return s
> -
> -class TftpPacketDAT(TftpPacket):
> -    """
> -::
> -
> -            2 bytes    2 bytes       n bytes
> -            ---------------------------------
> -    DATA  | 03    |   Block #  |    Data    |
> -            ---------------------------------
> -    """
> -    def __init__(self):
> -        TftpPacket.__init__(self)
> -        self.opcode = 3
> -        self.blocknumber = 0
> -        self.data = None
> -
> -    def __str__(self):
> -        s = 'DAT packet: block %s' % self.blocknumber
> -        if self.data:
> -            s += '\n    data: %d bytes' % len(self.data)
> -        return s
> -
> -    def encode(self):
> -        """Encode the DAT packet. This method populates self.buffer, and
> -        returns self for easy method chaining."""
> -        if len(self.data) == 0:
> -            log.debug("Encoding an empty DAT packet")
> -        data = self.data
> -        if not isinstance(self.data, bytes):
> -            data = self.data.encode('ascii')
> -        fmt = b"!HH%ds" % len(data)
> -        self.buffer = struct.pack(fmt,
> -                                  self.opcode,
> -                                  self.blocknumber,
> -                                  data)
> -        return self
> -
> -    def decode(self):
> -        """Decode self.buffer into instance variables. It returns self for
> -        easy method chaining."""
> -        # We know the first 2 bytes are the opcode. The second two are the
> -        # block number.
> -        (self.blocknumber,) = struct.unpack(str("!H"), self.buffer[2:4])
> -        log.debug("decoding DAT packet, block number %d", self.blocknumber)
> -        log.debug("should be %d bytes in the packet total", len(self.buffer))
> -        # Everything else is data.
> -        self.data = self.buffer[4:]
> -        log.debug("found %d bytes of data", len(self.data))
> -        return self
> -
> -class TftpPacketACK(TftpPacket):
> -    """
> -::
> -
> -            2 bytes    2 bytes
> -            -------------------
> -    ACK   | 04    |   Block #  |
> -            --------------------
> -    """
> -    def __init__(self):
> -        TftpPacket.__init__(self)
> -        self.opcode = 4
> -        self.blocknumber = 0
> -
> -    def __str__(self):
> -        return 'ACK packet: block %d' % self.blocknumber
> -
> -    def encode(self):
> -        log.debug("encoding ACK: opcode = %d, block = %d",
> -            self.opcode, self.blocknumber)
> -        self.buffer = struct.pack(str("!HH"), self.opcode, self.blocknumber)
> -        return self
> -
> -    def decode(self):
> -        if len(self.buffer) > 4:
> -            log.debug("detected TFTP ACK but request is too large, will truncate")
> -            log.debug("buffer was: %s", repr(self.buffer))
> -            self.buffer = self.buffer[0:4]
> -        self.opcode, self.blocknumber = struct.unpack(str("!HH"), self.buffer)
> -        log.debug("decoded ACK packet: opcode = %d, block = %d",
> -            self.opcode, self.blocknumber)
> -        return self
> -
> -class TftpPacketERR(TftpPacket):
> -    """
> -::
> -
> -            2 bytes  2 bytes        string    1 byte
> -            ----------------------------------------
> -    ERROR | 05    |  ErrorCode |   ErrMsg   |   0  |
> -            ----------------------------------------
> -
> -    Error Codes
> -
> -    Value     Meaning
> -
> -    0         Not defined, see error message (if any).
> -    1         File not found.
> -    2         Access violation.
> -    3         Disk full or allocation exceeded.
> -    4         Illegal TFTP operation.
> -    5         Unknown transfer ID.
> -    6         File already exists.
> -    7         No such user.
> -    8         Failed to negotiate options
> -    """
> -    def __init__(self):
> -        TftpPacket.__init__(self)
> -        self.opcode = 5
> -        self.errorcode = 0
> -        # FIXME: We don't encode the errmsg...
> -        self.errmsg = None
> -        # FIXME - integrate in TftpErrors references?
> -        self.errmsgs = {
> -            1: b"File not found",
> -            2: b"Access violation",
> -            3: b"Disk full or allocation exceeded",
> -            4: b"Illegal TFTP operation",
> -            5: b"Unknown transfer ID",
> -            6: b"File already exists",
> -            7: b"No such user",
> -            8: b"Failed to negotiate options"
> -            }
> -
> -    def __str__(self):
> -        s = 'ERR packet: errorcode = %d' % self.errorcode
> -        s += '\n    msg = %s' % self.errmsgs.get(self.errorcode, '')
> -        return s
> -
> -    def encode(self):
> -        """Encode the DAT packet based on instance variables, populating
> -        self.buffer, returning self."""
> -        fmt = b"!HH%dsx" % len(self.errmsgs[self.errorcode])
> -        log.debug("encoding ERR packet with fmt %s", fmt)
> -        self.buffer = struct.pack(fmt,
> -                                  self.opcode,
> -                                  self.errorcode,
> -                                  self.errmsgs[self.errorcode])
> -        return self
> -
> -    def decode(self):
> -        "Decode self.buffer, populating instance variables and return self."
> -        buflen = len(self.buffer)
> -        tftpassert(buflen >= 4, "malformed ERR packet, too short")
> -        log.debug("Decoding ERR packet, length %s bytes", buflen)
> -        if buflen == 4:
> -            log.debug("Allowing this affront to the RFC of a 4-byte packet")
> -            fmt = b"!HH"
> -            log.debug("Decoding ERR packet with fmt: %s", fmt)
> -            self.opcode, self.errorcode = struct.unpack(fmt,
> -                                                        self.buffer)
> -        else:
> -            log.debug("Good ERR packet > 4 bytes")
> -            fmt = b"!HH%dsx" % (len(self.buffer) - 5)
> -            log.debug("Decoding ERR packet with fmt: %s", fmt)
> -            self.opcode, self.errorcode, self.errmsg = struct.unpack(fmt,
> -                                                                     self.buffer)
> -        log.error("ERR packet - errorcode: %d, message: %s"
> -                     % (self.errorcode, self.errmsg))
> -        return self
> -
> -class TftpPacketOACK(TftpPacket, TftpPacketWithOptions):
> -    """
> -::
> -
> -    +-------+---~~---+---+---~~---+---+---~~---+---+---~~---+---+
> -    |  opc  |  opt1  | 0 | value1 | 0 |  optN  | 0 | valueN | 0 |
> -    +-------+---~~---+---+---~~---+---+---~~---+---+---~~---+---+
> -    """
> -    def __init__(self):
> -        TftpPacket.__init__(self)
> -        TftpPacketWithOptions.__init__(self)
> -        self.opcode = 6
> -
> -    def __str__(self):
> -        return 'OACK packet:\n    options = %s' % self.options
> -
> -    def encode(self):
> -        fmt = b"!H" # opcode
> -        options_list = []
> -        log.debug("in TftpPacketOACK.encode")
> -        for key in self.options:
> -            value = self.options[key]
> -            if isinstance(value, int):
> -                value = str(value)
> -            if not isinstance(key, bytes):
> -                key = key.encode('ascii')
> -            if not isinstance(value, bytes):
> -                value = value.encode('ascii')
> -            log.debug("looping on option key %s", key)
> -            log.debug("value is %s", value)
> -            fmt += b"%dsx" % len(key)
> -            fmt += b"%dsx" % len(value)
> -            options_list.append(key)
> -            options_list.append(value)
> -        self.buffer = struct.pack(fmt, self.opcode, *options_list)
> -        return self
> -
> -    def decode(self):
> -        self.options = self.decode_options(self.buffer[2:])
> -        return self
> -
> -    def match_options(self, options):
> -        """This method takes a set of options, and tries to match them with
> -        its own. It can accept some changes in those options from the server as
> -        part of a negotiation. Changed or unchanged, it will return a dict of
> -        the options so that the session can update itself to the negotiated
> -        options."""
> -        for name in self.options:
> -            if name in options:
> -                if name == 'blksize':
> -                    # We can accept anything between the min and max values.
> -                    size = int(self.options[name])
> -                    if size >= MIN_BLKSIZE and size <= MAX_BLKSIZE:
> -                        log.debug("negotiated blksize of %d bytes", size)
> -                        options['blksize'] = size
> -                    else:
> -                        raise TftpException("blksize %s option outside allowed range" % size)
> -                elif name == 'tsize':
> -                    size = int(self.options[name])
> -                    if size < 0:
> -                        raise TftpException("Negative file sizes not supported")
> -                else:
> -                    raise TftpException("Unsupported option: %s" % name)
> -        return True
> diff --git a/tester/rt/tftpy/TftpServer.py b/tester/rt/tftpy/TftpServer.py
> deleted file mode 100644
> index 2789322..0000000
> --- a/tester/rt/tftpy/TftpServer.py
> +++ /dev/null
> @@ -1,271 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements the TFTP Server functionality. Instantiate an
> -instance of the server, and then run the listen() method to listen for client
> -requests. Logging is performed via a standard logging object set in
> -TftpShared."""
> -
> -
> -import socket, os, time
> -import select
> -import threading
> -import logging
> -from errno import EINTR
> -from .TftpShared import *
> -from .TftpPacketTypes import *
> -from .TftpPacketFactory import TftpPacketFactory
> -from .TftpContexts import TftpContextServer
> -
> -log = logging.getLogger('tftpy.TftpServer')
> -
> -class TftpServer(TftpSession):
> -    """This class implements a tftp server object. Run the listen() method to
> -    listen for client requests.
> -
> -    tftproot is the path to the tftproot directory to serve files from and/or
> -    write them to.
> -
> -    dyn_file_func is a callable that takes a requested download
> -    path that is not present on the file system and must return either a
> -    file-like object to read from or None if the path should appear as not
> -    found. This permits the serving of dynamic content.
> -
> -    upload_open is a callable that is triggered on every upload with the
> -    requested destination path and server context. It must either return a
> -    file-like object ready for writing or None if the path is invalid."""
> -
> -    def __init__(self,
> -                 tftproot='/tftpboot',
> -                 dyn_file_func=None,
> -                 upload_open=None):
> -        self.listenip = None
> -        self.listenport = None
> -        self.sock = None
> -        # FIXME: What about multiple roots?
> -        self.root = os.path.abspath(tftproot)
> -        self.dyn_file_func = dyn_file_func
> -        self.upload_open = upload_open
> -        # A dict of sessions, where each session is keyed by a string like
> -        # ip:tid for the remote end.
> -        self.sessions = {}
> -        # A threading event to help threads synchronize with the server
> -        # is_running state.
> -        self.is_running = threading.Event()
> -
> -        self.shutdown_gracefully = False
> -        self.shutdown_immediately = False
> -
> -        for name in 'dyn_file_func', 'upload_open':
> -            attr = getattr(self, name)
> -            if attr and not callable(attr):
> -                raise TftpException("{} supplied, but it is not callable.".format(name))
> -        if os.path.exists(self.root):
> -            log.debug("tftproot %s does exist", self.root)
> -            if not os.path.isdir(self.root):
> -                raise TftpException("The tftproot must be a directory.")
> -            else:
> -                log.debug("tftproot %s is a directory" % self.root)
> -                if os.access(self.root, os.R_OK):
> -                    log.debug("tftproot %s is readable" % self.root)
> -                else:
> -                    raise TftpException("The tftproot must be readable")
> -                if os.access(self.root, os.W_OK):
> -                    log.debug("tftproot %s is writable" % self.root)
> -                else:
> -                    log.warning("The tftproot %s is not writable" % self.root)
> -        else:
> -            raise TftpException("The tftproot does not exist.")
> -
> -    def __del__(self):
> -        if self.sock is not None:
> -            try:
> -                self.sock.close()
> -            except:
> -                pass
> -
> -    def listen(self, listenip="", listenport=DEF_TFTP_PORT,
> -               timeout=SOCK_TIMEOUT):
> -        """Start a server listening on the supplied interface and port. This
> -        defaults to INADDR_ANY (all interfaces) and UDP port 69. You can also
> -        supply a different socket timeout value, if desired."""
> -        tftp_factory = TftpPacketFactory()
> -
> -        # Don't use new 2.5 ternary operator yet
> -        # listenip = listenip if listenip else '0.0.0.0'
> -        if not listenip: listenip = '0.0.0.0'
> -        log.info("Server requested on ip %s, port %s" % (listenip, listenport))
> -        try:
> -            # FIXME - sockets should be non-blocking
> -            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
> -            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
> -            self.sock.bind((listenip, listenport))
> -            _, self.listenport = self.sock.getsockname()
> -        except socket.error as err:
> -            # Reraise it for now.
> -            raise err
> -
> -        self.is_running.set()
> -
> -        log.info("Starting receive loop...")
> -        while True:
> -            log.debug("shutdown_immediately is %s" % self.shutdown_immediately)
> -            log.debug("shutdown_gracefully is %s" % self.shutdown_gracefully)
> -            if self.shutdown_immediately:
> -                log.warning("Shutting down now. Session count: %d" %
> -                         len(self.sessions))
> -                self.sock.close()
> -                for key in self.sessions:
> -                    self.sessions[key].end()
> -                self.sessions = []
> -                break
> -
> -            elif self.shutdown_gracefully:
> -                if not self.sessions:
> -                    log.warning("In graceful shutdown mode and all "
> -                             "sessions complete.")
> -                    self.sock.close()
> -                    break
> -
> -            # Build the inputlist array of sockets to select() on.
> -            inputlist = []
> -            inputlist.append(self.sock)
> -            for key in self.sessions:
> -                inputlist.append(self.sessions[key].sock)
> -
> -            # Block until some socket has input on it.
> -            log.debug("Performing select on this inputlist: %s", inputlist)
> -            try:
> -                readyinput, readyoutput, readyspecial = \
> -                        select.select(inputlist, [], [], SOCK_TIMEOUT)
> -            except select.error as err:
> -                if err[0] == EINTR:
> -                    # Interrupted system call
> -                    log.debug("Interrupted syscall, retrying")
> -                    continue
> -                else:
> -                    raise
> -
> -            deletion_list = []
> -
> -            # Handle the available data, if any. Maybe we timed-out.
> -            for readysock in readyinput:
> -                # Is the traffic on the main server socket? ie. new session?
> -                if readysock == self.sock:
> -                    log.debug("Data ready on our main socket")
> -                    buffer, (raddress, rport) = self.sock.recvfrom(MAX_BLKSIZE)
> -
> -                    log.debug("Read %d bytes", len(buffer))
> -
> -                    if self.shutdown_gracefully:
> -                        log.warning("Discarding data on main port, "
> -                                 "in graceful shutdown mode")
> -                        continue
> -
> -                    # Forge a session key based on the client's IP and port,
> -                    # which should safely work through NAT.
> -                    key = "%s:%s" % (raddress, rport)
> -
> -                    if not key in self.sessions:
> -                        log.debug("Creating new server context for "
> -                                     "session key = %s" % key)
> -                        try:
> -                            self.sessions[key] = TftpContextServer(raddress,
> -                                                                   rport,
> -                                                                   timeout,
> -                                                                   self.root,
> -                                                                   self.dyn_file_func,
> -                                                                   self.upload_open)
> -                            self.sessions[key].start(buffer)
> -                        except TftpException as err:
> -                            deletion_list.append(key)
> -                            log.error("Fatal exception thrown from "
> -                                      "session %s: %s" % (key, str(err)))
> -                        except KeyboardInterrupt:
> -                            pass
> -                        except:
> -                            deletion_list.append(key)
> -                            log.error("Fatal exception thrown from "
> -                                      "session %s: %s" % (key, str(err)))
> -                    else:
> -                        log.warning("received traffic on main socket for "
> -                                 "existing session??")
> -                    log.info("Currently handling these sessions:")
> -                    for session_key, session in list(self.sessions.items()):
> -                        log.info("    %s" % session)
> -                else:
> -                    # Must find the owner of this traffic.
> -                    for key in self.sessions:
> -                        if readysock == self.sessions[key].sock:
> -                            log.debug("Matched input to session key %s"
> -                                % key)
> -                            try:
> -                                self.sessions[key].cycle()
> -                                if self.sessions[key].state == None:
> -                                    log.info("Successful transfer.")
> -                                    deletion_list.append(key)
> -                            except TftpException as err:
> -                                deletion_list.append(key)
> -                                log.error("Fatal exception thrown from "
> -                                          "session %s: %s"
> -                                          % (key, str(err)))
> -                            # Break out of for loop since we found the correct
> -                            # session.
> -                            break
> -                    else:
> -                        log.error("Can't find the owner for this packet. "
> -                                  "Discarding.")
> -
> -            log.debug("Looping on all sessions to check for timeouts")
> -            now = time.time()
> -            for key in self.sessions:
> -                try:
> -                    self.sessions[key].checkTimeout(now)
> -                except TftpTimeout as err:
> -                    log.error(str(err))
> -                    self.sessions[key].retry_count += 1
> -                    if self.sessions[key].retry_count >= TIMEOUT_RETRIES:
> -                        log.debug("hit max retries on %s, giving up" %
> -                            self.sessions[key])
> -                        deletion_list.append(key)
> -                    else:
> -                        log.debug("resending on session %s" % self.sessions[key])
> -                        self.sessions[key].state.resendLast()
> -
> -            log.debug("Iterating deletion list.")
> -            for key in deletion_list:
> -                log.info('')
> -                log.info("Session %s complete" % key)
> -                if key in self.sessions:
> -                    log.debug("Gathering up metrics from session before deleting")
> -                    self.sessions[key].end()
> -                    metrics = self.sessions[key].metrics
> -                    if metrics.duration == 0:
> -                        log.info("Duration too short, rate undetermined")
> -                    else:
> -                        log.info("Transferred %d bytes in %.2f seconds"
> -                            % (metrics.bytes, metrics.duration))
> -                        log.info("Average rate: %.2f kbps" % metrics.kbps)
> -                    log.info("%.2f bytes in resent data" % metrics.resent_bytes)
> -                    log.info("%d duplicate packets" % metrics.dupcount)
> -                    log.debug("Deleting session %s" % key)
> -                    del self.sessions[key]
> -                    log.debug("Session list is now %s" % self.sessions)
> -                else:
> -                    log.warning(
> -                        "Strange, session %s is not on the deletion list" % key)
> -
> -        self.is_running.clear()
> -
> -        log.debug("server returning from while loop")
> -        self.shutdown_gracefully = self.shutdown_immediately = False
> -
> -    def stop(self, now=False):
> -        """Stop the server gracefully. Do not take any new transfers,
> -        but complete the existing ones. If force is True, drop everything
> -        and stop. Note, immediately will not interrupt the select loop, it
> -        will happen when the server returns on ready data, or a timeout.
> -        ie. SOCK_TIMEOUT"""
> -        if now:
> -            self.shutdown_immediately = True
> -        else:
> -            self.shutdown_gracefully = True
> diff --git a/tester/rt/tftpy/TftpShared.py b/tester/rt/tftpy/TftpShared.py
> deleted file mode 100644
> index 88530c3..0000000
> --- a/tester/rt/tftpy/TftpShared.py
> +++ /dev/null
> @@ -1,52 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module holds all objects shared by all other modules in tftpy."""
> -
> -
> -
> -MIN_BLKSIZE = 8
> -DEF_BLKSIZE = 512
> -MAX_BLKSIZE = 65536
> -SOCK_TIMEOUT = 5
> -MAX_DUPS = 20
> -TIMEOUT_RETRIES = 5
> -DEF_TFTP_PORT = 69
> -
> -# A hook for deliberately introducing delay in testing.
> -DELAY_BLOCK = 0
> -
> -def tftpassert(condition, msg):
> -    """This function is a simple utility that will check the condition
> -    passed for a false state. If it finds one, it throws a TftpException
> -    with the message passed. This just makes the code throughout cleaner
> -    by refactoring."""
> -    if not condition:
> -        raise TftpException(msg)
> -
> -class TftpErrors(object):
> -    """This class is a convenience for defining the common tftp error codes,
> -    and making them more readable in the code."""
> -    NotDefined = 0
> -    FileNotFound = 1
> -    AccessViolation = 2
> -    DiskFull = 3
> -    IllegalTftpOp = 4
> -    UnknownTID = 5
> -    FileAlreadyExists = 6
> -    NoSuchUser = 7
> -    FailedNegotiation = 8
> -
> -class TftpException(Exception):
> -    """This class is the parent class of all exceptions regarding the handling
> -    of the TFTP protocol."""
> -    pass
> -
> -class TftpTimeout(TftpException):
> -    """This class represents a timeout error waiting for a response from the
> -    other end."""
> -    pass
> -
> -class TftpFileNotFoundError(TftpException):
> -    """This class represents an error condition where we received a file
> -    not found error."""
> -    pass
> diff --git a/tester/rt/tftpy/TftpStates.py b/tester/rt/tftpy/TftpStates.py
> deleted file mode 100644
> index 42bac1d..0000000
> --- a/tester/rt/tftpy/TftpStates.py
> +++ /dev/null
> @@ -1,611 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""This module implements all state handling during uploads and downloads, the
> -main interface to which being the TftpState base class.
> -
> -The concept is simple. Each context object represents a single upload or
> -download, and the state object in the context object represents the current
> -state of that transfer. The state object has a handle() method that expects
> -the next packet in the transfer, and returns a state object until the transfer
> -is complete, at which point it returns None. That is, unless there is a fatal
> -error, in which case a TftpException is returned instead."""
> -
> -
> -from .TftpShared import *
> -from .TftpPacketTypes import *
> -import os
> -import logging
> -
> -log = logging.getLogger('tftpy.TftpStates')
> -
> -###############################################################################
> -# State classes
> -###############################################################################
> -
> -class TftpState(object):
> -    """The base class for the states."""
> -
> -    def __init__(self, context):
> -        """Constructor for setting up common instance variables. The involved
> -        file object is required, since in tftp there's always a file
> -        involved."""
> -        self.context = context
> -
> -    def handle(self, pkt, raddress, rport):
> -        """An abstract method for handling a packet. It is expected to return
> -        a TftpState object, either itself or a new state."""
> -        raise NotImplementedError("Abstract method")
> -
> -    def handleOACK(self, pkt):
> -        """This method handles an OACK from the server, syncing any accepted
> -        options."""
> -        if len(pkt.options.keys()) > 0:
> -            if pkt.match_options(self.context.options):
> -                log.info("Successful negotiation of options")
> -                # Set options to OACK options
> -                self.context.options = pkt.options
> -                for key in self.context.options:
> -                    log.info("    %s = %s" % (key, self.context.options[key]))
> -            else:
> -                log.error("Failed to negotiate options")
> -                raise TftpException("Failed to negotiate options")
> -        else:
> -            raise TftpException("No options found in OACK")
> -
> -    def returnSupportedOptions(self, options):
> -        """This method takes a requested options list from a client, and
> -        returns the ones that are supported."""
> -        # We support the options blksize and tsize right now.
> -        # FIXME - put this somewhere else?
> -        accepted_options = {}
> -        for option in options:
> -            if option == 'blksize':
> -                # Make sure it's valid.
> -                if int(options[option]) > MAX_BLKSIZE:
> -                    log.info("Client requested blksize greater than %d "
> -                             "setting to maximum" % MAX_BLKSIZE)
> -                    accepted_options[option] = MAX_BLKSIZE
> -                elif int(options[option]) < MIN_BLKSIZE:
> -                    log.info("Client requested blksize less than %d "
> -                             "setting to minimum" % MIN_BLKSIZE)
> -                    accepted_options[option] = MIN_BLKSIZE
> -                else:
> -                    accepted_options[option] = options[option]
> -            elif option == 'tsize':
> -                log.debug("tsize option is set")
> -                accepted_options['tsize'] = 0
> -            else:
> -                log.info("Dropping unsupported option '%s'" % option)
> -        log.debug("Returning these accepted options: %s", accepted_options)
> -        return accepted_options
> -
> -    def sendDAT(self):
> -        """This method sends the next DAT packet based on the data in the
> -        context. It returns a boolean indicating whether the transfer is
> -        finished."""
> -        finished = False
> -        blocknumber = self.context.next_block
> -        # Test hook
> -        if DELAY_BLOCK and DELAY_BLOCK == blocknumber:
> -            import time
> -            log.debug("Deliberately delaying 10 seconds...")
> -            time.sleep(10)
> -        dat = None
> -        blksize = self.context.getBlocksize()
> -        buffer = self.context.fileobj.read(blksize)
> -        log.debug("Read %d bytes into buffer", len(buffer))
> -        if len(buffer) < blksize:
> -            log.info("Reached EOF on file %s"
> -                % self.context.file_to_transfer)
> -            finished = True
> -        dat = TftpPacketDAT()
> -        dat.data = buffer
> -        dat.blocknumber = blocknumber
> -        self.context.metrics.bytes += len(dat.data)
> -        log.debug("Sending DAT packet %d", dat.blocknumber)
> -        self.context.sock.sendto(dat.encode().buffer,
> -                                 (self.context.host, self.context.tidport))
> -        if self.context.packethook:
> -            self.context.packethook(dat)
> -        self.context.last_pkt = dat
> -        return finished
> -
> -    def sendACK(self, blocknumber=None):
> -        """This method sends an ack packet to the block number specified. If
> -        none is specified, it defaults to the next_block property in the
> -        parent context."""
> -        log.debug("In sendACK, passed blocknumber is %s", blocknumber)
> -        if blocknumber is None:
> -            blocknumber = self.context.next_block
> -        log.info("Sending ack to block %d" % blocknumber)
> -        ackpkt = TftpPacketACK()
> -        ackpkt.blocknumber = blocknumber
> -        self.context.sock.sendto(ackpkt.encode().buffer,
> -                                 (self.context.host,
> -                                  self.context.tidport))
> -        self.context.last_pkt = ackpkt
> -
> -    def sendError(self, errorcode):
> -        """This method uses the socket passed, and uses the errorcode to
> -        compose and send an error packet."""
> -        log.debug("In sendError, being asked to send error %d", errorcode)
> -        errpkt = TftpPacketERR()
> -        errpkt.errorcode = errorcode
> -        if self.context.tidport == None:
> -            log.debug("Error packet received outside session. Discarding")
> -        else:
> -            self.context.sock.sendto(errpkt.encode().buffer,
> -                                     (self.context.host,
> -                                      self.context.tidport))
> -        self.context.last_pkt = errpkt
> -
> -    def sendOACK(self):
> -        """This method sends an OACK packet with the options from the current
> -        context."""
> -        log.debug("In sendOACK with options %s", self.context.options)
> -        pkt = TftpPacketOACK()
> -        pkt.options = self.context.options
> -        self.context.sock.sendto(pkt.encode().buffer,
> -                                 (self.context.host,
> -                                  self.context.tidport))
> -        self.context.last_pkt = pkt
> -
> -    def resendLast(self):
> -        "Resend the last sent packet due to a timeout."
> -        log.warning("Resending packet %s on sessions %s"
> -            % (self.context.last_pkt, self))
> -        self.context.metrics.resent_bytes += len(self.context.last_pkt.buffer)
> -        self.context.metrics.add_dup(self.context.last_pkt)
> -        sendto_port = self.context.tidport
> -        if not sendto_port:
> -            # If the tidport wasn't set, then the remote end hasn't even
> -            # started talking to us yet. That's not good. Maybe it's not
> -            # there.
> -            sendto_port = self.context.port
> -        self.context.sock.sendto(self.context.last_pkt.encode().buffer,
> -                                 (self.context.host, sendto_port))
> -        if self.context.packethook:
> -            self.context.packethook(self.context.last_pkt)
> -
> -    def handleDat(self, pkt):
> -        """This method handles a DAT packet during a client download, or a
> -        server upload."""
> -        log.info("Handling DAT packet - block %d" % pkt.blocknumber)
> -        log.debug("Expecting block %s", self.context.next_block)
> -        if pkt.blocknumber == self.context.next_block:
> -            log.debug("Good, received block %d in sequence", pkt.blocknumber)
> -
> -            self.sendACK()
> -            self.context.next_block += 1
> -
> -            log.debug("Writing %d bytes to output file", len(pkt.data))
> -            self.context.fileobj.write(pkt.data)
> -            self.context.metrics.bytes += len(pkt.data)
> -            # Check for end-of-file, any less than full data packet.
> -            if len(pkt.data) < self.context.getBlocksize():
> -                log.info("End of file detected")
> -                return None
> -
> -        elif pkt.blocknumber < self.context.next_block:
> -            if pkt.blocknumber == 0:
> -                log.warning("There is no block zero!")
> -                self.sendError(TftpErrors.IllegalTftpOp)
> -                raise TftpException("There is no block zero!")
> -            log.warning("Dropping duplicate block %d" % pkt.blocknumber)
> -            self.context.metrics.add_dup(pkt)
> -            log.debug("ACKing block %d again, just in case", pkt.blocknumber)
> -            self.sendACK(pkt.blocknumber)
> -
> -        else:
> -            # FIXME: should we be more tolerant and just discard instead?
> -            msg = "Whoa! Received future block %d but expected %d" \
> -                % (pkt.blocknumber, self.context.next_block)
> -            log.error(msg)
> -            raise TftpException(msg)
> -
> -        # Default is to ack
> -        return TftpStateExpectDAT(self.context)
> -
> -class TftpServerState(TftpState):
> -    """The base class for server states."""
> -
> -    def __init__(self, context):
> -        TftpState.__init__(self, context)
> -
> -        # This variable is used to store the absolute path to the file being
> -        # managed.
> -        self.full_path = None
> -
> -    def serverInitial(self, pkt, raddress, rport):
> -        """This method performs initial setup for a server context transfer,
> -        put here to refactor code out of the TftpStateServerRecvRRQ and
> -        TftpStateServerRecvWRQ classes, since their initial setup is
> -        identical. The method returns a boolean, sendoack, to indicate whether
> -        it is required to send an OACK to the client."""
> -        options = pkt.options
> -        sendoack = False
> -        if not self.context.tidport:
> -            self.context.tidport = rport
> -            log.info("Setting tidport to %s" % rport)
> -
> -        log.debug("Setting default options, blksize")
> -        self.context.options = { 'blksize': DEF_BLKSIZE }
> -
> -        if options:
> -            log.debug("Options requested: %s", options)
> -            supported_options = self.returnSupportedOptions(options)
> -            self.context.options.update(supported_options)
> -            sendoack = True
> -
> -        # FIXME - only octet mode is supported at this time.
> -        if pkt.mode != 'octet':
> -            #self.sendError(TftpErrors.IllegalTftpOp)
> -            #raise TftpException("Only octet transfers are supported at this time.")
> -            log.warning("Received non-octet mode request. I'll reply with binary data.")
> -
> -        # test host/port of client end
> -        if self.context.host != raddress or self.context.port != rport:
> -            self.sendError(TftpErrors.UnknownTID)
> -            log.error("Expected traffic from %s:%s but received it "
> -                            "from %s:%s instead."
> -                            % (self.context.host,
> -                               self.context.port,
> -                               raddress,
> -                               rport))
> -            # FIXME: increment an error count?
> -            # Return same state, we're still waiting for valid traffic.
> -            return self
> -
> -        log.debug("Requested filename is %s", pkt.filename)
> -
> -        # Build the filename on this server and ensure it is contained
> -        # in the specified root directory.
> -        #
> -        # Filenames that begin with server root are accepted. It's
> -        # assumed the client and server are tightly connected and this
> -        # provides backwards compatibility.
> -        #
> -        # Filenames otherwise are relative to the server root. If they
> -        # begin with a '/' strip it off as otherwise os.path.join will
> -        # treat it as absolute (regardless of whether it is ntpath or
> -        # posixpath module
> -        if pkt.filename.startswith(self.context.root):
> -            full_path = pkt.filename
> -        else:
> -            full_path = os.path.join(self.context.root, pkt.filename.lstrip('/'))
> -
> -        # Use abspath to eliminate any remaining relative elements
> -        # (e.g. '..') and ensure that is still within the server's
> -        # root directory
> -        self.full_path = os.path.abspath(full_path)
> -        log.debug("full_path is %s", full_path)
> -        if self.full_path.startswith(self.context.root):
> -            log.info("requested file is in the server root - good")
> -        else:
> -            log.warning("requested file is not within the server root - bad")
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("bad file path")
> -
> -        self.context.file_to_transfer = pkt.filename
> -
> -        return sendoack
> -
> -
> -class TftpStateServerRecvRRQ(TftpServerState):
> -    """This class represents the state of the TFTP server when it has just
> -    received an RRQ packet."""
> -    def handle(self, pkt, raddress, rport):
> -        "Handle an initial RRQ packet as a server."
> -        log.debug("In TftpStateServerRecvRRQ.handle")
> -        sendoack = self.serverInitial(pkt, raddress, rport)
> -        path = self.full_path
> -        log.info("Opening file %s for reading" % path)
> -        if os.path.exists(path):
> -            # Note: Open in binary mode for win32 portability, since win32
> -            # blows.
> -            self.context.fileobj = open(path, "rb")
> -        elif self.context.dyn_file_func:
> -            log.debug("No such file %s but using dyn_file_func", path)
> -            self.context.fileobj = \
> -                self.context.dyn_file_func(self.context.file_to_transfer, raddress=raddress, rport=rport)
> -
> -            if self.context.fileobj is None:
> -                log.debug("dyn_file_func returned 'None', treating as "
> -                          "FileNotFound")
> -                self.sendError(TftpErrors.FileNotFound)
> -                raise TftpException("File not found: %s" % path)
> -        else:
> -            log.warn("File not found: %s", path)
> -            self.sendError(TftpErrors.FileNotFound)
> -            raise TftpException("File not found: {}".format(path))
> -
> -        # Options negotiation.
> -        if sendoack and 'tsize' in self.context.options:
> -            # getting the file size for the tsize option. As we handle
> -            # file-like objects and not only real files, we use this seeking
> -            # method instead of asking the OS
> -            self.context.fileobj.seek(0, os.SEEK_END)
> -            tsize = str(self.context.fileobj.tell())
> -            self.context.fileobj.seek(0, 0)
> -            self.context.options['tsize'] = tsize
> -
> -        if sendoack:
> -            # Note, next_block is 0 here since that's the proper
> -            # acknowledgement to an OACK.
> -            # FIXME: perhaps we do need a TftpStateExpectOACK class...
> -            self.sendOACK()
> -            # Note, self.context.next_block is already 0.
> -        else:
> -            self.context.next_block = 1
> -            log.debug("No requested options, starting send...")
> -            self.context.pending_complete = self.sendDAT()
> -        # Note, we expect an ack regardless of whether we sent a DAT or an
> -        # OACK.
> -        return TftpStateExpectACK(self.context)
> -
> -        # Note, we don't have to check any other states in this method, that's
> -        # up to the caller.
> -
> -class TftpStateServerRecvWRQ(TftpServerState):
> -    """This class represents the state of the TFTP server when it has just
> -    received a WRQ packet."""
> -    def make_subdirs(self):
> -        """The purpose of this method is to, if necessary, create all of the
> -        subdirectories leading up to the file to the written."""
> -        # Pull off everything below the root.
> -        subpath = self.full_path[len(self.context.root):]
> -        log.debug("make_subdirs: subpath is %s", subpath)
> -        # Split on directory separators, but drop the last one, as it should
> -        # be the filename.
> -        dirs = subpath.split(os.sep)[:-1]
> -        log.debug("dirs is %s", dirs)
> -        current = self.context.root
> -        for dir in dirs:
> -            if dir:
> -                current = os.path.join(current, dir)
> -                if os.path.isdir(current):
> -                    log.debug("%s is already an existing directory", current)
> -                else:
> -                    os.mkdir(current, 0o700)
> -
> -    def handle(self, pkt, raddress, rport):
> -        "Handle an initial WRQ packet as a server."
> -        log.debug("In TftpStateServerRecvWRQ.handle")
> -        sendoack = self.serverInitial(pkt, raddress, rport)
> -        path = self.full_path
> -        if self.context.upload_open:
> -            f = self.context.upload_open(path, self.context)
> -            if f is None:
> -                self.sendError(TftpErrors.AccessViolation)
> -                raise TftpException("Dynamic path %s not permitted" % path)
> -            else:
> -                self.context.fileobj = f
> -        else:
> -            log.info("Opening file %s for writing" % path)
> -            if os.path.exists(path):
> -                # FIXME: correct behavior?
> -                log.warning("File %s exists already, overwriting..." % (
> -                    self.context.file_to_transfer))
> -            # FIXME: I think we should upload to a temp file and not overwrite
> -            # the existing file until the file is successfully uploaded.
> -            self.make_subdirs()
> -            self.context.fileobj = open(path, "wb")
> -
> -        # Options negotiation.
> -        if sendoack:
> -            log.debug("Sending OACK to client")
> -            self.sendOACK()
> -        else:
> -            log.debug("No requested options, expecting transfer to begin...")
> -            self.sendACK()
> -        # Whether we're sending an oack or not, we're expecting a DAT for
> -        # block 1
> -        self.context.next_block = 1
> -        # We may have sent an OACK, but we're expecting a DAT as the response
> -        # to either the OACK or an ACK, so lets unconditionally use the
> -        # TftpStateExpectDAT state.
> -        return TftpStateExpectDAT(self.context)
> -
> -        # Note, we don't have to check any other states in this method, that's
> -        # up to the caller.
> -
> -class TftpStateServerStart(TftpState):
> -    """The start state for the server. This is a transitory state since at
> -    this point we don't know if we're handling an upload or a download. We
> -    will commit to one of them once we interpret the initial packet."""
> -    def handle(self, pkt, raddress, rport):
> -        """Handle a packet we just received."""
> -        log.debug("In TftpStateServerStart.handle")
> -        if isinstance(pkt, TftpPacketRRQ):
> -            log.debug("Handling an RRQ packet")
> -            return TftpStateServerRecvRRQ(self.context).handle(pkt,
> -                                                               raddress,
> -                                                               rport)
> -        elif isinstance(pkt, TftpPacketWRQ):
> -            log.debug("Handling a WRQ packet")
> -            return TftpStateServerRecvWRQ(self.context).handle(pkt,
> -                                                               raddress,
> -                                                               rport)
> -        else:
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Invalid packet to begin up/download: %s" % pkt)
> -
> -class TftpStateExpectACK(TftpState):
> -    """This class represents the state of the transfer when a DAT was just
> -    sent, and we are waiting for an ACK from the server. This class is the
> -    same one used by the client during the upload, and the server during the
> -    download."""
> -    def handle(self, pkt, raddress, rport):
> -        "Handle a packet, hopefully an ACK since we just sent a DAT."
> -        if isinstance(pkt, TftpPacketACK):
> -            log.debug("Received ACK for packet %d" % pkt.blocknumber)
> -            # Is this an ack to the one we just sent?
> -            if self.context.next_block == pkt.blocknumber:
> -                if self.context.pending_complete:
> -                    log.info("Received ACK to final DAT, we're done.")
> -                    return None
> -                else:
> -                    log.debug("Good ACK, sending next DAT")
> -                    self.context.next_block += 1
> -                    log.debug("Incremented next_block to %d",
> -                        self.context.next_block)
> -                    self.context.pending_complete = self.sendDAT()
> -
> -            elif pkt.blocknumber < self.context.next_block:
> -                log.warning("Received duplicate ACK for block %d"
> -                    % pkt.blocknumber)
> -                self.context.metrics.add_dup(pkt)
> -
> -            else:
> -                log.warning("Oooh, time warp. Received ACK to packet we "
> -                         "didn't send yet. Discarding.")
> -                self.context.metrics.errors += 1
> -            return self
> -        elif isinstance(pkt, TftpPacketERR):
> -            log.error("Received ERR packet from peer: %s" % str(pkt))
> -            raise TftpException("Received ERR packet from peer: %s" % str(pkt))
> -        else:
> -            log.warning("Discarding unsupported packet: %s" % str(pkt))
> -            return self
> -
> -class TftpStateExpectDAT(TftpState):
> -    """Just sent an ACK packet. Waiting for DAT."""
> -    def handle(self, pkt, raddress, rport):
> -        """Handle the packet in response to an ACK, which should be a DAT."""
> -        if isinstance(pkt, TftpPacketDAT):
> -            return self.handleDat(pkt)
> -
> -        # Every other packet type is a problem.
> -        elif isinstance(pkt, TftpPacketACK):
> -            # Umm, we ACK, you don't.
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received ACK from peer when expecting DAT")
> -
> -        elif isinstance(pkt, TftpPacketWRQ):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received WRQ from peer when expecting DAT")
> -
> -        elif isinstance(pkt, TftpPacketERR):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received ERR from peer: " + str(pkt))
> -
> -        else:
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received unknown packet type from peer: " + str(pkt))
> -
> -class TftpStateSentWRQ(TftpState):
> -    """Just sent an WRQ packet for an upload."""
> -    def handle(self, pkt, raddress, rport):
> -        """Handle a packet we just received."""
> -        if not self.context.tidport:
> -            self.context.tidport = rport
> -            log.debug("Set remote port for session to %s", rport)
> -
> -        # If we're going to successfully transfer the file, then we should see
> -        # either an OACK for accepted options, or an ACK to ignore options.
> -        if isinstance(pkt, TftpPacketOACK):
> -            log.info("Received OACK from server")
> -            try:
> -                self.handleOACK(pkt)
> -            except TftpException:
> -                log.error("Failed to negotiate options")
> -                self.sendError(TftpErrors.FailedNegotiation)
> -                raise
> -            else:
> -                log.debug("Sending first DAT packet")
> -                self.context.pending_complete = self.sendDAT()
> -                log.debug("Changing state to TftpStateExpectACK")
> -                return TftpStateExpectACK(self.context)
> -
> -        elif isinstance(pkt, TftpPacketACK):
> -            log.info("Received ACK from server")
> -            log.debug("Apparently the server ignored our options")
> -            # The block number should be zero.
> -            if pkt.blocknumber == 0:
> -                log.debug("Ack blocknumber is zero as expected")
> -                log.debug("Sending first DAT packet")
> -                self.context.pending_complete = self.sendDAT()
> -                log.debug("Changing state to TftpStateExpectACK")
> -                return TftpStateExpectACK(self.context)
> -            else:
> -                log.warning("Discarding ACK to block %s" % pkt.blocknumber)
> -                log.debug("Still waiting for valid response from server")
> -                return self
> -
> -        elif isinstance(pkt, TftpPacketERR):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received ERR from server: %s" % pkt)
> -
> -        elif isinstance(pkt, TftpPacketRRQ):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received RRQ from server while in upload")
> -
> -        elif isinstance(pkt, TftpPacketDAT):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received DAT from server while in upload")
> -
> -        else:
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received unknown packet type from server: %s" % pkt)
> -
> -        # By default, no state change.
> -        return self
> -
> -class TftpStateSentRRQ(TftpState):
> -    """Just sent an RRQ packet."""
> -    def handle(self, pkt, raddress, rport):
> -        """Handle the packet in response to an RRQ to the server."""
> -        if not self.context.tidport:
> -            self.context.tidport = rport
> -            log.info("Set remote port for session to %s" % rport)
> -
> -        # Now check the packet type and dispatch it properly.
> -        if isinstance(pkt, TftpPacketOACK):
> -            log.info("Received OACK from server")
> -            try:
> -                self.handleOACK(pkt)
> -            except TftpException as err:
> -                log.error("Failed to negotiate options: %s" % str(err))
> -                self.sendError(TftpErrors.FailedNegotiation)
> -                raise
> -            else:
> -                log.debug("Sending ACK to OACK")
> -
> -                self.sendACK(blocknumber=0)
> -
> -                log.debug("Changing state to TftpStateExpectDAT")
> -                return TftpStateExpectDAT(self.context)
> -
> -        elif isinstance(pkt, TftpPacketDAT):
> -            # If there are any options set, then the server didn't honour any
> -            # of them.
> -            log.info("Received DAT from server")
> -            if self.context.options:
> -                log.info("Server ignored options, falling back to defaults")
> -                self.context.options = { 'blksize': DEF_BLKSIZE }
> -            return self.handleDat(pkt)
> -
> -        # Every other packet type is a problem.
> -        elif isinstance(pkt, TftpPacketACK):
> -            # Umm, we ACK, the server doesn't.
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received ACK from server while in download")
> -
> -        elif isinstance(pkt, TftpPacketWRQ):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received WRQ from server while in download")
> -
> -        elif isinstance(pkt, TftpPacketERR):
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            log.debug("Received ERR packet: %s", pkt)
> -            if pkt.errorcode == TftpErrors.FileNotFound:
> -                raise TftpFileNotFoundError("File not found")
> -            else:
> -                raise TftpException("Received ERR from server: {}".format(pkt))
> -
> -        else:
> -            self.sendError(TftpErrors.IllegalTftpOp)
> -            raise TftpException("Received unknown packet type from server: %s" % pkt)
> -
> -        # By default, no state change.
> -        return self
> diff --git a/tester/rt/tftpy/__init__.py b/tester/rt/tftpy/__init__.py
> deleted file mode 100644
> index 71b8e3d..0000000
> --- a/tester/rt/tftpy/__init__.py
> +++ /dev/null
> @@ -1,27 +0,0 @@
> -# vim: ts=4 sw=4 et ai:
> -# -*- coding: utf8 -*-
> -"""
> -This library implements the tftp protocol, based on rfc 1350.
> -http://www.faqs.org/rfcs/rfc1350.html
> -At the moment it implements only a client class, but will include a server,
> -with support for variable block sizes.
> -
> -As a client of tftpy, this is the only module that you should need to import
> -directly. The TftpClient and TftpServer classes can be reached through it.
> -"""
> -
> -
> -import sys
> -
> -# Make sure that this is at least Python 2.7
> -required_version = (2, 7)
> -if sys.version_info < required_version:
> -    raise ImportError("Requires at least Python 2.7")
> -
> -from .TftpShared import *
> -from . import TftpPacketTypes
> -from . import TftpPacketFactory
> -from .TftpClient import TftpClient
> -from .TftpServer import TftpServer
> -from . import TftpContexts
> -from . import TftpStates
> diff --git a/tester/rtems-tftp-server b/tester/rtems-tftp-server
> new file mode 100755
> index 0000000..e03f183
> --- /dev/null
> +++ b/tester/rtems-tftp-server
> @@ -0,0 +1,46 @@
> +#! /usr/bin/env python
> +
> +#
> +# RTEMS Tools Project (http://www.rtems.org/)
> +# Copyright 2020 Chris Johns (chrisj at rtems.org)
> +# All rights reserved.
> +#
> +# This file is part of the RTEMS Tools package in 'rtems-tools'.
> +#
> +# Redistribution and use in source and binary forms, with or without
> +# modification, are permitted provided that the following conditions are met:
> +#
> +# 1. Redistributions of source code must retain the above copyright notice,
> +# this list of conditions and the following disclaimer.
> +#
> +# 2. Redistributions in binary form must reproduce the above copyright notice,
> +# this list of conditions and the following disclaimer in the documentation
> +# and/or other materials provided with the distribution.
> +#
> +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
> +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
> +# POSSIBILITY OF SUCH DAMAGE.
> +#
> +
> +from __future__ import print_function
> +
> +import sys, os
> +
> +base = os.path.dirname(os.path.abspath(sys.argv[0]))
> +rtems = os.path.dirname(base)
> +sys.path = [rtems] + sys.path
> +
> +try:
> +    import rt.tftpserver
> +    rt.tftpserver.run(sys.argv)
> +except ImportError:
> +    print("Incorrect RTEMS Tools installation", file = sys.stderr)
> +    sys.exit(1)
> --
> 2.24.1
>
> _______________________________________________
> devel mailing list
> devel at rtems.org
> http://lists.rtems.org/mailman/listinfo/devel


More information about the devel mailing list