从Linux内核探索 Socket 的本质

一、引言

二、Socket 的概念

三、Socket 的使用场景

四、Socket 的设计

五、提供 Socket 层

六、Socket 如何实现网络通信

（一）建立连接

（二）数据传输

七、Socket 怎么实现“继承”

八、总结

一、引言

相信大家刚开始学 Socket 的时候，都跟我一样，对 Socket 的概念很模糊。本文将从一个初学者的角度开始聊起，让大家了解 Socket 是什么以及它的原理和内核实现。

二、Socket 的概念

Socket 就如同我们日常生活中的插头与插座的连接关系。在网络编程中，Socket 是一种实现网络通信的接口或机制。想象一下，插头插入插座后，电流得以流通，实现了能量的传递。而在网络世界里，当一个程序使用 Socket 与另一台机子建立“连接”时，就如同插头成功插入了插座，数据能够在两者之间进行流通和交换。

例如，当我们在网上聊天时，发送方的程序通过 Socket 将消息发送出去，接收方的程序通过对应的 Socket 接收这些消息。又比如在下载文件时，下载程序通过 Socket 与提供文件的服务器建立连接，从而能够获取到所需的文件数据。总之，它是网络通信的端点，用于在不同的计算机进程之间进行通信，而计算机中通过五元组：协议类型、源IP地址、源端口号、目标IP地址、目标端口号，通过五元组来唯一

三、Socket 的使用场景

我们想要将数据从 A 电脑的某个进程发到 B 电脑的某个进程。如果需要确保数据能发给对方，就选可靠的 TCP 协议；如果数据丢了也没关系，就选择不可靠的 UDP 协议。初学者一般首选 TCP。
这时就需要用 socket 进行编程，首先创建关于 TCP 的 socket：

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() {
    int sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock_fd == -1) {
        std::cerr << "Failed to create socket" << std::endl;
        return 1;
    }

    // 后续代码...

    return 0;
}

这个方法会返回 sock_fd，它是 socket 文件的句柄。
对于服务端，得到 sock_fd 后，依次执行 bind()、listen()、accept() 方法，等待客户端的连接请求；对于客户端，得到 sock_fd 后，执行 connect() 方法向服务端发起建立连接的请求，此时会发生 TCP 三次握手。
连接建立完成后，客户端可以执行 send() 方法发送消息，服务端可以执行 recv() 方法接收消息，反之亦然。

四、Socket 的设计

现在我们抛开socket，重新设计一个内核网络传输功能。我们想要将数据从 A 电脑的某个进程发到 B 电脑的某个进程，从操作上来看，就是发数据给远端和从远端接收数据，也就是写数据和读数据。
但这里有两个问题：

接收端和发送端可能不止一个，因此需要用 IP 和端口做区分，IP 用来定位是哪台电脑，端口用来定位是这台电脑上的哪个进程。
发送端和接收端的传输方式有很多区别，如可靠的 TCP 协议、不可靠的 UDP 协议，甚至还需要支持基于 icmp 协议的 ping 命令。

为了支持这些功能，需要定义一个数据结构 sock，在 sock 里加入 IP 和端口字段。这些协议虽然各不相同，但有一些功能相似的地方，可以将不同的协议当成不同的对象类（或结构体），将公共的部分提取出来，通过“继承”的方式复用功能。

于是，定义了一些数据结构：

sock 是最基础的结构，维护一些任何协议都有可能会用到的收发数据缓冲区。
在 Linux 内核 2.6 相关的源码中，sock 结构体的定义可能类似于：

struct sock {
    // 相关字段
    struct sk_buff_head sk_receive_queue; // 接收数据缓冲区
    struct sk_buff_head sk_write_queue;  // 发送数据缓冲区
    // 其他可能的字段
};

