【linux下c语言服务器开发系列5】功能齐全的聊天室 sever [IO复用+多进程+信号处...

上个博客的最后，说要写一个功能齐全一些服务器，所以，这边博客主要对这个服务器进行一个简单的介绍。这个服务器，是一个聊天室服务器。 当客户端连接到服务器后，就可以收到所有其他客户端发送给服务器的内容。主要实现原理如下：

1.IO复用：

利用epoll函数，对多个套接字进行监听，包括：listenfd，标准输入套接字，与子进程通讯的套接字还有信号处理的套接字。

listenfd：这个套接字主要是服务器端用来监听是否有新的客户端的连接的。一旦有连接，则视为新的客户到来，然后，准备连接，分配用户内存，对应各种信息，连接成功后，fork一个子进程进行对这个连接进行一对一的处理。这里的处理，主要是对各种套接字进行监听，并进行相应的处理，下文的多进程部分会有。

标准输入套接字：为的是在服务器端也能输入一些信息，并让这个服务器根据输入的信息进行反应。不过，我这里的反应主要是让服务器原样输出。

与子进程通讯的套接字：因为没个客户，都是用一个子进程在单独的处理，各个子进程之间的通信，首先需要通过父进程，然后再进行广播，从而实现子进程与其他所有子进程之间的通信。这里，子进程与父进程之间的通信，是靠管道完成的。但是，传统的管道是pipe()函数创建的，只能单工的通信，我这里为了双工的通信，使用的是socketpair()创建的管道，管道的两端都可以进行读写操作。如果子进程有数据写给父进程，一般是它有小弟到达，于是，父进程告诉所有其他子进程，说数据可读了，于是各子进程往对应的客户端写数据。

信号处理文件描述符：为了将事件源统一，于是将信号处理的管道的描述符也用epoll来统一监听。这里，信号处理函数要做的事情是如果有信号出现，则向管道里写消息。于是epoll接收到这个消息后，再调用更具体的信号处理函数，进行具体的处理。

上面说的都是父进程要做的内容，下面说说子进程需要完成的内容：

子进程：每个客户端需要一个子进程对其进行处理。父子进程间的通讯方法、各种联系已经在fork()函数调用之间记录好了。子进程需要建立自己的epoll注册事件表。对自己的一些文件描述符使用epoll函数进行监听。这里的epoll主要监听一下：与客户端的连接套接字，与父进程的通信管道套接字和信号处理套接字。

与客户端的连接套接字：这个是用来读写的主要依据。是服务器与客户端通信的窗口。只需对这个套接字进行读写即可。

与父进程的通信套接字:上文提到了该通信管道。用于父子进程间交换信息。一般是客户有数据到达了，子进程要通知父进程，父进程知道这个消息到达后，告诉其他子进程，有人发言了，你们把这个发言发送到各自的客户端去。子进程得知父进程的通知后，对各自的连接套接字进行写操作。

子进程的主要处理函数是runchild函数，该函数如下：

int runchild(user* curuser,char *shmem)
{
assert(curuser!=NULL);

int child_epollfd=epoll_create(5);
assert(child_epollfd!=-1);

epoll_event events[MAX_EVENT_NUMBER];

int conn=curuser->conn;
addfd(child_epollfd,conn);

addfd(child_epollfd,curuser->pipefd[1]);
int stop_child=0;
int ret=0;

while(!stop_child)
{
printf("in child\n");
int number=epoll_wait(child_epollfd,events,MAX_EVENT_NUMBER,-1);
if(number<0 && errno!=EINTR)
{
printf("epoll error in child");
break;
}

for(int i=0;i<number;i++)
{
int sockfd=events[i].data.fd;

if(sockfd ==conn && (events[i].events & EPOLLIN) )
{
memset(shmem+curuser->user_number*BUF_SIZE,'\0',BUF_SIZE);
ret=recv(conn,shmem+curuser->user_number*BUF_SIZE,BUF_SIZE-1,0);
if(ret<0 && errno!=EAGAIN)
stop_child=1;
else if (ret==0)
stop_child=1;
else
//通知父进程，有了数据啦，让父进程告诉别的子进程去读吧。哈哈
{
shmem[curuser->user_number*BUF_SIZE+ret]='\0';

printf("some thing\n");
send(curuser->pipefd[1],(char*)&(curuser->user_number),sizeof(curuser->user_number),0);

}

}
else if (sockfd==curuser->pipefd[1] && events[i].events & EPOLLIN)
{
printf("some thing from father\n");

int client_number;
ret=recv(sockfd,(char*)&client_number,sizeof(client_number),0);
if(ret<0 && errno!=EAGAIN)
{
stop_child=1;
}
else if (ret==0)
stop_child=1;
else
//从收到的客户端那里读取内容，往自己这里写
{
// printf("rec from father,then write to his client\n");
char tmpbuf[BUF_SIZE*2];
sprintf(tmpbuf,"client %d says: ",client_number);

//memcpy(tmpbuf+sizeof(tmpbuf),shmem+(client_number)*BUF_SIZE,BUF_SIZE);

sprintf(tmpbuf+15,"%s",shmem+(client_number*BUF_SIZE));
// send(conn,tmpbuf,sizeof(tmpbuf),0);
send(conn,tmpbuf,strlen(tmpbuf),0);

}

}
}
}

}

进程间通信：

上文说到了进程间通信的方法，一个是管道，主要是信号处理部分。一个是套接字，父子进程间的管道实际是本地域的套接字。还有一个是共享内存。父进程开辟一块共享内存，用于各种进程间的内容共享。于是，每个子进程可以通过这块内从，与其他子进程进行信息的共享。这就是聊天室的内容能够共享的一个原因。而且，还不需要大量的数据拷贝，具有一定的效率。共享内存代码如下

//开辟一块内存,返回一个共享内存对象
shmfd=shm_open(shm_name,O_CREAT|O_RDWR,0666);
assert(shmfd!=-1);

//将这个共享内存对象的大小设定为 ＊＊
int ret=ftruncate(shmfd,USER_LIMIT*BUF_SIZE);
assert(ret!=-1);

//将刚才开辟的共享内存，关联到调用进程
share_mem=(char *) mmap(NULL,USER_LIMIT*BUF_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,shmfd,0);
assert(share_mem!=MAP_FAILED);

管道如下：

typedef struct user
{
int conn;
int stop;
int pipefd[2]; //父子进程间的管道。
int user_number;
sockaddr_in client_addr;
char bufread[BUF_SIZE];
char bufwrite[BUF_SIZE];
pid_t pid; // which process deal with this user
} user;
[code=plain]

//父子进程间的管道

int

piperet

=

socketpair

(

AF_UNIX

,

SOCK_STREAM

,

0

,

users

[

user_number

].

pipefd

);

assert

(

piperet

==

0

);

[/code]

//用来作为信号与epoll链接的管道
int retsigpipe=socketpair(AF_UNIX,SOCK_STREAM,0,sig_pipefd);

信号处理：

这里主要处理3个信号，sigterm，sigint，sigchld。对于前两个信号，父子进程的处理方法有一些不同。添加要处理的信号及其处理函数如下：

int add_sig(int signum, void(handler)(int) )
{
struct sigaction sa;
memset(&sa,'\0',sizeof(sa));
sa.sa_handler=handler;
sa.sa_flags|=SA_RESTART;
//这个的意思是将所有的信号都监听，然后都是调用一个handler来处理。这样看上去好像不太合理。但是，后面我们就知道，为了统一事件源，在此将所有信号一视同仁的处理，在接下来的IO复用中，会有好处的。
sigfillset(&sa.sa_mask);
assert(sigaction(signum,&sa,NULL)!=-1);
}

统一的信号处理函数如下：（关联到epoll）

/* 当信号发生时，调用这个函数来处理该信号*/

void sig_handler(int sig)
{
int save_errno=errno;
int msg=sig;
send(sig_pipefd[1],(char*)&msg,sizeof(msg),0);
errno=save_errno;

}

epoll中，出现信号事件了，调用具体的函数处理函数：

/*具体用来处理信号事件的函数*/
void sig_concrete_handler(int sig,int epollfd)
{
printf("signal  chld occur\n");
pid_t pid;
int stat_loc;
while(pid=waitpid(-1,&stat_loc,WNOHANG)>0)
//pid=waitpid(-1,&stat_loc,WNOHANG)>0;
if(pid>0)
{
/*作一些具体的回收工作，比如关闭子进程中打开的socket，但是，我们目前无法直接获得该socket，无法关闭；只能获取目前的子进程的pid，所以，需要建立pid与连接socket之间的联系，可以用一个简单的数组作对应。也可以用一个结构体（记录多种数据）＋一个全局化的数组来作对应,这里用subprocess将pid于user对应*/
printf("close process %d\n",pid);
subprocess[pid].u->stop=1;
subprocess[pid].u->pid=-1;
//不再监听与父进程通信的管道了
epoll_ctl(epollfd,EPOLL_CTL_DEL,subprocess[pid].u->pipefd[0],0);
//关闭与父进程通信的管道了
close(subprocess[pid].u->pipefd[0]);

//关闭与客户端的连接
close(subprocess[pid].u->conn);
}
}

完成的代码见：http://git.oschina.net/mengqingxi89/codelittle/blob/master/codes/echoserver/final_echo_server.cpp

编译于运行：

因为使用了共享内存，需要在编译的时候加上-lrt选项。即 g++ -lrt -o outfile file.cpp.然后运行该文件。

./outfile 127.0.0.1 12345

再开多个telnet 127.0.0.1 12345 就可以进行多个telnet之间的聊天了。

我接下来写一个简单的客户端，不用telnet了，再把多进程改成进程池。然后把多进程改成多线程，再改成线程池，敬请期待。