20155216 2017-2018-1 第八周课下作业2
作业内容：
把daytime服务器分别用多进程和多线程实现成并发服务器并测试。
多进程实现daytime服务器
服务器端源代码：
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <unistd.h> // for fork
#include <sys/signal.h> // for signal
#include <sys/wait.h> // for wait
#include <time.h>
#include <arpa/inet.h>
#define HELLO_WORLD_SERVER_PORT 6666
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
void reaper(int sig)
{
int status;
//调用wait3读取子进程的返回值,使zombie状态的子进程彻底释放
while(wait3(&status,WNOHANG,(struct rusage*)0) >=0)
;
}
int main(int argc, char **argv)
{
//设置一个socket地址结构server_addr,代表服务器internet地址, 端口
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr)); //把一段内存区的内容全部设置为0
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
time_t t;
//创建用于internet的流协议(TCP)socket,用server_socket代表服务器socket
int server_socket = socket(AF_INET,SOCK_STREAM,0);
if( server_socket < 0)
{
printf("Create Socket Failed!
");
exit(1);
}
//把socket和socket地址结构联系起来
if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
{
printf("Server Bind Port : %d Failed!
", HELLO_WORLD_SERVER_PORT);
exit(1);
}
//server_socket用于监听
if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
{
printf("Server Listen Failed!");
exit(1);
}
//通知操作系统,当收到子进程的退出信号(SIGCHLD)时,执行reaper函数,释放zombie状态的进程
(void)signal(SIGCHLD,reaper);
while (1) //服务器端要一直运行
{
//定义客户端的socket地址结构client_addr
struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);
//接受一个到server_socket代表的socket的一个连接
//如果没有连接请求,就等待到有连接请求--这是accept函数的特性
//accept函数返回一个新的socket,这个socket(new_server_socket)用于同连接到的客户的通信
//new_server_socket代表了服务器和客户端之间的一个通信通道
//accept函数把连接到的客户端信息填写到客户端的socket地址结构client_addr中
int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
if ( new_server_socket < 0)
{
printf("Server Accept Failed!
");
break;
}
int child_process_pid = fork(); //fork()后,子进程是主进程的拷贝
//在主进程和子进程中的区别是fork()的返回值不同.
if(child_process_pid == 0 )//如果当前进程是子进程,就执行与客户端的交互
{
t=time(NULL);
close(server_socket); //子进程中不需要被复制过来的server_socket
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
//strcpy(buffer,"20155216实现");
strcat(buffer,"
"); //C语言字符串连接
//发送buffer中的字符串到new_server_socket,实际是给客户端
send(new_server_socket,buffer,BUFFER_SIZE,0);
printf("服务器实现者学号：20155216
");
printf("客户端IP：%s
",inet_ntoa(client.sin_addr));
printf("当前时间： %s
",ctime(&t));
send(new_server_socket,(void *)&t,sizeof(time_t),0);
bzero(buffer,BUFFER_SIZE);
//接收客户端发送来的信息到buffer中
length = recv(new_server_socket,buffer,BUFFER_SIZE,0);
if (length < 0)
{
printf("Server Recieve Data Failed!
");
exit(1);
}
printf("
%s
",buffer);
//关闭与客户端的连接
close(new_server_socket);
exit(0);
}
else if(child_process_pid > 0) //如果当前进程是主进程
close(new_server_socket); //主进程中不需要用于同客户端交互的new_server_socket
}
//关闭监听用的socket
close(server_socket);
return 0;
}
客户端源代码：
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <time.h>
#define HELLO_WORLD_SERVER_PORT 6666
#define BUFFER_SIZE 1024
void talk_to_server(char ** argv)
{
//设置一个socket地址结构client_addr,代表客户机internet地址, 端口
struct sockaddr_in client_addr;
bzero(&client_addr,sizeof(client_addr)); //把一段内存区的内容全部设置为0
client_addr.sin_family = AF_INET; //internet协议族
client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自动获取本机地址
client_addr.sin_port = htons(0); //0表示让系统自动分配一个空闲端口
//创建用于internet的流协议(TCP)socket,用client_socket代表客户机socket
int client_socket = socket(AF_INET,SOCK_STREAM,0);
time_t t;
if( client_socket < 0)
{
printf("Create Socket Failed!
");
exit(1);
}
//把客户机的socket和客户机的socket地址结构联系起来
if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
{
printf("Client Bind Port Failed!
");
exit(1);
}
//设置一个socket地址结构server_addr,代表服务器的internet地址, 端口
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family = AF_INET;
if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //服务器的IP地址来自程序的参数
{
printf("Server IP Address Error!
");
exit(1);
}
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
socklen_t server_addr_length = sizeof(server_addr);
//向服务器发起连接,连接成功后client_socket代表了客户机和服务器的一个socket连接
if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
{
printf("Can Not Connect To %s!
",argv[1]);
exit(1);
}
char buffer[BUFFER_SIZE];
bzero(buffer,BUFFER_SIZE);
//从服务器接收数据到buffer中
int length = recv(client_socket,buffer,BUFFER_SIZE,0);
if(length < 0)
{
printf("Recieve Data From Server %s Failed!
", argv[1]);
exit(1);
}
printf("From Server %s : %s
",argv[1],buffer);
length = recv(client_socket,(void *)&t,sizeof(time_t),0);
if(length < 0)
{
printf("Recieve Data From Server %s Failed!
", argv[1]);
exit(1);
}
printf("当前时间： %s
",ctime(&t));
bzero(buffer,BUFFER_SIZE);
//strcpy(buffer,"Thanks!");
//向服务器发送buffer中的数据
send(client_socket,buffer,BUFFER_SIZE,0);
//关闭socket
close(client_socket);
}
int main(int argc, char **argv)
{
if (argc != 2)
{
printf("Usage: .\%s ServerIPAddress
",argv[0]);
exit(1);
}
talk_to_server(argv);
return 0;
}
实现结果：
可实现并发，即多个客户端同时访问服务器，并给出不同的系统时间。
多线程实现daytime服务器
服务器源代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <errno.h>
#include <time.h>
#define PORT 1234
#define BACKLOG 2
#define MAXDATASIZE 1000
void process_cli(int connectfd,struct sockaddr_in client);
void sig_handler(int s);
int main()
{
int opt,listenfd,connectfd;
pid_t pid;
struct sockaddr_in server;
struct sockaddr_in client;
int sin_size;
struct sigaction act;
struct sigaction oact;
act.sa_handler=sig_handler;
sigemptyset(&act.sa_mask);
act.sa_flags=0;
printf("服务器实现者学号：20155216
");
if(sigaction(SIGCHLD,&act,&oact)<0)
{
perror("Sigaction failed!
");
exit(1);
}
if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("Creating socket failed.
");
exit(1);
}
opt=SO_REUSEADDR;
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr.s_addr=htonl(INADDR_ANY);
if(bind(listenfd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)
{
perror("Bind error.
");
exit(1);
}
if(listen(listenfd,BACKLOG)==-1)
{
perror("listen() error.
");
exit(1);
}
sin_size=sizeof(struct sockaddr_in);
while(1)
{
if((connectfd=accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1)
{
if(errno==EINTR) continue;
perror("accept() error.
");
exit(1);
}
if((pid=fork())>0)
{
close(connectfd);
continue;
}
else if(pid==0)
{
close(listenfd);
process_cli(connectfd,client);
exit(0);
}
else
{
printf("fork error.
");
exit(1);
}
}
close(listenfd);
return 0;
}
void process_cli(int connectfd,struct sockaddr_in client)
{
int i,num;
char recvbuf[MAXDATASIZE];
char sendbuf[MAXDATASIZE];
char cli_name[MAXDATASIZE];
time_t t;
t=time(NULL);
printf("客户端IP：%s
",inet_ntoa(client.sin_addr));
num=recv(connectfd,cli_name,MAXDATASIZE,0);
if(num==0)
{
close(connectfd);
printf("Client disconnected.
");
return;
}
send(connectfd,(void *)&t,sizeof(time_t),0);
while(num=recv(connectfd,recvbuf,MAXDATASIZE,0))
{
recvbuf[num]=' ';
printf("当前时间：%s
",ctime(&t));
//send(connectfd,(void *)&t,sizeof(time_t),0);
}
close(connectfd);
}
void sig_handler(int s)
{
pid_t pid;
int stat;
while((pid=waitpid(-1,&stat,WNOHANG))>0)
printf("子进程 %d 关闭。
",pid);
return;
}
客户端源代码：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <time.h>
#define PORT 1234
#define MAXDATASIZE 1000
void process(FILE *fp,int sockfd);
char *getMessage(char *sendline,int len,FILE *fp);
int main(int argc,char *argv[])
{
int fd;
struct hostent *he;
struct sockaddr_in server;
if(argc!=2)
{
printf("Usage: %s <IP Address>
",argv[0]);
exit(1);
}
if((he=gethostbyname(argv[1]))==NULL)
{
printf("gethostbyname error.
");
exit(1);
}
if((fd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket() error.
");
exit(1);
}
bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr=*((struct in_addr *)he->h_addr);
if(connect(fd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)
{
perror("connect() error.
");
exit(1);
}
process(stdin,fd);
close(fd);
return 0;
}
void process(FILE *fp,int sockfd)
{
char sendbuf[MAXDATASIZE];
char recvbuf[MAXDATASIZE];
int num;
time_t t;
t=time(NULL);
printf("用户名：
");
if(fgets(sendbuf,MAXDATASIZE,fp)==NULL)
{
printf("lease enter your name,now you have exit.
");
return;
}
send(sockfd,sendbuf,strlen(sendbuf),0);
while(getMessage(sendbuf,MAXDATASIZE,fp)!=NULL)
{
send(sockfd,sendbuf,strlen(sendbuf),0);
if((num=recv(sockfd,recvbuf,MAXDATASIZE,0))==0)
{
printf("Server no send you any data.
");
return;
}
recvbuf[num]=' ';
printf("服务器消息：%s
",ctime(&t));
}
printf("Exit.
");
}
char *getMessage(char *sendline,int len,FILE *fp)
{
printf("请输入请求:
");
return(fgets(sendline,len,fp));
}
运行结果：
可实现并发，即多个客户端同时访问服务器，并给出不同的系统时间。