今天笔者带来的是server型号第一，这是最经常使用的模型的最基本的一个–TCP并发server，每个客户一个子进程。

首先简单介绍：TCP并发server，每个客户一个子进程，并发server调用fork派生一个子进程来处理每一个子进程，使得server能够同一时候为多个客户服务，每一个进程一个客户。

客户数目的唯一限制是操作系统对以其名义执行server的用户ID能够同一时候拥有多少子进程的限制。

详细到我们的需求，我们的client发送某个指令，服务端接收。假设符合服务端的要求。就将当时的时间发回给client。

需求非常easy，我们的着重点在server的模型。

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

到了这里，server基本的模型已经展示出来了，如今我们来看基本的处理client连接的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));

            }

        }

    }

}

这里採用的处理非常easy，就如同我凝视中讲的，比較前几个字符串。是不是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(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);

}

这里就是简单的client代码，通过參数传进来要连接的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);

}

至此，我们的第一种server模型就已经完毕了。全部的代码都已经晒了出来。并经过測试。你能够在你自己的linux上试试。看行不行。

另外，我们这里就是简单的client与服务端查询时间的处理请求。你也能够进行别的处理请求。比方能够两方通信。採用多线程，或者试试发送文件，都能够。

Just up to you.并且，你仅仅须要改动do_child()和str_cli()函数。其它的能够不改动，除非你有别的需求。

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

好了。这就是我们的今天博客的全部内容，你懂了吗?假设我有出错的地方，欢迎大家指出。假设认为好。也能够点赞哦。