Robust Buffered Reading

For files that contain both text lines and binary data (such as the HTTP responses), we provide a buffered version of rio_readn,
called rio_readnb, that transfers raw bytes from an internal read buffer. The rio_readnb function reads
up to n bytes from file rp to memory location usrbuf. The format of a read buffer is showed below.

#define RIO_BUFSIZE 8192
typedef struct {
int rio_fd;					// Descriptor for this internal buf
int rio_cnt;				// Unread bytes in internal buf
char *rio_bufptr;			// Next unread byte in internal buf
char rio_buf[RIO_BUFSIZE];	// Internal buffer
} rio_t;

The heart of the robust read routine is the rio_read function showed
below. The rio_read function is a buffered version of the Unix read function.

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
while (rp->rio_cnt <= 0) {		// Refill if buf is empty
rp->rio_cnt = read(rp->rio_fd, rp->rio_buf,
sizeof(rp->rio_buf));
if (rp->rio_cnt < 0) {
if (errno != EINTR)		// Interrupted by signal
return -1;				// handle return
}
else if (rp->rio_cnt == 0)	// EOF
return 0;
else
rp->rio_bufptr = rp->rio_buf;	// Reset buffer ptr
}

// Copy min(n, rp->rio_cnt) bytes from internal buf to user buf
int cnt = n;
if (rp->rio_cnt < n)
cnt = rp->rio_cnt;
memcpy(usrbuf, rp->rio_bufptr, cnt);
rp->rio_bufptr += cnt;
rp->rio_cnt -= cnt;
return cnt;
}

When rio_read is called with a request to read n bytes, there are rp->rio_cnt unread bytes in the read buffer. If the buffer is empty, then it is replenished
with a call to read. Receiving a short count from this invocation of read is not an error, and simply has the effect of partially filling the read buffer.
To an application program, the rio_read function has the same semantics as the Unix read function. The similarity of the two functions makes
it easy to build different kinds of buffered read functions by substituting rio_read for read. For example, the
rio_readnb function, which performs robust buffered reading, has the same structure as rio_readn, with rio_read substituted for
read.

ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n)
{
size_t nleft = n;
ssize_t nread;
char *bufp = usrbuf;

while (nleft > 0) {
if ((nread = rio_read(rp, bufp, nleft)) < 0) {
if (errno == EINTR)		// Interrupted by signal handle return
nread = 0;			// Call read() again
else
return -1;			// errno set by read()
}
else if (nread == 0)
break;						// EOF
nleft -= nread;
bufp += nread;
}
return (n - nleft);					// Return >= 0
}