inet_sock 特指用了网络传输功能的 sock，在 sock 的基础上还加入了 TTL、端口、IP 地址这些跟网络传输相关的字段信息。比如 Unix domain socket，用于本机进程之间的通信，直接读写文件，不需要经过网络协议栈。
可能的定义：
```
struct inet_sock {
    struct sock sk; // 继承自 sock
    __be32 port;    // 端口
    __be32 saddr;   // IP 地址
    // 其他相关字段
};
```
inet_connection_sock 是指面向连接的 sock，在 inet_sock 的基础上加入面向连接的协议里相关字段，比如 accept 队列、数据包分片大小、握手失败重试次数等。虽然现在提到面向连接的协议就是指 TCP，但设计上 Linux 需要支持扩展其他面向连接的新协议。
例如：
```
struct inet_connection_sock {
    struct inet_sock inet; // 继承自 inet_sock
    struct request_sock_queue accept_queue; // accept 队列
    // 其他相关字段
};
```
tcp_sock 就是正儿八经的 TCP 协议专用的 sock 结构，在 inet_connection_sock 基础上还加入了 TCP 特有的滑动窗口、拥塞避免等功能。同样 UDP 协议也会有一个专用的数据结构，叫 udp_sock。
大概如下：
```
struct tcp_sock {
    struct inet_connection_sock icsk; // 继承自 inet_connection_sock
    // TCP 特有的字段，如滑动窗口、拥塞避免等相关字段
};
```

有了这套数据结构，将它跟硬件网卡对接一下，就实现了网络传输的功能。

五、提供 Socket 层

由于这里面的代码复杂，还操作了网卡硬件，需要较高的操作系统权限，再考虑到性能和安全，于是将它放在操作系统内核里。
为了让用户空间的应用程序使用这部分功能，将这部分功能抽象成简单的接口，将内核的 sock 封装成文件。创建 sock 的同时也创建一个文件，文件有个文件描述符 fd，通过它可以唯一确定是哪个 sock。将fd暴露给用户，用户就可以像操作文件句柄那样去操作这个 sock 。

struct file{
    //文件相关的字段
    .....
    void *private_data; //指向sock
}

创建socket时，其实就是创建了一个文件结构体，并将private_data字段指向sock。

有了 sock_fd 句柄后，提供了一些接口，如 send()、recv()、bind()、listen()、connect() 等，这些就是 socket 提供出来的接口。

所以说，socket 其实就是个代码库或接口层，它介于内核和应用程序之间，提供了一堆接口，让我们去使用内核功能，本质上就是一堆高度封装过的接口。

我们平时写的应用程序里代码里虽然用了socket实现了收发数据包的功能，但其实真正执行网络通信功能的，不是应用程序，而是linux内核。

在操作系统内核空间里，实现网络传输功能的结构是sock，基于不同的协议和应用场景，会被泛化为各种类型的xx_sock，它们结合硬件，共同实现了网络传输功能。为了将这部分功能暴露给用户空间的应用程序使用，于是引入了socket层，同时将sock嵌入到文件系统的框架里，sock就变成了一个特殊的文件，用户就可以在用户空间使用文件句柄，也就是socket_fd来操作内核sock的网络传输能力。

六、Socket 如何实现网络通信

以最常用的 TCP 协议为例，实现网络传输功能分为建立连接和数据传输两个阶段。

（一）建立连接

在客户端，执行 socket 提供的 connect(sockfd, "ip:port") 方法时，会通过 sockfd 句柄找到对应的文件，再根据文件里的信息指向内核的 sock 结构，通过这个 sock 结构主动发起三次握手。
在服务端，握手次数还没达到“三次”的连接叫半连接，完成好三次握手的连接叫全连接，它们分别会用半连接队列和全连接队列来存放，这两个队列会在执行 listen() 方法的时候创建好。当服务端执行 accept() 方法时，就会从全连接队列里拿出一条全连接。

虽然都叫队列，但半连接队列其实是个哈希表，而全连接队列其实是个链表。

