docs: 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