基于 Linux 平台

shutdown() 函数介绍

§ shutdown()优雅断开连接 - 图1

当我们使用 socket 来传输文件的时候，怎么检测到文件传输完成了呢？

这个时候服务器端应该最后向客户端传递 EOF 表示文件传输结束，客户端通过函数返回值接收 EOF，这样可以避免与被传输的文件内容产生冲突。所以现在的问题就变成了，服务器如何传递 EOF？

这个时候就用到了优雅的函数 shutdown，服务器关闭输出流，同时服务器发送 EOF 表示文件传输完成，但是这个时候因为保留了输入流，所以可以接收客户端的数据。

§ shutdown()优雅断开连接 - 图2

§ shutdown()优雅断开连接 - 图3 函数原型为：

  1. #include <sys/socket.h>
  2. int shutdown(int sock, int howto);

§ shutdown()优雅断开连接 - 图4 参数：

  • sock：需要断开的套接字文件描述符
  • howto：传递断开方式信息，其可能值如下
    • SHUT_RD：断开输入流
    • SHUT_WR：断开输出流
    • SHUT_RDWR：断开输入和输出流

§ shutdown()优雅断开连接 - 图5 返回值：成功时返回 0，失败时返回 -1.

§ shutdown()优雅断开连接 - 图6 例子：

  1. // 这个例子就是把下面代码中的句子
  2. int clnt_sd;
  3. socklen_t clnt_adr_sz;
  4. clnt_sd = accept(serv_sd, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
  5. shutdown(clnt_sd, SHUT_WR);

服务器代码

看一下针对这种情况，服务器的代码是什么样的

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <arpa/inet.h>
  6. #include <sys/socket.h>
  8. #define BUF_SIZE 30
  9. void error_handling(char *message);
  11. int main(int argc, char *argv[]) {
  12.     int serv_sd, clnt_sd;
  13.     FILE *fp;
  14.     char buf[BUF_SIZE];
  15.     int read_cnt;
  17.     struct sockaddr_in serv_adr, clnt_adr;
  18.     socklen_t clnt_adr_sz;
  20.     if (argc != 2) {
  21.         printf("Usage: %s <port>\n", argv[0]);
  22.         exit(1);
  23.     }
  25.     fp = fopen("file_server.c", "rb");
  26.     serv_sd = socket(PF_INET, SOCK_STREAM, 0);        // 服务器套接字
  28.     memset(&serv_adr, 0, sizeof(serv_adr));            // 结构体初始化
  29.     serv_adr.sin_family = AF_INET;                    // IPV4 地址
  30.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);    // INADDR_ANY 表示任意 IP
  31.     // 注意：INADDR_ANY 相当于 0.0.0.0
  32.     serv_adr.sin_port = htons(atoi(argv[1]));
  34.     bind(serv_sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
  35.     listen(serv_sd, 5);                                // TCP 监听
  37.     clnt_adr_sz = sizeof(clnt_adr);
  38.     clnt_sd = accept(serv_sd, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
  40.     while(1) {
  41.         read_cnt = fread((void*)buf, 1, BUF_SIZE, fp);        // 接收客户端数据放到 buf
  42.         if (read_cnt < BUF_SIZE) {
  43.             write(clnt_sd, buf, read_cnt);
  44.             break;
  45.         }
  46.         write(clnt_sd, buf, BUF_SIZE);
  47.     }
  49.     shutdown(clnt_sd, SHUT_WR);                            // shutdown 对输出流半关闭
  50.     read(clnt_sd, buf, BUF_SIZE);                        // 半关闭后仍然可以接收消息
  51.     printf("Message from client:%s\n", buf);
  53.     fclose(fp);
  54.     close(clnt_sd);
  55.     close(serv_sd);
  56.     return 0;
  57. }
  59. void error_handling(char *message) {
  60.     fputs(message, stderr);
  61.     fputc('\n', stderr);
  62.     exit(1);
  63. }

客户端代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <arpa/inet.h>
  6. #include <sys/socket.h>
  8. #define BUF_SIZE 30
  9. void error_handling(char *message);
  11. int main(int argc, char *argv[]) {
  12.     int sd;
  13.     FILE *sp;
  15.     char buf[BUF_SIZE];
  16.     int read_cnt;
  17.     struct sockaddr_in serv_adr;
  18.     if (argc != 3) {
  19.         printf("Usage: %s <IP> <port>\n", argv[0]);
  20.         exit(1);
  21.     }
  23.     fp = fopen("receive.dat", "wb");
  24.     sd = socket(PF_INET, SOCK_STREAM, 0);
  26.     memset(&serv_adr, 0, sizeof(serv_adr));
  27.     serv_adr.sin_family = AF_INET;
  28.     serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
  29.     serv_adr.sin_port = htons(atoi(argv[2]));
  31.     connect(sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
  33.     while((read_cnt=read(sd, buf, BUF_SIZE))!=0) {
  34.         // 接收数据并且保存到文件中，直到最后接收到 EOF
  35.         fwrite((void*)buf, 1, read_cnt, fp);
  36.     }
  38.     puts("Received file data");
  39.     write(sd, "Thank you", 10);
  40.     fclose(fp);
  41.     close(sd);
  42.     return 0;
  43. }
  45. void error_handling(char *message) {
  46.     fputs(message, stderr);
  47.     fputc('\n', stderr);
  48.     exit(1);
  49. }

基于 Windows 平台

Windows 平台同样通过调用 shutdown() 函数完成半关闭，只是向其传递的参数名略有不同，需要确认。

§ shutdown()优雅断开连接 - 图7 函数原型

  1. #include <winsock2.h>
  2. int shudown(SOCKET sock, int howto);

§ shutdown()优雅断开连接 - 图8 函数参数

  • sock：要断开的套接字句柄
  • howto：断开方式的信息，该参数的可能值和其含义可整理如下：
    • SD_RECEIVE：断开输入流
    • SD_SEND：断开输出流
    • SD_BOTH：同时断开输入输出流

§ shutdown()优雅断开连接 - 图9 函数返回值：函数成功时返回 0，失败时返回 SOCKET_ERROR。

服务器端代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <winsock2.h>
  6. #define BUF_SIZE 30
  7. void ErrorHandling(char *message);
  9. int main(int argc, char *argv[]) {
  10.     WSADATA wsaData;
  11.     SOCKET hServSock, hClntSock;
  12.     FILE *fp;
  13.     char buf[BUF_SIZE];
  14.     int readCnt;
  16.     SOCKADDR_IN servAdr, clntAdr;
  17.     int clntAdrSz;
  19.     if (argc != 2) {
  20.         printf("Usage: %s <port>\n", argv[0]);
  21.         exit(1);
  22.     }
  24.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
  25.         ErrorHandling("WSAStartup() error!");
  26.     }
  28.     fp = fopen("file_server_win.c", "rb");
  29.     hServSock = socket(PF_INET, SOCK_STREAM, 0);        // 服务器套接字
  31.     memset(&servAdr, 0, sizeof(servAdr));            // 结构体初始化
  32.     servAdr.sin_family = AF_INET;                    // IPV4 地址
  33.     servAdr.sin_addr.s_addr = htonl(INADDR_ANY);    // INADDR_ANY 表示任意 IP
  34.     // 注意：INADDR_ANY 相当于 0.0.0.0
  35.     servAdr.sin_port = htons(atoi(argv[1]));
  37.     bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr));
  38.     listen(hServSock, 5);                                // TCP 监听
  40.     clntAdrSz = sizeof(clntAdr);
  41.     hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSz);
  43.     while(1) {
  44.         readCnt = fread((void*)buf, 1, BUF_SIZE, fp);        // 接收客户端数据放到 buf
  45.         if (readCnt < BUF_SIZE) {
  46.             send(hClntSock, (char*)&buf, readCnt, 0);
  47.             break;
  48.         }
  49.         write(hClntSock, (char*)&buf, BUF_SIZE, 0);
  50.     }
  52.     shutdown(hClntSock, SD_SEND);                            // shutdown 对输出流半关闭
  53.     recv(hClntSock, (char*)buf, BUF_SIZE, 0);                // 半关闭后仍然可以接收消息
  54.     printf("Message from client:%s\n", buf);
  56.     fclose(fp);
  57.     closesocket(hClntSock);
  58.     closesocket(hServSock);
  59.     WSACleanup();
  60.     return 0;
  61. }
  63. void ErrorHandling(char *message) {
  64.     fputs(message, stderr);
  65.     fputc('\n', stderr);
  66.     exit(1);
  67. }

