内容

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

上方提交代码
附件提交测试截图,至少要测试附件中的两个文件

client.c:

#include<netinet/in.h>   // sockaddr_in  
    #include<sys/types.h>    // socket  
    #include<sys/socket.h>   // socket  
    #include<stdio.h>        // printf  
    #include<stdlib.h>       // exit  
    #include<string.h>       // bzero  
      
    #define SERVER_PORT 8000  
    #define BUFFER_SIZE 1024  
    #define FILE_NAME_MAX_SIZE 512  
      
    int main()  
    {  
        // 声明并初始化一个客户端的socket地址结构  
        struct sockaddr_in client_addr;  
        bzero(&client_addr, sizeof(client_addr));  
        client_addr.sin_family = AF_INET;  
        client_addr.sin_addr.s_addr = htons(INADDR_ANY);  
        client_addr.sin_port = htons(0);  
      
        // 创建socket,若成功,返回socket描述符  
        int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);  
        if(client_socket_fd < 0)  
        {  
            perror("Create Socket Failed:");  
            exit(1);  
        }  
      
        // 绑定客户端的socket和客户端的socket地址结构 非必需  
        if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))  
        {  
            perror("Client Bind Failed:");  
            exit(1);  
        }  
      
        // 声明一个服务器端的socket地址结构,并用服务器那边的IP地址及端口对其进行初始化,用于后面的连接  
        struct sockaddr_in server_addr;  
        bzero(&server_addr, sizeof(server_addr));  
        server_addr.sin_family = AF_INET;  
        if(inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) == 0)  
        {  
            perror("Server IP Address Error:");  
            exit(1);  
        }  
        server_addr.sin_port = htons(SERVER_PORT);  
        socklen_t server_addr_length = sizeof(server_addr);  
      
        // 向服务器发起连接,连接成功后client_socket_fd代表了客户端和服务器的一个socket连接  
        if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
        {  
            perror("Can Not Connect To Server IP:");  
            exit(0);  
        }  
      
        // 输入文件名 并放到缓冲区buffer中等待发送  
        char file_name[FILE_NAME_MAX_SIZE+1];  
        bzero(file_name, FILE_NAME_MAX_SIZE+1);  
        printf("Please Input File Name :\t");  
        scanf("%s", file_name);  
      
        char buffer[BUFFER_SIZE];  
        bzero(buffer, BUFFER_SIZE);  
        strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));  
          
        // 向服务器发送buffer中的数据  
        if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  
        {  
            perror("Send File Name Failed:");  
            exit(1);  
        }  
      
     
        FILE *fp = fopen(file_name, "w");  
        if(NULL == fp)  
        {  
            printf("File:\t%s Can Not Open To Write\n", file_name);  
            exit(1);  
        }  
      
        // 从服务器接收数据到buffer中  
        // 每接收一段数据,便将其写入文件中,循环直到文件接收完并写完为止  
        bzero(buffer, BUFFER_SIZE);  
        int length = 0;  
        while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)  
        {  
            if(fwrite(buffer, sizeof(char), length, fp) < length)  
            {  
                printf("File:\t%s Write Failed\n", file_name);  
                break;  
            }  
            bzero(buffer, BUFFER_SIZE);  
        }  
      
        // 接收成功后,关闭文件,关闭socket  
        printf("Send File:\t%s  Successful!\n", file_name);  
        close(fp);  
        close(client_socket_fd);  
        return 0;  
    }  

server.c:

#include<netinet/in.h>  // sockaddr_in  

#include<sys/types.h>   // socket  

#include<sys/socket.h>  // socket  

#include<stdio.h>       // printf  

#include<stdlib.h>      // exit  

#include<string.h>      // bzero  

  

#define SERVER_PORT 8000  

#define LENGTH_OF_LISTEN_QUEUE 20  

#define BUFFER_SIZE 1024  

#define FILE_NAME_MAX_SIZE 512  





