TCP并发server，每个客户一个子进程
今天笔者带来的是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连接都是上百万的。这里就会有问题。当然，假设系统负载较轻，这样的模型是不错好的选择。
好了。这就是我们的今天博客的全部内容，你懂了吗?假设我有出错的地方，欢迎大家指出。假设认为好。也能够点赞哦。
