When using NSS, only schedule transport socket reads when the transport buffer is empty.

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 37 matching lines @@
     struct memio_buffer readbuf;
 
     /* write requests are satisfied from this buffer */
     struct memio_buffer writebuf;
 
     /* SSL needs to know socket peer's name */
     PRNetAddr peername;
 
     /* if set, empty I/O returns EOF instead of EWOULDBLOCK */
     int eof;
+
+    /* if set, the number of bytes requested from readbuf that were not
+     * fulfilled (due to readbuf being empty) */
+    int read_requested;
 };
 
 /*--------------- private memio_buffer functions ---------------------*/
 
 /* Forward declarations.  */
 
 /* Allocate a memio_buffer of given size. */
 static void memio_buffer_new(struct memio_buffer *mb, int size);
 
 /* Deallocate a memio_buffer allocated by memio_buffer_new. */
@@ skipping 148 matching lines @@
     if (flags) {
         PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
         return -1;
     }
 
     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
             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,
@@ skipping 132 matching lines @@
     secret->peername = *peername;
 }
 
 memio_Private *memio_GetSecret(PRFileDesc *fd)
 {
     PRFileDesc *memiofd = PR_GetIdentitiesLayer(fd, memio_identity);
     struct PRFilePrivate *secret =  memiofd->secret;
     return (memio_Private *)secret;
 }
 
+int memio_GetReadRequest(memio_Private *secret)
+{
+    return ((PRFilePrivate *)secret)->read_requested;
+}
+
 int memio_GetReadParams(memio_Private *secret, char **buf)
 {
     struct memio_buffer* mb = &((PRFilePrivate *)secret)->readbuf;
     PR_ASSERT(mb->bufsize);
 
     *buf = &mb->buf[mb->tail];
     return memio_buffer_unused_contiguous(mb);
 }
 
 void memio_PutReadResult(memio_Private *secret, int bytes_read)
@@ skipping 96 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