简易命令行聊天室程序

//实现epoll服务器端需要三个函数。
//1）epoll_create：创建保持epoll文件描述符的空间，即epoll例程，size只是建议的例程大小。
#include<sys/epoll.h>
int epoll_create(int size);//成功时返回epoll文件描述符，失败时返回-1
/**
2)epoll_ctl:向空间注册并且注销文件描述符。
要使用epoll_event结构体：
struct epoll_event{
    __uint32_t events;
    epoll_data_t data;
}
    typedef union epoll_data{
         void * ptr;
         int fd;
         __uint32_t u32;
         __uint64_t u64;
    }epoll_data_t;
这里注意要声明足够大的epoll_event结构体数组后，传递给epoll_eait函数时，发生变化的文件描述符信息被填入该数组。可以直接申明也可以动态分配。
op有三个宏选项：
@EPOLL_CTL_ADD：将文件描述符注册到epoll例程。
@EPOLL_CTL_DEL：从epoll例程中删除文件描述符。
@EPOLL_CTL_MOD：更改注册的文件描述符的关注事件发生情况。
events常用的可以保存的常量以及事件类型。
@EPOLLIN：需要读取数据的情况.
@EPOLLET:以边缘触发的方式得到事件通知。
@EPOLLONESHOT：发生一次事件后，相应文件描述符不在接收事件通知，需要再次设置事件才能继续使用。

**/
int epoll_ctl(int epfd,int op,int fd,struct epoll_event* event);
//成功时返回0，失败时返回-1
int epoll_wait(int wpfd,struct epoll_event* events,int maxevents,int timeout);
//成功时返回发生事件的文件描述符数，失败时返回-1

int fd_sock = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0);

    pid_t pid = fork();
    if(pid == 0){//子进程负责写
        write_routine(clntSock,buff);
    }
    else{//父进程负责读
        read_routine(clntSock,buff);
    }

//utility.h
#ifndef _UTILITY_
#define _UTILITY_

#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<sys/epoll.h>
#include<list>
#include<string>

using namespace std;
/*存储客户端文件描述符*/
list<int> clientLists;

#define MAX_EVENT_NUMBER 1024

#define BUFF_SIZE 400

/*服务器ip*/
#define SERVERIP "127.0.0.1"

/*端口号(只要在1024~5000都行)*/
#define PORT "6666"

/*epoll例程大小*/
#define EPOLLSIZE 50 

#define EXIT "exit"

/**
  *将文件描述符设置成非阻塞的
  *返回文件描述符旧的状态，以便日后恢复该状态标志
**/
int setNonBlocking(int fd){
    int oldOption = fcntl(fd,F_GETFL);
    int newOption = oldOption | O_NONBLOCK;
    fcntl(fd,F_SETFL,newOption);
    return oldOption;
}

/**
 * 将文件描述符fd上的EPOLLIN注册到epollfd指示的内核事件表中
 * 参数enable_et指定是否对fd启用ET模式  
**/
void addfd(int epollfd,int fd,bool enable_et){
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;//主要读取客服端套接字信息
    if(enable_et){
        event.events |= EPOLLET;
    }
    setNonBlocking(fd);
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);    
}
/**
 * 服务端向其他客户端发送消息
 **/
void sendBroadCast(struct epoll_event* waitEvents,int eventsNumber,int epollfd,int listenfd){
    int clntSock = 0;
    struct sockaddr_in clntAdr;
    char buff[BUFF_SIZE];
    for(int i = 0;i < eventsNumber;++i){
        if(waitEvents[i].data.fd == listenfd){//未建立连接，先建立连接
        socklen_t clientLength = sizeof(clntAdr);
            clntSock = accept(listenfd,(struct sockaddr*) &clntAdr,&clientLength);
            addfd(epollfd,clntSock,true);
            /*第一次connect*/
            const char* message = "welcome join chatting!\n\n";
            printf("%d join chatting!!!\n",clntSock);
            write(clntSock,message,strlen(message));
            /*将新clientID加入链表*/
            clientLists.push_back(clntSock);
            /*向例程中注册事件*/
            addfd(epollfd,clntSock,true);
        }
        else{//已经建立连接，需要读取数据,然后发送给其他客户端
            clntSock = waitEvents[i].data.fd;
            bzero(&buff,strlen(buff));
            int strLen = sprintf(buff,"te clientID %d saying: ",clntSock);
            strLen += read(clntSock,buff + strLen,BUFF_SIZE);
            if(strLen < 0){//客户端读取数据出错
                perror("read");
                close(clntSock);
                exit(-1);
            }
            else if(strLen == 0){//已经没数据，需要关闭客户端
                epoll_ctl(epollfd,EPOLL_CTL_DEL,clntSock,NULL);
                clientLists.remove(clntSock);
                close(clntSock);                    
            }
            else{
                buff[strLen] = 0;
                /*发送给其他的所有客户端*/ 
                if(clientLists.size() == 1){
                    const char *mess = "Atention!only one client in the chatting room!\n";
                    write(clntSock,mess,strlen(mess));
                    printf("Atention!only ID %d client in the chatting room!\n",clntSock);                    
                }                
                
                printf("saved: %s\n",buff);

                list<int> :: iterator iter;
                for(iter = clientLists.begin();iter != clientLists.end();++iter){
                    if(*iter == clntSock){
                        continue;
                    }                
                    write(*iter,buff,strLen + 1);

                }
            }
        }
    }        
}

