diff --git a/bin/Barreleye.py b/bin/Barreleye.py
old mode 100644
new mode 100755
diff --git a/bin/Openbmc.py b/bin/Openbmc.py
old mode 100644
new mode 100755
diff --git a/bin/Palmetto.py b/bin/Palmetto.py
old mode 100644
new mode 100755
index 2786723..dbe9675
--- a/bin/Palmetto.py
+++ b/bin/Palmetto.py
@@ -4,9 +4,13 @@
 import Openbmc
 
 HOME_PATH = './'
-BIN_PATH = HOME_PATH+'bin/'
 CACHE_PATH = HOME_PATH+'cache/'
 FRU_PATH = CACHE_PATH+'frus/'
+FLASH_DOWNLOAD_PATH = "/tmp"
+
+#use filename as system name, strip off path and ext
+parts = __file__.replace('.pyc','').split('/')
+SYSTEM_NAME = parts[len(parts)-1]
 
 SYSTEM_STATES = [
 	'INIT',
@@ -45,10 +49,10 @@
 		'monitor_process' : True,
 		'process_name' : 'inventory_items.py',
 		'heartbeat' : 'no',
-		'instances' : [	{ 'name' : 'Palmetto' } ]
+		'instances' : [	{ 'name' : SYSTEM_NAME } ]
 	}
 SYSTEM_CONFIG['org.openbmc.control.PciePresent'] = {
-		'system_state' : 'POWERING_ON',
+		'system_state' : 'POWERED_ON',
 		'start_process' : True,
 		'monitor_process' : False,
 		'process_name' : 'pcie_slot_present.exe',
@@ -63,7 +67,7 @@
 		'monitor_process' : True,
 		'process_name' : 'sensor_manager.py',
 		'heartbeat' : 'no',
-		'instances' : [ { 'name' : 'Palmetto' } ]
+		'instances' : [ { 'name' : SYSTEM_NAME } ]
 	}
 
 SYSTEM_CONFIG['org.openbmc.watchdog.Host'] = {
@@ -173,7 +177,7 @@
 		'monitor_process' : True,
 		'process_name' : 'download_manager.py',
 		'heartbeat' : 'no',
-		'instances' : [	{ 'name' : 'DownloadManager_0' } ]
+		'instances' : [	{ 'name' : SYSTEM_NAME } ]
 	}
 
 SYSTEM_CONFIG['org.openbmc.control.Host'] = {
@@ -352,14 +356,14 @@
 }
 
 GPIO_CONFIG = {}
-GPIO_CONFIG['FSI_CLK']    = { 'gpio_num': 4, 'direction': 'out' }
-GPIO_CONFIG['FSI_DATA']   = { 'gpio_num': 5, 'direction': 'out' }
-GPIO_CONFIG['FSI_ENABLE'] = { 'gpio_num': 24, 'direction': 'out' }
-GPIO_CONFIG['POWER_PIN']  = { 'gpio_num': 33, 'direction': 'out'  }
-GPIO_CONFIG['CRONUS_SEL'] = { 'gpio_num': 6, 'direction': 'out'  }
-GPIO_CONFIG['PGOOD']      = { 'gpio_num': 23, 'direction': 'in'  }
-GPIO_CONFIG['IDENTIFY']   = { 'gpio_num': 34, 'direction': 'out' }
-GPIO_CONFIG['POWER_BUTTON'] =  { 'gpio_num': 32, 'direction': 'falling' }
+GPIO_CONFIG['FSI_CLK']    = { 'gpio_num': 484, 'direction': 'out' }
+GPIO_CONFIG['FSI_DATA']   = { 'gpio_num': 485, 'direction': 'out' }
+GPIO_CONFIG['FSI_ENABLE'] = { 'gpio_num': 504, 'direction': 'out' }
+GPIO_CONFIG['POWER_PIN']  = { 'gpio_num': 449, 'direction': 'out'  }
+GPIO_CONFIG['CRONUS_SEL'] = { 'gpio_num': 486, 'direction': 'out'  }
+GPIO_CONFIG['PGOOD']      = { 'gpio_num': 503, 'direction': 'in'  }
+GPIO_CONFIG['IDENTIFY']   = { 'gpio_num': 365, 'direction': 'out' }
+GPIO_CONFIG['POWER_BUTTON'] =  { 'gpio_num': 448, 'direction': 'falling' }
 GPIO_CONFIG['SLOT0_RISER_PRESENT'] =   { 'gpio_num': 104, 'direction': 'in' }
 GPIO_CONFIG['SLOT1_RISER_PRESENT'] =   { 'gpio_num': 105, 'direction': 'in' }
 GPIO_CONFIG['SLOT2_RISER_PRESENT'] =   { 'gpio_num': 106, 'direction': 'in' }
