用poll来实现群聊功能

客户端：

#include<stdio.h>
#include<sys/socket.h>
#include<sys/poll.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<unistd.h>
#include<fcntl.h>
int main(int argc,const char *argv[])
{
	if(argc < 3)
	{
		printf("usage: %s ip_address port_number\n",argv[0]);
		return 1;
	}

	const char* ip = argv[1];
	int port = atoi(argv[2]);

	struct sockaddr_in sockaddr;
	sockaddr.sin_family = AF_INET;
	sockaddr.sin_port = htons(port);
	inet_pton(AF_INET,ip,&sockaddr.sin_addr);

	int sockfd = socket(AF_INET,SOCK_STREAM,0);

	if(connect(sockfd,(struct sockaddr*)&sockaddr,sizeof(sockaddr)) < 0)
	{
		perror("connect error:");
		close(sockfd);
		return 1;
	}

	struct pollfd fds[2];
	fds[0].fd = STDIN_FILENO;
	fds[0].events = POLLIN;
	fds[0].revents = 0;
	fds[1].fd = sockfd;
	fds[1].events = POLLIN;
	fds[1].revents = 0;
	char buf[BUFSIZ];
	int pipefd[2];
	int ret = pipe(pipefd);
	if(ret == -1)
	{
		perror("pipe error:");
		exit(1);
	}

	while(1)
	{
		ret = poll(fds,2,-1);
		if(ret < 0)
		{
			printf("poll failure\n");
			break;
		}

		if(fds[0].revents & POLLIN)
		{
			splice(STDIN_FILENO,NULL,pipefd[1],NULL,32768,SPLICE_F_MORE | SPLICE_F_MOVE);
			splice(pipefd[0],NULL,sockfd,NULL,32768,SPLICE_F_MORE | SPLICE_F_MOVE);
		}

		/*不建议使用该方法判断对端是否关闭，因为若对端在发送一次消息后立即关闭连接，
		会立即触发该事件，导致本端读不到最后的数据。从recv的返回值来判断对端是否关闭
		才是比较好的做法*/
		/*if(fds[1].revents & POLLRDHUP) 			
		{								 		
			printf("server close the connection\n");
			break;
		}*/

		if(fds[1].revents & POLLIN)
		{
			//memset(buf,'\0',sizeof(buf));
			int ret = recv(fds[1].fd,buf,sizeof(buf),0);
			if(ret == 0)
			{
				printf("server close the connection\n");
				break;
			}
			buf[ret] = '\0';
			printf("%s",buf);
		}
	}
	close(sockfd);
	close(pipefd[0]);
	close(pipefd[1]);
	return 0;
}

服务器：

#include<stdio.h>
#include<errno.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<sys/poll.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#define MAX_CLIENT_NUMBER 5 //最大客户数量
struct client_data{
	sockaddr_in address;
	char *write_buf;
	char buf[BUFSIZ];
};
//设置非阻塞
void setnonblock(int fd)
{
	int flag = fcntl(fd,F_GETFL);
	flag |= O_NONBLOCK;
	fcntl(fd,F_SETFL,flag);
}
//设置端口复用
void set_reuseaddr(int fd)
{
	int reuse = 1;
	setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse));
}
int main(int argc,const char *argv[])
{
	if(argc < 3)
	{
		printf("usage: %s ip_address port_number\n",argv[0]);
		exit(1);
	}

	const char *ip = argv[1];
	int port = atoi(argv[2]);

	struct sockaddr_in listenaddr,connaddr;
	socklen_t connlen = sizeof(connaddr);
	listenaddr.sin_family = AF_INET;
	listenaddr.sin_port = htons(port);
	inet_pton(AF_INET,ip,&listenaddr.sin_addr);

	int listenfd = socket(AF_INET,SOCK_STREAM,0);
	bind(listenfd,(struct sockaddr*)&listenaddr,sizeof(listenaddr));
	listen(listenfd,3);

	/*存放客户数据，通过客户的socket来索引数组*/
	client_data *user = new client_data[MAX_CLIENT_NUMBER + 4];
	pollfd fds[MAX_CLIENT_NUMBER + 1];
	int client_number = 0;
	for(int i = 1;i <= MAX_CLIENT_NUMBER;i++)
	{
		fds[i].fd = -1;
		fds[i].events = 0;
		fds[i].revents = 0;
	}
	set_reuseaddr(listenfd);//允许端口复用
	fds[0].fd = listenfd;
	fds[0].events = POLLIN;
	fds[0].revents = 0;

	while(1)
	{
		int ret = poll(fds,client_number + 1,-1);
		if(ret < 0)
		{
			perror("poll error:");
			exit(1);
		}
		
		for(int i = 0;i < client_number + 1;i++)
		{
			int sockfd = fds[i].fd;
			if((sockfd == listenfd) && (fds[i].revents & POLLIN))
			{
				int connfd = accept(sockfd,(struct sockaddr*)&connaddr,&connlen);
				if(connfd < 0)
				{
					perror("accept error:");
					continue;
				}
				if(client_number >= MAX_CLIENT_NUMBER)//请求太多则关闭新的连接
				{
					const char *info = "too many users\n";
					printf("%s",info);
					int n = send(connfd,info,strlen(info),0);
					close(connfd);
					continue;
				}
				user[connfd].address = connaddr;
				fds[++client_number].fd = connfd;
				fds[client_number].events = POLLIN | POLLRDHUP;
				fds[client_number].revents = 0;
				setnonblock(connfd);
				printf("come a new user,now hava %d users\n",client_number);
			}
			else if(fds[i].revents & POLLRDHUP)
			{
				char ip[100];
				printf("ip is %s and port is %d client close connection\n",inet_ntop(AF_INET,&user[sockfd].address.sin_addr,ip,sizeof(ip)),ntohs(user[sockfd].address.sin_port));
				/*用最后一个socket的数据，替换当前要关闭连接的socket数据*/
				user[sockfd] = user[fds[client_number].fd];
				fds[i] = fds[client_number];
				i--;//当前发生的事件已经替换为未处理的事件，所以要重新处理。
				client_number--;//客户数量减一
				close(sockfd);
			}
			else if(fds[i].revents & POLLIN)
			{
				memset(user[sockfd].buf,'\0',sizeof(user[sockfd].buf));
				int n = recv(sockfd,user[sockfd].buf,sizeof(user[sockfd].buf),0);
				if(n == -1)
				{
					if(errno != EAGAIN)
					{
						perror("recv error:");
						user[sockfd] = user[fds[client_number].fd];
						fds[i] = fds[client_number];
						close(sockfd);
						i--;
						client_number--;
					}
				}
				else if(n > 0){
					/*如果收到客户数据，则通知其他socket连接准备写数据*/
					for(int i = 1;i <= client_number;i++)
					{
						if(fds[i].fd == sockfd)
							continue;
						fds[i].events |= ~POLLIN;
						fds[i].events |= POLLOUT;
						user[fds[i].fd].write_buf = user[sockfd].buf;
					}
				}
			}
			else if(fds[i].revents & POLLOUT)
			{
				if(user[sockfd].write_buf != NULL)
				{
					int n = send(sockfd,user[sockfd].write_buf,strlen(user[sockfd].write_buf),0);
					if(n == -1)
					{
						perror("send error:");
						continue;
					}
					user[sockfd].write_buf = NULL;
					/*写完数据重新注册fds[i]上的可读事件*/
					fds[i].events |= ~POLLOUT;
					fds[i].events |= POLLIN;
				}
			}
		}
	}
	close(listenfd);
	delete [] user;
	return 0;
}

参考: Linux高性能服务器编程 游双