基于TCP流协议的socket网络文件传输Demo

时间：2021-12-16 19:30:29

基于TCP流协议的socket网络文件传输Demo：

实现：C语言
功能：文件传输（可以传任何格式的文件）

[cpp]  view plain  copy
  1. /************************************************************************* 
  2.     > File Name: Server.c 
  3.     > Author: SongLee 
  4.     > E-mail: lisong.shine@qq.com  
  5.     > Created Time: 2014年03月13日 星期四 22时17分43秒 
  6.     > Personal Blog: http://songlee24.github.io/ 
  7.  ************************************************************************/  
  8.   
  9. #include<netinet/in.h>  // sockaddr_in  
  10. #include<sys/types.h>   // socket  
  11. #include<sys/socket.h>  // socket  
  12. #include<stdio.h>       // printf  
  13. #include<stdlib.h>      // exit  
  14. #include<string.h>      // bzero  
  15.   
  16. #define SERVER_PORT 8000  
  17. #define LENGTH_OF_LISTEN_QUEUE 20  
  18. #define BUFFER_SIZE 1024  
  19. #define FILE_NAME_MAX_SIZE 512  
  20.   
  21. int main(void)  
  22. {  
  23.     // 声明并初始化一个服务器端的socket地址结构  
  24.     struct sockaddr_in server_addr;  
  25.     bzero(&server_addr, sizeof(server_addr));  
  26.     server_addr.sin_family = AF_INET;  
  27.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
  28.     server_addr.sin_port = htons(SERVER_PORT);  
  29.   
  30.     // 创建socket，若成功，返回socket描述符  
  31.     int server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);  
  32.     if(server_socket_fd < 0)  
  33.     {  
  34.         perror("Create Socket Failed:");  
  35.         exit(1);  
  36.     }  
  37.     int opt = 1;  
  38.     setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  
  39.   
  40.     // 绑定socket和socket地址结构  
  41.     if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))  
  42.     {  
  43.         perror("Server Bind Failed:");  
  44.         exit(1);  
  45.     }  
  46.       
  47.     // socket监听  
  48.     if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))  
  49.     {  
  50.         perror("Server Listen Failed:");  
  51.         exit(1);  
  52.     }  
  53.   
  54.     while(1)  
  55.     {  
  56.         // 定义客户端的socket地址结构  
  57.         struct sockaddr_in client_addr;  
  58.         socklen_t client_addr_length = sizeof(client_addr);  
  59.   
  60.         // 接受连接请求，返回一个新的socket(描述符)，这个新socket用于同连接的客户端通信  
  61.         // accept函数会把连接到的客户端信息写到client_addr中  
  62.         int new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length);  
  63.         if(new_server_socket_fd < 0)  
  64.         {  
  65.             perror("Server Accept Failed:");  
  66.             break;  
  67.         }  
  68.   
  69.         // recv函数接收数据到缓冲区buffer中  
  70.         char buffer[BUFFER_SIZE];  
  71.         bzero(buffer, BUFFER_SIZE);  
  72.         if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  
  73.         {  
  74.             perror("Server Recieve Data Failed:");  
  75.             break;  
  76.         }  
  77.   
  78.         // 然后从buffer(缓冲区)拷贝到file_name中  
  79.         char file_name[FILE_NAME_MAX_SIZE+1];  
  80.         bzero(file_name, FILE_NAME_MAX_SIZE+1);  
  81.         strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));  
  82.         printf("%s\n", file_name);  
  83.   
  84.         // 打开文件并读取文件数据  
  85.         FILE *fp = fopen(file_name, "r");  
  86.         if(NULL == fp)  
  87.         {  
  88.             printf("File:%s Not Found\n", file_name);  
  89.         }  
  90.         else  
  91.         {  
  92.             bzero(buffer, BUFFER_SIZE);  
  93.             int length = 0;  
  94.             // 每读取一段数据，便将其发送给客户端，循环直到文件读完为止  
  95.             while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)  
  96.             {  
  97.                 if(send(new_server_socket_fd, buffer, length, 0) < 0)  
  98.                 {  
  99.                     printf("Send File:%s Failed./n", file_name);  
  100.                     break;  
  101.                 }  
  102.                 bzero(buffer, BUFFER_SIZE);  
  103.             }  
  104.   
  105.             // 关闭文件  
  106.             fclose(fp);  
  107.             printf("File:%s Transfer Successful!\n", file_name);  
  108.         }  
  109.         // 关闭与客户端的连接  
  110.         close(new_server_socket_fd);  
  111.     }  
  112.     // 关闭监听用的socket  
  113.     close(server_socket_fd);  
  114.     return 0;  
  115. }  


