基于UNIX的网络编程(理论篇：设计迭代服务器)

注意：read的返回值为0说明读的字节数，如果为EOF则为0.

之前腾讯一面的时候，面试官看见了我的最近一篇博客《TCP和UDP详解》感觉我的理论还行。但是，问我有没实际做过TCP/UDP的项目。结果我就只能说我在大一做过的一个没有搭在服务器上面的下载器，感觉有点丢人。于是，自己马上下来做了准备一个基于UNIX的网络编程的小项目。准备分为两个理论篇和一个实践篇。
现在马上进入我们的第一个理论篇：设计迭代服务器
在这篇博客中，你将看到以下内容：

好的，好戏开始：

UNIX I/O

一.UNIX的I/O系统是怎么回事？

计算机专业的都知道，我们的计算机都是基于冯诺伊曼的架构(当然还是哈佛架构总线分开)。那么，对于冯诺伊曼架构的计算机I/O就成了很重要的一环。在我们的UNIX系统的I/O是怎么样的呢？对于I/O（输入、输出），UNIX系统做了一个非常优美的抽象,UNIX系统将所有的I/O设备，正如网络、磁盘和终端，都抽象为了我们的文件。包括我们写程序中用到的prinf,scanf,sprintf,sscanf都是我们的文件。
针对于每一个程序，内核都会自动分配出三个文件：stdin,stdout,stderr（标准输入、标准输出、标准错误流），文件描述符分别为0,1,2.
这里提一下，UNIX是怎么进行文件区分的，下面直接来放一张UNIX系统的文件头结构体：

看起来有点多，我们挑我们常用的几个来说
1.mode_t st_mode. 说明文件的具体类型，是可读的，还是可写的，还是可执行的。
我们可以利用我们的宏指令来看文件的类型

其他的相关信息：st_atime、st_mtime、st_ctime可以用来做文件的mac或者hash来进行传输，来保证文件在发送的时候没有被修改，这又涉及到安全方面的知识了，这又是另一个故事了，对信息安全感兴趣的可以看我的这篇博文：http://blog.csdn.net/github_33873969/article/details/79008664
这里还是上一段代码如何查询和处理一个文件的st_mode位吧

#include<unistd.h>
#include<sys/stat.h>

int main(int argc, char **argv)
{
    struct stat stat;
    char *type, *readok;

    stat(argv[1],&stat);
    /* Determine file type */
    if(S_ISREG(stat.st_mode))
        type="regular";
    else if(S_ISDIR(stat.st_mode))
        type="directory";
    else
        type="other";
    /* Check read access */
    if((stat.st_mode & S_IRUSR))
        readok="yes";
    else
        readok="no";

    printf("type: %s, read: %s\n",type,readok);
    exit(0);
}

接下来，我还是想说一下针对每一个进程而言，文件是如何管理的，映射到操作系统内核文件又是怎样的？
还是先上图：

从头开始：
1.对于每一个进程而言，都会独立维护一个描述符表，这个描述符表就是我刚刚所说的对于进程而言，区分不同的文件而准备的(比如:stdin、stdout、stderr)
这里说明一个打开对应文件的函数吧。

#include <sys/types.h>
#inlcude <sys/stat.h>
#include <fcntl.h>
int open(char *filename,int flags,mode_t mode);   //返回：若成功则为新文件描述符，若出错为-1.

flags说明我们的进程将以什么样的方式访问这个文件，O_RDONLY:只读、O_WRONLY:只写、O_RDWR:可读可写。
接下来说明一下mode，这个参数，这个参数指定了我们对文件的访问权限，我们可以通过调用umask函数来设置。
还是直接上表吧，这个表中说明了各种权限。

