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 
", 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 
", fd);
    fp = fdopen(fd, "w");
    fputs("TCP/IP SOCKET PROGRAMMING 
", fp);
    printf("Second file descriptor: %d 
", 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>
", 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 
", 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('
', 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>
", 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
") || !strcmp(message, "Q
"))
            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('
', 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