健壮的网络编程IO函数-RIO包

RIO包

简介

Rio包即为Robust io函数包。包中函数是对Linux基本I/O函数的封装，使其更加健壮、高效，更适用于网络编程。

分析

Rio包由rio_t结构体和系列函数组成。
首先是两个不涉及缓冲区的函数rio_readn()和rio_writen();

rio_readn 与 rio_writen

为了解释这两个函数存在的必要，我们先来看看基本IO函数write、read存在哪些问题。

以下摘自UNP：

字节流套接字上的read和write函数所表现的行为不同于通常的文件IO。字节流套接字上调用read或write输入或输出的字节数可能比请求的数量少，然而这不是出错的状态。这个现象的原因在于内核中用于套接字的缓冲区可能已经到达了极限。此时所需的是调用者再次调用read或write函数，以输入或输出剩余的字节。

再来谈一谈EINTR：

如果进程在一个慢系统调用(slow system call)中阻塞时，当捕获到某个信号且相应信号处理函数返回时，这个系统调用被中断，调用返回错误，设置errno为EINTR（相应的错误描述为“Interrupted system call”）。

以上两点表明，在网络编程中，你虽然调用read/write读/写了n个字符，但实际读写的数量可能比请求的数量少。

而rio包中的两个函数解决了这一问题。

rio_readn

此函数尝试从fd中读取n个字符到usrbuf中，与read函数相比，它被信号处理函数中断后会再次尝试读取。因此，在除了可读字符数小于n情况下，该函数可以保证读取n个字节。

ssize_t rio_readn(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n; //剩下未读字符数
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
	if ((nread = read(fd, bufp, nleft)) < 0) {
        if (errno == EINTR)  //被信号处理函数中断
		nread = 0;      //本次读到0个字符，再次读取
	    else
		return -1;      //出错，errno由read设置
    } 
	else if (nread == 0) //读取到EOF
        break;              
    nleft -= nread; //剩下的字符数减去本次读到的字符数
	bufp += nread;  //缓冲区指针向右移动
    }
    //返回实际读取的字符数
    return (n - nleft);         /* return >= 0 */
}

rio_writen

此函数同理，保证写出n字节。

ssize_t rio_writen(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nwritten;
    char *bufp = usrbuf;

    while (nleft > 0) {
	if ((nwritten = write(fd, bufp, nleft)) <= 0) {
	    if (errno == EINTR)  
		nwritten = 0;    
	    else
		return -1;       
	}
	nleft -= nwritten;
	bufp += nwritten;
    }
    return n;
}

---

接下来是带有缓冲区的RIO函数。缓冲区存在的目的是为了减少因多次调用系统级IO函数，陷入内核态而带来的额外开销。详情如下：

在Linux中，read 和 write 是基本的系统级I/O函数。当用户进程使用read 和 write 读写linux的文件时,进程会从用户态进入内核态，通过I/O操作读取文件中的数据。内核态（内核模式）和用户态（用户模式）是linux的一种机制，用于限制应用可以执行的指令和可访问的地址空间，这通过设置某个控制寄存器的位来实现。进程处于用户模式下，它不允许发起I/O操作，所以它必须通过系统调用进入内核模式才能对文件进行读取。
从用户模式切换到内核模式，主要的开销是处理器要将返回地址（当前指令的下一条指令地址）和额外的处理器状态（寄存器）压入到栈中，这些数据到会被压到内核栈而不是用户栈。另外，一个进程使用系统调用还隐含了一点——调用系统调用的进程可能会被抢占。当内核代表用户执行系统调用时，若该系统调用被阻塞，该进程就会进入休眠，然后由内核选择一个就绪状态，当前优先级最高的进程运行。另外，即使系统调用没有被阻塞，当系统调用结束，从内核态返回时，若在系统调用期间出现了一个优先级更高的进程，则该进程会抢占使用了系统调用的进程。内核态返回会返回到优先级高的进程，而不是原本的进程。

rio_t 结构体

typedef struct {
    int rio_fd;                //与内部缓冲区关联的描述符
    int rio_cnt;               //缓冲区中剩下的字节数
    char *rio_bufptr;          //指向缓冲区中下一个未读的字节
    char rio_buf[RIO_BUFSIZE]; 
} rio_t;

rio_readinitb

初始化函数

void rio_readinitb(rio_t *rp, int fd) 
{
    rp->rio_fd = fd;  
    rp->rio_cnt = 0;  
    rp->rio_bufptr = rp->rio_buf;
}

rio_read

此函数首先检查缓冲区是否为空，若为空，则调用read从fd中读取最数量非的数据填充缓冲区。若不为空则从缓冲区中取出n个字节。若缓冲区中剩余字节数不足n，则将缓冲区中全部取出，并返回读取到的字节数。

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0) {  //缓冲区为空，调用read填充
	rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, 
			   sizeof(rp->rio_buf));
	if (rp->rio_cnt < 0) {
	    if (errno != EINTR) /* Interrupted by sig handler return */
		return -1;
	}
	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 */
    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;
}

rio_readnb

此函数类似rio_readn,不过因为加入了缓冲区，所以减少了陷入内核态时的开销。

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) 
            return -1;          /* errno set by read() */ 
	else if (nread == 0)
	    break;              /* EOF */
	nleft -= nread;
	bufp += nread;
    }
    return (n - nleft);         /* return >= 0 */
}

rio_readlineb

带缓冲的读取一行，返回字节数包括换行符。

ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
{
    int n, rc;
    char c, *bufp = usrbuf;

    for (n = 1; n < maxlen; n++) { 
        if ((rc = rio_read(rp, &c, 1)) == 1) {
	    *bufp++ = c;
	    if (c == '
') {
                n++;
     		break;
            }
	} else if (rc == 0) {
	    if (n == 1)
		return 0; //第一次读取就到了EOF
	    else
		break;    //读了一些数据后遇到EOF
	} else
	    return -1;	  /* Error */
    }
    *bufp = 0;
    return n-1;
}

参考：
《UNIX网络编程》
《深入理解计算机系统》
http://blog.csdn.net/u013613341/article/details/51019075