int countChar(char input[]){

    int p_input = 0;

    int count = 0;

    int word = 0;

    char ch;



    while(p_input < strlen(input)){

        ch = input[p_input];

        if(ch==' '){

            if(word){ //读取到空字符,而之前是非空字符,则说明读完了一个单词

                count++;

                word = 0;

            }

        }else{ //读取到第一个非空字符,说明是单词的开始

            word = 1;

        }

        p_input++;

    }

    return count;

}



int main(void)  

{  

    // 声明并初始化一个服务器端的socket地址结构  

    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(SERVER_PORT);  

  

    // 创建socket,若成功,返回socket描述符  

    int server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);  

    if(server_socket_fd < 0)  

    {  

        perror("Create Socket Failed:");  

        exit(1);  

    }  

    int opt = 1;  

    setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  

  

    // 绑定socket和socket地址结构  

    if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))  

    {  

        perror("Server Bind Failed:");  

        exit(1);  

    }  

      

    // socket监听  

    if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))  

    {  

        perror("Server Listen Failed:");  

        exit(1);  

    }  

  

    while(1)  

    {  

        // 定义客户端的socket地址结构  

        struct sockaddr_in client_addr;  

        socklen_t client_addr_length = sizeof(client_addr);  

  

        // 接受连接请求,返回一个新的socket(描述符),这个新socket用于同连接的客户端通信  

        // accept函数会把连接到的客户端信息写到client_addr中  

        int new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length); 

        char ch; 

        if(new_server_socket_fd < 0)  

        {  

            perror("Server Accept Failed:");  

            break;  

        }  

  

        // recv函数接收数据到缓冲区buffer中  

        char buffer[BUFFER_SIZE];  

        bzero(buffer, BUFFER_SIZE);  

        if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  

        {  

            perror("Server Recieve Data Failed:");  

            break;  

        }  

  

        // 然后从buffer(缓冲区)拷贝到file_name中  

        char file_name[FILE_NAME_MAX_SIZE+1];  

        bzero(file_name, FILE_NAME_MAX_SIZE+1);  

        strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));  

        printf("%s\n", file_name);  

  

        FILE *fp = fopen(file_name, "r");  

        if(NULL == fp)  

        {  

            printf("File:%s Not Found\n", file_name);  

        }  

        else  

        {  

            bzero(buffer, BUFFER_SIZE);  

            int length = 0;  

            

            while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)  

            {  

                if(send(new_server_socket_fd, buffer, length, 0) < 0)  

                {  

                    printf("Send File:%s Failed./n", file_name);  

                    break;  

                }  

                bzero(buffer, BUFFER_SIZE);  

            }  

  

    

     

    char input[256];

    int p_input = 0;

    int count = 0;

fgets(input,256,fp);

// 关闭文件  

            fclose(fp);  

            printf("File:%s Recieve Successful!\n", file_name); 

     count = countChar(input);

    printf("Your words count:\n%d\n",count);



        }  

        // 关闭与客户端的连接  

        close(new_server_socket_fd);  

    }  

    // 关闭监听用的socket  

    close(server_socket_fd);  

    return 0;  

}  

运行截图:

实验二:

使用多线程实现wc服务器并使用同步互斥机制保证计数正确
上方提交代码
下方提交测试
对比单线程版本的性能,并分析原因

