Linux 网络编程(实现多路IO转接服务器)

1.select函数实现多路IO转接服务器

select函数原型：包含在头文件<sys/time.h>，<sys/types.h>和<unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

作用：确定一个或多个套接字的状态等待指向并同步

参数nfds：就是服务器的套接字(监听的所有文件描述符中，最大文件描述符+1)

参数readfds：监听读状态（读 文件描述符监听集合）

参数writefds：监听写状态（写 文件描述符监听集合）

参数exceptfds：监听异常状态（异常 文件描述符监听集合）

参数timeout：超时参数

>0：表述设置监听超时时长

NULL：阻塞监听

0：表示非阻塞监听，轮询

返回值：

>0：所有监听集合中，满足对应事件的总数

0：没有满足监听条件的文件描述符

-1：出错

需要配合使用的有如下四个函数

void FD_CLR(int fd, fd_set *set);//将一个文件描述符从监听集合中移除
int  FD_ISSET(int fd, fd_set *set);//判断一个文件描述符是否在监听集合中，存在返回1，否则返回0
void FD_SET(int fd, fd_set *set);//将待监听的文件描述符，添加到监听集合中
void FD_ZERO(fd_set *set);//清空一个文件描述符集合

select模型的优缺点：

缺点：监听上限受文件描述符限制，最大1024

检测满足条件的fd，需要自己添加业务逻辑提高效率，提高了编码难度

优点：可以跨平台

select多路IO服务器代码实例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>#include "wrap.h"#define SER_PORT 9990int main(int argc, char* argv[])
{int lfd = Socket(AF_INET, SOCK_STREAM, 0);struct sockaddr_in serv_addr;serv_addr.sin_family = AF_INET;serv_addr.sin_port = htons(SER_PORT);serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);Bind(lfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));Listen(lfd, 128);//进行IO多路转接fd_set allSock;//全部的sockint ret;//select返回值存放int maxfd = lfd;//最大文件描述符fd_set allread;//读socket集合struct sockaddr_in client_addr;//存放客户端信息的结构体对象bzero(&client_addr, sizeof(client_addr));int connfd;//保存客户端的idint i = 0;char buf[1024] = {0};FD_ZERO(&allSock);FD_SET(lfd, &allSock);//先存放服务器的sockwhile(1){allread = allSock;ret = select(maxfd+1, &allread, NULL, NULL, NULL);if(ret < 0)//表示没有客户端发来消息{perr_exit("select error");}if(FD_ISSET(lfd, &allread))//如果服务器socket存在监听中则表示有可以和端连接{int client_len = sizeof(client_addr);connfd = Accept(lfd, (struct sockaddr*)&client_addr, &client_len);//把客户端socket加入到监听集合中FD_SET(connfd, &allSock);//判断最大文件描述符是否有变化if(maxfd<connfd){maxfd = connfd;}if(ret == 1)//表示响应的客户端只有一个，那就是表示只需要执行接受连//接的操作，下面的语句就不需要用执行{continue;}}for(i = lfd+1; i <= maxfd; i++){if(FD_ISSET(i, &allread)){int n = read(i, buf, 1024);//判断客户端的状态if(n == 0)//表示客户端下线{close(i);//关闭客户端FD_CLR(i, &allSock);//从集合中移除}else if(n < 0)//表示读取出错{perr_exit("read error");}for(int j = 0;j < n; j++){buf[j] = toupper(buf[j]);}write(i, buf, n);write(STDOUT_FILENO, buf, n);    }}}Close(lfd); return 0;
}

2.poll函数实现的多路IO转接服务器

poll函数原型：包含在头文件<poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);参数解释：参数fds：监听文件描述符的数组参数nfds：监听数组的实际有效个数参数timeout：超时时长
返回值：返回满足对应监听事件的文件描述符总个数//需要使用到的结构体  该结构体作为poll函数的第一个参数
struct pollfd {int   fd;         /* 待监听的文件描述符 */short events;     /* 待监听的文件描述符对应的监听事件 */short revents;    /* 传入时给0，如果满足对应事件的话，返回非0，表示返回的监听事件集合 */};

优缺点：

优点：自带数组结构，可以将监听事件集合和返回事件集合分离，可以扩展监听数量的上限，

缺点：不能跨平台，无法直接定位满足监听事件的文件描述符，编码难度大

