标准I/O缓冲与套接字缓冲#

创建套接字时，操作系统已经为套接字准备了输入、输出缓冲。使用标准$I/O$函数后，数据还会经过标准库内部维护的另一层缓冲。

以$fputs$发送字符串为例，数据的移动过程大致如下：

1. 程序先把数据写入标准$I/O$输出缓冲。
2. 标准库在适当时机把数据转移到套接字输出缓冲。
3. 操作系统按照$TCP$协议完成实际传输。

两层缓冲的目的并不完全相同。套接字缓冲主要服务于$TCP$协议，例如保存尚未确认的数据，以便发生丢包时重新发送；标准$I/O$缓冲则主要用于把多次少量读写合并起来，减少函数调用、系统调用和数据移动次数。

如果每次只发送$1$字节，重复$10$次，程序会频繁进入系统调用，网络上也可能产生更多首部开销。先在标准$I/O$缓冲中积累数据，再集中写入套接字缓冲，通常更有效率。数据规模越大、零散操作越多，缓冲带来的收益越明显。

NOTE

标准$I/O$缓冲提高的是一般情况下的批量处理效率，并不意味着每个程序使用标准$I/O$后都会明显变快。若程序需要严格控制每次收发时机，还要主动处理缓冲刷新问题。

标准I/O函数的缺点#

标准$I/O$并非只有优点。在套接字编程中主要有以下限制：

• 不容易在同一个流上频繁切换读取和写入状态。
• 为了立即发送缓冲中的内容，有时需要频繁调用$fflush$。
• 套接字创建后得到的是文件描述符，使用标准$I/O$前还要转换为$FILE$指针。

标准$I/O$流存在自己的缓冲。调用$fputs$只表示把数据交给标准库，不保证数据已经立刻进入套接字输出缓冲。若协议要求当前消息马上发送，需要显式调用：

1
fputs(message, writefp);
2
fflush(writefp);

频繁刷新会削弱缓冲原本用于合并操作的优势。因此，是否使用标准$I/O$，应根据数据格式、读写模式和发送时机决定。

利用fdopen转换为FILE指针#

套接字函数返回文件描述符，而$fgets$、$fputs$等标准函数需要$FILE$指针。$fdopen$用于在二者之间建立关联：

1
#include <stdio.h>
2

3
FILE *fdopen(int fildes, const char *mode);
4
//成功时返回FILE指针，失败时返回NULL。

$fildes$是已有文件描述符，$mode$表示标准$I/O$流的使用模式，常见值为读模式$"r"$和写模式$"w"$。

1
int fd;
2
FILE *fp;
3

4
fd = open("data.dat", O_WRONLY | O_CREAT | O_TRUNC);
5
fp = fdopen(fd, "w");
6

7
fputs("Network C programming\n", fp);
8
fclose(fp);

$fdopen$不会复制文件内容或重新打开文件，它只是基于现有描述符创建标准$I/O$流。调用$fclose(fp)$时，标准库不仅会处理流缓冲，也会关闭与该$FILE$指针关联的文件描述符，因此之后不应继续使用原来的$fd$。

利用fileno取得文件描述符#

$fileno$执行相反的转换，根据$FILE$指针返回其底层文件描述符：

1
#include <stdio.h>
2

3
int fileno(FILE *stream);
4
//成功时返回文件描述符，失败时返回-1。

1
FILE *fp = fdopen(fd, "w");
2
int same_fd = fileno(fp);

$fileno$不会创建新的描述符。这里的$same\_fd$与创建$FILE$流时使用的$fd$指向同一个底层对象，数值通常也相同。它适合在使用标准$I/O$的同时，调用$shutdown$等只接受文件描述符的系统函数。

标准I/O回声服务器#

服务器端可以根据客户端套接字分别创建读模式和写模式$FILE$指针：

1
readfp = fdopen(clnt_sock, "r");
2
writefp = fdopen(clnt_sock, "w");
3

4
while (fgets(message, BUF_SIZE, readfp) != NULL)
5
{
6
    fputs(message, writefp);
7
    fflush(writefp);
8
}
9

10
fclose(readfp);
11
fclose(writefp);

$fgets$按字符串读取数据，遇到$EOF$时返回$NULL$；$fputs$把字符串写入标准$I/O$缓冲，随后通过$fflush$立即推入下一层缓冲。与直接调用$read$相比，程序不再需要手动在接收数据末尾添加字符串结束符。

标准I/O回声客户端#

客户端的数据交换逻辑也可以改为标准$I/O$函数：

1
readfp = fdopen(sock, "r");
2
writefp = fdopen(sock, "w");
3

