Gracefully handle an asynchronous write disconnect when an SSL read is pending

net/base/nss_memio.c

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 // Written in NSPR style to also be suitable for adding to the NSS demo suite
 
 /* memio is a simple NSPR I/O layer that lets you decouple NSS from
  * the real network.  It's rather like openssl's memory bio,
  * and is useful when your app absolutely, positively doesn't
  * want to let NSS do its own networking.
  */
@@ skipping 212 matching lines @@
     }
 
     secret = fd->secret;
     mb = &secret->readbuf;
     PR_ASSERT(mb->bufsize);
     rv = memio_buffer_get(mb, buf, len);
     if (rv == 0 && !secret->eof) {
         secret->read_requested = len;
         if (mb->last_err)
             PR_SetError(mb->last_err, 0);
+        else if (secret->writebuf.last_err)
+            PR_SetError(secret->writebuf.last_err, 0);
         else
             PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
         return -1;
     }
 
     secret->read_requested = 0;
     return rv;
 }
 
 static int PR_CALLBACK memio_Read(PRFileDesc *fd, void *buf, PRInt32 len)
 {
     /* pull bytes from buffer */
     return memio_Recv(fd, buf, len, 0, PR_INTERVAL_NO_TIMEOUT);
 }
 
 static int PR_CALLBACK memio_Send(PRFileDesc *fd, const void *buf, PRInt32 len,
                                   PRIntn flags, PRIntervalTime timeout)
 {
     struct PRFilePrivate *secret;
     struct memio_buffer *mb;
     int rv;
 
     secret = fd->secret;
     mb = &secret->writebuf;
     PR_ASSERT(mb->bufsize);
 
     if (mb->last_err) {
         PR_SetError(mb->last_err, 0);
         return -1;
     }

[wtc, 2013/06/14 21:45:07]

Should we also check secret->readbuf.last_err here?

If not, this asymmetry between memio_Recv and memio_Send is worth a comment.

I guess memio_Send probably doesn't need to report read error, especially
because read error cannot be reported until all the buffered data have been
consumed. On the other hand, memio_Recv needs to help report write error because
the upper layer may not have more data to write. I think we can put this comment
in memio_Recv.

     rv = memio_buffer_put(mb, buf, len);
     if (rv == 0) {
         PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
         return -1;
     }
     return rv;
 }
 
 static int PR_CALLBACK memio_Write(PRFileDesc *fd, const void *buf, PRInt32 len)
 {
@@ skipping 237 matching lines @@
     CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
     CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
 
     /* TODO: add more cases */
 
     printf("Test passed\n");
     exit(0);
 }
 
 #endif