poll实现的多路IO转接服务器代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include <ctype.h>#include "wrap.h"#define MAXLINE 80
#define SERV_PORT 8000
#define OPEN_MAX 1024int main(int argc, char *argv[])
{int i, j, maxi, listenfd, connfd, sockfd;int nready;                                 /*接收poll返回值, 记录满足监听事件的fd个数*/ssize_t n;char buf[MAXLINE], str[INET_ADDRSTRLEN];socklen_t clilen;struct pollfd client[OPEN_MAX];struct sockaddr_in cliaddr, servaddr;listenfd = Socket(AF_INET, SOCK_STREAM, 0);int opt = 1;setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = htonl(INADDR_ANY);servaddr.sin_port = htons(SERV_PORT);Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));Listen(listenfd, 128);client[0].fd = listenfd;                    /* 要监听的第一个文件描述符 存入client[0]*/client[0].events = POLLIN;                  /* listenfd监听普通读事件 */for (i = 1; i < OPEN_MAX; i++)client[i].fd = -1;                      /* 用-1初始化client[]里剩下元素 0也是文件描述符,不能用 */maxi = 0;                                   /* client[]数组有效元素中最大元素下标 */for ( ; ; ) {nready = poll(client, maxi+1, -1);      /* 阻塞监听是否有客户端链接请求 */if (client[0].revents & POLLIN) {       /* listenfd有读事件就绪 */clilen = sizeof(cliaddr);connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);/* 接收客户端请求 Accept 不会阻塞 */printf("received from %s at PORT %d\n",inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),ntohs(cliaddr.sin_port));for (i = 1; i < OPEN_MAX; i++)if (client[i].fd < 0) {client[i].fd = connfd;      /* 找到client[]中空闲的位置,存放accept返回的connfd */break;}if (i == OPEN_MAX)                  /* 达到了最大客户端数 */perr_exit("too many clients");client[i].events = POLLIN;          /* 设置刚刚返回的connfd,监控读事件 */if (i > maxi)maxi = i;                       /* 更新client[]中最大元素下标 */if (--nready <= 0)continue;                       /* 没有更多就绪事件时,继续回到poll阻塞 */}for (i = 1; i <= maxi; i++) {           /* 前面的if没满足,说明没有listenfd满足. 检测client[] 看是那个connfd就绪 */if ((sockfd = client[i].fd) < 0)continue;if (client[i].revents & POLLIN) {if ((n = Read(sockfd, buf, MAXLINE)) < 0) {/* connection reset by client */if (errno == ECONNRESET) {  /* 收到RST标志 */printf("client[%d] aborted connection\n", i);Close(sockfd);client[i].fd = -1;      /* poll中不监控该文件描述符,直接置为-1即可,不用像select中那样移除 */} elseperr_exit("read error");} else if (n == 0) {            /* 说明客户端先关闭链接 */printf("client[%d] closed connection\n", i);Close(sockfd);client[i].fd = -1;} else {for (j = 0; j < n; j++)buf[j] = toupper(buf[j]);Writen(sockfd, buf, n);}if (--nready <= 0)break;}}}return 0;
}

3.epoll模型实现的多路IO转接服务器

epoll本质上是一个平衡二叉树

epoll函数的工作方式：

epoll的两种工作方式：1.水平触发（LT）2.边缘触发（ET）

LT模式：若就绪的事件一次没有处理完要做的事件，就会一直去处理。即就会将没有处理完的事件继续放回到就绪队列之中（即那个内核中的链表），一直进行处理(缓冲区剩余未读尽的数据会导致 epoll_wait 返回)

ET模式：就绪的事件只能处理一次，若没有处理完会在下次的其它事件就绪时再进行处理。而若以后再也没有就绪的事件，那么剩余的那部分数据也会随之而丢，高效模式，只支持非阻塞模式 (缓冲区剩余未读尽的数据不会导致 epoll_wait 返回)

由此可见：ET模式的效率比LT模式的效率要高很多。只是如果使用ET模式，就要保证每次进行数据处理时，要将其处理完，不能造成数据丢失，这样对编写代码的人要求就比较高。

注意：ET模式只支持非阻塞的读写：为了保证数据的完整性。

1.函数的解析

1.epoll_crl函数：包含在头文件<sys/epoll.h>

作用：用于操作epoll函数所生成的实例，

函数原型：

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
参数解释：参数epfd：epoll_create函数返回的epoll实例的句柄参数op：表示需要执行的操作，有添加，删除，修改可选选项：1.EPOLL_CTL_ADD：在文件描述符epfd所引用的epoll实例上注册目标文件描述符fd，并将事件事件与内部文件链接到fd。2.EPOLL_CTL_MOD：更改与目标文件描述符fd相关联的事件。3.EPOLL_CTL_DEL：从epfd引用的epoll实例中删除（注销）目标文件描述符fd。该事件将被忽略，并且可以为NULL参数fd：需要添加，修改，删除的socket文件描述符参数event：需要epoll监视的fd对应的事件类型(本质上是struct epoll_event结构体对象的指针)
返回值：成功时，epoll_ctl（）返回零。发生错误时，epoll_ctl（）返回-1并正确设置了errno使用到的结构体typedef union epoll_data {//这是一个联合体void        *ptr;int          fd;    //对应监听的事件socketuint32_t     u32;uint64_t     u64;} epoll_data_t;struct epoll_event {uint32_t     events;      /* epoll监视的事件类型 */epoll_data_t data;        /* 用户数据 */};
events成员的选项宏：1.EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；2.EPOLLOUT：表示对应的文件描述符可以写；3.EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；4.EPOLLERR：表示对应的文件描述符发生错误； EPOLLHUP：表示对应的文件描述符被挂断；5.EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。6.EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里。

2.epoll_create函数：包含在头文件<sys/epoll.h>

函数原型：

int epoll_create(int size);函数解释：该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket数

3.epoll_wait函数

函数原型：

int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);作用：该函数用于轮询I/O事件的发生参数解释：1.epfd:由epoll_create 生成的epoll专用的文件描述符； 2.epoll_event:用于回传待处理事件的数组； 3.maxevents:每次能处理的事件总数4.timeout:等待I/O事件发生的超时值(单位我也不太清楚)；-1相当于阻塞，
·           0相当于非阻塞，大于0表示设置的超时时间返回值：返回发生事件的soket数量

