docs: def feed_ssldata(self, data):
          """Feed SSL record level data into the pipe.
  
          The data must be a bytes instance. It is OK to send an empty bytes
          instance. This can be used to get ssldata for a handshake initiated by
          this endpoint.
  
          Return a (ssldata, appdata) tuple. The ssldata element is a list of
          buffers containing SSL data that needs to be sent to the remote SSL.
  
          The appdata element is a list of buffers containing plaintext data that
          needs to be forwarded to the application. The appdata list may contain
          an empty buffer indicating an SSL "close_notify" alert. This alert must
          be acknowledged by calling :meth:`shutdown`.
          """
          if self._state == self.S_UNWRAPPED:
              # If unwrapped, pass plaintext data straight through.
              return ([], [data] if data else [])
          ssldata = []; appdata = []
          self._need_ssldata = False
          if data:
              self._incoming.write(data)
          try:
              if self._state == self.S_DO_HANDSHAKE:
                  # Call do_handshake() until it doesn't raise anymore.
                  self._sslobj.do_handshake()
                  self._state = self.S_WRAPPED
                  if self._handshake_cb:
                      self._handshake_cb()
              if self._state == self.S_WRAPPED:
                  # Main state: read data from SSL until close_notify
                  while True:
                      chunk = self._sslobj.read(self.bufsize)
                      appdata.append(chunk)
                      if not chunk:  # close_notify
                          break
              if self._state == self.S_SHUTDOWN:
                  # Call shutdown() until it doesn't raise anymore.
                  self._sslobj.unwrap()
                  self._sslobj = None
                  self._state = self.S_UNWRAPPED
                  if self._shutdown_cb:
                      self._shutdown_cb()
              if self._state == self.S_UNWRAPPED:
                  # Drain possible plaintext data after close_notify.
                  appdata.append(self._incoming.read())
          except (ssl.SSLError, sslcompat.CertificateError) as e:
              if getattr(e, 'errno', None) not in (ssl.SSL_ERROR_WANT_READ,
                          ssl.SSL_ERROR_WANT_WRITE, ssl.SSL_ERROR_SYSCALL):
                  if self._state == self.S_DO_HANDSHAKE and self._handshake_cb:
                      self._handshake_cb(e)
                  raise
              self._need_ssldata = e.errno == ssl.SSL_ERROR_WANT_READ
          # Check for record level data that needs to be sent back.
          # Happens for the initial handshake and renegotiations.
          if self._outgoing.pending:
              ssldata.append(self._outgoing.read())
          return (ssldata, appdata)