TCP/IP网络编程之套接字与标准I/O
标准I/O函数
标准标准I/O函数有两个优点：
- 标准I/O函数具有良好的移植性
- 标准I/O函数可以利用缓冲提高性能
关于移植性无需过多解释，不仅是I/O函数，所有标准函数都具有良好的移植性。因为，为了支持所有操作系统（编译器），这些函数都是按照ANSIC标准定义的。当然，这并不局限于网络编程，而是适用于所有编程领域
接下来讨论标准I/O函数的第二个优点，使用标准I/O函数时会得到额外的缓冲支持，这种表达方式也许会带来一些混乱，因为之前讲过，创建套接字时操作系统会准备I/O缓冲。造成更大混乱之前，先说明这两种缓冲之间的关系。创建套接字时，操作系统将生成用于I/O的缓冲。此缓冲在执行TCP协议时发挥着重要的作用，此时若使用标准I/O函数，将得到额外的另一缓冲的支持，如图1-1所示
图1-1 缓冲的关系
从图1-1中可以看到，使用标准I/O函数传输数据时，经过两个缓冲。例如，通过fputs函数传输字符串“Hello”时，首先将数据传递到标准I/O函数的缓冲。然后数据将移动到套接字输出缓冲，最后将字符串发送到对方主机
既然知道了两个缓冲的关系，接下来再说明各自的用途。设置缓冲的主要目的是为了提高性能，但套接字中的缓冲主要是为了实现TCP协议而设立的。例如，TCP传输中丢失数据时将再次传递，而再次发送数据意味着在某地保存了数据。存在什么地方呢？套接字的输出缓冲。与之相反，使用标准I/O函数缓冲的主要目的是为了提高性能
那么，使用缓冲可以提高性能吗？实际上，缓冲并非在所有情况下都能带来卓越的性能。但需要传输的数据越多，有无缓冲带来的性能差异越大，可以通过如下两个角度说明性能的提高：
- 传输的数据量
- 数据向输出缓冲移动的次数
比较一个字节的数据发送10次（10个数据包）的情况和累计10个字节发送1次的情况，发送数据时使用的数据包中含有头信息。头信息与数据大小无关，是按照一定的格式填入的。即使假设该头信息占用40个字节（实际上更大），需要传递的数据量也存在较大差别
- 1个字节10次：40*10=400字节
- 10个字节1次：40*1=40字节
另外，为了发送数据，向套接字输出缓冲移动数据也会消耗不少时间。但这同样与移动次数有关，1个字节数据共移动10次花费的时间将近10个字节数据移动1次花费时间的10倍
标准I/O函数和系统函数之间的性能对比
前面讲了缓冲可以提升性能的原因，接下来分别利用标准I/O函数和系统函数编写文件复制程序，这主要是为了检验缓冲提高性能的程度。首先是利用系统函数复制文件的示例
syscpy.c
#include <stdio.h>
#include <fcntl.h>
#define BUF_SIZE 3 //用最短数组长度构成
int main(int argc, char *argv[])
{
int fd1, fd2; //保存在fd1和fd2中的是文件描述符
int 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函数的文件复制程序，复制对象仅限于文本文件，并且是300M字节以上的文件。因为只有这样才能明显感觉到性能的差异。如果使用未提供缓冲的read和write函数传输数据，向目的地发送需要花费很长的时间，下面示例采用标准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;
}
上述示例利用示例syscpy.c中复制的文件再次进行复制，该示例利用fputs和fgets函数复制文件，因此是一种基于缓冲的复制。现在，让我们测试一下两个示例的执行时间
我们先用dd命令创建一个5M的文件（大家可用dd命令创建300M文件甚至更大的文件用于测试），用于测试
# dd if=/dev/zero of=news.txt bs=1M count=5 300+0 records in 300+0 records out 314572800 bytes (315 MB) copied, 0.475557 s, 661 MB/s # ls news.txt
编译syscpy.c并运行
# gcc syscpy.c -o syscpy # time ./syscpy real 0m8.609s user 0m0.734s sys 0m7.875s
编译stdcpy.c并运行
# gcc stdcpy.c -o stdcpy # time ./stdcpy real 0m0.169s user 0m0.165s sys 0m0.004s
只对照real指标，可以看到，使用标准I/O函数的性能高于系统函数
标准I/O函数的缺点：
- 不容易进行双向通信
- 有时可能频繁调用fflush函数
- 需要以FILE结构体指针的形式返回文件描述
当打开文件时，如果希望同时进行读写操作，则应以r+、w+、a+模式打开。但因为缓冲的缘故，每次切换读写工作状态时应调用fflush函数。这也会影响基于缓冲的性能提高，而且，为了使用I/O函数，需要FILE结构体指针。而创建套接字时默认返回文件描述符，因此需要将文件描述符转化为FILE指针
使用标准I/O函数
如前所述，创建套接字时返回文件描述符，而为了使用标准I/O函数，只能将其转换为FILE结构体指针。先介绍其转换方法
#include <stdio.h> FILE * fdopen(int fildes, const char * mode);//成功时返回转换的FILE结构体指针，失败时返回NULL
- filedes：需要转换的文件描述符
- mode：将要创建的FILE结构体指针的模式（mode）信息
上述函数的第二个函数与fopen函数中的打开模式相同，常用的参数有读模式“r”和写模式“w”。下面通过简单示例给出上述函数的使用方法
desto.c
#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;
}
- 第7行：使用open函数创建文件并返回文件描述符
- 第14行：调用fdopen函数将文件描述符转换为FILE指针，此时向第二个参数传递了“w”，因此返回写模式的FILE指针
- 第15行：利用第14行获取的指针调用标准输出函数fputs
- 第16行：利用FILE指针关闭文件，此时完全关闭，因此无需再通过文件描述符关闭。而且调用fclose函数后，文件描述符也变成毫无意义的整数
编译desto.c 并运行
# gcc desto.c -o desto # ./desto # cat data.dat Network C programming
利用fileno函数转换为文件描述符
与fdopen函数相反，fileno是将FILE指针转换为文件描述符的函数
#include <stdio.h> int fileno(FILE *stream);//成功时返回转换的文件描述符，失败时返回-1
todes.c
#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;
}
- 第14行：输出第7行返回的文件描述符整数值
- 第15、17行：第15行调用fdopen函数将文件描述符转换为FILE指针，第17行调用fileno函数再次转换回文件描述符，并输出该整数值
编译todes.c 并运行
# gcc todes.c -o todes # ./todes First file descriptor: 3 Second file descriptor: 3
基于套接字的标准I/O函数使用
前面介绍了标准I/O函数的优缺点，同时介绍了文件描述符和FILE指针的互转。下面将其适用于套接字，虽然是套接字操作，但并没有需要另外说明的内容。只需简单应用这些函数。接下来将之前的回声服务端和客户端改为基于标准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行的循环语句，调用基于字符串的fgets、fputs函数提供服务，并在第60行调用fflush函数。标准I/O函数为了提高性能，内部提供额外的缓冲。因此，若不调用fflush函数则无法保证立即将数据传输到客户端，接下来给出回声客户端代码
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);
}
回声客户端需要将接收的数据转换为字符串（数据的尾部插入0），但上述示例中并无这一过程。因为使用标准I/O函数后可以按字符串单位进行数据交换，运行结果与之前的回声客户端并无差异。
编译echo_stdserv.c 并运行
# gcc echo_stdserv.c -o echo_stdserv # ./echo_stdserv 8500 Connected client 1
编译echo_stdclnt.c并运行
# gcc echo_stdclnt.c -o echo_stdclnt # ./echo_stdclnt 127.0.0.1 8500 Connected........... Input message(Q to quit): Hello world! Message from server: Hello world! Input message(Q to quit): Java Message from server: Java Input message(Q to quit): Python Message from server: Python Input message(Q to quit): q
