用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高性能服務器編程 遊雙