4
while (1)
5
{
6
    fputs("Input message(Q to quit): ", stdout);
7
    fgets(message, BUF_SIZE, stdin);
8

9
    if (!strcmp(message, "q\n") ||
10
        !strcmp(message, "Q\n"))
11
        break;
12

13
    fputs(message, writefp);
14
    fflush(writefp);
15

16
    fgets(message, BUF_SIZE, readfp);
17
    printf("Message from server: %s", message);
18
}

使用标准$I/O$可以让面向文本行的程序更简洁，但也引入了$FILE$流的缓冲和资源管理问题。尤其是从同一个套接字描述符创建读、写两个$FILE$指针后，关闭其中一个流会产生怎样的影响，需要在下一章进一步处理。

分离I/O流的好处#

根据分离方式不同，主要收益包括：

• 将输入代码和输出代码分开，降低实现难度。
• 让与输入无关的输出操作独立进行。
• 明确区分读模式与写模式$FILE$指针。
• 分开管理标准$I/O$缓冲，简化读写状态切换。

但读写工具被分开后，底层仍可能是同一个套接字和同一个文件描述符。如果忽略这层关系，关闭某个$FILE$流时就可能意外终止整个连接。

流分离带来的EOF问题#

假设服务器从同一个客户端套接字创建两个$FILE$指针：

1
readfp = fdopen(clnt_sock, "r");
2
writefp = fdopen(clnt_sock, "w");

两者虽然模式不同，但都关联同一个文件描述符，而该描述符又指向同一个套接字。

服务器发送完数据后，可能希望关闭输出流、向客户端传递$EOF$，同时保留输入流接收客户端的最后一条响应。直觉上可以这样写：

1
fflush(writefp);
2
fclose(writefp);
3

4
fgets(buf, sizeof(buf), readfp);

但$fclose(writefp)$会关闭它关联的文件描述符。由于读、写$FILE$指针使用的是同一个描述符，底层套接字也会随之终止，$readfp$无法再接收客户端响应。

因此，关闭写模式$FILE$指针并不等于只关闭套接字输出流。$fclose$负责关闭标准$I/O$流和描述符，而套接字的方向性半关闭仍应通过$shutdown$完成。

复制文件描述符#

文件描述符复制不是复制文件或套接字，也不是生成一个相同的描述符整数值。它是在同一进程中创建另一个描述符，使两个描述符共同指向同一底层对象。

$Linux$中可以使用$dup$或$dup2$：

1
#include <unistd.h>
2

3
int dup(int fildes);
4
int dup2(int fildes, int fildes2);
5
//成功时返回复制出的文件描述符，失败时返回-1。

$dup$返回当前可用的最小描述符；$dup2$则尝试把副本放到$fildes2$指定的描述符编号上。

1
int copied_fd1 = dup(fd);
2
int copied_fd2 = dup2(fd, 7);

复制得到的描述符数值彼此不同，但它们共享同一个底层文件或套接字状态。关闭其中一个只会减少一次引用，直到相关描述符全部关闭，底层对象才会被真正释放。

这与$fork$后的描述符复制也有所区别：$fork$复制整个进程的描述符表，原描述符与副本分别存在于父子进程；$dup$和$dup2$则直接在同一进程内产生新的描述符。

复制描述符后分离标准I/O流#

基于复制描述符创建读写流：

1
readfp = fdopen(clnt_sock, "r");
2
writefp = fdopen(dup(clnt_sock), "w");

此时$readfp$与$writefp$持有不同的描述符，但底层仍是同一条$TCP$连接。服务器完成发送后，应先刷新标准$I/O$缓冲，再通过写流的描述符执行半关闭：

1
fputs("FROM SERVER: Hi client?\n", writefp);
2
fputs("You are awesome!\n", writefp);
3
fflush(writefp);
4

5
shutdown(fileno(writefp), SHUT_WR);
6
fclose(writefp);
7

8
fgets(buf, sizeof(buf), readfp);
9
fputs(buf, stdout);
10
fclose(readfp);

这里的执行顺序十分重要：

1. $fflush$把标准$I/O$输出缓冲中的数据交给套接字。
2. $shutdown(..., SHUT\_WR)$关闭套接字输出方向，剩余数据发送完成后向客户端传递$EOF$。
3. $fclose(writefp)$释放写模式$FILE$流及其描述符。
4. $readfp$仍可通过保留的输入方向接收客户端最后的响应。

$shutdown$操作的是套接字的通信方向。无论同一套接字复制出多少文件描述符，调用$shutdown(sock, SHUT\_WR)$都会使这条连接进入输出半关闭状态；而$fclose$或$close$只负责释放某个流或描述符引用。

因此，文件描述符复制解决的是“分别管理两个$FILE$流”的问题，$shutdown$解决的才是“发送$EOF$但继续接收数据”的问题。二者配合后，才能在使用标准$I/O$的同时实现正确的$TCP$半关闭。