注意哦，这些文件权限，关系到我们的网络编程中的动态文件（可执行的文件）还是静态文件（html、jpg）图片的发送有关哦。
2.打开文件表
打开文件表位于内核中（所有进程共享），存储着所有的打开文件的信息。存储着文件位置和引用计数，关于这个引用计数可是又一定的技术故事的啦，引用计数技术在这里简单来说，就是有哪些进程打开了这个文件，引用了这个问题，一旦进程销毁后，引用计数就会减一。直到引用计数为0，则该文件被销毁。
Reference:https://www.zhihu.com/question/21539353
这种引用计数的方法也被引用在java的垃圾回收以及C++对象中。关于java的垃圾回收，我这里还是简单的聊一下吧：
2.1.引用计数。大家都知道java是一门面向对象的语言，针对于每一个对象都有的一个引用计数，谁引用了这个对象，这个对象的引用计数+1。引用结束就-1。直到对应的引用计数为0，说明该对象被销毁，这样的垃圾内存需要被回收。但是这样的回收方式，是基于局部的引用的情况，是局部最优解，可能产生无法回收的情况，如下面的例子：由于不方便转载，这个例子还是去这个网站上看比较好：https://www.zhihu.com/question/21539353
2.2.不可达图回收：如果把每一个对象看到一个结点，相互引用的关系看作是结点与结点相连关系，就可以构成一张图，那么那些图中达不到（不可达）的结点就是垃圾结点(垃圾对象)，需要进行回收。所以，我们只要从GC开始对所有结点进行bfs,达不到的结点就是垃圾结点。
题外话说多了，回到我们的正题：
3.v-node表
这个才是我们在硬盘里面的真正文件，所有进程共享。所以会出现多个文件表指向同一个v-node（利用I/O重定向dup2来实现文件描述符指向同一个，这个之后会马上 讲），如果是父子进行（fork）出来的会共享同一个文件表，如下图所示：

二.如何编写健壮的I/O函数

这里举一个非常形象的例子来说明我们的普通的I/O函数，read,write有什么缺陷。假设我们要拷贝1个G的文件，我们如果用read和write一个个字节的拷贝，我们将会重复的陷入（trap into）系统调用，这会大量消耗我们无用的性能。我们基于这样的缺陷，设计了一个带有缓冲区的Rio_read和Rio_write,它的基本设计思路是调用rio_read要求读n个字节时，读缓冲区内有rp->rio_cnt个未读字节。如果缓冲区为空，那么会通过调用read再填满它。（原则其实就是多读数据进来）。
写也是同理。

这里还是直接上代码吧：

/*
 * rio_writen - robustly write n bytes (unbuffered)
 */
/* $begin rio_writen */
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)  /* Interrupted by sig handler return */
        nwritten = 0;    /* and call write() again */
        else
        return -1;       /* errno set by write() */
    }
    nleft -= nwritten;
    bufp += nwritten;
    }
    return n;
}
/* $end rio_writen */


/* 
 * rio_read - This is a wrapper for the Unix read() function that
 *    transfers min(n, rio_cnt) bytes from an internal buffer to a user
 *    buffer, where n is the number of bytes requested by the user and
 *    rio_cnt is the number of unread bytes in the internal buffer. On
 *    entry, rio_read() refills the internal buffer via a call to
 *    read() if the internal buffer is empty.
 */
/* $begin rio_read */
static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    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 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;
}
/* $end rio_read */

/*
 * rio_readinitb - Associate a descriptor with a read buffer and reset buffer
 */
/* $begin rio_readinitb */
void rio_readinitb(rio_t *rp, int fd) 
{
    rp->rio_fd = fd;  
    rp->rio_cnt = 0;  
    rp->rio_bufptr = rp->rio_buf;
}
/* $end rio_readinitb */

/*
 * rio_readnb - Robustly read n bytes (buffered)
 */
/* $begin rio_readnb */
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 */
}
/* $end rio_readnb */

/* 
 * rio_readlineb - robustly read a text line (buffered)
 */
/* $begin 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') {
                n++;
            break;
            }
    } else if (rc == 0) {
        if (n == 1)
        return 0; /* EOF, no data read */
        else
        break;    /* EOF, some data was read */
    } else
        return -1;    /* Error */
    }
    *bufp = 0;
    return n-1;
}

三.I/O重定向

这个就更简单了，有了我们上面懂得UNIX系统中对文件中的抽象。我们利用下面的函数

#include <unitstd.h>
int dup2(int oldfd, int newfd);   //返回：若成功则为非负的描述符，若出错则为-1.

假设我们调用dup2(3,1)，即使让3也指向和文件表1中的同一个v-node,一是标准输出，那么3的输出会直接被定向到标准输出。同理，重定向到网络套接字描述符，重定向到标准输入，那么文件3的输出就变成了网络套接字的输入或者标准输入，这就是重定向I/O以及“一切都是文件”的魅力，刚刚的过程我用下面的图表示出来：

网络编程

这部分我将尽量简化网络例如TCP/IP协议以及HTTP的理论部分，着眼于代码以及相关函数部分

一.客户端与服务端的基本模式

这里我将说明一个最简单的模型，并且我们的第一个服务器也是基于这个模式。
1.客户端发送情况。2.服务器去请求资源。（(1).可能是磁盘中的静态资源，html/css/jpg文件。（2）也可能是动态文件(需要fork出一个进程去execve该程序)）.3.之后就将服务器的相关资源发送。4.客户端进行响应。中间的TCP的可靠传输的实现，HTTPS和SSL的加密等内容，可以看我的其他博客：http://blog.csdn.net/github_33873969/article/details/79422188
这里就不细说了。