epoll实现的多路IO转接服务器代码实例

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/epoll.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<errno.h>
#include<ctype.h>
#include<stdlib.h>#include "wrap.h"#define SERV_PORT 10001
#define OPEN_MAX 5000 //可以监听的socket数量int main()
{int lfd = Socket(AF_INET, SOCK_STREAM, 0);struct sockaddr_in serv_addr;bzero(&serv_addr, sizeof(serv_addr));//把serv_addr对象清零serv_addr.sin_family = AF_INET;serv_addr.sin_port = htons(SERV_PORT);serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);Bind(lfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));Listen(lfd, 128);ssize_t efd = epoll_create(OPEN_MAX);//创建epoll模型，efd指向红黑书根节点if(efd == -1){perr_exit("epoll_create error");}struct epoll_event tep;//作为epoll_ctl的参数struct epoll_event ep[OPEN_MAX];//作为epoll_wait的参数struct sockaddr_in client_addr;//创建一个客户端使用的结构体bzero(&client_addr, sizeof(client_addr));tep.events = EPOLLIN;//这里指定lfd套接字指定为读事件tep.data.fd = lfd;//把tep结构体邦上lfd(初始化)int res = epoll_ctl(efd, EPOLL_CTL_ADD, lfd, &tep);if(res == -1){perr_exit("epoll_ctl error");}while(1){//epoll为server阻塞监听事件,会返回有事件的socket的数量,把所有有事件的客户端socket存放到ep数组中int nready = epoll_wait(efd, ep, OPEN_MAX, -1);//-1表示阻塞if(nready == -1)//表示出错{perr_exit("epoll_wait error");}int i = 0;for(i = 0;i < nready;i++){if(!ep[i].events & EPOLLIN)//判断是否是读事件{continue;//如果不是读事件则继续循环}if(ep[i].data.fd == lfd){//表示有连接请求int client_len = sizeof(client_addr);int connfd = Accept(lfd,(struct sockaddr*)&client_addr,&client_len);//邦定事件类型tep.events = EPOLLIN;tep.data.fd = connfd;res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);if(res == -1){perr_exit("epoll_ctl error");}}else//表示有读事件{int clientfd = ep[i].data.fd;char buf[1024] = {0};int n = Read(clientfd, buf, 1024);if(n == 0)//表示客户端下线{res = epoll_ctl(efd, EPOLL_CTL_DEL, clientfd, NULL);if(res == -1){perr_exit("epoll_ctl del error");}close(clientfd);//关闭客户端printf("client[%d] closed connect\n", clientfd);}else if(n == -1){perror("read < 0 error:");//也要从数组中删除res = epoll_ctl(efd, EPOLL_CTL_DEL, clientfd, NULL);close(clientfd);}else{for(i = 0; i < n;i ++){buf[i] = toupper(buf[i]);}Write(STDOUT_FILENO, buf, n);Write(clientfd, buf, n);}}}}Close(lfd);Close(efd);//把epoll实例关闭return 0;
}    

epoll两种工作模型实现代码

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <unistd.h>#define MAXLINE 10
#define SERV_PORT 9000int main(void)
{struct sockaddr_in servaddr, cliaddr;socklen_t cliaddr_len;int listenfd, connfd;char buf[MAXLINE];char str[INET_ADDRSTRLEN];int efd;listenfd = socket(AF_INET, SOCK_STREAM, 0);bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = htonl(INADDR_ANY);servaddr.sin_port = htons(SERV_PORT);bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));listen(listenfd, 20);struct epoll_event event;struct epoll_event resevent[10];int res, len;efd = epoll_create(10);event.events = EPOLLIN | EPOLLET;     /* ET 边沿触发 *///event.events = EPOLLIN;                 /* 默认 LT 水平触发 */printf("Accepting connections ...\n");cliaddr_len = sizeof(cliaddr);connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);printf("received from %s at PORT %d\n",inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),ntohs(cliaddr.sin_port));event.data.fd = connfd;epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event);while (1) {res = epoll_wait(efd, resevent, 10, -1);printf("res %d\n", res);if (resevent[0].data.fd == connfd) {len = read(connfd, buf, MAXLINE/2);         //readn(500)   write(STDOUT_FILENO, buf, len);}}return 0;
}