diff --git a/bin/PropertyManager.py b/bin/PropertyManager.py
old mode 100644
new mode 100755
diff --git a/bin/chassis_control.py b/bin/chassis_control.py
old mode 100644
new mode 100755
diff --git a/bin/download_manager.py b/bin/download_manager.py
old mode 100644
new mode 100755
index dbf7c8e..a079efb
--- a/bin/download_manager.py
+++ b/bin/download_manager.py
@@ -6,13 +6,16 @@
 import dbus.service
 import dbus.mainloop.glib
 import tftpy
-
+import Openbmc
+if (len(sys.argv) < 2):
+	print "Usage:  download_manager.py [system name]"
+	exit(1)
+System = __import__(sys.argv[1])
 
 
 DBUS_NAME = 'org.openbmc.managers.Download'
 OBJ_NAME = '/org/openbmc/managers/Download'
 TFTP_PORT = 69
-DOWNLOAD_DIR = '/tmp'
 
 class DownloadManagerObject(dbus.service.Object):
 	def __init__(self,bus,name):
@@ -34,7 +37,7 @@
 			filename = str(filename)
 			client = tftpy.TftpClient(url, TFTP_PORT)
 			print "Downloading: "+filename+" from "+url
-			outfile = DOWNLOAD_DIR+"/"+filename
+			outfile = System.FLASH_DOWNLOAD_PATH+"/"+filename
 			client.download(filename,outfile)
 			self.DownloadComplete(outfile)
 					
diff --git a/bin/flash_manager.py b/bin/flash_manager.py
old mode 100644
new mode 100755
diff --git a/bin/inventory_items.py b/bin/inventory_items.py
old mode 100644
new mode 100755
diff --git a/bin/ipmi_debug.py b/bin/ipmi_debug.py
old mode 100644
new mode 100755
diff --git a/bin/ipmi_example.py b/bin/ipmi_example.py
old mode 100644
new mode 100755
diff --git a/bin/sensor_manager.py b/bin/sensor_manager.py
old mode 100644
new mode 100755
diff --git a/bin/system_manager.py b/bin/system_manager.py
old mode 100644
new mode 100755
index 864688d..7ea3f02
--- a/bin/system_manager.py
+++ b/bin/system_manager.py
@@ -40,6 +40,8 @@
 		self.system_states = {}
 		self.bus_name_lookup = {}
 
+		self.bin_path = os.path.dirname(os.path.realpath(sys.argv[0]))
+
 		for bus_name in System.SYSTEM_CONFIG.keys():
 			sys_state = System.SYSTEM_CONFIG[bus_name]['system_state']
 			if (self.system_states.has_key(sys_state) == False):
@@ -107,7 +109,7 @@
 	
 	def start_process(self,bus_name):
 		if (System.SYSTEM_CONFIG[bus_name]['start_process'] == True):
-			process_name = System.BIN_PATH+System.SYSTEM_CONFIG[bus_name]['process_name']
+			process_name = self.bin_path+"/"+System.SYSTEM_CONFIG[bus_name]['process_name']
 			cmdline = [ ]
 			cmdline.append(process_name)
 			System.SYSTEM_CONFIG[bus_name]['popen'] = None
@@ -158,11 +160,12 @@
 		r = True
 		if (self.current_state == ""):
 			return True
-		for bus_name in self.system_states[self.current_state]:
-			if (System.SYSTEM_CONFIG[bus_name].has_key('popen') == False and
-				System.SYSTEM_CONFIG[bus_name]['start_process'] == True):
-				r = False
-				break;	
+		if (self.system_states.has_key(self.current_state)):
+			for bus_name in self.system_states[self.current_state]:
+				if (System.SYSTEM_CONFIG[bus_name].has_key('popen') == False and
+					System.SYSTEM_CONFIG[bus_name]['start_process'] == True):
+					r = False
+					break;	
 		return r
 	
 