[cpp]  view plain  copy
  1. /************************************************************************* 
  2.     > File Name: Client.c 
  3.     > Author: SongLee 
  4.     > E-mail: lisong.shine@qq.com  
  5.     > Created Time: 2014年03月14日 星期五 09时41分46秒 
  6.     > Personal Blog: http://songlee24.github.io/ 
  7.  ************************************************************************/  
  8.   
  9. #include<netinet/in.h>   // sockaddr_in  
  10. #include<sys/types.h>    // socket  
  11. #include<sys/socket.h>   // socket  
  12. #include<stdio.h>        // printf  
  13. #include<stdlib.h>       // exit  
  14. #include<string.h>       // bzero  
  15.   
  16. #define SERVER_PORT 8000  
  17. #define BUFFER_SIZE 1024  
  18. #define FILE_NAME_MAX_SIZE 512  
  19.   
  20. int main()  
  21. {  
  22.     // 声明并初始化一个客户端的socket地址结构  
  23.     struct sockaddr_in client_addr;  
  24.     bzero(&client_addr, sizeof(client_addr));  
  25.     client_addr.sin_family = AF_INET;  
  26.     client_addr.sin_addr.s_addr = htons(INADDR_ANY);  
  27.     client_addr.sin_port = htons(0);  
  28.   
  29.     // 创建socket，若成功，返回socket描述符  
  30.     int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);  
  31.     if(client_socket_fd < 0)  
  32.     {  
  33.         perror("Create Socket Failed:");  
  34.         exit(1);  
  35.     }  
  36.   
  37.     // 绑定客户端的socket和客户端的socket地址结构 非必需  
  38.     if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))  
  39.     {  
  40.         perror("Client Bind Failed:");  
  41.         exit(1);  
  42.     }  
  43.   
  44.     // 声明一个服务器端的socket地址结构，并用服务器那边的IP地址及端口对其进行初始化，用于后面的连接  
  45.     struct sockaddr_in server_addr;  
  46.     bzero(&server_addr, sizeof(server_addr));  
  47.     server_addr.sin_family = AF_INET;  
  48.     if(inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) == 0)  
  49.     {  
  50.         perror("Server IP Address Error:");  
  51.         exit(1);  
  52.     }  
  53.     server_addr.sin_port = htons(SERVER_PORT);  
  54.     socklen_t server_addr_length = sizeof(server_addr);  
  55.   
  56.     // 向服务器发起连接，连接成功后client_socket_fd代表了客户端和服务器的一个socket连接  
  57.     if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
  58.     {  
  59.         perror("Can Not Connect To Server IP:");  
  60.         exit(0);  
  61.     }  
  62.   
  63.     // 输入文件名 并放到缓冲区buffer中等待发送  
  64.     char file_name[FILE_NAME_MAX_SIZE+1];  
  65.     bzero(file_name, FILE_NAME_MAX_SIZE+1);  
  66.     printf("Please Input File Name On Server:\t");  
  67.     scanf("%s", file_name);  
  68.   
  69.     char buffer[BUFFER_SIZE];  
  70.     bzero(buffer, BUFFER_SIZE);  
  71.     strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));  
  72.       
  73.     // 向服务器发送buffer中的数据  
  74.     if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)  
  75.     {  
  76.         perror("Send File Name Failed:");  
  77.         exit(1);  
  78.     }  
  79.   
  80.     // 打开文件，准备写入  
  81.     FILE *fp = fopen(file_name, "w");  
  82.     if(NULL == fp)  
  83.     {  
  84.         printf("File:\t%s Can Not Open To Write\n", file_name);  
  85.         exit(1);  
  86.     }  
  87.   
  88.     // 从服务器接收数据到buffer中  
  89.     // 每接收一段数据，便将其写入文件中，循环直到文件接收完并写完为止  
  90.     bzero(buffer, BUFFER_SIZE);  
  91.     int length = 0;  
  92.     while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)  
  93.     {  
  94.         if(fwrite(buffer, sizeof(char), length, fp) < length)  
  95.         {  
  96.             printf("File:\t%s Write Failed\n", file_name);  
  97.             break;  
  98.         }  
  99.         bzero(buffer, BUFFER_SIZE);  
  100.     }  
  101.   
  102.     // 接收成功后，关闭文件，关闭socket  
  103.     printf("Receive File:\t%s From Server IP Successful!\n", file_name);  
  104.     close(fp);  
  105.     close(client_socket_fd);  
  106.     return 0;  
  107. }  



个人站点：http://songlee24.github.io/

标签：

相关文章