二.UNIX有哪些函数与我们的客户端与服务端相关

说了这么多，终于开始调函数了。受首先是我们的客户端，可以想象我们发送一个消息，需要一个对应服务器主机的IP地址，了解到需要发送服从的协议。代码如下：

#include <sys/types.h>
#include <sys/socket.h>

//domain表示使用的网络（常用的是AF_INET）,type常为SOCK_STREAM表示因特网连接的一个结点，
int socket(int domain, int type, int protocol);

现在只是连接起一个套接字，但是，还不能用于读写。

#include <sys/types.h>
#include <sys/socket.h>
int connect(int socketfd,struct sockaddr *serv_addr,int addslen)

emmmm,这个参数的含义我觉得直接看参数名都能看懂，值得注意的是，当connect在执行过程中，函数处于阻塞状态，意思就是说其他套接字不能进行连接状态，直到连接上或者返回报错信息，IP在sockaddr这里结构体中。
我们直接将socket函数和connect函数封装成一个函数。
如下所示：

/* $begin open_clientfd */
int open_clientfd(char *hostname, int port) 
{
    int clientfd;
    struct hostent *hp;
    struct sockaddr_in serveraddr;

    if ((clientfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    return -1; /* Check errno for cause of error */

    /* Fill in the server's IP address and port */
    if ((hp = gethostbyname(hostname)) == NULL)
    return -2; /* Check h_errno for cause of error */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    bcopy((char *)hp->h_addr_list[0], 
      (char *)&serveraddr.sin_addr.s_addr, hp->h_length);
    serveraddr.sin_port = htons(port);

    /* Establish a connection with the server */
    if (connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr)) < 0)
    return -1;
    return clientfd;
}

对于服务器

1.第一个仍然是我们的socket函数，这个不多说了，创建一个套接字描述符。
2.bind函数。

#include <sys/socket.h>
int bind(int socketfd,struct sockaddr *my_addr,int addrlen);

即让操作系统内核将对应的socketfd绑定到我们的my_addr结构题中。
3.listen函数

#include <sys/socket.h>
int listen(int sockfd,int backlog);

这个函数是想主动的套接字转化为监听套接字（服务器专用），这个函数可是有的说呀，这个函数足以和我们的TCP握手协议连接起来，还是先图：
Reference:https://www.cnblogs.com/chris-cp/p/4022262.html

我们都知道TCP有着三次握手和四次挥手协议。但这些协议老实说都在操作系统底层实现了。但是，其中的函数还是会影响到我们的listen函数，我们的listen函数维护着两个队列：
3.1.已完成连接队列，负责排队已经完成三次握手的客户端socket。即是已经是ESTABLISHED状态的连接。
3.2.未完成连接队列：这个更好理解了，就是还处于三次握手的连接(连接处于SYN_RCVD状态)。
这里要注意，listen函数负责三次握手的连接，但是accept函数却不负责三次握手的连接。这个还要注意一点，accept函数只首发处于已连接状态的套接字，所以当以完成连接队列为空的时候,accept会处于阻塞状态。知道已完成连接队列中有已经完成握手的套接字存在。
然后已完成连接队列+未完成连接队列=我们的参数backlog。
4.accept函数

#include <sys/socket.h>
int accept(int listenfd,struct sockaddr *addr,int *addrlen)

这时候，我们输入的listenfd监听描述符就返回出了连接描述符，记住listenfd监听描述符针对的一个服务器，而通过accept创建的连接描述符是针对服务器针对一个客户端的连接。具体的连接过程如下图所示：

图已经很清楚哒。
同时我们也将socket和listen函数封装成一个函数

/* $begin open_listenfd */
int open_listenfd(int port) 
{
    int listenfd, optval=1;
    struct sockaddr_in serveraddr;

    /* Create a socket descriptor */
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    return -1;

    /* Eliminates "Address already in use" error from bind */
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, 
           (const void *)&optval , sizeof(int)) < 0)
    return -1;

    /* Listenfd will be an endpoint for all requests to port
       on any IP address for this host */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET; 
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    serveraddr.sin_port = htons((unsigned short)port); 
    if (bind(listenfd, (SA *)&serveraddr, sizeof(serveraddr)) < 0)
    return -1;

    /* Make it a listening socket ready to accept connection requests */
    if (listen(listenfd, LISTENQ) < 0)
    return -1;
    return listenfd;
}

设计我们的第一个迭代服务器

代码有点多，我就直接下地址啦:https://github.com/HBKO/tiny-server