Linux网络编程之SOCKET文件传输

[html]  view plain  copy

 

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

[html]  view plain  copy

 

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