单进程socket的服务器/客户端模型

1.tcp.h：头文件

2.socklib.c：基本的socket模型的实现函数

3.server.c：服务器端的模型

4.client.c：客户端的模型

5.process_request.c：处理客户端的请求

6.connect_server.c：与服务端进行通信

1.tcp.h：头文件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <strings.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <errno.h>

#define IPSERV    "127.0.0.1"
#define PORT      13000
#define BACKLOG   1

#define oops(msg) {perror(msg);exit(1);}

extern int errno;

2.socklib.c：基本的socket模型的实现函数

#include "tcp.h"

//函数声明
int make_server_socket_q(int,int);

/*
* 输入：端口号
*
*/
int make_server_socket(int port){

return make_server_socket_q(port,BACKLOG);
}

int make_server_socket_q(int port,int backlog){

// build our address
struct sockaddr_in serv;
int sockfd;

// get a socket
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0)
oops("socket");

// build address struct
/* clear out struct */
bzero((void *)&serv,sizeof(serv));
/* fill in addr family */
serv.sin_family      = AF_INET;
/* fill in ip address */
serv.sin_addr.s_addr = inet_addr(IPSERV);
/* fill in socket port */
serv.sin_port        = htons(port);

// bind the address information  to the socket
if(bind(sockfd,(struct sockaddr *)&serv,sizeof(serv))<0)
oops("bind");

// waiting for the client request
if(listen(sockfd,backlog)<0)
oops("listen");

return sockfd;
}

int connect_to_server(char *host,int port){

// build our address
struct sockaddr_in serv;
int sockfd;

// get a socket
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd < 0)
oops("socket");

// build address struct
bzero((void *)&serv,sizeof(serv));
serv.sin_family      = AF_INET;
serv.sin_addr.s_addr = inet_addr(host);
serv.sin_port        = htons(port);

// connect to server
if(connect(sockfd,(struct sockaddr *)&serv,sizeof(serv))<0)
oops("connect");

return sockfd;
}

3.server.c：服务器端的模型

#include "tcp.h"

void child_waiter(int);

/*
* 标准的服务器处理模型
*
*
* 程序运行到信号处理函数跳转时中断accept。
* accept被中断时，返回-1，设置errno=EINTR，会跳出主循环
* if(fd<0){
* if(errno == EINTR)
*    continue;
* else
*    oops("accept");
*}
*/

int main(int ac,char *av[]){

// the socket
int sockfd;
int fd;

// get a socket which is listening
sockfd = make_server_socket(PORT);
if(sockfd == -1)
exit(1);

// deal with signal of SIGCHLD
/*
* when the child exit or be out，
* kernel will send a signal——SIGCHLD to parent
* 默认情况下SIGCHLD会被忽略
*
* 僵尸进程会在什么时候产生
* 子进程结束，但是他的父进程没有等待(wait/waitpid)
* 该子进程会变成僵尸进程
* 可是如果父进程已经提前结束
* 该子进程会变成孤儿进程，被init接管
*
* 为了防止子进程成为僵尸进程，处理SIGCHLD信号
* 调用wait(NULL)来处理
*
*/
signal(SIGCHLD,child_waiter);

// the connect request is coming
while(1){

// take the connection
fd = accept(sockfd,NULL,NULL);

if(fd<0){

if(errno == EINTR)
continue;
else
oops("accept");

}

// connect with the client
process_request(fd);
// close the socket
close(fd);
}

close(sockfd);
}

/*
* 可是呢，调用wait(NULL)来处理会出现问题
* 如果多个子进程几乎同时退出
* 最先到到达的信号会导致父进程跳转到处理函数中
* 然后父进程调用wait将子进程从进程表中删除
* 可是，其他到来的信号怎么办呢
* 我们知道，信号是没有缓存机制的
* 第二个到来的信号被阻塞
* 第三个到来的信号会丢失，以后的依次类推
* 信号处理函数只调用wait一次，
* 可是后来到达的信号没被处理，子进程会变成僵尸进程
*
* 解决方法：在处理函数中，
* 调用wait足够多的次数去清除所有的子进程
* waitpid提供了wait函数超集的功能
* 参数1：表示要等待的进程ID，-1，表示等待所有的子进程
* 参数2：指向整型值的指针，用来获取子进程状态
* 在未来的改版中，会根据这个参数来跟踪服务器信息
* 参数3：选项，WNOHANG高速waitpid若没有僵尸进程，则不必等待
*
* 该循环直到所有退出的子进程都被等待才停止。
* 即使多个子进程同时退出并产生SIGCHLD，所有信号都会被处理。
*
*/
void child_waiter(int signum){

while(waitpid(-1,NULL,WNOHANG)>0);

}

4.client.c：客户端的模型

#include "tcp.h"

int main(){

int sockfd;

sockfd = connect_to_server(IPSERV,PORT);

if(sockfd == -1)
oops("sockfd");

talk_with_server(sockfd);

close(sockfd);
}

5.process_request.c：处理客户端的请求

6.connect_server.c：与服务端进行通信

talk_with_server(int fd){
talk_with_server_v1(fd);
}

process_request(int fd){
process_request_v1(fd);
}