TCP/IP 网络编程（十四）---套接字和标准 I/O

标准 I/O 函数

（一）标准 I/O 函数的优点

标准 I/O 函数有两大优点：

• ① 标准 I/O 函数具有良好的移植性（portability）。

• ② 标准 I/O 函数可以利用缓冲提高性能。

关于移植性无需过多解释。不仅是 I/O 函数，所有标准函数都具有良好的移植性。

接下来讨论标准 I/O 函数的第二个优点。使用标准的 I/O 函数时会得到额外的缓冲支持。 创建套接字时，操作系统将生成用于 I/O 的缓冲。此缓冲在执行 TCP 协议时发挥着非常重要的作用。此时若使用标准 I/O 函数，将得到额外的另一缓冲的支持：

从图中可以看出，使用标准 I/O 函数传递数据时经过两个缓冲。例如通过 fputs 函数传输数据时，首先将数据传递到标准 I/O 函数的缓冲。然后数据将移动到套接字输出缓冲，最后将数据发送到对方主机。

（二）标准 I/O 函数缓冲和套接字缓冲的用途

上面介绍了两个缓冲的关系，接下来介绍各自的用途：

套接字的缓冲主要是为了实现 TCP 协议而设立的。 TCP 传输中丢失数据时将再次传递，能够再次传递的基础就是在套接字的输出缓冲中保存了数据。

使用标准 I/O 函数缓冲的主要目的是为了提高性能。 例如程序多次调用 fwrite 写入少量数据时，数据先被写入用户空间的缓冲区，只有当缓冲区满时或显式刷新时，才会进行一次 write 系统调用。这样，大量的小数据写操作被合并成一次更大的操作，从而减少系统调用的频率和开销。

（三） 标准 I/O 函数和系统函数之间的性能对比

直接给出结果，使用系统函数复制文件（大于300M字节）的速度远远慢于使用标准 I/O 函数。下面给出两个分别利用系统函数和标准 I/O 函数复制文件的示例：

（1）系统函数复制文件示例（syscpy.c）

#include <stdio.h>
#include <fcntl.h>
#define BUF_SIZE 3

int main(int argc, char *argv[])
{
	int fd1, fd2, len;
	char buf[BUF_SIZE];

	fd1=open("news.txt", O_RDONLY);
	fd2=open("cpy.txt", O_WRONLY|O_CREAT|O_TRUNC);

	while((len=read(fd1, buf, sizeof(buf)))>0)
		write(fd2, buf, len);

	close(fd1);
	close(fd2);
	return 0;
}

read 和 write 是系统函数（即系统调用），因为它们涉及到与操作系统内核直接交互，以实现对硬件资源（如文件、设备、网络）的读写操作。这类操作需要在内核态执行，而不是用户态。

（2）标准 I/O 函数复制文件示例（stdcpy.c）

#include <stdio.h>
#define BUF_SIZE 3

int main(int argc, char *argv[])
{
	FILE * fp1;
	FILE * fp2;
	char buf[BUF_SIZE];
	
	fp1=fopen("news.txt", "r");
	fp2=fopen("cpy.txt", "w");

	while(fgets(buf, BUF_SIZE, fp1)!=NULL)
		fputs(buf, fp2); 

	fclose(fp1);
	fclose(fp2);
	return 0;
}

（四）标准 I/O 函数的缺点

标准 I/O 函数有如下缺点：

• ① 不容易进行双向通信。

• ② 有时可能频繁调用 fflush 函数。

• ③ 需要以 FILE 结构体指针的形式返回文件描述符。

打开文件时，如果希望同时进行读写操作，则应以 r+、w+、a+ 模式打开，但因为缓冲的缘故，每次切换工作状态时，应调用 fflush 函数，这也会影响基于缓冲的性能提高。而且，为了使用标准I/O 函数,需要 FILE 结构体指针，而创建套接字时默认返回文件描述符，因此需要将文件描述符转化为 FILE 指针。

使用标准 I/O 函数

如前所述，创建套接字时返回文件描述符，而为了使用标准 I/O 函数，只能将其转换为 FILE 结构体指针。

（一）利用 fdopen 转换为 FILE 结构体指针

#include <stdio.h>
// 成功时返回转换的 FILE 结构体指针，失败时返回 NULL
FILE* fdopen(int fildes, const char* mode);

