目录
一、五种网络I/O模型
1.常见的IO模型：
(1)同步阻塞IO：即传统的IO模型，在linux中默认情况下所有的socket都是阻塞模式。
(2)非同步阻塞IO：默认创建的socket都是阻塞的，同步非阻塞IO是在同步阻塞IO的基础上，将socket设置为NONBLOCK，这个可以使用ioctl()来设置。这样做用户线程再发起IO请求后可以立即返回，如果该次读操作并未读取到任何数据，用户线程需要不断的发起IO请求，直到数据到达后，才真正读取到数据，继续执行，整个过程中，虽然用户线程每次发起IO请求都可以立即返回，但是为了等到数据仍然需要不断轮询、重复请求，消耗大部分CPU资源。一般很少直接使用这种模型，而是在其他IO模型中使用非阻塞IO这一特性。
(3)IO多路复用：IO多路复用是建立在select()函数上，使用select函数可以避免同步非阻塞IO模型中的轮询问题，此外poll、epoll都是这种模型。在这种模型下，用户首先将需要进行IO操作的socket添加到select中去，然后阻塞等待select函数返回。当数据到达时，socket被激活，select函数返回，然后系统内核开始read数据并进一步执行操作。使用select最大的优势是用户可以在同一个线程内同时处理多个socket的请求，用户可以注册多个socket，然后不断的调用select读取被激活的socket，即可以达到同一个线程内处理多个IO请求的目的。在同步阻塞模型中，必须调用很多的线程才能达到同样的效果。
（4）信号驱动IO：调用sigaltion系统调用，当内核中IO数据就绪时以SIGIO信号通知请求进程，请求进程再把数据从内核读入到用户空间，这一步是阻塞的。
(5)异步IO：即经典的Proactor设计模式，也称异步非阻塞IO。“真正” 的异步IO需要操作系统更强的支持。在IO多路复用模型中，事件循环将文件句柄的状态事件通知给用户线程，由用户线程自行读取数据、处理数据。而在异步IO模型中，当用户线程收到通知时，数据已经被内核读取完毕，并放在了用户线程的指定缓冲区内，内核在IO完成后通知用户线程直接使用即可。
相比于IO多路复用模型，信号驱动IO和异步IO并不十分常用，不少高性能并发服务程序使用IO多路复用模型+多线程任务处理的架构基本可以满足需求。
二、select()多路复用
select()函数允许进程指示内核等待多个事件（文件描述符）中的任何一个发生，并只有在一个或多个事件发生或经历一段指定时间后唤醒她，然后判断究竟是哪个文件描述符发生了事件并进行相应的处理。
#include<sys/select.h>
#include<sys/time.h>
struct timeval
{
long tv_sec;//seconds
long tv_usec;//microseconds
};
FD_ZERO(fd_set* fds) //清空集合
FD_SET(int fd,fd_set* fds) //将给定的描述符加入集合
FD_ISSET(int fd,fd_set* fds) //判断指定描述符是否在集合中
FD_CLR(int fd,fd_set* fds) //将给定的描述符从文件中删除
int select(int max_fd,fd_set *readset,fd_set *exceptset,struct timeval *timeout);
说明：select监视并等待多个文件描述符属性发生变化，它监视的属性分为三类：分别是readfds（文件描述符有数据到来可读）、writefds（文件描述符可写）、和exceptfds（文件描述符异常）。调用select之后函数会阻塞，直到有描述符就绪（有数据可读、有数据可写、或者错误异常）或者超时（timeout指定等待时间）发生函数才返回。当select()函数返回后，可以通过遍历 fdset，来找到究竟是哪些文件描述符就绪。
1.select函数的返回值是就绪文件描述符的数目，超时返回0，出错返回-1。
2.第一个参数max_fd指待测试的fd的总个数，它的值是待测试的最大文件描述符加1。Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件（读、写、异常）返回；假设需要监测的文件描述符是8、9、10，那么Linux内核也要检测0~7，此时真正待测试的文件描述符为0~10，共11个；
3.中间三个参数readset、writset和exceptset指定要让内核测试读、写和异常条件的fd集合，如果不需要测试可以设为NULL；
4.最后一个参数是设置select的超时时间，如果设为NULL，则代表永不超时；
下面是使用select()实现socket客户端的示意图：
使用select实现服务器端代码：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<ctype.h>
#include<time.h>
#include<pthread.h>
#include<getopt.h>
#include<libgen.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>/*计算数组中元素的个数*/
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))static inline void msleep(unsigned long ms);
static inline void printf_usage(char *progname);
int socket_server_init(char *listen_ip,int listen_port);
int main(int argc,char **argv)
{
int listenfd,connfd;
int serv_port = 0;
int daemon_run = 0;
char *progname = NULL;
int opt;
fd_set rdset;
int rv;
int i,j;
int found;
int maxfd = 0;
char buf[1024];
int fds_array[1024];
/*参数解析*/struct option long_options[] =
{
{"daemon",no_argument,NULL,'b'},
{"port",required_argument,NULL,'p'},
{"help",no_argument,NULL,'h'},
{NULL,0,NULL,0}
};progname = basename(argv[0]);
/*Parser the command line parameters*/
while((opt = getopt_long(argc,argv,"bp:h",long_options,NULL)) != -1)
{
switch(opt)
{
case 'b':
daemon_run = 1;
break;case 'p':
serv_port = atoi(optarg);
break;/*Get help information*/
case 'h':
printf_usage(progname);
return EXIT_SUCCESS;default:
break;
}
}if( !serv_port )
{
printf_usage(progname);
return -1;
}if( (listenfd = socket_server_init(NULL,serv_port)) < 0 )
{
printf("ERROR: %s server listen on prot %d failure\n",argv[0],serv_port);
return -2;
}printf("%s server start to listen on port %d\n",argv[0],serv_port);
/*set program running on background*/if(daemon_run)
{
daemon(0,0);}
for(i = 0;i < ARRAY_SIZE(fds_array);i++)
{
fds_array[i] = -1;
}fds_array[0] = listenfd;
for( ; ; )
{
FD_ZERO(&rdset);for(i = 0;i < ARRAY_SIZE(fds_array); i++)
{
if(fds_array[i] < 0 )
continue;
maxfd = fds_array[i]>maxfd?fds_array[i]:maxfd;
FD_SET(fds_array[i],&rdset);
}/*program will blocked here*/
rv = select(maxfd+1,&rdset,NULL,NULL,NULL);
if(rv < 0)
{
printf("select failure: %s\n",strerror(errno));
break;
}else if(rv == 0)
{
printf("select get timeeout\n");
continue;
}/*listen socket get event means new client start connect now*/
if( FD_ISSET(listenfd,&rdset) )
{if( (connfd = accept(listenfd,(struct sockaddr *)NULL,NULL)) < 0 )
{
printf("accept new client failure : %s\n",strerror(errno));
continue;
}found = 0;
for(i = 0;i < ARRAY_SIZE(fds_array);i++)
{
if(fds_array[i] < 0 )
{
printf("accept new client[%d] and add it into arrray\n",connfd);
fds_array[i] = connfd;
found = 1;
break;
}
}if( !found )
{
printf("accept new client[%d] but full,so refuse it\n",connfd);
close(connfd);
}
}/*data arrive from already connected client*/
else
{for(i = 0;i < ARRAY_SIZE(fds_array);i++)
{if(fds_array[i] < 0 || !FD_ISSET(fds_array[i],&rdset))
continue;if( (rv = read(fds_array[i],buf,sizeof(buf))) <= 0)
{
printf("socket[%d] read failure or get disconnected\n",fds_array[i]);
close(fds_array[i]);
fds_array[i] = -1;
}else
{printf("socket[%d] read get %d bytes data\n",fds_array[i],rv);
/*convert letter from lowercase to uppercase*/
for(j = 0;j < rv;j++)
buf[j] = toupper(buf[j]);
if( write(fds_array[i],buf,rv) < 0 )
{
printf("socke[%d] write failure : %s\n",fds_array[i],strerror(errno));
close(fds_array[i]);
fds_array[i] = -1;
}
}
}}
}
Cleanup:
close(listenfd);
return 0;}
static inline void msleep(unsigned long ms)
{
struct timeval tv;
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;select(0,NULL,NULL,NULL,&tv);
}
static inline void printf_usage(char *progname)
{
printf("Usage: %s [OPTION]...\n",progname);printf("%s is a socket server program,which used to verify client and echo back string from it\n",progname);
printf("\nMandatory arguments to long options are mandatory for short options too : \n");printf(" -b[daemon ] set program running on background\n");
printf(" -p[port ] Socket server port address\n");
printf(" -h[help ] Display this help information\n");
printf("\nExample : %s -b -p 8900\n",progname);
return ;
}int socket_server_init(char *listen_ip,int listen_port)
{
struct sockaddr_in servaddr;
int rv = 0;
int on = 1;
int listenfd;
if( (listenfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
{printf("Use socket() to create a TCP socket failure : %s\n",strerror(errno));
return -1;
}/*Set socket port reuseable ,fix 'Address already in use' bug when socket server restart*/
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(listen_port);/*Listen all the local IP address*/
if( !listen_ip )
{
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
}/*listen the specified IP address*/
else
{
if(inet_pton(AF_INET,listen_ip,&servaddr.sin_addr) <= 0)
{
printf("inet_pton() set listen IP address failure.\n");rv = -2;
goto Cleanup;
}
}
if( bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
{
printf("Use bind() to bind the IP the TCP socket failure : %s\n",strerror(errno));
rv = -3;
goto Cleanup;
}
Cleanup:
if(rv < 0)
close(listenfd);
else
rv = listenfd;
return rv;
}
三、poll()多路复用
select()与poll()系统调用的本质一样，前者在BSD UNIX中引入，后者在System Ⅴ中引入。poll()机制与select()类似，管理多个描述符也是进行轮询，根据描述符状态进行处理，但是poll()没有最大文件描述符的限制（select默认最多1024个）。poll()与select()同样的缺点是包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就位，她的开销随着文件描述符数量的增加而线性增大。
#include <poll.h>
struct pollfd
{
int fd; /* 文件描述符 */
short events; /* 等待的事件 */
short revents; /* 实际发生了的事件 */
};
int poll(struct pollfd *fds,nfds_t nfds,int timeout);
参数说明：
第一个参数用来指向struct pollfd类型的数组，每一个pollfd结构体指定了一个被监视的文件描述符，指示poll()监视多个文件描述符。每个结构体的events域是监视该文件描述符的事件掩码，内核在调用返回时设置这个域，events域中请求任何事件都可能在revents域中返回。下图给出指定的events标志以及测试revents标志的一些常值：
POLLIN | POLLPRI等价于select可读事件，POLLOUT | POLLWRBAND等价于select写事件。POLLIN等价于POLLRDNORM | POLLRDBAND，而POLLOUT等价于POLLWRNORM。例如：要同时监视一个文件描述符是否可读和可写，我们可以设置events为POLLIN | POLLOUT。在poll返回时，我们可以检查revents中的标志，对应于文件描述符请求的events结构体。如果POLLIN事件被设置，则文件描述符可以被读取而不阻塞。如果POLLOUT被设置，则文件描述符可以写入而不导致阻塞。这些标志并不是互斥的：它们可能被同时设置，表示这个文件描述符的读取和写入操作都正常返回而不被阻塞。
第二个参数nfds指定数组中监听元素的个数；
第三个参数timeout指等待的毫秒数。无论I/O是否准备好，poll都会返回。timeout若为负数则表示无限超时，使poll()一直挂起直到一个指定事件发生；timeout为0指示poll调用立即返回并列出准备好的I/O文件描述符，但并不等待其它事件，在这种情况下，poll()就像他的名字一样，一旦选举出来，立即返回；
poll()函数成功调用时 ，poll返回结构体中revents域不为0的文件描述符个数；如果在超时前没有任何事件发生，poll()返回0；失败时，poll()返回-1，并设置errno为下值之一：
EBADF 一个或多个结构体中指定的文件描述符无效
EFAULTfds 指针指向的地址超出进程的地址空间
EINTR 请求的事件之前产生一个信号，调用可以重新发起
EINVALnfds 参数超出PLIMIT_NOFILE值
ENOMEM 可用内存不足、无法完成请求
下面是使用poll()实现socket服务器端的代码：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<ctype.h>
#include<time.h>
#include<pthread.h>
#include<getopt.h>
#include<libgen.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<poll.h>#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
static inline void print_usage(char *progname);int socket_server_init(char *listen_ip,int listen_port);
int main(int argc,char **argv)
{int listenfd,connfd;
int serv_port = 0;
int daemon_run = 0;
char *progname = NULL;
int opt;
int rv;
int i,j;
int found;
int max;
char buf[1024];
struct pollfd fds_array[1024];struct option long_options[] =
{{"daemon",no_argument,NULL,'b'},
{"port",required_argument,NULL,'p'},
{"help",no_argument,NULL,'h'},
{NULL,0,NULL,0}
};progname = basename(argv[0]);
/*Parser the command line parameters*/while( (opt = getopt_long(argc,argv,"bp:h",long_options,NULL)) != -1)
{switch(opt)
{case 'b':
daemon_run = 1;
break;case 'p':
serv_port = atoi(optarg);
break;
/*Get help information*/case 'h':
print_usage(progname);
return EXIT_SUCCESS;default:
break;
}
}
if( !serv_port )
{
print_usage(progname);
}
if( (listenfd = socket_server_init(NULL,serv_port)) < 0 )
{
printf("ERROR: %s server listen on port %d\n",argv[0],serv_port);return -2;
}printf("%s server start to listen on port %d\n",argv[0],serv_port);
/*set program running on background*/if(daemon_run)
{
daemon(0,0);
}for(i = 0;i < ARRAY_SIZE(fds_array);i++)
{
fds_array[i].fd = -1;
}fds_array[0].fd = listenfd;
fds_array[0].events = POLLIN;max = 0;
for( ; ; )
{/*Program will blockd here*/
rv = poll(fds_array,max+1,-1);
if(rv < 0)
{
printf("select failure : %s\n",strerror(errno));
break;
}else if(rv == 0)
{
printf("select get timeout\n");
continue;
}/*listen socket get event means new client start connect now*/
if(fds_array[0].revents & POLLIN)
{if( (connfd = accept(listenfd,(struct sockaddr *)NULL,NULL)) < 0 )
{
printf("accept new client failure : %s\n",strerror(errno));
continue;
}found = 0;
for(i = 1;i < ARRAY_SIZE(fds_array) ; i++)
{
if(fds_array[i].fd < 0)
{
printf("accept new client[%d] and add it into array\n",connfd);fds_array[i].fd = connfd;
fds_array[i].events = POLLIN;
found = 1;
break;}
}if( !found )
{printf("accept new client[%d] buf full,so refuse it\n",connfd);
close(connfd);
continue;
}max = i>max?i:max;
if(--rv <= 0)
continue;
}
/*data arrive from already connected client*/
else
{for(i = 1;i < ARRAY_SIZE(fds_array);i++)
{if(fds_array[i].fd < 0)
continue;if( (rv = read(fds_array[i].fd,buf,sizeof(buf))) <= 0 )
{
printf("socket[%d] read failure or get disconnect.\n",fds_array[i].fd);
close(fds_array[i].fd);
fds_array[i].fd = -1;
}else
{
printf("socket[%d] read get %d datas\n",fds_array[i].fd,rv);
/*convert letter from lowercase to uppercase*/for(j = 0;j < rv; j++)
buf[j] = toupper(buf[j]);if( write(fds_array[i].fd,buf,rv) < 0 )
{
printf("socket[%d] write failure : %s\n",fds_array[i].fd,strerror(errno));
close(fds_array[i].fd);
fds_array[i].fd = -1;
}}
}
}
}
Cleanup:
close(listenfd);
return 0;
}
static inline print_usage(char *progname)
{
printf("Usage: %s [OPTION]...\n",progname);printf("%s is a socket server program,which used to verify client and echo back string form it\n",
progname);printf("\nMandatory arguments to long options are mandatory for short options too:\n");
printf(" -b[daemon] set program running on background\n");
printf(" -p[port] Socket server port address\n");
printf(" -h[help] Display this help information\n");printf("\nExample : %s -b -p 8900\n",progname);
return ;
}int socket_server_init(char *listen_ip,int listen_port)
{struct sockaddr_in servaddr;
int rv = 0;
int on = 1;
int listenfd;if( (listenfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
{
printf("Use socket() to create a TCP socket failure : %s\n",strerror(errno));
return -1;
}/*set socket port resusable,fix 'Address already in use' bug when socket server restart*/
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(listen_port);/*Listen all the local IP address*/
if( !listen_ip )
{
servaddr.sin_addr.s_addr = htonl(listen_port);/*listen the specified IP address*/
else
{
if(inet_pton(AF_INET,listen_ip,&servaddr.sin_addr) <= 0 )
{
printf("inet_pton() set listen IP address failure\n");
rv = -2;
goto Cleanup;
}}
if(bind(listenfd,(struct aockaddr *)&servaddr,sizeof(servaddr)) < 0)
{
printf("Use bind() to bind the TCP socket failure : %s\n",strerror(errno));
rv = -3;
goto Cleanup;
}if(listen(listenfd,13) < 0)
{
printf("Use bind() to bind TCP socket failure : %s\n",strerror(errno));
rv = -4;
goto Cleanup;}
Cleanup:
if(rv < 0)
close(listenfd);
elserv = listenfd;
return rv;}
}
四、epoll()多路复用
epoll()的实现与select()实现完全不同。epoll通过在Linux内核中申请一个简易的文件系统，把原来的select/poll分成了下面三个部分：
（1）调用epoll_create()建立一个epoll对象（在epoll文件系统中为这个句柄对象分配资源）
（2）调用epoll_ctl向epoll对象中添加100万个套接字
（3）调用epoll_wait收集发生事件的连接
如此，要实现与select/poll相同的场景，只需要在进程启动时建立一个epoll对象，然后在需要的时候向这个epoll对象中添加或者删除连接。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有将这100万个连接句柄全部复制给操作系统，内核也不需要遍历全部连接。
1.创建epoll实例：epoll_create()
#include<sys/epoll.h>
int epoll_create(int size);
系统调用epoll_create()创建了一个新的epoll()实例，其对应的兴趣列表初始化为空。成功返回文件描述符，是=失败返回-1；参数size指定了我们想要通过实例来检查的文件描述符的个数。现在一般忽略不用。
2.修改epoll()兴趣列表：epoll_ctl()
#include <sys/epoll.h>
int epoll_ctl(int epfd,int op,int fd,struct epoll_event *ev);
参数说明：
第一个参数epfd是epoll_ctl的返回值；
第二个参数op用来指定需要执行的操作，他可以是如下几种值：
EPOLL_CTL_ADD (添加事件)：
将文件描述符添加到
epoll实例的监听集合中，以便监听该文件描述符上的事件。EPOLL_CTL_MOD (修改事件)：
修改
epoll实例中已经存在的文件描述符的监听事件，可以用于修改感兴趣的事件类型或者修改文件描述符关联的数据。EPOLL_CTL_DEL (删除事件)：
从
epoll实例的监听集合中删除一个文件描述符，不再监听它上面的事件。第三个参数fd指明了要修改兴趣列表中哪一个文件描述符的设定。该参数可以代表管道、FIFO、套接字、POSIX消息队列、inotify实例、终端、设备，甚至是另一个epoll实例的文件描述符。但是，这里fd、不能作为普通文件或目录的文件描述符；
第四个参数ev是指向结构体epoll_event的指针，结构体定义如下：
typedef union epoll_data
{
void *ptr; /* Pointer to user-defind data */
int fd; /* File descripter */
uint32_t u32; /* 32-bit interger */
uint64 u64; /* 64 bit interger */
}epoll_data_t;
struct epoll_event
{
uint32 events; /* epoll events(bit mask) */
epoll_data_t data data; /* User data */
};
·events字段是一个位掩码，他指定了我们为待检查的描述符fd上的所感兴趣的集合
·data字段是一个联合体，当描述符fd稍后称为就绪态时，联合的成员可用来指定传回给调用进程的信息
系统调用epoll_ctl()能够修改由文件描述符epfd所代表的epoll实例中的兴趣列表 。成功返回0.出错返回-1；
3.等待事件：epoll_wait()
#include <sys/epoll.h>
int epoll_wait(int epfd,struct epoll_event *evlist,int maxevents,int timeout);
参数说明：
第一个参数epfd是epoll_create的返回值；
第二个参数evlist所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；
第三个参数maxevents所制定evlist数组中包含的元素个数；
第四个参数timeout用来确定epoll_wait的阻塞行为，有以下几种：
timeout等于-1，一直阻塞，直到兴趣列表中的文件描述符有事件产生或者直到捕捉到一个信号为止；
timeout等于0，执行一次非阻塞式的检查，看兴趣列表中的文件描述符上发生了哪个事件；
timeout大于0，调用将阻塞至多timeout毫秒，直到文件描述符上有事件发生，或者直到捕捉到一个信号为止。
数组evlist中，每个元素返回的都是单个就绪态文件描述符的信息。events字段返回在该文件描述符上已经发生事件的事件掩码。data字段返回的是我们在描述符上使用epoll_ctl()注册感兴趣的事件时在ev.data中所指定的值。
当我们调用epoll_ctl()时可以在ev.events职工指定的位掩码以及由epoll_wait()返回的evlist[].events中的值如下所示：
下面是通过epoll实现客户端的代码：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<ctype.h>
#include<time.h>
#include<pthread.h>
#include<getopt.h>
#include<libgen.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<sys/resource.h>#define MAX_EVENTS 512
#define ARRAY_SIZE (sizeof(x)/sizeof(x[0]))static inline void print_usage(char *progrname);
int socket_server_init(char *listen_ip,int listen_port);
void set_socket_rlimit(void);int main(int argc,char **argv)
{
int listenfd,connfd;
int serv_port = 0;
int daemon_run = 0;
char *progname = NULL;
int opt;
int rv;
int i,j;
int found;
char buf[1024];
int epollfd;
struct epoll_event event;
struct epoll_event event_array[MAX_EVENTS];
int events;
struct option long_options[] =
{
{"daemon",no_argument,NULL,'b'},
{"port",required_argument,NULL,'p'},
{"help",no_argument,NULL,'h'},
{NULL,0,NULL,0}
};progname = basename(argv[0]);
/*Parser the command line parameters*/
while((opt = getopt_long(argc,argv,"bp:h",long_options,NULL)) != -1)
{
switch(opt)
{
case 'b':
daemon_run = 1;
break;case 'p':
serv_port = atoi(optarg);
break;/*get help information*/
case 'h':
print_usage(progname);
return EXIT_SUCCESS;default:
break;
}
}if( !serv_port )
{
print_usage(progname);
return -1;
}/*set max open socket count*/
set_socket_rlimit();
if( (listenfd = socket_server_init(NULL,serv_port)) < 0)
{
printf("ERROR: %s server listen on port %d failure\n",argv[0],serv_port);
return -2;
}printf("%s server start to listen on port %d\n",argv[0],serv_port);
/*set program running on background*/
if(daemon_run)
{
daemon(0,0);
}if( (epollfd = epoll_create(MAX_EVENTS)) < 0 )
{
printf("epoll_create() failure : %s\n",strerror(errno));
return -3;
}event.events = EPOLLIN;
event.data.fd = listenfd;
if( epoll_ctl(epollfd,EPOLL_CTL_ADD,listenfd,&event) < 0 )
{
printf("epoll add listen socket failure : %s\n",strerror(errno));
return -4;
}
for( ; ; )
{/*program will blocked here*/
events = epoll_wait(epollfd,event_array,MAX_EVENTS,-1);
if(events < 0)
{
printf("epoll failure : %s\n",strerror(errno));
break;
}else if(events == 0)
{
printf("epoll get timeout\n");
continue;
}/*rv > 0 is the active events count*/
for(i = 0;i < events;i++)
{
if( (event_array[i].events&EPOLLERR)||(event_array[i].events&EPOLLHUP) )
{
printf("epoll_wait get error on fd[%d] : %s\n",event_array[i].data.fd,NULL);
epoll_ctl(epollfd,EPOLL_CTL_DEL,event_array[i].data.fd,NULL);
close(event_array[i].data.fd);
}/* listen socket get event means new client start connect now */
if(event_array[i].data.fd == listenfd )
{
if( ( connfd = accept(listenfd,(struct sockaddr *)NULL,NULL) ) < 0 )
{
printf("accept new client failure : %s\n",strerror(errno));
continue;
}event.data.fd = connfd;
event.events = EPOLLIN;if( epoll_ctl(epollfd,EPOLL_CTL_ADD,connfd,&event) < 0 )
{
printf("epoll add client socket failure : %s\n",strerror(errno));
close(event_array[i].data.fd);
continue;
}printf("epoll add new client socket[%d] ok\n",connfd);
}/*already connected client socket get data incoming */
else
{
if( (rv = read(event_array[i].data.fd,buf,sizeof(buf))) <= 0 )
{
printf("socket[%d] read failure or get disconnect and will be removed\n",event_array[i].data.fd);
epoll_ctl(epollfd,EPOLL_CTL_DEL,event_array[i].data.fd,NULL);
close(event_array[i].data.fd);
continue;
}
else
{
printf("socket[%d] read get %d bytes data\n",event_array[i].data.fd,rv);/*convert letter from lowercase to uppercase*/
for(j = 0;j < rv;j++)
buf[j] = toupper(buf[j]);
if(write(event_array[i].data.fd,buf,rv) < 0)
{
printf("socket[%d] write failure : %s\n",event_array[i].data.fd,strerror(errno));epoll_ctl(epollfd,EPOLL_CTL_DEL,event_array[i].data.fd,NULL);
close(event_array[i].data.fd);
}}
}
}
}Cleanup:
close(listenfd);
return 0;
}static inline void print_usage(char *progname)
{
printf("Usage: %s [OPTION]...\n",progname);
printf("%s is a socket server program,which used to verify client and echo back string from it\n",progname);printf("\nMandatory arguments to long options are mandatory for short options too :\n");
printf(" -b[daemon] set program running on background\n");
printf(" -p[port ] Socket server port daaress\n");
printf( " -h[help ] Display this help information\n");printf("\nExample : %s -b -p 8900\n",progname);
return ;
}
int socket_server_init(char *listen_ip,int listen_port)
{struct sockaddr_in servaddr;
int rv = 0;
int on = 1;
int listenfd;if( (listenfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
{
printf("Use socket() to create a TCP socket failure : %s\n",strerror(errno));
return -1;
}/*Set socket port reuseable ,fix 'Address already in use 'bug when socket server restart */
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(listen_port);/*listen all the local IP Address*/
if( !listen_ip )
{
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
}/*listen the specified IP address*/
else
{if( inet_pton(AF_INET,listen_ip,&servaddr.sin_addr) <= 0 )
{
printf("inet_pton() set listen IP address failure\n");
rv = -2;
goto Cleanup;
}
}
if( bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
{
printf("Use bind() to bind the TCP socket failure : %s\n",strerror(errno));rv = -3;
goto Cleanup;
}if( listen(listenfd,64) < 0 )
{
printf("Listen failure :%s\n",strerror(errno));rv = -4;
goto Cleanup;
}Cleanup:
if( rv < 0 )
close(listenfd);
else
rv = listenfd;
return rv;
}/*Set open file description count to Max*/
void set_socket_rlimit(void)
{
struct rlimit limit = {0};
getrlimit(RLIMIT_NOFILE,&limit);
limit.rlim_cur = limit.rlim_max;
setrlimit(RLIMIT_NOFILE,&limit);
printf("set socket open fd max count to %d\n",limit.rlim_max);
}
935
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
