Linux 有一个准则：一切皆文件。所以在 Linux 中，文件 I/O 函数 read 和 write 就是金字招牌，哪里都可以使用。但是在 Windows 中，文件 I/O 函数和套接字 I/O 函数需要被严格区分使用。现在将它们总结一下放到一个表格里

在 Windows 中，使用 send 和 recv 来传递数据，在 Linux 中同样也有这套函数。两者其实并没有什么差别。

send 函数原型

#include <sys/socket.h>
// 成功时返回发送的字节数，失败时返回 -1
ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);

函数参数：

• sockfd：表示与数据传输对象连接的套接字文件描述符
• buf：保存待传输数据的缓冲地址值
• nbytes：待传输的字节数
• flags：传输数据时指定的可选项信息

recv 函数原型

#include <sys/socket.h>
// 成功时返回接收的字节数，收到 EOF 时返回 0，失败时返回 -1
ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);

函数参数：

• sockfd：表示与数据接收对象连接的套接字文件描述符
• buf：保存接收数据的缓冲地址值
• nbytes：可接收的最大字节数
• flags：接收数据时指定的可选项信息

send 函数 recv 函数的最后一个参数是收发数据时的可选项，该可选项可利用 位或 (bit OR) 运算同时传递多个信息。下表是 flags 的种类及其含义

不同操作系统对上述可选项的支持也不同，所以需要对实际开发中采用的操作系统有一定了解才能使用不同可选项。下面介绍几种不受操作系统影响的可选项进行讲解，表示其可以移植。

可移植可选项：MSG_OOB 发送和接收紧急消息

发送紧急消息

MSG_OOB 可选项用于 “带外数据” 紧急消息。拿一个例子：假设医院里有很多病人在等待看病，此时若有急诊患者该怎么办？

“当然应该优先处理。”

如果急诊患者较多，就需要得到等待看病的普通病人的谅解。因此，医院一般会设立单独的急诊室。需要紧急处理时，应采用不同的处理方法和通道。MSG_OOB 可选项就用于创建特殊发送方法和通道，然后发送紧急消息。下列示例通过 MSG_OOB 可选项收发数据：

