• 《TCP/IP网络编程》阅读笔记--标准I/O和I/O流分离

    目录

    1--标准I/O

    1-1--标准I/O的优缺点

    1-2--FILE 指针和文件描述符的转换

    1-3--基于Socket的标准I/O函数使用

    2--I/O流分离

    2-1--文件描述符的复制和半关闭

    2-2--复制文件描述符实现 I/O 流的分离

    1--标准I/O

    1-1--标准I/O的优缺点

    标准 I/O 函数的优点：

            ① 具有良好的移植性：为了支持所有操作系统（编译器），标准 I/O 函数均按照 ANSI C 标准定义的；

            ② 利用 I/O 缓冲提高性能：通过缓冲区缓存数据，再进行一次完整的数据收发，减少数据移动的次数；

    标准 I/O 函数的缺点：

            ① 不容易进行双向通信；

            ② 需要频繁调用 fflush 函数来刷新缓冲区；

            ③ 需要以 FILE 结构体指针的形式返回文件描述符：标准 I/O 函数操作的对象是 FILE 结构体指针，因此需要将文件描述符转换为 FILE 指针；

    1-2--FILE 指针和文件描述符的转换

            利用 fdopen() 函数将文件描述符转换为 FILE*；

    1. #include 
    2. FILE* fdopen(int fildes, const char* mode);
    3. // 成功时返回转换的 FILE 结构体指针，失败时返回 NULL
    4. // fildes 表示需要转换的文件描述符
    5. // mode 表示将要创建的 FILE* 的模式信息，常用的模式有读模式 "r" 和写模式 "w"
    1. // gcc desto.c -o desto
    2. // ./desto 
    3.  
    4. #include 
    5. #include 
    6.  
    7. int main(void){
    8.     FILE* fp;
    9.     int fd = open("data.dat", O_WRONLY | O_CREAT | O_TRUNC); // 打开data.dat文件，返回其文件描述符
    10.     if(fd == -1){
    11.         fputs("file open error", stdout);
    12.         return -1;
    13.     }
    14.     fp = fdopen(fd, "w"); // 文件描述符转换为 FILE*
    15.     fputs("Network C programming \n", fp); // 通过标准 I/O 函数向 FILE* 指向的文件写数据
    16.     fclose(fp); // 通过标准 I/O 函数关闭文件
    17.     return 0;
    18. }

            利用 fileno() 函数将 FILE* 转换为文件描述符；

    1. #include 
    2. int fileno(FILE* stream);
    3. // 成功时返回转换后的文件描述符，失败时返回 -1
    1. // gcc todes.c -o todes
    2. // ./todes
    3.  
    4. #include 
    5. #include 
    6.  
    7. int main(void){
    8.     FILE* fp;
    9.     int fd = open("data.dat", O_WRONLY | O_CREAT | O_TRUNC); // 返回文件描述符
    10.     if(fd == -1){
    11.         fputs("file open error", stdout);
    12.         return -1;
    13.     }
    14.  
    15.     printf("First file descriptor: %d \n", fd);
    16.     fp = fdopen(fd, "w"); // 文件描述符转换为 FILE*
    17.     fputs("TCP/IP SOCKET PROGRAMMING \n", fp);
    18.     printf("Second file descriptor: %d \n", fileno(fp)); // FILE* 转换为文件描述符
    19.     fclose(fp);
    20.     return 0;
    21. }

    1-3--基于Socket的标准I/O函数使用

            Socket 也有对应的文件描述符，因此可以使用 fdopen() 函数将文件描述符转换为 FILE*，进而使用标准 I/O 函数；

    回声服务端：

    1. // gcc echo_stdserv.c -o echo_stdserv
    2. // ./echo_stdserv 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12. void error_handling(char *message){
    13.     fputs(message, stderr);
    14.     fputc('\n', stderr);
    15.     exit(1);
    16. }
    17.  
    18. int main(int argc, char *argv[]){
    19.     int serv_sock, clnt_sock;
    20.     char message[BUF_SIZE];
    21.     int str_len, i;
    22.  
    23.     struct sockaddr_in serv_adr;
    24.     struct sockaddr_in clnt_adr;
    25.     socklen_t clnt_adr_sz;
    26.     FILE* readfp;
    27.     FILE* writefp;
    28.     if(argc != 2){
    29.         printf("Usage : %s \n", argv[0]);
    30.         exit(1);
    31.     }
    32.  
    33.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    34.     if(serv_sock == -1){
    35.         error_handling("socket() error");
    36.     }
    37.  
    38.     memset(&serv_adr, 0, sizeof(serv_adr));
    39.     serv_adr.sin_family = AF_INET;
    40.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    41.     serv_adr.sin_port = htons(atoi(argv[1]));
    42.  
    43.     if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1){
    44.         error_handling("bind() error");
    45.     }
    46.     if(listen(serv_sock, 5) == -1){
    47.         error_handling("listen() error");
    48.     }
    49.     clnt_adr_sz = sizeof(clnt_adr);
    50.  
    51.     for(i = 0; i < 5; i++){
    52.         clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
    53.         if(clnt_sock == -1){
    54.             error_handling("accept() error");
    55.         }
    56.         else{
    57.             printf("Connected client %d \n", i+1);
    58.         }
    59.  
    60.         readfp = fdopen(clnt_sock, "r"); // 读模式，socket文件描述符转换为 FILE*
    61.         writefp = fdopen(clnt_sock, "w"); // 写模式，socket文件描述符转换为 FILE*
    62.         while(!feof(readfp)){
    63.             fgets(message, BUF_SIZE, readfp); // 调用标准I/O进行读写
    64.             fputs(message, writefp);
    65.             fflush(writefp); // 刷新缓冲区
    66.         }
    67.         close(serv_sock);
    68.         return 0;
    69.     }
    70. }

    回声客户端：

    1. // gcc echo_client.c -o echo_client
    2. // ./echo_client 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12. void error_handling(char *message){
    13.     fputs(message, stderr);
    14.     fputc('\n', stderr);
    15.     exit(1);
    16. }
    17.  
    18. int main(int argc, char *argv[]){
    19.     int sock;
    20.     char message[BUF_SIZE];
    21.     int str_len;
    22.     struct sockaddr_in serv_adr;
    23.     FILE* readfp;
    24.     FILE* writefp;
    25.     if(argc != 3){
    26.         printf("Usage : %s  \n", argv[0]);
    27.         exit(1);
    28.     }
    29.  
    30.     sock = socket(PF_INET, SOCK_STREAM, 0);
    31.     if(sock == -1){
    32.         error_handling("socket() error");
    33.     }
    34.  
    35.     memset(&serv_adr, 0, sizeof(serv_adr));
    36.     serv_adr.sin_family = AF_INET;
    37.     serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    38.     serv_adr.sin_port = htons(atoi(argv[2]));
    39.  
    40.     if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1){
    41.         error_handling("connect() error!");
    42.     }
    43.     else{
    44.         puts("Connected.......");
    45.     }
    46.  
    47.     readfp = fdopen(sock, "r"); // 读模式，socket文件描述符转换为 FILE*
    48.     writefp = fdopen(sock, "w"); // 写模式，socket文件描述符转换为 FILE*
    49.     while(1){
    50.         fputs("Input message(Q to quit): ", stdout);
    51.         fgets(message, BUF_SIZE, stdin);
    52.         if(!strcmp(message, "q\n") || !strcmp(message, "Q\n")){
    53.             break;
    54.         }
    55.  
    56.         fputs(message, writefp); // 调用标准I/O进行读写
    57.         fflush(writefp);
    58.         fgets(message, BUF_SIZE, readfp);
    59.         printf("Message from server: %s", message);
    60.     }
    61.     fclose(writefp);
    62.     fclose(readfp);
    63.     return 0;
    64. }

    运行结果：

    2--I/O流分离

    分离 I/O 流的目的：

            ① 为了将 FILE 指针按读模式和写模式加以区分；

            ② 可以通过区分读写模式降低实现难度；

            ③ 通过区分 I/O 缓冲提高缓冲性能；

    2-1--文件描述符的复制和半关闭

            当多个 FILE 指针都是基于同一个文件描述符创建时，针对任意一个 FILE 指针调用 fclose() 函数都会关闭文件描述符，同时终结对应的 socket；

            以下代码实例展示了当服务器端 fclose() 掉 FILE 指针同时终结 socket 时，客户端的消息无法顺利发送到服务器端；

    1. // gcc seq_serv.c -o seq_serv
    2. // ./seq_serv 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12.  
    13. int main(int argc, char *argv[]){
    14.     int serv_sock, clnt_sock;
    15.     FILE* readfp;
    16.     FILE* writefp;
    17.  
    18.     struct sockaddr_in serv_adr, clnt_adr;
    19.     socklen_t clnt_adr_sz;
    20.     char buf[BUF_SIZE] = {0,};
    21.  
    22.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    23.     memset(&serv_adr, 0, sizeof(serv_adr));
    24.     serv_adr.sin_family = AF_INET;
    25.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    26.     serv_adr.sin_port = htons(atoi(argv[1]));
    27.  
    28.     bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
    29.     listen(serv_sock, 5);
    30.     clnt_adr_sz = sizeof(clnt_adr);
    31.     clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
    32.  
    33.     readfp = fdopen(clnt_sock, "r"); // 基于同一个socket文件描述符的 FILE*
    34.     writefp = fdopen(clnt_sock, "w");
    35.  
    36.     fputs("FROM SERVER: Hi~ client? \n", writefp);
    37.     fputs("I Love all of the world \n", writefp);
    38.     fputs("You are awesome! \n", writefp);
    39.     fflush(writefp);
    40.  
    41.     fclose(writefp); // 关闭 writefp，会终止 socket，同时向客户端发送 EOF
    42.     fgets(buf, sizeof(buf), readfp);
    43.     fputs(buf, stdout);
    44.     fclose(readfp);
    45.     return 0;
    46. }
    1. // gcc seq_clnt.c -o seq_clnt
    2. // ./seq_clnt 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12.  
    13. int main(int argc, char *argv[]){
    14.     int sock;
    15.     char buf[BUF_SIZE];
    16.     struct sockaddr_in serv_adr;
    17.  
    18.     FILE* readfp;
    19.     FILE* writefp;
    20.  
    21.     sock = socket(PF_INET, SOCK_STREAM, 0);
    22.     memset(&serv_adr, 0, sizeof(serv_adr));
    23.     serv_adr.sin_family = AF_INET;
    24.     serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    25.     serv_adr.sin_port = htons(atoi(argv[2]));
    26.  
    27.     connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
    28.     readfp = fdopen(sock, "r"); // 基于同一个socket文件描述符的 FILE*
    29.     writefp = fdopen(sock, "w");
    30.  
    31.     while(1){
    32.         if(fgets(buf, sizeof(buf), readfp) == NULL){ // 客户端收到 EOF 终止循环
    33.             break;
    34.         }
    35.         fputs(buf, stdout);
    36.         fflush(stdout);
    37.     }
    38.  
    39.     // 由于服务器端关闭了 socket，因此该消息无法发送到服务器端
    40.     fputs("FROM CLIENT: Thank you! \n", writefp); 
    41.     fflush(writefp);
    42.     fclose(writefp);
    43.     fclose(readfp);
    44.     return 0;
    45. }

            销毁所有文件描述符后才能销毁 socket，因此通过复制文件描述符，利用各自的文件描述符生成读写模式的 FILE*，可以避免上述情况；

            复制文件描述符的两个常用函数：dup() 和 dup2()；这里的复制可以理解为：为了访问同一文件或 socket，创建另一个文件描述符；

    1. #include 
    2. int dup(int fildes);
    3. int dup2(int fildes, int fildes2);
    4. // 成功时返回复制的文件描述符，失败时返回 -1
    5. // fildes 表示需要复制的文件描述符
    6. // fildes2 表示复制后，新生成的文件描述符数值
    1. // gcc dup.c -o dup
    2. // ./dup
    3.  
    4. #include 
    5. #include 
    6.  
    7. int main(int argc, char* argv[]){
    8.     int cfd1, cfd2;
    9.     char str1[] = "Hi~ \n";
    10.     char str2[] = "It's nice day~ \n";
    11.  
    12.     cfd1 = dup(1); // 复制标准输出
    13.     cfd2 = dup2(cfd1, 7); // 复制标准输出，指定生成的文件描述符 cfd2 为 7
    14.  
    15.     printf("fd1=%d, fd2=%d \n", cfd1, cfd2);
    16.     write(cfd1, str1, sizeof(str1)); // 写到标准输出
    17.     write(cfd2, str2, sizeof(str2));
    18.  
    19.     close(cfd1); // 关闭复制的文件描述符
    20.     close(cfd2);
    21.     write(1, str1, sizeof(str1)); // 还能输出，因为文件描述符1还没关闭
    22.     close(1);
    23.     write(1, str2, sizeof(str2)); // 不能输出
    24.     return 0;
    25. }

    2-2--复制文件描述符实现 I/O 流的分离

    为了解决以下问题并实现 I/O 流的分离：

            当多个 FILE 指针都是基于同一个文件描述符创建时，针对任意一个 FILE 指针调用 fclose() 函数都会关闭文件描述符，同时终结对应的 socket；

            通过复制文件描述符，再分离 I/O 流，实现服务器端的半关闭；

            调用 shutdown() 函数时，无论复制出了多少个文件描述符，服务器端都会进入半关闭状态；

    1. // gcc seq_serv2.c -o seq_serv2
    2. // ./seq_serv2 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 1024
    12.  
    13. int main(int argc, char *argv[]){
    14.     int serv_sock, clnt_sock;
    15.     FILE* readfp;
    16.     FILE* writefp;
    17.  
    18.     struct sockaddr_in serv_adr, clnt_adr;
    19.     socklen_t clnt_adr_sz;
    20.     char buf[BUF_SIZE] = {0,};
    21.  
    22.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    23.     memset(&serv_adr, 0, sizeof(serv_adr));
    24.     serv_adr.sin_family = AF_INET;
    25.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    26.     serv_adr.sin_port = htons(atoi(argv[1]));
    27.  
    28.     bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
    29.     listen(serv_sock, 5);
    30.     clnt_adr_sz = sizeof(clnt_adr);
    31.     clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
    32.  
    33.     readfp = fdopen(clnt_sock, "r"); 
    34.     writefp = fdopen(dup(clnt_sock), "w"); // 复制文件描述符后，再创建写模式的 FILE*，实现 I/O 流分离
    35.  
    36.     fputs("FROM SERVER: Hi~ client? \n", writefp);
    37.     fputs("I Love all of the world \n", writefp);
    38.     fputs("You are awesome! \n", writefp);
    39.     fflush(writefp);
    40.  
    41.     shutdown(fileno(writefp), SHUT_WR); // 设置半关闭，向客户端发送 EOF
    42.     fclose(writefp); // 关闭 writefp，会终止 socket，同时向客户端发送 EOF
    43.     // 此时不会导致 socket 的关闭，因为还有一个文件描述符
    44.     fgets(buf, sizeof(buf), readfp);
    45.     fputs(buf, stdout);
    46.     fclose(readfp);
    47.     return 0;
    48. }

  • 相关阅读:
    springboot文件下载功能开发!
    数据要素市场又添力作，《数据要素安全流通》正式出版发售！
    【ue5】滑铲系统蓝图笔记
    MySQl表的增删查改（聚合查询+联合查询）
    CH549/CH548学习笔记1 - 硬件设计
    【Linux Socket C++】为什么IO复用需要用到非阻塞IO？EAGAIN的简单介绍与应用
    流程图 and/or/xor 讲解
    【LangChain系列 8】Prompt模版——少样本prompt模版(二)
    Vue.js 组件通信——父组件向子组件通过props传值
    Error response from daemon
  • 原文地址：https://blog.csdn.net/weixin_43863869/article/details/132836702