zoukankan html css js c++ java

2017-2018-1 20155312 实验三实时系统

实验目的

任务一

学习使用Linux命令wc(1)
基于Linux Socket程序设计实现wc（1）服务器(端口号是你学号的后6位)和客户端
- 客户端传一个文本文件给服务器
- 服务器返加文本文件中的单词数

任务二

使用多线程实现wc服务器并使用同步互斥机制保证计数正确

实验步骤

任务一

任务一实现过程一共分为三个阶段：

实现wc功能
实现客户端给服务器传文件功能
在客户端调用wc函数统计传过来的文件的单词个数

1.实现wc功能

为了正确实现统计单词个数的功能，找到其与wc命令的关系，先用「man 1 wc」查看wc命令的manpages，如下所示：

wc指令功能：统计指定文件中的字节数、字数、行数，并将统计结果显示输出。
wc指令格式：wc [选项] 文件...
wc指令描述：其中word字长是由空格分隔的非零长度序列。
wc命令参数：
- -c 统计字节数。
- -l 统计行数。
- -m 统计字符数。这个标志不能与 -c 标志一起使用。
- -w 统计字数。一个字被定义为由空白、跳格或换行字符分隔的字符串。
- -L 打印最长行的长度。

这里和我们的目标：统计单词数最相近的功能参数是『-w』。wc -w 命令统计字数时，要注意：字的定义是“空白、跳格或换行字符分隔的字符串”，和单词数不完全相同。

以test3.txt为例，其文件内容如下图所示，其包含的单词数有8个：

但是通过wc -w命令划分为以下6个字，所以显示的结果为6：

所以本人编写了两个mywc，分别实现wc -w功能和统计单词数的功能，其主要的区别在于划分单元时的分隔符范围：

wc -w命令实现时：由' '，' '，' '，' '作为分隔符
单词数统计功能实现时：除上述分隔符，还加入了文本文件中常见的符号：'!'，'"'，'?'，'.'，','，'('，')'，':'，';'，'-'。

两个功能实现的过程类似，描述如下：

逐个字符的访问文件，直到读到文件结尾
如果当前字符是分割符，则将flag置0；
如果非分隔符，且flag=0，则将flag置1，将计数器加1；否则，不进行任何操作

mywc版本1实现

