2018-2019-1 20165211 實驗三 實時系統

任務一

1.實驗要求

學習使用Linux命令wc(1)
基於Linux Socket程序設計實現wc（1）服務器(端口號是你學號的後6位)和客戶端
客戶端傳一個文本文件給服務器
服務器返加文本文件中的單詞數

2. 實驗步驟

• 使用man命令查看wc(1)命令的主要內容

  ?

• 編寫服務器和客戶端代碼

  服務器:

  #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 165211
  #define LENGTH_OF_LISTEN_QUEUE 20
  #define BUFFER_SIZE 1024
  #define FILE_NAME_MAX_SIZE 512
  
  void itoa(int i,char* string)
  {
      int power,j;
      j=i;
      for(power=1;j>=10;j/=10)
          power*=10;
      for(;power>0;power/=10)
      {
          *string++=‘0‘+i/power;
          i%=power;
      }
      *string=‘\0‘;
  }
  
  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);
      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, "w");
      if(NULL == fp)
      {
        printf("File:%s Not Found\n", file_name);
      }
      else
      {
        bzero(buffer, BUFFER_SIZE);
        int length = 0;
        // 每讀取一段數據，便將其發送給客戶端，循環直到文件讀完為止
        char*ch="bye";
  while((length = recv(new_server_socket_fd, buffer, 1024, 0)) > 0)
    {
      if(strcmp(buffer,ch)==0)break;
      if(fwrite(buffer, sizeof(char), length, fp) < length)
      {
        printf("File:\t%s Write Failed\n", file_name);
        break;
      }
      bzero(buffer, BUFFER_SIZE);
    }fclose(fp);
  int count=0;
      char s[21];
      FILE *fp1;
      if((fp1=fopen(file_name,"r"))==NULL){
          printf("Open the file failure...\n");
          exit(0);
      }
      while(fscanf(fp,"%s",s)!=EOF)
          count++;
      fclose(fp1);
  itoa(count,buffer);
      printf("There is(are) %s word(s) in the text.\n",buffer);
        // 關閉文件
  
        send(new_server_socket_fd, buffer, strlen(buffer), 0);
        printf("File:%s Transfer Successful!\n", file_name);
      }
      // 關閉與客戶端的連接
      close(new_server_socket_fd);
    }
    // 關閉監聽用的socket
    close(server_socket_fd);
    return 0;
  }
   
  

  客戶端

  #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 165211
  #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 On Server:\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, "r");
    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 = fread(buffer, sizeof(char), 1024, fp)) > 0)
        {
          if(send(client_socket_fd, buffer, length, 0) < 0)
          {
            printf("Send File:%s Failed./n", file_name);
            break;
          }
          bzero(buffer, BUFFER_SIZE);
        }
  char ch[1024];
  scanf("%s",ch);
  send(client_socket_fd, "bye", 1024, 0);
      recv(client_socket_fd, buffer, 1024, 0);
      printf("There is(are) %s word(s) in the text %s.\n",buffer,file_name);
    // 接收成功後，關閉文件，關閉socket
    printf("Receive File:\t%s From Server IP Successful!\n", file_name);
  
    close(client_socket_fd);
    return 0;
  }
   
  

3. 操作截圖

任務二

1. 實驗要求

使用多線程實現wc服務器並使用同步互斥機制保證計數正確
上方提交代碼
下方提交測試
對比單線程版本的性能，並分析原因

2. 實驗步驟

服務器

#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    165211
#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;
    FILE *fp;
    if((fp = fopen(file_name,"r"))==NULL)
    {
        printf("Failure to open %s\n",file_name);
        exit(0);
    }
    while((ch=fgetc(fp))!=EOF)
    {
         if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
        {
            flag=0;
        }
        else
        {
            if(flag==0)
            {
                flag=1;
                num++;
            }

        }            
    }
    printf("count：%d \n",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!\n");  
        exit(1);  
    }  

// 把socket和socket地址結構綁定   
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))  
    {  
        printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);  
        exit(1);  
    }  

// server_socket用於監聽   
    if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))  
    {  
        printf("Server Listen Failed!\n");  
        exit(1);  
    }  
// 服務器端一直運行用以持續為客戶端提供服務   
      
    while(1)
    {
// 定義客戶端的socket地址結構client_addr，當收到來自客戶端的請求後，調用accept  
// 接受此請求，同時將client端的地址和端口等信息寫入client_addr中  
        struct sockaddr_in client_addr;  
        socklen_t length = sizeof(client_addr);  


        int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);  
        printf("connected to client\n");
        if (new_server_socket < 0)  
        {  
            printf("Server Accept Failed!\n");  
              
        }
        //添加進程相關代碼
        pthread_t pid;
        if(pthread_create(&pid, NULL, process_client,(void *) &new_server_socket) < 0){
              printf("pthread_create error\n");
        }
        
    }
//  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失敗\n",buffer);
        }
        strcpy(file_name,buffer);
        strcat(file_name,"-server");
        if((fp = fopen(file_name,"w"))==NULL)
        {
            printf("Failure to open %s\n",file_name);
            exit(0);
        }
        while( length = recv(sockid, buffer, BUFFER_SIZE, 0))
        {
            if(length<0)
            {
                printf("fail to accept file\n");
                exit(0);
            }
            
            if(fwrite(buffer,sizeof(char),length,fp)<length)
            {
                printf("fail to write file\n");
            }
            bzero(buffer, BUFFER_SIZE);
        }
        fclose(fp);
        printf("accept the file successfully\n");
        int number=0;
        number=mywc(file_name);
        bzero(buffer, BUFFER_SIZE);  
        buffer[0]=number+48;
 
     
        bzero(buffer, sizeof(buffer));  
        

        printf("File Transfer Finished!\n");    
        close(new_server_socket);  
} 
 

客戶端

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

// 把客戶端的socket和客戶端的socket地址結構綁定   
    if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    {  
        printf("Client Bind Port Failed!\n");  
        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!\n");  
        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!\n", argv[1]);  
        exit(1);  
    }  

    char file_name[FILE_NAME_MAX_SIZE + 1];  
    bzero(file_name, sizeof(file_name));  
    printf("Please Input File Name.\t");  
    scanf("%s", file_name);  
    if((fp = fopen(file_name,"r"))==NULL)
    {
         printf("Failure to open %s\n",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("fail to send filename\n");
    }
    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("fail to send file\n");
            }
            bzero(buffer, sizeof(buffer));
            i=0;
        }
    }
    if(i<BUFFER_SIZE)
    {
        if((send(client_socket, buffer, i, 0))==-1)
        {
            printf("fail to send file\n");
        }
    }
    printf("send %s finish\n",file_name);
    mywc(file_name);
    // 向服務器發送buffer中的數據，此時buffer中存放的是客戶端需要接收的文件 
    //以下接收服務器發來的單詞個數
    bzero(buffer, sizeof(buffer));

    fclose(fp);  
    close(client_socket);  
    return 0;  

}  
 int mywc(char file_name[])
  {
       FILE *fp;
       char ch;
       int flag=0,num=0;
       if((fp = fopen(file_name,"r"))==NULL)
       {
            printf("Failure to open %s\n",file_name);
            exit(0);
       }
       while((ch=fgetc(fp))!=EOF)
       {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
            flag=0;
            else
            {
                 if(flag==0)
                 {
                      flag=1;
                      num++;
                 }
            }
       }
       printf("result is:%d \n",num);
       fclose(fp);
       return num;
}

3. 實驗截圖

2018-2019-1 20165211 實驗三 實時系統