• fildes：需要转换的文件描述符。

• mode：表示文件操作模式的字符串，与 fopen 的模式类似。它决定了 FILE* 流的读写方式。常见的模式包括：

  • "r"：以只读方式打开文件。
  • "w"：以只写方式打开文件。
  • "a"：以追加写入方式打开文件。
  • "r+"：以读写方式打开文件。
  • "w+"：以读写方式打开文件，同时清空文件内容。
  • "a+"：以读写方式打开文件，且写入时追加到文件末尾。

下面给出示例：

#include <stdio.h>
#include <fcntl.h>

int main(void)
{
	FILE *fp;
	int fd=open("data.dat", O_WRONLY|O_CREAT|O_TRUNC);
	if(fd==-1)
	{
		fputs("file open error", stdout);
		return -1;
	}

	fp=fdopen(fd, "w");
	fputs("Network C programming \n", fp);
	fclose(fp);
	return 0;
}

（二）利用 fileno 函数转换为文件描述符

#include <stdio.h>
// 成功时返回转换后的文件描述符，失败时返回 -1
int fileno(FILE* stream);

此函数用法简单，向函数传递 FILE 指针参数时返回相应文件描述符，下面给出调用示例：

#include <stdio.h>
#include <fcntl.h>

int main(void)
{
	FILE *fp;
	int fd=open("data.dat", O_WRONLY|O_CREAT|O_TRUNC);
	if(fd==-1)
	{
		fputs("file open error", stdout);
		return -1;
	}
	
	printf("First file descriptor: %d \n", fd); 
	fp=fdopen(fd, "w");
	fputs("TCP/IP SOCKET PROGRAMMING \n", fp);
  	printf("Second file descriptor: %d \n", fileno(fp));
	fclose(fp);
	return 0;
}

基于套接字的标准 I/O 函数使用

（一）echo_stdserv.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sock, clnt_sock;
	char message[BUF_SIZE];
	int str_len, i;
	
	struct sockaddr_in serv_adr;
	struct sockaddr_in clnt_adr;
	socklen_t clnt_adr_sz;
	FILE * readfp;
	FILE * writefp;
	
	if(argc!=2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	serv_sock=socket(PF_INET, SOCK_STREAM, 0);   
	if(serv_sock==-1)
		error_handling("socket() error");
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_adr.sin_port=htons(atoi(argv[1]));

	if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
		error_handling("bind() error");
	
	if(listen(serv_sock, 5)==-1)
		error_handling("listen() error");
	
	clnt_adr_sz=sizeof(clnt_adr);

	for(i=0; i<5; i++)
	{
		clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
		if(clnt_sock==-1)
			error_handling("accept() error");
		else
			printf("Connected client %d \n", i+1);
	
		readfp=fdopen(clnt_sock, "r");
		writefp=fdopen(clnt_sock, "w");
	
		while(!feof(readfp))
		{
			fgets(message, BUF_SIZE, readfp);
			fputs(message, writefp);
			fflush(writefp);
		}
		fclose(readfp);
		fclose(writefp);
	}
	close(serv_sock);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

第56行的循环语句调用了 fflush 函数，如果不调用则无法保证立即将数据传送到客户端。

fflush 是一个标准 I/O 函数，用于刷新文件流的缓冲区。它确保缓冲区中的数据被及时写入到目标设备或文件中，而不是等待缓冲区自动填满或程序结束时自动刷新。

（二）echo_stdclnt.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sock;
	char message[BUF_SIZE];
	int str_len;
	struct sockaddr_in serv_adr;
	FILE * readfp;
	FILE * writefp;

	if(argc!=3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	sock=socket(PF_INET, SOCK_STREAM, 0);   
	if(sock==-1)
		error_handling("socket() error");
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_adr.sin_port=htons(atoi(argv[2]));
	
	if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
		error_handling("connect() error!");
	else
		puts("Connected...........");

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

	while(1) 
	{
		fputs("Input message(Q to quit): ", stdout);
		fgets(message, BUF_SIZE, stdin);
		if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))
			break;

		fputs(message, writefp);
		fflush(writefp);
 		fgets(message, BUF_SIZE, readfp);
		printf("Message from server: %s", message);
	}	
	fclose(writefp);
	fclose(readfp);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}