以下代码实现了单词个数统计功能：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFFERSIZE 1024
/*int num=0;
void wc(char buffer[],int size)
{
	int i,flag=0;
	for(i=0;i<size;i++)
	{
		if(buffer[i]==' ' || buffer[i]=='
' || buffer[i]=='	' || buffer[i]=='' || buffer[i]=='!' || buffer[i]=='?' || buffer[i]=='"' || buffer[i]=='.' || buffer[i]== ',' || buffer[i]==':' || buffer[i]=='(' || buffer[i]==')' || buffer[i]==';' || buffer[i]=='■ ' || buffer[i]=='•' )
		{
			flag=0;
		}
		else
		{
			if(flag==0)
			{
				num++;
			}
			flag=1;
		}
	}
	return num;
}*/
int main()
{
	FILE *fp;
	char ch;
	char filename[100];
	int flag=0,num=0;
		printf("input filename: ");
	scanf("%s",filename);
	if((fp = fopen(filename,"r"))==NULL)
	{
		printf("Failure to open %s
",filename);
		exit(0);
	}
	while((ch=fgetc(fp))!=EOF)
	{
		if(ch==' ' || ch=='
' || ch=='	' ||  ch=='!' || ch=='?' || ch=='"' || ch=='.' || ch== '\,' || ch==':' || ch=='(' || ch==')'     || ch==';' || ch=='-')
		{
			flag=0;
		}
		else
		{
			if(flag==0)
			{
				flag=1;
				num++;
			}

		}

	}
	printf("%d
",num);
	fclose(fp);
	return 0;
}

运行结果如下图所示：

mywc版本2

实现了wc -w功能

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFFERSIZE 1024

int main()
{
	FILE *fp;
	char ch;
	char filename[100];
	int flag=0,num=0;
		printf("input filename: ");
	scanf("%s",filename);
	if((fp = fopen(filename,"r"))==NULL)
	{
		printf("Failure to open %s
",filename);
		exit(0);
	}
	while((ch=fgetc(fp))!=EOF)
	{
		if(ch==' ' || ch=='
' || ch=='	' || ch=='
')
		{
			flag=0;
		}
		else
		{
			if(flag==0)
			{
				flag=1;
				num++;
			}

		}

	}
	printf("%c
",num+48);
	fclose(fp);
	return 0;
}

运行结果如下所示：

感谢惟佳告诉我用gedit打开文件，让我开启新世界的大门

2.文件传输功能

实现文件传输功能之前，首先要实现客户端和服务器的通信，结合我们在网络安全编程基础中学习的内容，我们知道客户端和服务器的通信过程如下：

客户端：socket()→bind()→connect()→send()→recv()→close()
服务器：socket()→bind()→accept()→recv()→send()→close()

搭建好几本框架后，客户端文件发送思路如下：

打开待发送文件，并按字符读取文件内容；
将读取到的内容存到数组buffer中
将buffer发送到服务器

这里涉及到定义buffer数组大小的问题，因为我们并不确定文件大小，又无法将buffer定义成无限大，所以步骤2、3的具体实现思路是：

将字符存入数组，若达到数组最大值，则将buffer数组发送到客户端；
每发送一次buffer，都将其清零，并把控制变量修改为0
文件读取完毕退出后，判断最后一次读取的buffer是否达到最大值，若未达到最大值，还需要将最后一次写入的buffer发送给服务器。

至此完成了客户端发送文件的操作。

服务器端接收文件思路如下：

以"w"写方式打开接收文件“recvfile.txt”
不断接收客户端传送的数据，并存入buffer，直到接收数据长度为0
每接收一个buffer，就将其写入接收文件“recvfile.txt”
最后关闭文件

3.统计单词个数

实现思路：

在客户端调用mywc函数，用两种方式分别计算文件的“字数”和“单词数”，在服务器端调用mywc函数，通过输入，选择一种方式计算文件中“字数”或“单词数”
客户端mywc函数的参数为文件名和模式标号，调用时，分别用“1”，“2”两种模式调用两次；服务器端mywc函数的参数只有文件名，在函数内部接收代表模式的输入。

实现了以上功能后，任务一就完成了。其中客户端代码如下：

#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  
  
#define HELLO_WORLD_SERVER_PORT       155312  
#define BUFFER_SIZE                   1024  
#define FILE_NAME_MAX_SIZE            512  
int mywc(char file_name[],int choose);
int main(int argc, char **argv)  
{  
	FILE *fp;
	if (argc != 2)  
	{  
		printf("Usage: ./%s ServerIPAddress
", argv[0]);  
		exit(1);  
	}  

// 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
	struct sockaddr_in client_addr;  
	bzero(&client_addr, sizeof(client_addr));  
	client_addr.sin_family = AF_INET; // internet协议族  
	client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
	client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  

// 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
	int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
	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;  

// 服务器的IP地址来自程序的参数   
	if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
	{  
		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 file_name[FILE_NAME_MAX_SIZE + 1];  
	bzero(file_name, sizeof(file_name));  
	printf("Please Input File Name.	");  
	scanf("%s", file_name);  
	if((fp = fopen(file_name,"r"))==NULL)
    {
         printf("Failure to open %s
",file_name);
         exit(0);
	}
	
	char buffer[BUFFER_SIZE];  
	bzero(buffer, sizeof(buffer));  
	char ch;
	int i=0;
	while((ch=fgetc(fp))!=EOF)
	{
		buffer[i++]=ch;
		if(i>=BUFFER_SIZE)
		{
			if((send(client_socket, buffer, BUFFER_SIZE, 0))==-1)
			{
				printf("发送文件失败
");
			}
			bzero(buffer, sizeof(buffer));
			i=0;
		}
	}
	if(i<BUFFER_SIZE)
	{
		if((send(client_socket, buffer, i, 0))==-1)
		{
			printf("发送文件失败
");
		}
	}
	printf("发送%s完毕
",file_name);
	mywc(file_name,1);
	 mywc(file_name,2);
	// 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件 
	//以下接收服务器发来的单词个数
	bzero(buffer, sizeof(buffer));
//	int length = 0;  
/*	int length = recv(client_socket, buffer, sizeof(buffer), 0);
	  
		if (length < 0)  
		{  
			printf("Recieve Data From Server %s Failed!
", argv[1]);   
		}  
		else
		{
		printf("Recieve words number %c From Server[%s] Finished!
",buffer[0],argv[1]);

		}
		bzero(buffer, BUFFER_SIZE);  */
// 传输完毕，关闭socket   
	
	fclose(fp);  
	close(client_socket);  
	return 0;  

}  
 int mywc(char file_name[],int choose)
  {
       FILE *fp;
	   char ch;
        int flag=0,num=0;
        // int choose;
	    //  printf("统计单词个数还是实现“wc -w”?(1or2)
");
	      // scanf("%d",&choose);
	        if((fp = fopen(file_name,"r"))==NULL)
	         {
		          printf("Failure to open %s
",file_name);
		           exit(0);
		        }
		     
			      if(choose==1)
			       {
			        while((ch=fgetc(fp))!=EOF)
			         {
				          if(ch==' ' || ch=='
' || ch=='	' ||  ch=='!' || ch=='?' || ch=='"' || ch=='.' || ch== '\,' || ch==':' || ch=='(' || ch==')' || ch==';'     || ch=='-')
						  {
						  flag=0;
						  }
						  else
						  {
						  if(flag==0)
						  {
						  flag=1;
						  num++;
						  }
						  
						  }

					}

				}
				else if(choose==2)
				{
					while((ch=fgetc(fp))!=EOF)
					{
						if(ch==' ' || ch=='
' || ch=='	' || ch=='
')
						flag=0;
						else
						{
							if(flag==0)
							{
								flag=1;
								num++;
							}
						}
					}
				}
				printf("单词个数为：%d_用方式%d计算
",num,choose);
				fclose(fp);
				return num;
}

服务器端代码如下：

#include<netinet/in.h>   
#include<sys/types.h>   
#include<sys/socket.h>   
#include<stdio.h>   
#include<stdlib.h>   
#include<string.h>   
  
#define HELLO_WORLD_SERVER_PORT    155312  
#define LENGTH_OF_LISTEN_QUEUE     20  
#define BUFFER_SIZE                1024  
#define FILE_NAME_MAX_SIZE         512  
int mywc(char file_name[])
{
	char ch;
	int flag=0,num=0;
	int choose;
	FILE *fp;
	printf("统计单词个数还是实现“wc -w”?(1or2)
");
	scanf("%d",&choose);
	if((fp = fopen(file_name,"r"))==NULL)
	{
		printf("Failure to open %s
",file_name);
	    exit(0);
	}

	if(choose==1)
	{
	while((ch=fgetc(fp))!=EOF)
	{
		if(ch==' ' || ch=='
' || ch=='	' ||  ch=='!' || ch=='?' || ch=='"' || ch=='.' || ch== '\,' || ch==':' || ch=='(' || ch==')' || ch==';' || ch=='-')
		{
			flag=0;
		}
		else
		{
			if(flag==0)
			{
				flag=1;
				num++;
			}

		}
				   
	}

	}
	else if(choose==2)
	{
		while((ch=fgetc(fp))!=EOF)
		{
			if(ch==' ' || ch=='
' || ch=='	' || ch=='
')
				flag=0;
			else
			{
				if(flag==0)
				{
					flag=1;
					num++;
				}
			}
		}
	}
	printf("单词个数为：%d
",num);
	fclose(fp);
	return num;
}
int main(int argc, char **argv)  
{  
// set socket's address information   
// 设置一个socket地址结构server_addr,代表服务器internet的地址和端口  
	struct sockaddr_in   server_addr;  
	bzero(&server_addr, sizeof(server_addr));  
	server_addr.sin_family = AF_INET;  
	server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
	server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
// create a stream socket   
// 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口  
	int server_socket = socket(PF_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);  
	}  
// 服务器端一直运行用以持续为客户端提供服务   
	  
	  
// 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept  
// 接受此请求，同时将client端的地址和端口等信息写入client_addr中  
		struct sockaddr_in client_addr;  
		int length = sizeof(client_addr);  

// 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中  
// 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以  
// 用select()来实现超时检测   
// accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信  
// 这里的new_server_socket代表了这个通信通道  
		int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);  
		printf("连接到客户端
");
		if (new_server_socket < 0)  
		{  
			printf("Server Accept Failed!
");  
			  
		}
		FILE *fp;
		if((fp = fopen("recvfile.txt","w"))==NULL)
	    {
		 	printf("Failure to open recvfile
");
	        exit(0);
	    }

		//接受来自客户端的文件
		char buffer[BUFFER_SIZE];  
		bzero(buffer, sizeof(buffer));  
		length=0;
		while( length = recv(new_server_socket, buffer, BUFFER_SIZE, 0) )
		{
			if(length<0)
			{
				printf("接受文件出错
");
				exit(0);
			}
			
			if(fwrite(buffer,sizeof(char),length,fp)<length)
			{
				printf("写文件失败
");
			}
			bzero(buffer, BUFFER_SIZE);
		}
		fclose(fp);
		printf("接受文件完毕
");
		int number=0;
		char file_name[512]="recvfile.txt";
		number=mywc(file_name);
		printf("%d
",number);  
		bzero(buffer, BUFFER_SIZE);  
		buffer[0]=number+48;
// 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端  
		if (send(new_server_socket, buffer, sizeof(buffer), 0) < 0)  
		{  
			printf("Send number Failed!
");  
			 
		}  
		printf("发送单词个数完毕
");
	    bzero(buffer, sizeof(buffer));  
 		
//		fclose(fp);  
		printf("File Transfer Finished!
");    
		close(new_server_socket);  
	  

	close(server_socket);  

	return 0;  
}

运行截图如下所示：

任务二

多线程实现wc服务器时，会出现多个客户端同时像服务器传送文件的情况，所以仅仅在服务器端创建一个recvfile.txt用于接收文件是远远不够的，需要根据发送的不同文件名创建新的接收文件。

为此，修改了客户端代码，在发送文件之前先将文件名发送至服务器；服务器端就收文件名后，在该文件后面加上“-server”作为接收文件的名字，这样就避免了多个文件写入一个recvfile的冲突。

此外，在服务器端实现多线程的思路如下：

建立一个while循环，不断接收来自客户端的连接；
在循环内创建一个线程
将接收文件、调用mywc函数等过程抽象为一个万能函数，void *process_client(void *newnew_server_socket)
在线程中调用这个函数，并将用于接收客户端连接的accept函数返回值newnew_server_socket的地址作为参数。

客户端添加文件名传输后的代码client.c如下：

#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  
  
#define HELLO_WORLD_SERVER_PORT       155312  
#define BUFFER_SIZE                   1024  
#define FILE_NAME_MAX_SIZE            512  
int mywc(char file_name[],int choose);
int main(int argc, char **argv)  
{  
	FILE *fp;
	if (argc != 2)  
	{  
		printf("Usage: ./%s ServerIPAddress
", argv[0]);  
		exit(1);  
	}  

// 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
	struct sockaddr_in client_addr;  
	bzero(&client_addr, sizeof(client_addr));  
	client_addr.sin_family = AF_INET; // internet协议族  
	client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
	client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  

// 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
	int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
	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;  

// 服务器的IP地址来自程序的参数   
	if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
	{  
		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 file_name[FILE_NAME_MAX_SIZE + 1];  
	bzero(file_name, sizeof(file_name));  
	printf("Please Input File Name.	");  
	scanf("%s", file_name);  
	if((fp = fopen(file_name,"r"))==NULL)
    {
         printf("Failure to open %s
",file_name);
         exit(0);
	}
	
	char buffer[BUFFER_SIZE];  
	bzero(buffer, sizeof(buffer));  
	strcpy(buffer,file_name);
	if(send(client_socket,buffer,BUFFER_SIZE,0)==-1)
	{
		printf("发送文件名失败
");
	}
	char ch;
	int i=0;
	while((ch=fgetc(fp))!=EOF)
	{
		buffer[i++]=ch;
		if(i>=BUFFER_SIZE)
		{
			if((send(client_socket, buffer, BUFFER_SIZE, 0))==-1)
			{
				printf("发送文件失败
");
			}
			bzero(buffer, sizeof(buffer));
			i=0;
		}
	}
	if(i<BUFFER_SIZE)
	{
		if((send(client_socket, buffer, i, 0))==-1)
		{
			printf("发送文件失败
");
		}
	}
	printf("发送%s完毕
",file_name);
	mywc(file_name,1);
	 mywc(file_name,2);
	// 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件 
	//以下接收服务器发来的单词个数
	bzero(buffer, sizeof(buffer));
//	int length = 0;  
/*	int length = recv(client_socket, buffer, sizeof(buffer), 0);
	  
		if (length < 0)  
		{  
			printf("Recieve Data From Server %s Failed!
", argv[1]);   
		}  
		else
		{
		printf("Recieve words number %c From Server[%s] Finished!
",buffer[0],argv[1]);

		}
		bzero(buffer, BUFFER_SIZE);  */
// 传输完毕，关闭socket   
	
	fclose(fp);  
	close(client_socket);  
	return 0;  

}  
 int mywc(char file_name[],int choose)
  {
       FILE *fp;
	   char ch;
        int flag=0,num=0;
        // int choose;
	    //  printf("统计单词个数还是实现“wc -w”?(1or2)
");
	      // scanf("%d",&choose);
	        if((fp = fopen(file_name,"r"))==NULL)
	         {
		          printf("Failure to open %s
",file_name);
		           exit(0);
		        }
		     
			      if(choose==1)
			       {
			        while((ch=fgetc(fp))!=EOF)
			         {
				          if(ch==' ' || ch=='
' || ch=='	' ||  ch=='!' || ch=='?' || ch=='"' || ch=='.' || ch== '\,' || ch==':' || ch=='(' || ch==')' || ch==';'     || ch=='-')
						  {
						  flag=0;
						  }
						  else
						  {
						  if(flag==0)
						  {
						  flag=1;
						  num++;
						  }
						  
						  }

					}

				}
				else if(choose==2)
				{
					while((ch=fgetc(fp))!=EOF)
					{
						if(ch==' ' || ch=='
' || ch=='	' || ch=='
')
						flag=0;
						else
						{
							if(flag==0)
							{
								flag=1;
								num++;
							}
						}
					}
				}
				printf("单词个数为：%d_用方式%d计算
",num,choose);
				fclose(fp);
				return num;
}

服务器端实现多线程后的代码newfile.c如下：

#include<netinet/in.h>   
#include<sys/types.h>   
#include<sys/socket.h>   
#include<stdio.h>   
#include<stdlib.h>   
#include<string.h>   
#include<pthread.h>  
#define HELLO_WORLD_SERVER_PORT    155312  
#define LENGTH_OF_LISTEN_QUEUE     20  
#define BUFFER_SIZE                1024  
#define FILE_NAME_MAX_SIZE         512  
void *process_client(void *new_server_socket);
int mywc(char file_name[])
{
	char ch;
	int flag=0,num=0;
	int choose;
	FILE *fp;
	printf("统计单词个数还是实现“wc -w”?(1or2)
");
	scanf("%d",&choose);
	if((fp = fopen(file_name,"r"))==NULL)
	{
		printf("Failure to open %s
",file_name);
	    exit(0);
	}

	if(choose==1)
	{
	while((ch=fgetc(fp))!=EOF)
	{
		if(ch==' ' || ch=='
' || ch=='	' ||  ch=='!' || ch=='?' || ch=='"' || ch=='.' || ch== '\,' || ch==':' || ch=='(' || ch==')' || ch==';' || ch=='-')
		{
			flag=0;
		}
		else
		{
			if(flag==0)
			{
				flag=1;
				num++;
			}

		}
				   
	}

	}
	else if(choose==2)
	{
		while((ch=fgetc(fp))!=EOF)
		{
			if(ch==' ' || ch=='
' || ch=='	' || ch=='
')
				flag=0;
			else
			{
				if(flag==0)
				{
					flag=1;
					num++;
				}
			}
		}
	}
	printf("单词个数为：%d
",num);
	fclose(fp);
	return num;
}
int main(int argc, char **argv)  
{  
// set socket's address information   
// 设置一个socket地址结构server_addr,代表服务器internet的地址和端口  
	struct sockaddr_in   server_addr;  
	bzero(&server_addr, sizeof(server_addr));  
	server_addr.sin_family = AF_INET;  
	server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
	server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
// create a stream socket   
// 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口  
	int server_socket = socket(PF_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);  
	}  
// 服务器端一直运行用以持续为客户端提供服务   
	  
	while(1)
	{
// 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept  
// 接受此请求，同时将client端的地址和端口等信息写入client_addr中  
		struct sockaddr_in client_addr;  
		socklen_t length = sizeof(client_addr);  

// 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中  
// 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以  
// 用select()来实现超时检测   
// accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信  
// 这里的new_server_socket代表了这个通信通道  
		int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);  
		printf("连接到客户端
");
		if (new_server_socket < 0)  
		{  
			printf("Server Accept Failed!
");  
			  
		}
		//添加进程相关代码
		pthread_t pid;
		if(pthread_create(&pid, NULL, process_client,(void *) &new_server_socket) < 0){
		      printf("pthread_create error
");
		}
		
	}
//	close(server_socket);
}
void *process_client(void *new_server_socket)
{
		int sockid=*(int *)new_server_socket;
		FILE *fp;
		//接受来自客户端的文件
		char buffer[BUFFER_SIZE]; 
		char file_name[FILE_NAME_MAX_SIZE];
		bzero(buffer, sizeof(buffer));  
		int length=0;
		if(recv(sockid,buffer,BUFFER_SIZE, 0)==-1)
		{
			printf("接受文件名%s失败
",buffer);
		}
		strcpy(file_name,buffer);
		strcat(file_name,"-server");
		if((fp = fopen(file_name,"w"))==NULL)
		{
			printf("Failure to open %s
",file_name);
			exit(0);
		}
		while( length = recv(sockid, buffer, BUFFER_SIZE, 0))
		{
			if(length<0)
			{
				printf("接受文件出错
");
				exit(0);
			}
			
			if(fwrite(buffer,sizeof(char),length,fp)<length)
			{
				printf("写文件失败
");
			}
			bzero(buffer, BUFFER_SIZE);
		}
		fclose(fp);
		printf("接受文件完毕
");
		int number=0;
		number=mywc(file_name);
		bzero(buffer, BUFFER_SIZE);  
		buffer[0]=number+48;
// 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端  
		/*if (send(new_server_socket, buffer, sizeof(buffer), 0) < 0)  
		{  
			printf("Send number Failed!
");  
			 
		}  
		printf("发送单词个数完毕
");*/
	    bzero(buffer, sizeof(buffer));  
 		
//		fclose(fp);  
		printf("File Transfer Finished!
");    
		close(new_server_socket);  
}

运行时可以同时多个客户端一起给服务器传文件效率更高，如下所示：

实验中的问题及解决过程

问题1：完成任务一时，服务器无法显示读取文件完毕，只有关闭了客户端，服务器才能进行下一步计算个数的操作，总是显示单词数为0.
问题1解决过程：
1. 首先确定文件是否传输成功，发现执行程序后，可以发现在服务器所在文件夹可以生成相应的recvfile.txt，这说明发送文件和接收文件没有问题；
2. 最开始调用mywc之前，不会关闭文件，而是将文件指针作为参数传递给mywc函数，执行完函数返回主函数再关闭文件。经过分析，发现原因是写文件结束后，文件指针的位置指向文件结尾，所以此时传递给mywc函数的指针跟打开文件时指向文件头的指针是完全不同的。
3. 发现问题后，修改了mywc函数参数，从文件指针变为文件名；在服务器主函数中写入文件后就关闭文件，然后在mywc函数中再次打开这个文件，统计完个数就在该函数中关闭文件。这样修改后，解决了问题。
问题2：改写服务器和客户端的代码实现多线程时，服务器显示“接收文件失败”并退出。
问题2解决过程：
1. 首先分析代码，确定设定的循环包含的内容正确，不缺少关键环节；
2. 其次检查进程函数process_client参数，参数类型传递正确；
3. 最后检查proces_client函数内部，发现自己误将void *类型的指针变量new_server_socket当成了主函数中的int型变量new_server_socket，导致执行recv(new_server_socket,buffer,BUFFER_SIZE, 0)时，由于第一个参数类型不匹配而接收文件失败；
4. 定义一个int 型变量，int sockid=*(int *)new_server_socket;用于取指针new_server_socket中的值，然后在后续操作中执行recv函数时，使用这个变量sockid作为参数，最后解决了问题。

新学到的知识点

学会了sock传文件的相关知识
学习了如何动态读、写文件
学习了如何实现wc指令、如何统计一个文本的单词个数
学习了多线程编程方法，了解了pthread_creat等函数的用法

参考资料

查看全文

相关阅读:
Binary Tree Level Order Traversal
Search a 2D Matrix
Minimum Path Sum
Remove Duplicates from Sorted Array II
AngularJS 过滤器
 AngularJS 控制器
 AngularJS ng-model 指令
 AngularJS Scope(作用域)
AngularJS 指令
 AngularJS表达式

原文地址：https://www.cnblogs.com/zjy1997/p/7838381.html

2017-2018-1 20155312 实验三 实时系统

2017-2018-1 20155312 实验三 实时系统

实验目的

任务一

任务二

实验步骤

任务一

1.实现wc功能

mywc版本1实现

mywc版本2

2.文件传输功能

3.统计单词个数

任务二

实验中的问题及解决过程

新学到的知识点

参考资料

2017-2018-1 20155312 实验三实时系统

2017-2018-1 20155312 实验三实时系统