// oob_send.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define BUF_SIZE 30
void error_handling(char *message);
int main(int argc, char *argv[]) {
    // 1.检查输入
    if (argc != 3) {
        printf("Usage: %s <IP> <port> \n", argv[0]);
    }
    // 2.初始化套接字
    int sock;
    struct sockaddr_in recv_adr;
    sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&recv_adr, 0, sizeof(recv_adr));
    recv_adr.sin_family = AF_INET;
    recv_adr.sin_addr.s_addr = inet_addr(argv[1]);                // argv[1]: 要连接的服务器的 IP
    recv_adr.sin_port = htons(atoi(argv[2]));                    // argv[2]: 服务器开启的端口号
    // 3.向发起连接请求
    if (connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1)
        error_handling("connect() error!");
    write(sock, "123", strlen("123"));
    send(sock, "4", strlen("4"), MSG_OOB);                        // 加急消息
    write(sock, "567", strlen("567"));
    send(sock, "890", strlen("890"), MSG_OOB);                    // 加急消息
    close(sock);
    return 0;
}
void error_handling(char *message) {
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

在上述代码中，使用 MSG_OOB 可以把重要的消息先发出去。

接收紧急消息

相比于紧急消息的传输，紧急消息的接收过程要相对复杂一些。

// oob_recv.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#define BUF_SIZE 30
void error_handling(char *message);
void urg_handler(int signo);
int acpt_sock;
int recv_sock;
int main(int argc, char *argv[]) {
    // 1.检查输入格式
    if (argc != 2) {
        printf("Usage: %s <port> \n", argv[0]);
        exit(1);
    }
    // 2.初始化套接字
    struct sockaddr_in recv_adr, serv_adr;
    acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&recv_adr, 0, sizeof(recv_adr));
    recv_adr.sin_family = AF_INET;                            // IPV4
    recv_adr.sin_addr.s_addr = htonl(INADDR_ANY);            // 不限定客户端 IP
    recv_adr.sin_port = htons(atoi(argv[1]));                // 开放端口 argv[1]
    // 3.收到 MSG_OOB 紧急消息时，操作系统将产生 SIGURE，并调用注册的信号处理函数
    struct sigaction act;
    int state;
    act.sa_handler = urg_handler;                            // 信号处理函数
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    state = sigaction(SIGURG, &act, 0);
    // 4.bind() 函数将套接字与特定的 IP 地址和端口绑定起来
    if (bind(acpt_sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1)
        error_handling("bind() error");
    // 5.listen() 函数可以让套接字进入被动监听状态
    listen(acpt_sock, 5);
    // 6.为连接的客户端分配套接字
    socklen_t serv_adr_sz;
    recv_sock = accept(acpt_sock, (struct sockaddr*)&serv_adr, &serv_adr_sz);
     // 7.调用 fcntl 函数
    fcntl(recv_sock, F_SETOWN, getpid());
    // 8.接收客户端发送的数据
    int str_len;
    char buf[BUF_SIZE];
    while ((str_len=recv(recv_sock, buf, sizeof(buf), 0)) != 0) {
        if (str_len == -1)
            continue;
        buf[str_len] = 0;
        puts(buf);
    }
    close(recv_sock);
    close(acpt_sock);
    return 0;
}
void urg_handler(int signo) {
    int str_len;
    char buf[BUF_SIZE];
    str_len = recv(recv_sock, buf, sizeof(buf)-1, MSG_OOB);
    buf[str_len] = 0;
    printf("Urgent message: %s \n", buf);
}
void error_handling(char *message) {
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

和原来的子进程结束，就会发出 SIGCHLD ，操作系统就会调用处理函数类似；这里套接字接收到紧急消息以后，使用紧急接收函数 str_len = recv(recv_sock, buf, sizeof(buf)-1, MSG_OOB); 来处理。

关于 fcntl 函数

fcntl(recv_sock, F_SETOWN, getpid());

fcntl 函数用于控制文件描述符，上述调用语句的含义为：“将文件描述符” recv_sock 指向的套接字拥有者 (F_SETOWN) 改为把 getpid 函数返回值用作 ID 的进程。

什么是套接字拥有者呢？操作系统实际创建并管理套接字，所以从严格意义上来说，“套接字拥有者” 是操作系统。但是这里的 “拥有者” 是指负责套接字所有事物的主体。

所以上述函数在这里的含义为：“文件描述符 recv_sock 指向的套接字引发的 SIGURG 信号处理进程变为将 getpid 函数返回值用作 ID 的进程”。

看到这里仍旧是一脸懵逼吧，这都是什么玩意？不要着急，继续往下看

在多进程服务器学习过，通过 fork 函数创建子进程并同时复制文件描述符，这样会有多个进程有一个 1 个套接字的文件描述符。如果这个时候有紧急消息传入的时候，我们是选取哪个进程的 urg_handler 函数来处理呢？

而这就是 fcntl 的作用，这个时候处理的进程应该是 getpid 函数返回的调用此函数的进程 ID。

运行紧急发送和接收程序

将上述 oob_send.c 和 oob_recv.c 编译运行，先运行服务器端程序，使其进入 listen 状态，不然服务器端的请求连接会出错。

服务器端的信息如下所示：

可以看到，通过 MSG_OOB 可选项传递的数据在读取时只能读取 1 个字节，剩下的数据通过普通输入函数读取。这是因为 TCP 并不存在真正意义的 “带外数据”（带外数据：通过完全不同的通信路径传输的数据），但是 TCP 提供一种紧急模式进行传输。

TCP 紧急模式

MSG_OOB 可选项有如下作用：

“嗨！这里有数据需要紧急处理，别磨蹭了！”

MSG_OOB 的真正意义：督促数据接收对象尽快处理数据，这也就是紧急模式的全部内容。并且 TCP 保持传输顺序的传输特性依旧成立。

当有紧急消息的时候，需要做的事情有两件：

• 尽快传输
• 尽快被对象接收处理

传输会和网速有关系，这里不可控因素很多。而尽快被对象接收处理就对应前面的 urg_handler 信号处理函数，下面看一下上述紧急发送消息的发送阶段。

如果将缓冲最左端的位置视作偏移量为 0，字符 0 则保存在偏移量为 2 的位置。字符 0 右侧偏移量为 2 的位置存有紧急指针。紧急指针指向紧急消息的下一个位置，同时向对方主机（这里为服务器端）传递如下消息：

“紧急指针指向的偏移量 3 之前的部分就是紧急消息！”

但是，却并不知道，紧急消息到底是 “890”、“90” 还是 “0”，书上说这个功能不重要，因为我们所做的事情只是督促对方接收数据，这里理解不了！！！

可移植选项 MSG_PEEK & MSG_DONTWAIT 检查输入缓冲

同时设置 MSG_PEEK 选项和 MSG_DONTWAIT 选项，验证输入缓冲中是否存在接受的数据。设置 MSG_PEEK 选项并调用 recv 函数时，即使读取了输入缓冲的数据也不会删除。

因此，该选项通常与 MSG_DONTWAIT 合作，用于调用以非阻塞方式验证待读数据存在与否的函数。下面看个例子：

客户端发送：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
void error_handling(char *message);
int main(int argc, char *argv[]) {
    // 1.检查输入
    if (argc != 3) {
        printf("Usage: %s<IP><port> \n", argv[0]);
        exit(1);
    }
    // 2.初始化套接字描述符
    int sock;
    struct sockaddr_in send_adr;
    sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&send_adr, 0, sizeof(send_adr));
    send_adr.sin_family = AF_INET;
    send_adr.sin_addr.s_addr = inet_addr(argv[1]);
    send_adr.sin_port = htons(atoi(argv[2]));
    // 3.发起请求
    if (connect(sock, (struct sockaddr*)&send_adr, sizeof(send_adr)) == -1)
        error_handling("connect() error");
    write(sock, "123", strlen("123"));
    close(sock);
    return 0;
}
void error_handling(char *message) {
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

服务器端接收：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define BUF_SIZE 30
void error_handling(char *message);
int main(int argc, char *argv[]) {
    // 1.检查输入
    if (argc != 2) {
        printf("Usage: %s <port>", argv[0]);
        exit(1);
    }
    // 2.初始化套接字描述符
    int acpt_sock, recv_sock;
    struct sockaddr_in acpt_adr, recv_adr;
    acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&acpt_adr, 0, sizeof(acpt_adr));
    acpt_adr.sin_family = AF_INET;
    acpt_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    acpt_adr.sin_port = htons(atoi(argv[1]));
    // 3.bind绑定套接字与端口
    if (bind(acpt_sock, (struct sockaddr*)&acpt_adr, sizeof(acpt_adr)) == -1)
        error_handling("bind() error");
    // 4.listen监听
    listen(acpt_sock, 5);
    socklen_t recv_adr_sz;
    recv_adr_sz = sizeof(recv_adr);
    recv_sock = accept(acpt_sock, (struct sockaddr*)&recv_adr, &recv_adr_sz);
    int str_len;
    char buf[BUF_SIZE];
    while(1) {
        str_len = recv(recv_sock, buf, sizeof(buf)-1, MSG_PEEK|MSG_DONTWAIT);
        if (str_len > 0)
            break;
    }
    buf[str_len] = 0;
    printf("Buffering %d bytes: %s \n", str_len, buf);
    str_len = recv(recv_sock, buf, sizeof(buf)-1, 0);
    buf[str_len] = 0;
    printf("Read again: %s \n", buf);
    close(acpt_sock);
    close(recv_sock);
    return 0;
}
void error_handling(char *message) {
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

运行以上两个程序：

客户端：

服务器端：

通过上述运行结果可以发现，仅发送 1 次的数据被读取了 2 次，因为第一次调用 recv 函数时设置了 MSG_PEEK 可选项。