TCP并发服务器，每个客户一个子进程

在阅读完《unix 网络编程：卷一》之后，感觉作者真是unix下编程的大师级的人物。而对于我个人而言，每次阅读完一本技术书籍之后，一定还是得自己重新再写一遍程序（换点内容），复习书本中的内容（大致结构，或者说思想，相同），否则，你很难做到真的理解并掌握的地步。

Okay,今天我带来的是服务器模型中的第一种，也是最基本最常用的一种模型–TCP并发服务器，每个客户一个子进程。

先简单介绍一下：TCP并发服务器，每个客户一个子进程，也就是说并发服务器调用fork派生一个子进程来处理每个子进程，使得服务器能够同时为多个客户服务，每个进程一个客户。客户数目的唯一限制是操作系统对以其名义运行服务器的用户ID能够同时拥有多少子进程的限制。

具体到我们的需求，我们的客户端发送某个指令，服务端接收。如果符合服务端的要求，就将当时的时间发回给客户端。需求很简单，我们的着重点在服务器的模型。

Okay，来看代码：
这是服务端的主代码(serv.c):

#include "pub.h"

#define LISTENQ 1024

void sig_child(int signo);


//serv <port>
int main(int argc, char **argv)
{
    int listenfd,connfd;
    pid_t childpid;
    int on = 1;
    struct sockaddr_in servaddr, cliaddr;
    socklen_t clilen;
    char *ptr;
    if(argc != 2)
    {
        fprintf(stderr,"usage: serv <port>\n");
        exit(1);
    }

    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("serv socket error ");
        exit(-1);
    }
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(atoi(argv[1]));
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    //设置可重用
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("serv bind error");
        exit(-1);
    }

    if(listen(listenfd, LISTENQ) < 0)
    {
        perror("serv listen error");
        exit(-1);
    }

    //信号处理函数
    Signal(SIGCHLD, sig_child); //每一个子进程终止时就会产生SIGCHLD信号,默认是忽略


    for( ; ; )
    {
        clilen = sizeof(cliaddr);
        if((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0)
        {
            if(errno == EINTR)
                continue;
            else
            {   
                perror("serv accept error");
                exit(-1);
            }
        }
        ptr = inet_ntoa(cliaddr.sin_addr);//cliaddr.sin_addr不用取地址
        fprintf(stdout,"%s has connected\n", ptr);

        if((childpid = fork()) == 0)//child
        {
        //注意这里是另一个进程
            close(listenfd);    //子进程关闭listenfd

            do_child(connfd);

            ptr = inet_ntoa(cliaddr.sin_addr);//cliaddr.sin_addr不用取地址
            fprintf(stdout,"%s has disconnected\n", ptr);

            close(connfd);
            exit(0);
        }

        close(connfd);//父进程关闭connfd


    }

    close(listenfd);

    exit(0);
}



void sig_child(int signo)
{
    pid_t pid;
    int stat;

    while((pid = waitpid(-1, &stat, WNOHANG)) > 0)  //不阻塞，返回child pid
    {//防止同时有几个子进程killed，加while，知道处理完所有killed child
        fprintf(stdout,"%d terminated\n",pid);
        fflush(stdout);
    }

    return;
}

看这小段连接的代码：

