code: def feed_appdata(self, data, offset=0):
          
          if self._state == self.S_UNWRAPPED:
              # pass through data in unwrapped mode
              return ([data[offset:]] if offset < len(data) else [], len(data))
          ssldata = []
          view = memoryview(data)
          while True:
              self._need_ssldata = False
              try:
                  if offset < len(view):
                      offset += self._sslobj.write(view[offset:])
              except ssl.SSLError as e:
                  # It is not allowed to call write() after unwrap() until the
                  # close_notify is acknowledged. We return the condition to the
                  # caller as a short write.
                  if sslcompat.get_reason(e) == 'PROTOCOL_IS_SHUTDOWN':
                      e.errno = ssl.SSL_ERROR_WANT_READ
                  if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE,
                                     ssl.SSL_ERROR_SYSCALL):
                      raise
                  self._need_ssldata = e.errno == ssl.SSL_ERROR_WANT_READ
              # See if there's any record level data back for us.
              if self._outgoing.pending:
                  ssldata.append(self._outgoing.read())
              if offset == len(view) or self._need_ssldata:
                  break
          return (ssldata, offset)
docs: Feed plaintext data into the pipe.
  
          Return an (ssldata, offset) tuple. The ssldata element is a list of
          buffers containing record level data that needs to be sent to the
          remote SSL instance. The offset is the number of plaintext bytes that
          were processed, which may be less than the length of data.
  
          NOTE: In case of short writes, this call MUST be retried with the SAME
          buffer passed into the *data* argument (i.e. the ``id()`` must be the
          same). This is an OpenSSL requirement. A further particularity is that
          a short write will always have offset == 0, because the _ssl module
          does not enable partial writes. And even though the offset is zero,
          there will still be encrypted data in ssldata.