#endif

//server.cpp
#include"utility.h"

int main(){
    int err = 0;
    char buff[BUFF_SIZE];
    struct sockaddr_in servAddr;
    bzero(&servAddr,sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    inet_aton(SERVERIP,&servAddr.sin_addr);//将字符串IP地址转化为32位整数型数据
    servAddr.sin_port = htons(atoi(PORT));
    

    /*监听套接字描述符*/
    int listenfd = socket(PF_INET,SOCK_STREAM,0);
    if(listenfd == -1){
        perror("listenfd");
        exit(1);
    }
    /*更改服务器套接字的time_wait状态*/
    int option = 0;
    socklen_t optlen;
    optlen = sizeof(option);
    option = 1;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,(void*)&option,optlen);

    /*分配IP地址和端口号*/
    err = bind(listenfd,(struct sockaddr*)&servAddr,sizeof(servAddr));
    if(err == -1){
        perror("bind");
        exit(1);
    }
    /*转化为可接受请求转态*/
    err = listen(listenfd,10);
    if(err == -1){
        perror("listen");
        exit(1);
    }

    int epfd = epoll_create(EPOLLSIZE);    
    struct epoll_event waitEvents[MAX_EVENT_NUMBER]; //预留足够大的空间来存储后面发生变化的事件，也可以使用动态分配  
    
    /*注册监听套接字*/
    addfd(epfd,listenfd,true);    

    /*监测文件描述符的变化*/
    int eventsNumber = 0;    
    while(1){  
        eventsNumber = epoll_wait(epfd,waitEvents,EPOLLSIZE,-1);//一直等待事件的发生，除非出错返回
        if(eventsNumber == -1){
            perror("eventsNumber");
            exit(1);
        }        
        sendBroadCast(waitEvents,eventsNumber,epfd,listenfd);//将waitEvents当作平常的数组，数组名就是指针
    }
    close(listenfd);
    close(epfd);
    return 0;
}

#include"utility.h"

void read_routine(int clntSock,char *buf);
void write_routine(int clntSock,char *buf);

int main(){
    int clntSock;
    char buff[BUFF_SIZE];
    clntSock = socket(PF_INET,SOCK_STREAM,0);

    if(clntSock == -1){
        perror("clntSock");
        exit(1);
    }
    struct sockaddr_in servAdr;
    bzero(&servAdr,sizeof(servAdr));
    servAdr.sin_family = AF_INET;
    inet_aton(SERVERIP,&servAdr.sin_addr);//将字符串IP地址转化为32位整数型数据
    servAdr.sin_port = htons(atoi(PORT));

    int err = connect(clntSock,(struct sockaddr*)&servAdr,sizeof(servAdr));
    if(err == -1){
        perror("connect");
        exit(1);
    }

    pid_t pid = fork();
    if(pid == 0){//子进程负责写
        write_routine(clntSock,buff);
    }
    else{//父进程负责读
        read_routine(clntSock,buff);
    }
    close(clntSock);
    return 0;
}

void read_routine(int clntSock,char *buf){
    while(1){
        int strLen = read(clntSock,buf,BUFF_SIZE);
        if(strLen == 0){
            return;
        }
        buf[strLen] = 0;
        printf("%s",buf);
    }
}

void write_routine(int clntSock,char *buf){
    while(1){
        fgets(buf,BUFF_SIZE,stdin);
        if(!strcmp(buf,"exit\n")){
            shutdown(clntSock,SHUT_WR);
            return;
        }
        write(clntSock,buf,strlen(buf));
    }
}