docs: def cycle(self):
          """Here we wait for a response from the server after sending it
          something, and dispatch appropriate action to that response."""
          try:
              (buffer, (raddress, rport)) = self.sock.recvfrom(MAX_BLKSIZE)
          except socket.timeout:
              log.warning("Timeout waiting for traffic, retrying...")
              raise TftpTimeout("Timed-out waiting for traffic")
  
          # Ok, we've received a packet. Log it.
          log.debug("Received %d bytes from %s:%s",
                          len(buffer), raddress, rport)
          # And update our last updated time.
          self.last_update = time.time()
  
          # Decode it.
          recvpkt = self.factory.parse(buffer)
  
          # Check for known "connection".
          if raddress != self.address:
              log.warning("Received traffic from %s, expected host %s. Discarding"
                          % (raddress, self.host))
  
          if self.tidport and self.tidport != rport:
              log.warning("Received traffic from %s:%s but we're "
                          "connected to %s:%s. Discarding."
                          % (raddress, rport,
                          self.host, self.tidport))
  
          # If there is a packethook defined, call it. We unconditionally
          # pass all packets, it's up to the client to screen out different
          # kinds of packets. This way, the client is privy to things like
          # negotiated options.
          if self.packethook:
              self.packethook(recvpkt)
  
          # And handle it, possibly changing state.
          self.state = self.state.handle(recvpkt, raddress, rport)
          # If we didn't throw any exceptions here, reset the retry_count to
          # zero.
          self.retry_count = 0