diff --git a/bin/tftpy/COPYING b/bin/tftpy/COPYING
new file mode 100644
index 0000000..c9f2c9c
--- /dev/null
+++ b/bin/tftpy/COPYING
@@ -0,0 +1,21 @@
+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/bin/tftpy/README b/bin/tftpy/README
new file mode 100644
index 0000000..ad7a871
--- /dev/null
+++ b/bin/tftpy/README
@@ -0,0 +1,115 @@
+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@digitaltorque.ca>
diff --git a/bin/tftpy/TftpClient.py b/bin/tftpy/TftpClient.py
new file mode 100644
index 0000000..62f1dda
--- /dev/null
+++ b/bin/tftpy/TftpClient.py
@@ -0,0 +1,103 @@
+"""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
+from TftpShared import *
+from TftpPacketTypes import *
+from TftpContexts import TftpContextClientDownload, TftpContextClientUpload
+
+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, options={}, localip = ""):
+        TftpSession.__init__(self)
+        self.context = None
+        self.host = host
+        self.iport = port
+        self.filename = None
+        self.options = options
+        self.localip = localip
+        if self.options.has_key('blksize'):
+            size = self.options['blksize']
+            tftpassert(types.IntType == 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, output = %s",
+            self.host, self.iport, filename, output)
+        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/bin/tftpy/TftpContexts.py b/bin/tftpy/TftpContexts.py
new file mode 100644
index 0000000..4c41916
--- /dev/null
+++ b/bin/tftpy/TftpContexts.py
@@ -0,0 +1,397 @@
+"""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, time, sys
+
+###############################################################################
+# 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 self.dups.has_key(s):
+            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):
+        """Perform session cleanup, since the end method should always be
+        called explicitely by the calling code, this works better than the
+        destructor."""
+        log.debug("in TftpContext.end")
+        self.sock.close()
+        if 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.warn("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.warn("Received traffic from %s, expected host %s. Discarding"
+                        % (raddress, self.host))
+
+        if self.tidport and self.tidport != rport:
+            log.warn("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):
+        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
+
+    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, 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.warn("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
+        # If the output object has a write() function,
+        # assume it is file-like.
+        if hasattr(output, 'write'):
+            self.fileobj = output
+        # If the output filename is -, then use stdout
+        elif output == '-':
+            self.fileobj = sys.stdout
+        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, 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.warn("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()
diff --git a/bin/tftpy/TftpPacketFactory.py b/bin/tftpy/TftpPacketFactory.py
new file mode 100644
index 0000000..154aec8
--- /dev/null
+++ b/bin/tftpy/TftpPacketFactory.py
@@ -0,0 +1,41 @@
+"""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 *
+
+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("!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(self.classes.has_key(opcode),
+                   "Unsupported opcode: %d" % opcode)
+
+        packet = self.classes[opcode]()
+
+        return packet
diff --git a/bin/tftpy/TftpPacketTypes.py b/bin/tftpy/TftpPacketTypes.py
new file mode 100644
index 0000000..d7c25ca
--- /dev/null
+++ b/bin/tftpy/TftpPacketTypes.py
@@ -0,0 +1,445 @@
+"""This module implements the packet types of TFTP itself, and the
+corresponding encode and decode methods for them."""
+
+import struct
+from TftpShared import *
+
+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 = {}
+
+    def setoptions(self, options):
+        log.debug("in TftpPacketWithOptions.setoptions")
+        log.debug("options: %s", str(options))
+        myoptions = {}
+        for key in options:
+            newkey = str(key)
+            myoptions[newkey] = str(options[key])
+            log.debug("populated myoptions with %s = %s",
+                         newkey, myoptions[newkey])
+
+        log.debug("setting options hash to: %s", str(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."""
+        format = "!"
+        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 c in buffer:
+            if ord(c) == 0:
+                log.debug("found a null at length %d", length)
+                if length > 0:
+                    format += "%dsx" % length
+                    length = -1
+                else:
+                    raise TftpException, "Invalid options in buffer"
+            length += 1
+
+        log.debug("about to unpack, format is: %s", format)
+        mystruct = struct.unpack(format, buffer)
+
+        tftpassert(len(mystruct) % 2 == 0,
+                   "packet with odd number of option/value pairs")
+
+        for i in range(0, len(mystruct), 2):
+            log.debug("setting option %s to %s", mystruct[i], mystruct[i+1])
+            options[mystruct[i]] = mystruct[i+1]
+
+        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")
+
+        ptype = None
+        if self.opcode == 1: ptype = "RRQ"
+        else:                ptype = "WRQ"
+        log.debug("Encoding %s packet, filename = %s, mode = %s",
+                     ptype, self.filename, self.mode)
+        for key in self.options:
+            log.debug("    Option %s = %s", key, self.options[key])
+
+        format = "!H"
+        format += "%dsx" % len(self.filename)
+        if self.mode == "octet":
+            format += "5sx"
+        else:
+            raise AssertionError, "Unsupported mode: %s" % mode
+        # Add options.
+        options_list = []
+        if self.options.keys() > 0:
+            log.debug("there are options to encode")
+            for key in self.options:
+                # Populate the option name
+                format += "%dsx" % len(key)
+                options_list.append(key)
+                # Populate the option value
+                format += "%dsx" % len(str(self.options[key]))
+                options_list.append(str(self.options[key]))
+
+        log.debug("format is %s", format)
+        log.debug("options_list is %s", options_list)
+        log.debug("size of struct is %d", struct.calcsize(format))
+
+        self.buffer = struct.pack(format,
+                                  self.opcode,
+                                  self.filename,
+                                  self.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
+        format = ""
+        nulls = length = tlength = 0
+        log.debug("in decode: about to iterate buffer counting nulls")
+        subbuf = self.buffer[2:]
+        for c in subbuf:
+            if ord(c) == 0:
+                nulls += 1
+                log.debug("found a null at length %d, now have %d", length, nulls)
+                format += "%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 format: %s", format)
+        log.debug("unpacking buffer: %s", repr(shortbuf))
+        mystruct = struct.unpack(format, shortbuf)
+
+        tftpassert(len(mystruct) == 2, "malformed packet")
+        self.filename = mystruct[0]
+        self.mode = mystruct[1].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:])
+        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")
+        format = "!HH%ds" % len(self.data)
+        self.buffer = struct.pack(format,
+                                  self.opcode,
+                                  self.blocknumber,
+                                  self.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("!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("!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("!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: "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 __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."""
+        format = "!HH%dsx" % len(self.errmsgs[self.errorcode])
+        log.debug("encoding ERR packet with format %s", format)
+        self.buffer = struct.pack(format,
+                                  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")
+            format = "!HH"
+            log.debug("Decoding ERR packet with format: %s", format)
+            self.opcode, self.errorcode = struct.unpack(format,
+                                                        self.buffer)
+        else:
+            log.debug("Good ERR packet > 4 bytes")
+            format = "!HH%dsx" % (len(self.buffer) - 5)
+            log.debug("Decoding ERR packet with format: %s", format)
+            self.opcode, self.errorcode, self.errmsg = struct.unpack(format,
+                                                                     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):
+        format = "!H" # opcode
+        options_list = []
+        log.debug("in TftpPacketOACK.encode")
+        for key in self.options:
+            log.debug("looping on option key %s", key)
+            log.debug("value is %s", self.options[key])
+            format += "%dsx" % len(key)
+            format += "%dsx" % len(self.options[key])
+            options_list.append(key)
+            options_list.append(self.options[key])
+        self.buffer = struct.pack(format, 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 options.has_key(name):
+                if name == 'blksize':
+                    # We can accept anything between the min and max values.
+                    size = 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, "Unsupported option: %s" % name
+        return True
diff --git a/bin/tftpy/TftpServer.py b/bin/tftpy/TftpServer.py
new file mode 100644
index 0000000..12491a0
--- /dev/null
+++ b/bin/tftpy/TftpServer.py
@@ -0,0 +1,232 @@
+"""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
+from TftpShared import *
+from TftpPacketTypes import *
+from TftpPacketFactory import TftpPacketFactory
+from TftpContexts import TftpContextServer
+
+class TftpServer(TftpSession):
+    """This class implements a tftp server object. Run the listen() method to
+    listen for client requests.  It takes two optional arguments. tftproot is
+    the path to the tftproot directory to serve files from and/or write them
+    to. dyn_file_func is a callable that must return a file-like object to
+    read from during downloads. This permits the serving of dynamic
+    content."""
+
+    def __init__(self, tftproot='/tftpboot', dyn_file_func=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
+        # 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
+
+        if self.dyn_file_func:
+            if not callable(self.dyn_file_func):
+                raise TftpException, "A dyn_file_func supplied, but it is not callable."
+        elif 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 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.bind((listenip, listenport))
+            _, self.listenport = self.sock.getsockname()
+        except socket.error, err:
+            # Reraise it for now.
+            raise
+
+        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.warn("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.warn("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)
+            readyinput, readyoutput, readyspecial = select.select(inputlist,
+                                                                  [],
+                                                                  [],
+                                                                  SOCK_TIMEOUT)
+
+            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.warn("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 self.sessions.has_key(key):
+                        log.debug("Creating new server context for "
+                                     "session key = %s", key)
+                        self.sessions[key] = TftpContextServer(raddress,
+                                                               rport,
+                                                               timeout,
+                                                               self.root,
+                                                               self.dyn_file_func)
+                        try:
+                            self.sessions[key].start(buffer)
+                        except TftpException, err:
+                            deletion_list.append(key)
+                            log.error("Fatal exception thrown from "
+                                      "session %s: %s" % (key, str(err)))
+                    else:
+                        log.warn("received traffic on main socket for "
+                                 "existing session??")
+                    log.info("Currently handling these sessions:")
+                    for session_key, session in 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.info("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, 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, 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 self.sessions.has_key(key):
+                    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.warn("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/bin/tftpy/TftpShared.py b/bin/tftpy/TftpShared.py
new file mode 100644
index 0000000..d09d8bd
--- /dev/null
+++ b/bin/tftpy/TftpShared.py
@@ -0,0 +1,59 @@
+"""This module holds all objects shared by all other modules in tftpy."""
+
+import logging
+
+LOG_LEVEL = logging.NOTSET
+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
+
+# Initialize the logger.
+logging.basicConfig()
+# The logger used by this library. Feel free to clobber it with your own, if you like, as
+# long as it conforms to Python's logging.
+log = logging.getLogger('tftpy')
+
+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
+
+def setLogLevel(level):
+    """This function is a utility function for setting the internal log level.
+    The log level defaults to logging.NOTSET, so unwanted output to stdout is
+    not created."""
+    global log
+    log.setLevel(level)
+
+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
diff --git a/bin/tftpy/TftpStates.py b/bin/tftpy/TftpStates.py
new file mode 100644
index 0000000..1ea6c31
--- /dev/null
+++ b/bin/tftpy/TftpStates.py
@@ -0,0 +1,582 @@
+"""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
+
+###############################################################################
+# 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 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'] = 1
+            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
+        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.warn("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.warn("There is no block zero!")
+                self.sendError(TftpErrors.IllegalTftpOp)
+                raise TftpException, "There is no block zero!"
+            log.warn("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."
+
+        # 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.warn("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)
+
+            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:
+            self.sendError(TftpErrors.FileNotFound)
+            raise TftpException, "File not found: %s" % path
+
+        # Options negotiation.
+        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, 0700)
+
+    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
+        log.info("Opening file %s for writing" % path)
+        if os.path.exists(path):
+            # FIXME: correct behavior?
+            log.warn("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.info("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.warn("Received duplicate ACK for block %d"
+                    % pkt.blocknumber)
+                self.context.metrics.add_dup(pkt)
+
+            else:
+                log.warn("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.warn("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.warn("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: " + str(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: " + str(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, 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)
+            raise TftpException, "Received ERR from server: " + str(pkt)
+
+        else:
+            self.sendError(TftpErrors.IllegalTftpOp)
+            raise TftpException, "Received unknown packet type from server: " + str(pkt)
+
+        # By default, no state change.
+        return self
diff --git a/bin/tftpy/__init__.py b/bin/tftpy/__init__.py
new file mode 100644
index 0000000..fba9a9f
--- /dev/null
+++ b/bin/tftpy/__init__.py
@@ -0,0 +1,25 @@
+"""
+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.3
+required_version = (2, 3)
+if sys.version_info < required_version:
+    raise ImportError, "Requires at least Python 2.3"
+
+from tftpy.TftpShared import *
+from tftpy.TftpPacketTypes import *
+from tftpy.TftpPacketFactory import *
+from tftpy.TftpClient import *
+from tftpy.TftpServer import *
+from tftpy.TftpContexts import *
+from tftpy.TftpStates import *
+
diff --git a/includes/openbmc.h b/includes/openbmc.h
index 07546e2..ca44fb7 100644
--- a/includes/openbmc.h
+++ b/includes/openbmc.h
@@ -2,6 +2,7 @@
 #define __OPENBMC_H__
 
 #include <stdint.h>
+#include <stdio.h>
 
 //select which dbus
 #define DBUS_TYPE  G_BUS_TYPE_SYSTEM