客户端代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <winsock2.h>
  6. #define BUF_SIZE 30
  7. void ErrorHandling(char *message);
  9. int main(int argc, char *argv[]) {
  10.     WSADATA wsaData;
  11.     SOCKET hSocket;
  12.     FILE *fp;
  14.     char buf[BUF_SIZE];
  15.     int readCnt;
  16.     sockaddr_In servAdr;
  18.     if (argc != 3) {
  19.         printf("Usage: %s <IP> <port>\n", argv[0]);
  20.         exit(1);
  21.     }
  23.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
  24.         ErrorHandling("WSAStartup() error!");
  25.     }
  27.     fp = fopen("receive.dat", "wb");
  28.     hSocket = socket(PF_INET, SOCK_STREAM, 0);
  30.     memset(&servAdr, 0, sizeof(servAdr));
  31.     servAdr.sin_family = AF_INET;
  32.     servAdr.sin_addr.s_addr = inet_addr(argv[1]);
  33.     servAdr.sin_port = htons(atoi(argv[2]));
  35.     connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr));
  37.     while((readCnt=recv(hSocket, buf, BUF_SIZE, 0))!=0) {
  38.         // 接收数据并且保存到文件中，直到最后接收到 EOF
  39.         fwrite((void*)buf, 1, readCnt, fp);
  40.     }
  42.     puts("Received file data");
  43.     send(hSocket, "Thank you", 10, 0);
  44.     fclose(fp);
  45.     closesocket(hSocket);
  46.     WSACleanup();
  47.     return 0;
  48. }
  50. void ErrorHandling(char *message) {
  51.     fputs(message, stderr);
  52.     fputc('\n', stderr);
  53.     exit(1);
  54. }