对端的异常状况
前面我们已经初步接触过一些防范对端异常的方法，比如，通过 read 等调用时，可以通过对 EOF 的判断，随时防范对方程序崩溃。
int nBytes = recv(connfd, buffer, sizeof(buffer), 0);
if (nBytes == -1) {
error(1, errno, "error read message");
} else if (nBytes == 0) {
error(1, 0, "client closed \n");
}
read 函数返回 0 字节时，实际上就是内核返回 EOF 的一种反映。如果是服务器同时处理多个客户端连接，一般这里会调用 shutdown 关闭连接的这一端。
不是每种情况都可以通过读操作来感知异常，比如，服务器完全崩溃或网络中断的情况下，如果是阻塞套接字，会一直阻塞在 read 等调用上，没有办法感知套接字的异常。
其实有几种办法来解决这个问题。
第一个办法是给套接字的 read 操作设置超时，如果超过了一段时间就认为连接已经不存在
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
// 设置套接字的读操作超时
setsockopt(connfd, SOL_SOCKET, SO_RCVTIMEO, (const char *) &tv, sizeof tv);
while (1) {
int nBytes = recv(connfd, buffer, sizeof(buffer), 0);
if (nBytes == -1) {
// 根据出错信息是`EAGAIN`或者`EWOULDBLOCK`，判断出超时
if (errno == EAGAIN || errno == EWOULDBLOCK) {
printf("read timeout\n");
onClientTimeout(connfd);//转而调用`onClientTimeout`函数来进行处理。
} else {
error(1, errno, "error read message");
}
} else if (nBytes == 0) {
error(1, 0, "client closed \n");
}
...
}
这个处理方式虽然比较简单，却很实用，很多 FTP 服务器就是这么设计的。连接这种 FTP 服务器之后，如果 FTP 的客户端没有续传的功能，在碰到网络故障或服务器崩溃时就会挂断。
第二个办法是添加对连接是否正常的检测。如果连接不正常，需要从当前 read 阻塞中返回并处理。
还有一个办法就是利用多路复用技术自带的超时能力，来完成对套接字 I/O 的检查，如果超过了预设的时间，就进入异常处理。
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
FD_ZERO(&allreads);
FD_SET(socket_fd, &allreads);
for (;;) {
readmask = allreads;
int rc = select(socket_fd + 1, &readmask, NULL, NULL, &tv);
if (rc < 0) {
error(1, errno, "select failed");
}
if (rc == 0) {
printf("read timeout\n");
onClientTimeout(socket_fd);
}
...
}
这段代码使用了 select 多路复用技术来对套接字进行 I/O 事件的轮询，
缓冲区处理
一个好的网络程序可以在随机输入的情况下表现稳定。不仅是这样，网络程序能不能在黑客的刻意攻击之下表现稳定，也是一个重要考量因素。
黑客程序会针对性地构建一定格式的网络协议包，导致网络程序产生诸如缓冲区溢出、指针异常的后果，影响程序的服务能力，严重的甚至可以夺取服务器的控制权，比如著名的 SQL 注入，就是通过针对性地构造出 SQL 语句，完成对数据库敏感信息的窃取。
那么程序都有可能出现哪几种漏洞呢？
第一个例子
#include "common.h"
static int count;
static void sig_int(int signo) {
printf("\nreceived %d datagrams\n", count);
exit(0);
}
int main(int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
int connfd = tcp_server(SERV_PORT);
char buffer[128];
char Response[] = "COMMAND OK";
while (1) {
int nBytes = recv(connfd, buffer, sizeof(buffer), 0);
if (nBytes == -1) {
error(1, errno, "error read message");
} else if (nBytes == 0) {
error(1, 0, "client closed \n");
}
buffer[nBytes] = '\0';
if (strcmp(buffer, "quit") == 0) {
printf("client quit\n");
send(socket, Response, sizeof(Response), 0);
}
printf("received %d bytes: %s\n", nBytes, buffer);
}
exit(0);
}
从连接套接字中获取字节流，并且判断了出错和 EOF 情况，如果对端发送来的字符是“quit”就回应“COMAAND OK”的字符流，乍看上去一切正常。
但仔细看一下，这段代码很有可能会产生下面的结果。
char buffer[128];
buffer[128] = '\0';
通过 recv 读取的字符数为 128 时。因为 buffer 的大小只有 128 字节，最后的赋值环节，产生了缓冲区溢出的问题。
缓冲区溢出是计算机程序中出现的一种内存违规操作。本质是计算机程序向缓冲区填充的数据，超出了原本缓冲区设置的大小限制，导致了数据覆盖了内存栈空间的其他合法数据。这种覆盖破坏了原来程序的完整性
我们可以对这个程序稍加修改，主要的想法是留下 buffer 里的一个字节，以容纳后面的'\0'。
int nBytes = recv(connfd, buffer, sizeof(buffer)-1, 0);
这个例子发送的字符串，调用的是sizeof，意味着，Response 字符串中的'\0'是被发送出去的，而我们在接收字符时，则假设没有'\0'字符的存在。
为了统一，我们可以改成如下的方式，使用 strlen 的方式忽略最后一个'\0'字符。
send(socket, Response, strlen(Response), 0);
第二个例子
前面提到了对变长报文解析的两种手段，一个是使用特殊的边界符号，例如 HTTP 使用的回车换行符；另一个是将报文信息的长度编码进入消息。
在实战中，我们也需要对这部分报文长度保持警惕。
size_t read_message(int fd, char *buffer, size_t length) {
u_int32_t msg_length;
u_int32_t msg_type;
int rc;
rc = readn(fd, (char *) &msg_length, sizeof(u_int32_t));
if (rc != sizeof(u_int32_t))
return rc < 0 ? -1 : 0;
msg_length = ntohl(msg_length);
rc = readn(fd, (char *) &msg_type, sizeof(msg_type));
if (rc != sizeof(u_int32_t))
return rc < 0 ? -1 : 0;
if (msg_length > length) {//对实际的报文长度`msg_length`和应用程序分配的缓冲区大小进行比较
return -1;//报文长度过大，导致缓冲区容纳不下，直接返回 -1 表示出错
}
/* Retrieve the record itself */
rc = readn(fd, buffer, msg_length);
if (rc != msg_length)
return rc < 0 ? -1 : 0;
return rc;
}
下面是一段发送端消息的长度“不小心”被设置为 65535 长度，实际发送的报文数据为“just for fun”。在去掉实际的报文长度msg_length和应用程序分配的缓冲区大小做比较之后，服务器端一直阻塞在 read 调用上，这是因为服务器端误认为需要接收 65535 大小的字节。
struct {
u_int32_t message_length;
u_int32_t message_type;
char data[128];
} message;
int n = 65535;
message.message_length = htonl(n);
message.message_type = 1;
char buf[128] = "just for fun\0";
strncpy(message.data, buf, strlen(buf));
if (send(socket_fd, (char *) &message,
sizeof(message.message_length) + sizeof(message.message_type) + strlen(message.data), 0) < 0)
error(1, errno, "send failure");
第三个例子
开发一个函数，假设报文的分界符是换行符（\n），一个简单的想法是每次读取一个字符，判断这个字符是不是换行符。
这个函数的最大问题是工作效率太低，要知道每次调用 recv 函数都是一次系统调用，需要从用户空间切换到内核空间，上下文切换的开销太大。
size_t readline(int fd, char *buffer, size_t length) {
char *buf_first = buffer;
char c;
while (length > 0 && recv(fd, &c, 1, 0) == 1) {
*buffer++ = c;
length--;
if (c == '\n') {
*buffer = '\0';
return buffer - buf_first;
}
}
return -1;
}
于是，就有了第二个版本，这个函数一次性读取最多 512 字节到临时缓冲区，之后将临时缓冲区的字符一个一个拷贝到应用程序最终的缓冲区中，这样的做法明显效率会高很多。
size_t readline(int fd, char *buffer, size_t length) {
char *buf_first = buffer;
static char *buffer_pointer;
int nleft = 0;
static char read_buffer[512];
char c;
while (length-- > 0) {//通过对 length 变量的判断，试图解决缓冲区长度溢出问题
if (nleft <= 0) {
//判断临时缓冲区的字符有没有被全部拷贝完,如果被全部拷贝完，就会再次尝试读取最多 512 字节
int nread = recv(fd, read_buffer, sizeof(read_buffer), 0);
if (nread < 0) {
if (errno == EINTR) {
length++;
continue;
}
return -1;
}
if (nread == 0)
return 0;
// //读取字符成功之后，重置了临时缓冲区读指针、临时缓冲区待读的字符个数
buffer_pointer = read_buffer;
nleft = nread;
}
//拷贝临时缓冲区字符，并移动临时缓冲区读指针，对临时缓冲区待读的字符个数进行减 1 操作
c = *buffer_pointer++;
*buffer++ = c;
nleft--;
if (c == '\n') {//如果读到换行符则将应用程序最终缓冲区截断，返回最终读取的字符个数。
*buffer = '\0';
return buffer - buf_first;
}
}
return -1;
}
这个程序运行起来可能很久都没有问题，但是，它还是有一个微小的瑕疵，这个瑕疵很可能会造成线上故障。
为了讲清这个故障，我们假设这样调用， 输入的字符为012\n。
// 输入字符为: 012\n
char buf[4]
readline(fd, buf, 4)
当读到最后一个\n 字符时，length 为 1，问题在读到换行符，会增加一个字符串截止符，这显然越过了应用程序缓冲区的大小。
正确的程序如下，最关键的是需要先对 length 进行处理，再去判断 length 的大小是否可以容纳下字符。
size_t readline(int fd, char *buffer, size_t length) {
char *buf_first = buffer;
static char *buffer_pointer;
int nleft = 0;
static char read_buffer[512];
char c;
while (--length> 0) {
if (nleft <= 0) {
int nread = recv(fd, read_buffer, sizeof(read_buffer), 0);
if (nread < 0) {
if (errno == EINTR) {
length++;
continue;
}
return -1;
}
if (nread == 0)
return 0;
buffer_pointer = read_buffer;
nleft = nread;
}
c = *buffer_pointer++;
*buffer++ = c;
nleft--;
if (c == '\n') {
*buffer = '\0';
return buffer - buf_first;
}
}
return -1;
}