在 Linux 内核 2.6 版本的源码中，相关的代码实现可能位于网络子系统的部分。例如，建立连接的过程可能涉及到 tcp_connect() 等函数。

（二）数据传输

为了实现发送和接收数据的功能，sock 结构体里带了一个发送缓冲区和一个接收缓冲区，其实就是个链表，上面挂着一个个准备要发送或接收的数据。
当应用执行 send() 方法发送数据时，会通过 sock_fd 句柄找到对应的文件，根据文件指向的 sock 结构，找到这个 sock 结构里带的发送缓冲区，将数据放到发送缓冲区，然后结束流程，内核看心情决定什么时候将这份数据发送出去。

接收数据流程也类似，当数据送到 Linux 内核后，先放在接收缓冲区中，等待应用程序执行 recv() 方法来拿。
当应用进程执行 recv() 方法尝试获取（阻塞场景下）接收缓冲区的数据时，如果有数据，取走就好；如果没数据，就会将自己的进程信息注册到这个 sock 用的等待队列里，然后进程休眠。如果这时候有数据从远端发过来了，数据进入到接收缓冲区时，内核就会取出 sock 的等待队列里的进程，唤醒进程来取数据。

当多个进程通过 fork 的方式 listen 了同一个 socket_fd，在内核它们都是同一个 sock，多个进程执行 listen() 之后，都会将自身的进程信息注册到这个 socket_fd 对应的内核 sock 的等待队列中。在 Linux 2.6 以前，会唤醒等待队列里的所有进程，但最后其实只有一个进程会处理这个连接请求，其他进程又重新进入休眠，会消耗一定的资源，这就是惊群效应。在 Linux 2.6 之后，只会唤醒等待队列里的其中一个进程，这个问题被修复了。

服务端 listen 的时候，那么多数据到一个 socket 怎么区分多个客户端的？以 TCP 为例，服务端执行 listen 方法后，会等待客户端发送数据来。客户端发来的数据包上会有源 IP 地址和端口，以及目的 IP 地址和端口，这四个元素构成一个四元组，可以用于唯一标记一个客户端。服务端会创建一个新的内核 sock，并用四元组生成一个 hash key，将它放入到一个 hash 表中。下次再有消息进来的时候，通过消息自带的四元组生成 hash key 再到这个 hash 表里重新取出对应的 sock 就好了。

七、Socket 怎么实现“继承”

Linux 内核是 C 语言实现的，而 C 语言没有类也没有继承的特性，是通过结构体里的内存是连续的这一特点来实现“继承”的效果。将要继承的“父类”，放到结构体的第一位，然后通过结构体名的长度来强行截取内存，这样就能转换结构体，从而实现类似“继承”的效果。

例如：

struct tcp_sock {
    /* inet_connection_sock has to be the first member of tcp_sock */
    struct inet_connection_sock inet_conn;
    // 其他字段
};

struct inet_connection_sock {
    /* inet_sock has to be the first member! */
    struct inet_sock icsk_inet;
    // 其他字段
};

// sock 转为 tcp_sock
static inline struct tcp_sock *tcp_sk(const struct sock *sk) {
    return (struct tcp_sock *)sk;
}

八、总结

socket 中文套接字，可理解为一套用于连接的数字。
sock 在内核，socket_fd 在用户空间，socket 层介于内核和用户空间之间。
在操作系统内核空间里，实现网络传输功能的结构是 sock，基于不同的协议和应用场景，会被泛化为各种类型的 xx_sock，它们结合硬件，共同实现了网络传输功能。为了将这部分功能暴露给用户空间的应用程序使用，于是引入了 socket 层，同时将 sock 嵌入到文件系统的框架里，sock 就变成了一个特殊的文件，用户就可以在用户空间使用文件句柄，也就是 socket_fd 来操作内核 sock 的网络传输能力。
服务端可以通过四元组来区分多个客户端。
内核通过 C 语言“结构体里的内存是连续的”这一特点实现了类似继承的效果。