clilen = sizeof(cliaddr);
if((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0)
{
    if(errno == EINTR)
        continue;
    else
    {   
        perror("serv accept error");
        exit(-1);
    }
}
ptr = inet_ntoa(cliaddr.sin_addr);//cliaddr.sin_addr不用取地址
fprintf(stdout,"%s has connected\n", ptr);

注意我们这里的大循环，每次循环的开始都是accept，也就是从已连接的队列中返回其中一个，如果返回成功，就打印一下IP，显示是哪个IP来连接。

这里采用的是inet_ntoa()函数，这是个专门为IPV4准备的函数。你也可以使用inet_pton()函数，这是IPV4和IPV6通用的函数。

再看下面的一小段：

if((childpid = fork()) == 0)//child
        {
        //注意这里是另一个进程
            close(listenfd);    //子进程关闭listenfd

            do_child(connfd);

            ptr = inet_ntoa(cliaddr.sin_addr);//cliaddr.sin_addr不用取地址
            fprintf(stdout,"%s has disconnected\n", ptr);

            close(connfd);
            exit(0);
        }

这里就是真正的fork出一个子进程。

先close（listenfd），注意这里close并不会真正的关闭listenfd，这只是减少了listenfd的一个引用次数，父进程还有一个引用。

然后是do_child(connfd),这里是我们自定义的来处理连接的函数，注意已经将connfd传递给这个函数。稍后我们在讨论一下这个函数。

如果能从do_child()函数返回，就再打印一下，某一个IP 已经离开。

最后就是close(connfd)，再exit(0)退出，这里的close(connfd)，可以省略，子进程退出，就会关掉自身所打开的描述符。

注意到我们这里还有一信号处理函数，sig_child，如下所示：

void sig_child(int signo)
{
    pid_t pid;
    int stat;

while((pid = waitpid(-1, &stat, WNOHANG)) > 0)  //不阻塞，返回child pid
{//防止同时有几个子进程killed，加while，知道处理完所有killed child
    fprintf(stdout,"%d terminated\n",pid);
    fflush(stdout);
}

    return;
}

我们在之前已经注册了这个信号处理函数，
//信号处理函数
Signal(SIGCHLD, sig_child); //每一个子进程终止时就会产生SIGCHLD信号,默认是忽略

这里我们的处理函数，就是打印一下离开的子进程的pid，就如同注释所示，采用这种形式：
while((pid = waitpid(-1, &stat, WNOHANG)) > 0) 可以防止同时有几个子进程killed，加while，知道处理完所有killed child

到了这里，服务器主要的模型已经展示出来了，现在我们来看主要的处理客户端连接的do_child()函数。

来看代码：

#include "pub.h"


void do_child(int sockfd)
{
    time_t mytime;
    char buff[MAXLINE];
    int n;

    for( ; ; )
    {
        if((n = read(sockfd, buff, sizeof(buff))) <= 0)
        {
            if( n < 0 && errno == EINTR)
                continue;
            else if(n == 0){
                //交给外面的主循环处理(打印某某离开)
                break;
            }else{
                perror("child read error");
                exit(-1);
            }
        }
        else
        {
        //比较前几个字符串，是不是GETTIME，是则返回时间，否则返回 Gettime Command Error
            if((strncmp(buff,"GETTIME", 7) == 0) || 
                (strncmp(buff,"gettime", 7) == 0) )
            {
                mytime = time(NULL);
                snprintf(buff, sizeof(buff), "%s", ctime(&mytime));
                writen(sockfd, buff, strlen(buff));//这里最好用writen（自定义）
            }
            else
            {//不是的话，就返回 Gettime Command Error
                snprintf(buff, sizeof(buff), "Gettime Command Error ");
                writen(sockfd, buff, strlen(buff));
            }
        }

    }

}

这里采用的处理很简单，就如同我注释中讲的，比较前几个字符串，是不是GETTIME或者gettime，是则返回时间，否则返回 Gettime Command Error

看这里：

mytime = time(NULL);
snprintf(buff, sizeof(buff), "%s", ctime(&mytime));
writen(sockfd, buff, strlen(buff));//这里最好用writen（自定义）

通过time()和ctime()用字符串的形式打印出当前时间。注意这里采用的是writen()函数，自定义函数。
其实就是write相当数目的buff,同时防止信号打断

来看writen函数的代码：

#include "pub.h"


int writen(int sockfd,const char *buff, int n)
{
    int nleft = n;
    int ncount = 0;

    const char *ptr = buff;

    while(nleft > 0)
    {
        if((ncount = write(sockfd, ptr, nleft)) <= 0)
        {
            if(errno == EINTR)
                ncount = 0; //call again
            else
                return -1;
        }
        nleft -= ncount;
        ptr += ncount;
    }

    return n - nleft;
}

接下来，我们写了一个测试用的客户端(client.c)：
来看代码:

#include "pub.h"

//client <ip> <port>
int main(int argc, char **argv)
{
    int sockfd;
    struct sockaddr_in servaddr;
    int n;

    if(argc != 3)
    {
        fprintf(stderr,"usage: <ip> <port> \n");
        exit(1);
    }

    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("client socket error ");
        exit(-1);
    }

    memset(&servaddr, 0,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(atoi(argv[2]));
    inet_aton(argv[1], &servaddr.sin_addr);

    if((connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) < 0)
    {
        perror("client connect error");
        exit(-1);
    }
    strcli(sockfd);

    exit(0);
}

这里就是简单的客户端代码，通过参数传进来要连接的ip与port，发送请求的函数是str_cli()。

来看str_cli函数:

#include "pub.h"


void strcli(int sockfd)
{
    char sendbuff[MAXLINE], recvbuff[MAXLINE];

    while(fgets(sendbuff, sizeof(sendbuff), stdin) != NULL) 
    {
        writen(sockfd, sendbuff, strlen(sendbuff));

        if(read(sockfd, recvbuff, sizeof(recvbuff)) == 0)
            fprintf(stderr,"server has terminated\n");
        fputs(recvbuff, stdout);
    }

}

这里其实就是读取标准输入，发送给服务端，并read阻塞，等服务端发送回后，将服务端发送回的数据打印到标准输出上。

另外，还有一个注册信号处理函数Signal函数，之前讲过，但没有给出代码。
我这里直接将unix网络编程里的signal拿了过来，可以直接使用。
也来看一下，signal.c：

/* include signal */
#include    "pub.h"

Sigfunc *
signal(int signo, Sigfunc *func)
{
    struct sigaction    act, oact;

    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (signo == SIGALRM) {
#ifdef  SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;   /* SunOS 4.x */
#endif
    } else {
#ifdef  SA_RESTART
        act.sa_flags |= SA_RESTART;     /* SVR4, 44BSD */
#endif
    }
    if (sigaction(signo, &act, &oact) < 0)
        return(SIG_ERR);
    return(oact.sa_handler);
}
/* end signal */

Sigfunc *
Signal(int signo, Sigfunc *func)    /* for our signal() function */
{
    Sigfunc *sigfunc;

    if ( (sigfunc = signal(signo, func)) == SIG_ERR)
    {
        perror("signal error");
        exit(1);
    }
    return(sigfunc);
}

至此，我们的第一种服务器模型就已经完成了。全部的代码都已经晒了出来，并经过测试。你可以在你自己的linux上试试，看行不行。

另外，我们这里就是简单的客户端与服务端查询时间的处理请求。你也可以进行别的处理请求。比如可以双方通信，采用多线程，或者试试发送文件，都可以。Just depend on yourself.而且，你只需要修改do_child()和str_cli()函数，其他的可以不修改，除非你有别的需求。

最后，还得讲一下这种模型的问题。主要就是为每一个客户fork一个子进程比较消耗CPU时间，几百或几千的的客户是没有问题的，但是现在的每天的TCP连接都是上百万的，这里就会有问题。当然，如果系统负载较轻，这种模型是不错好的选择。

好了，这就是我们的今天博客的全部内容，你懂了吗?如果我有出错的地方，欢迎大家指出，如果觉得好，也可以点赞哦。