wc命令的实现:
#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>
#include<stdlib.h>
struct message{
int lines;
int words;
int max_line_length;
int size;
int chars;
}info;
void error_print(char str[]){
printf("Error:%s",str);
}
void init(char filename[]){
struct stat get_message = {};
FILE fp;
int ret_stat = stat(filename,&get_message);/
用stat函数读取filenmae文件的信息,并将结果写到get_message结构体中*/
if(ret_stat == -1){//stat函数不出错则进行信息输出
error_print(filename);
return ;
}
mode_t mode = get_message.st_mode; //接收文件信息,用于下面判断是不是目录
int length = 0;
if(S_ISDIR(mode)) //如果是目录,输出错误
printf("Error %s is dir\n0\t0\t0\t%s",filename,filename);
else{
info.size = get_message.st_size; //文件字节大小 wc -c
fp = fopen(filename,"r"); //以只读方式打开指定文件
char ch;
int flag = 0;
while((ch = fgetc(fp))!=EOF){ //一直读到文件尾
info.chars++; //字符数加1 wc -m

                        if(ch != '\n'){  
  
                                length++;   //记录当前行的长度 wc -L  
                        }  
                        if(ch == '\n'){  
                                info.lines ++;  //行数加1 wc -l  
                                if(length>info.max_line_length)  
                                        info.max_line_length = length;  //更新最大长度  
                                length = 0;  
                        }  
                        if(ch == '\t' || ch == ' ' || ch == '\n'){  
                                flag = 0;       //计算单词数 wc -w  
                                continue;  
                        }  
                        else{  
  
                                if(flag == 0){  
                                        info.words++;   //计算单词数 wc -w  
                                        flag = 1;  
                                }  
                        }  
                }  
                fclose(fp);  
        }  
  
}  
//计算键盘输入内容的相关信息,即参数中没有指定要打开的文件  
void EmptyFile(){  
        char ch;  
        int flag = 0;  
        int length = 0;  
  
        while((ch = getchar())!=EOF){  
               info.chars++;  
                info.size += sizeof(ch);    //字节累加  
                if(ch != '\n'){  
                        length++;  
               }  
               if(ch == '\n'){  
                        info.lines ++;  
                        if(length>info.max_line_length)  
                                info.max_line_length = length;  
                        length = 0;  
                }  
                if(ch == '\t' || ch == ' ' || ch == '\n'){  
                        flag = 0;  
                        continue;  
                }  
                else{  
  
                        if(flag == 0){  
                                info.words++;  
                               flag = 1;  
                        }  
                }  
  
        }  
}  
int main(int argc,char *argv[]){  
  
        if(argc == 2){  
                if(argv[1][0] != '-'){  
                       init(argv[1]);  
                       printf("%d %d %d %s\n",info.lines,info.words,info.size,argv[1]);  
                       return 0;  
                }  
                else{   //未指定打开文件,类似 wc -lmwcL  
                       EmptyFile();  
  
                }  
        }  
        else if(argc == 1){     //未指定打开文件和要输出的参数,(默认输出 -lwc)  
                EmptyFile();  
                printf("%d\t%d\t%d\n",info.lines,info.words,info.size);  
                return 0;  
        }  
        else if(argc == 3){  
                init(argv[2]);  
        }  
        int num;  
        while((num = getopt(argc,argv,"lwmcL"))!=-1){  
                switch(num){  
                        case 'l':  
                                printf("%d\t",info.lines);  
                                break;  
                        case 'w':  
                                printf("%d\t",info.words);  
                                break;  
                        case 'm':  
                                printf("%d\t",info.chars);  
                                break;  
                        case 'c':  
                                printf("%d\t",info.size);  
                                break;  
                        case 'L':  
                                printf("%d\t",info.max_line_length);  
                                break;  
                }  
        }  
        if(argc != 2 && argv[1][0] != '-')  //一定要判断,否则会越界  
                printf("%s\n",argv[2]);  
  
  
        return 0;  
}  

运行截图:

实验中的问题及解决方法

1.关于多线程的思考

参考
http://www.cnblogs.com/Autumoon/archive/2008/06/19/1225684.html

2.wc命令
-c 统计字节数。
-l 统计行数。
-m 统计字符数。这个标志不能与 -c 标志一起使用。
-w 统计字数。一个字被定义为由空白、跳格或换行字符分隔的字符串。
-L 打印最长行的长度。
-help 显示帮助信息
--version 显示版本信息