企业官网建设流程全解析

做网络开发这些年，Socket编程一直是绕不开的基本功。不管是写一个简单的聊天程序，还是做高并发的网络中间件，底层都要跟套接字打交道。而随着IPv6逐步落地，现在写Socket不问一句“支不支持IPv6”都有点说不过去。这篇文章我就把这几年在Linux下做Socket编程（IPv4和IPv6双栈）的经验整理出来，从基础原理到双栈适配，从核心API到排查技巧，尽量用大白话讲清楚，让新手能上手，让老手能查漏补缺。

1. 整体设计与思路拆解

1.1 从一次网络请求聊到Socket的作用

我先用一句话概括Socket的本质：它是一种跨进程通信的接口。所谓“跨进程”，既可以是同一台机器上的两个进程，也可以是网络上两台完全不同的机器之间的进程。操作系统把网络通信的细节封装成文件描述符（fd），你只要对这个fd做读、写、关闭操作，数据就能在网络中传输。

打个比方，你往国外寄快递，不需要自己开车跨海，只需要把包裹交到快递公司，填好地址和收件人。Socket就是这层“快递公司”的柜台接口。你告诉它“我要连谁、用什么方式传、传多少数据”，剩下的路由、分包、校验、重传，全部由内核协议栈处理。

从编程角度看，一个完整的Socket通信流程通常长这样：

• 服务端：创建套接字 → 绑定地址和端口 → 监听 → 接受连接 → 收发数据 → 关闭
• 客户端：创建套接字 → 连接服务端 → 收发数据 → 关闭

听着简单，但实际写起来细节极其容易翻车。尤其是IPv4时代很多API设计得比较粗糙（比如地址结构体在不同平台上不统一、可读性差），到了IPv6时代，又涉及双栈监听、地址格式转换、前缀长度等一系列新问题。

1.2 为什么选择IPv4和IPv6双栈方案

现在很多教材和旧博客只讲IPv4，代码示例全是struct sockaddr_in和inet_addr这类老函数。但在真实的业务环境里，IPv6已经是躲不开的选项。

首先是基础网络的推动。现在新的服务器、云主机默认都支持IPv6，很多运营商网络已经分配了IPv6地址。如果你写的服务只监听IPv4，那IPv6网络里的用户连不上你；只监听IPv6，老用户又无法访问。最稳妥的方式，就是让服务端同时支持IPv4和IPv6，在代码里用“双栈”方案处理。

双栈的核心思路是：一个Socket同时监听IPv4和IPv6的连接，IPv6套接字通过地址映射机制，把IPv4流量“伪装”成IPv6格式的地址（例如::ffff:192.168.1.10），从而用一个监听fd容纳两个协议族的连接。

这里就不得不提Linux系统上一个很重要的参数：IPV6_V6ONLY。默认情况下，Linux的IPv6 Socket是可以接受IPv4连接的（即双栈工作）；但有些系统可能被配置成只监听IPv6。所以我在实际开发时，往往会显式调用setsockopt去关闭或打开这个选项，避免不同发行版之间的行为不一致。

1.3 设计思想：一套代码兼容两族

双栈方案做到极致，不是写两套代码分别监听IPv4和IPv6，而是一套代码通过getaddrinfo动态解析地址族、通过sockaddr_storage统一存储地址。这样既能减少维护成本，也能在域名既有A记录又有AAAA记录时自动选择正确的地址族。

从我个人的项目经验来看，采用这套思路之后，代码的健壮性明显提升。你不需要关心客户端的IP到底是IPv4还是IPv6，只需要在收数据时从sockaddr_storage里面掏出地址来，再统一转成字符串打印即可。这比早期写两套逻辑要清爽得多。

2. 核心API与关键参数解析

2.1 socket()创建套接字的三个参数

int sockfd = socket(int domain, int type, int protocol);

这三个参数看似基础，但真选错一个就很麻烦。

• domain（协议族）：AF_INET表示IPv4，AF_INET6表示IPv6，AF_UNIX用于本地进程通信。注意，有人说“PF_INET和AF_INET等价”，在日常代码里基本可以混用，但语义上AF代表“地址族”，PF代表“协议族”，在Linux里两者值相同。
• type（类型）：SOCK_STREAM表示TCP流式套接字，SOCK_DGRAM表示UDP数据报套接字，SOCK_RAW用于原始套接字（抓包、构造自定数据包）。
• protocol（协议）：一般填0，让内核根据domain和type自动选择。比如AF_INET + SOCK_STREAM默认就是TCP，AF_INET + SOCK_DGRAM默认就是UDP。也可以显式填IPPROTO_TCP或IPPROTO_UDP，但没必要。

这里想提醒一个新手的坑：一旦你用了AF_INET6，后续绑定地址时就要用struct sockaddr_in6，而不是struct sockaddr_in。很多人最开始写IPv6代码的时候没注意，直接把sockaddr_in强制转换成sockaddr*传参，结果就是bind返回错误，或者数据收发行为异常。

2.2 bind()、listen()、accept() 服务端三板斧

服务端要对外服务，第一步是把Socket和本地地址绑在一起，这就是bind()。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

很多资料会把bind()和“端口绑定”画等号，其实它绑定的是“IP地址 + 端口”这个二元组。你可以绑定某个具体IP，比如192.168.1.100，也可以绑定通配地址（INADDR_ANY或IN6ADDR_ANY），表示监听本机所有网卡的连接。对服务器来说，监听通配地址是最常见的做法。

然后是listen()：

int listen(int sockfd, int backlog);

backlog参数控制的是“已完成握手但还未被accept的连接队列长度”，不是最大连接数。很多人误解了这一点。如果设置过小，高并发时连接会被内核直接丢弃；设得过大，又可能被泛滥的连接请求拖垮内存。

accept()返回一个新的已连接套接字：

int connfd = accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

注意，这个connfd和监听用的sockfd不是同一个。监听fd只负责接收新连接，真正收发数据的是connfd。如果不小心把sockfd当数据socket来读写，你会收到莫名其妙的异常。

2.3 connect()、send()、recv() 客户端通路

客户端那边相对简单，核心就是connect()：

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

对这个函数的几个常见判断，我多说几句：

• connect()成功不代表对端进程已经准备好接收应用层数据，只代表TCP三次握手完成。
• 对UDP而言，connect()的语义不是建立真正的连接，只是绑定对端地址。后续用send()/recv()时就不需要每次传地址参数。
• 在非阻塞模式下，connect()可能立即返回-1，并产生EINPROGRESS错误。这是正常现象，不是真的失败。

收发数据时，除了基础的send()/recv()，还有sendto()/recvfrom()（主要用于UDP）、write()/read()（本质是文件IO）等方法。选择哪种取决于场景，但从语义上来说，面向连接的使用send()/recv()更清晰。

2.4 地址结构体的演进：从sockaddr到sockaddr_in6

很多初学者看到那堆sockaddr结构体就头疼。这里我帮你理一下关系：

IPv4时代用struct sockaddr_in，里面存的是端口号和32位的IPv4地址：

struct sockaddr_in { sa_family_t sin_family; /* AF_INET */ in_port_t sin_port; /* 端口，网络字节序 */ struct in_addr sin_addr; /* IPv4地址 */ };

IPv6时代新增了struct sockaddr_in6：

struct sockaddr_in6 { sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* 端口 */ uint32_t sin6_flowinfo; /* 流信息，一般置0 */ struct in6_addr sin6_addr; /* 128位IPv6地址 */ uint32_t sin6_scope_id; /* 链路本地地址的接口索引 */ };

而sockaddr是通用的老结构，API函数（如bind、connect）为了统一接口，都接收struct sockaddr*类型的指针。这也是为什么代码里总有一堆强制类型转换。如果你不想纠结具体用哪个结构体，可以用sockaddr_storage，它足够大，能容纳IPv4和IPv6的地址。

这里有个细节：在传addrlen的时候，必须保证和实际传入的地址结构体大小匹配，否则可能出现内核读取越界的问题。最常见的是你明明用struct sockaddr_in6，结果传了sizeof(struct sockaddr_in)，这就会触发EINVAL错误。

3. 从IPv4迁移到IPv6的硬核改造

3.1 IPv6地址的赋值与打印

IPv6地址赋值没有IPv4的inet_addr那么直观，我推荐用inet_pton函数：

inet_pton(AF_INET6, "::1", &addr.sin6_addr);

inet_pton的“pton”意为“presentation to network”，即把点分十进制或冒号十六进制的文本地址转换成网络字节序的二进制结构。反过来用inet_ntop：

inet_ntop(AF_INET6, &addr.sin6_addr, buf, sizeof(buf));

很多老代码用的inet_ntoa或者inet_ntop(AF_INET, ...)，在IPv6环境下都会不兼容。我建议从新项目开始就统一使用inet_ntop，并且用INET6_ADDRSTRLEN作为缓冲区大小宏，避免溢出。

一个常见需求是打印客户端IP和端口，双栈场景下的写法是这样的：

char addr_str[INET6_ADDRSTRLEN]; void *addr_ptr = NULL; if (peer_addr.ss_family == AF_INET) { struct sockaddr_in *ipv4 = (struct sockaddr_in *)&peer_addr; addr_ptr = &(ipv4->sin_addr); } else { struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&peer_addr; addr_ptr = &(ipv6->sin6_addr); } inet_ntop(peer_addr.ss_family, addr_ptr, addr_str, sizeof(addr_str));

这个逻辑几乎可以用在所有的TCP/UDP服务器代码中。

3.2 双栈监听的实现细节

对于双栈监听，我推荐的做法是：

• 创建AF_INET6的socket。
• 设置IPV6_V6ONLY为0，允许IPv4映射。
• 绑定到in6addr_any（即::）。
• listen()后用accept()接收连接。

示例片段如下：

int sockfd = socket(AF_INET6, SOCK_STREAM, 0); int on = 0; // 0表示关闭V6ONLY，允许双栈 setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)); struct sockaddr_in6 addr6; memset(&addr6, 0, sizeof(addr6)); addr6.sin6_family = AF_INET6; addr6.sin6_port = htons(8080); addr6.sin6_addr = in6addr_any; // 监听所有IPv6地址，同时接收IPv4映射 bind(sockfd, (struct sockaddr *)&addr6, sizeof(addr6)); listen(sockfd, 128);

这里有几个非常容易出问题的点：

in6addr_any是全局变量，在部分系统上需要链接额外库或声明宏，但大多数Linux环境直接用就行。

如果系统管理员在/proc/sys/net/ipv6/bindv6only里设置了1，那么默认创建的IPv6 socket不会接收IPv4连接。所以代码里显式设置IPV6_V6ONLY比依赖系统默认值更可靠。

如果改了IPV6_V6ONLY之后还是收不到IPv4连接，检查一下是不是防火墙（如iptables、nftables）把IPv4流量单独过滤掉了。

3.3 用getaddrinfo实现真正的地址族无关代码

在写跨协议族的客户端时，getaddrinfo简直是救星。它不仅帮你做域名解析，还自动处理IPv4和IPv6的选择逻辑。

struct addrinfo hints, *res, *p; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; // 可以是IPv4或IPv6 hints.ai_socktype = SOCK_STREAM; int ret = getaddrinfo("example.com", "80", &hints, &res); if (ret != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret)); return -1; } for (p = res; p != NULL; p = p->ai_next) { int fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); if (fd < 0) continue; if (connect(fd, p->ai_addr, p->ai_addrlen) == 0) break; close(fd); } freeaddrinfo(res);

这个代码的精髓在于：你不用自己判断域名是A记录还是AAAA记录，只要把所有addrinfo结果遍历一遍，总有一个能连通。这在如今双栈网络环境里是标准的推荐做法。

3.4 IPv4映射地址的判别

收到一个IPv6连接后，怎么判断这个“客户端”本质上是不是IPv4的？判断方法是看地址是否是::ffff:0:0/96前缀。

比如::ffff:192.168.0.1，前96位是::ffff:0:0，后面32位是IPv4地址。你可以用宏IN6_IS_ADDR_V4MAPPED来判断。如果业务上需要给纯IPv4用户和纯IPv6用户配置不同的策略，这个判断就非常有用。

4. 实操：写一个支持双栈的TCP回显服务端

4.1 需求与代码框架

光说不练假把式。我写一个小而完整的TCP回显服务端，客户端发什么，服务端就原样返回什么。它同时支持IPv4和IPv6连接，核心逻辑可以套用到实际项目里。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #include <sys/socket.h> #include <netdb.h> #define PORT "8080" #define BACKLOG 128 #define BUFSIZE 1024 // 从sockaddr_storage提取IP地址并打印 void print_client_addr(struct sockaddr_storage *addr, socklen_t addrlen) { char ipstr[INET6_ADDRSTRLEN]; int port = 0; if (addr->ss_family == AF_INET) { struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr; inet_ntop(AF_INET, &ipv4->sin_addr, ipstr, sizeof(ipstr)); port = ntohs(ipv4->sin_port); } else if (addr->ss_family == AF_INET6) { struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr; inet_ntop(AF_INET6, &ipv6->sin6_addr, ipstr, sizeof(ipstr)); port = ntohs(ipv6->sin6_port); } printf("New connection from %s:%d\n", ipstr, port); } int main(void) { struct addrinfo hints, *res; int listen_fd = -1; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; // 利用getaddrinfo尝试双栈 hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; // 监听所有网卡 int ret = getaddrinfo(NULL, PORT, &hints, &res); if (ret != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret)); exit(1); } // 遍历结果并创建socket struct addrinfo *p; for (p = res; p != NULL; p = p->ai_next) { listen_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); if (listen_fd < 0) continue; int opt = 1; setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); if (bind(listen_fd, p->ai_addr, p->ai_addrlen) == 0) break; // bind成功就使用这个fd close(listen_fd); listen_fd = -1; } freeaddrinfo(res); if (listen_fd < 0) { perror("bind failed"); exit(1); } if (listen(listen_fd, BACKLOG) < 0) { perror("listen failed"); close(listen_fd); exit(1); } printf("Echo server listening on port %s\n", PORT); while (1) { struct sockaddr_storage client_addr; socklen_t addr_len = sizeof(client_addr); int conn_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &addr_len); if (conn_fd < 0) continue; print_client_addr(&client_addr, addr_len); char buf[BUFSIZE]; ssize_t n; while ((n = recv(conn_fd, buf, sizeof(buf), 0)) > 0) { send(conn_fd, buf, n, 0); } close(conn_fd); } close(listen_fd); return 0; }

这里我特意用getaddrinfo(NULL, PORT, ...)来拿到本机通配地址的sockaddr结构，好处是它既可能返回IPv4的0.0.0.0，也可能返回IPv6的::。配合AI_PASSIVE标志后，它会优先返回一个能支持双栈监听的地址族。简单场景下这样写就够了。

4.2 编译与验证

编译命令一行搞定：

gcc -Wall -O2 echo_server.c -o echo_server

运行：

./echo_server

使用IPv4客户端测试：

echo "hello ipv4" | nc 127.0.0.1 8080

使用IPv6客户端测试：

echo "hello ipv6" | nc ::1 8080

如果网络环境里有真实的IPv6地址，也可以填主机对应的IPv6地址测试。你会发现监听fd不用换，两种连接都能接进来。这就是双栈监听的好处。

4.3 用ss排查监听状态

运行中可以用ss工具查看监听fd的状态：

ss -tln

如果看到类似：

LISTEN 0 128 [::]:8080

表示你的Socket正在IPv6通配地址上监听。带[::]的监听默认意味着IPv4映射也是可用的（除非系统强制V6ONLY）。如果想确认IPv4映射是否开启，可以用：

ss -tlnp | grep 8080

结合ip -6 addr看一下本机IPv6地址是否就绪。如果IPv6地址没有配置，IPv6监听仍然会处于UNCONN或者不完整状态，但IPv4连接通常不受影响。

4.4 服务端为什么建议同时设置SO_REUSEADDR

代码里设置了SO_REUSEADDR，这是一个实战中几乎必须的选项。它解决的是TIME_WAIT状态下端口占用问题。假设服务端主动断开连接，或者连接双方中有一方先关闭，TCP连接会进入TIME_WAIT状态，端口短时间内无法复用。如果没有SO_REUSEADDR，服务端重启时会报Address already in use。

注意：SO_REUSEADDR不解决SO_REUSEPORT的问题，后者用于多个进程绑定同一端口做负载均衡。如果只是普通单进程服务，不需要设置SO_REUSEPORT。

5. 常见问题与排查技巧实录

5.1 bind返回“Address already in use”

绝大多数情况下就是因为端口被占用。用下面命令查看：

ss -tulpn | grep 8080

看到进程号后，要么停掉旧进程，要么等TIME_WAIT超时（通常60秒左右），要么加上SO_REUSEADDR重启。

但有一种隐蔽情况：你监听的IPv6 socket占用了端口，IPv4 socket再bind同一个端口也会报这个错。反过来也一样。所以如果你配置了双栈监听，就不要再去单独创建一个IPv4监听相同端口。这也是为什么我建议共用一个双栈fd。

5.2 connect超时却不知道原因

connect超时常见原因为：目标IP和端口不通、防火墙丢弃了SYN包、路由不可达、对端服务没在监听。

排查顺序建议：

1. 先用ping测连通性，确认网络层通。
2. 再用nc -vz IP PORT测端口连通性。
3. 如果网络层通但端口不通，检查对端服务是否启动，并检查iptables/nftables规则。

IPv6环境下要特别注意：如果你用ping6测试本机IPv6地址，确保网卡有IPv6地址并且没有被防火墙拦截。有些云服务器默认不启用IPv6，虽然能解析AAAA记录，但实际网络包出不去，这类问题最容易让人摸不着头脑。

5.3 地址结构体长度不对导致EINVAL

这是一个非常隐蔽的错误。当你调用accept()或者recvfrom()时，内核需要知道传入的地址缓冲区到底有多大。如果缓冲区是sockaddr_storage，必须初始化它的长度：

struct sockaddr_storage addr; socklen_t addrlen = sizeof(addr); int conn = accept(listen_fd, (struct sockaddr *)&addr, &addrlen);

如果你忘记把addrlen初始化为sizeof(addr)，而是0，调用就会失败。还有一次我见过同事把sockaddr_in6的地址直接强转给sockaddr_in使用，结果客户端IPv6地址被错误解析成风马牛不相及的值，调试了很久才反应过来。

5.4 打印IPv6地址时缓冲区太小导致截断

IPv4点分式最长15个字符，IPv6的冒号十六进制文本最长39个字符，加上结尾的\0，推荐用INET6_ADDRSTRLEN（46字节）作为缓冲区大小。如果你固定用char buf[16]，IPv6地址必然被截断或溢出。

5.5 recv返回0和返回-1的区别

返回0表示对方已经正常关闭连接。返回-1则需要配合errno判断，常见的是EAGAIN/EWOULDBLOCK（非阻塞模式下暂时无数据）和ECONNRESET（对方强制断开）。很多新手拿到-1就报错退出，其实在非阻塞模式下这属于正常状态，处理逻辑上应该continue而不是break。

5.6 新老系统对IPV6_V6ONLY默认值不同

不同Linux发行版对/proc/sys/net/ipv6/bindv6only的默认值可能不同。有些默认0（允许双栈），有些默认1（仅IPv6）。代码里显式设置IPV6_V6ONLY是唯一稳妥的方案。如果你要的是双栈，就设置成0；如果业务上确实需要纯IPv6监听，再设置成1。

6. 高性能方向：从阻塞IO到多路复用

6.1 阻塞Socket的局限

上面的回显服务端是串行处理的：一个连接不关闭，其他连接只能排队等待accept()。在真实生产环境里，这种写法扛不住并发。

常规做法是引入多线程（一连接一线程），但线程数量有限，C10K问题就会暴露。于是现代高性能服务端普遍采用IO多路复用：select、poll、epoll。

• select：最早的多路复用方案，但fd数量上限受FD_SETSIZE限制，性能随fd数线性下降。
• poll：没有fd上限，但每次调用仍然要遍历全部fd，内核态和用户态之间拷贝代价大。
• epoll：Linux专属的事件驱动模型，只通知“有事件”的fd，复杂度降到O(1)级别，是目前高性能网络服务的主流选择。

6.2 非阻塞模式的配合

使用epoll时，通常要把fd设置为非阻塞模式，否则在边缘触发（ET）模式下，最后一次read/write如果没处理完所有数据，会卡住整个事件循环。设置非阻塞的常用方法：

int flags = fcntl(fd, F_GETFL, 0); fcntl(fd, F_SETFL, flags | O_NONBLOCK);

如果只是写简单工具，阻塞模式也可以；但做高并发服务时，非阻塞 + epoll是标配。

6.3 缓冲区管理与粘包问题

TCP是字节流协议，没有消息边界。一次send()的数据可能被拆成多个包到达，多次send()的数据也可能一次到达。这就产生“粘包/拆包”问题。

简单粗暴的解决方案是：约定协议为“定长包头 + 变长包体”，比如前4字节表示包体长度。服务端先把包头读完，解析出长度，再继续读对应长度的包体。这样才能保证应用层消息的完整性。

6.4 双栈服务在使用epoll时要注意什么

用epoll监听双栈socket时，不用特别判断accept()返回的地址族，因为逻辑上都是同一个监听fd的事件。你只需要在accept()之后，按我前面说的方式从sockaddr_storage里提取IP和端口即可。

但有一个坑：某些服务器上的IPv6链路本地地址（fe80开头的地址）需要指定sin6_scope_id（网卡索引）才能访问。如果你的服务需要绑定在物理网卡的链路本地地址上，记得在bind()时设置好sin6_scope_id，否则会得到“Address not available”的错误。

7. 我个人建议的调试方法和收尾经验

讲到这里，我特别想分享几个调试Socket程序时的土办法，它们在很多正式文档里看不到，但实战中非常好用。

第一招，学会使用strace。如果你不确定某个系统调用为什么失败，直接：

strace -f -o trace.log ./your_server

然后复现问题，打开trace.log看最后几个socket、bind、listen、accept调用的返回值。通常一眼就能看到是哪一步返回了错误的errno。

第二招，巧用nc和telnet做客户端测试。nc几乎支持一切基础网络测试：

nc -vz 192.0.2.1 8080 # 测试TCP端口 printf 'test\n' | nc ::1 8080 # 发送数据 nc -u -vz 192.0.2.1 53 # 测试UDP端口

第三招，别忽略/etc/hosts里的IPv6条目。有时候你以为自己连的是IPv6，但因为/etc/hosts里写了localhost 127.0.0.1，getaddrinfo可能优先返回IPv4地址。用getent ahosts可以查看系统的实际解析顺序：

getent ahosts localhost

如果输出里既没有::1也没有127.0.0.1，就要检查DNS和hosts配置。

最后，说回双栈改造这件事。很多老项目迁移到IPv6时，最大的障碍往往不是API不会用，而是以前的代码里到处散落着“硬编码IPv4地址”的逻辑，比如直接用inet_addr("127.0.0.1")、用sizeof(struct sockaddr_in)分配缓冲区。如果你在做一个长期维护的服务，建议尽早统一改造为sockaddr_storage + getaddrinfo + inet_ntop这套组合。改完之后，新协议族接入的成本会低很多，也顺手清掉不少潜在的越界和字节序问题。

从我个人的项目经验来说，Socket编程其实不怕“API背不出来”，最怕的是“结构体用错而编译器不报错”。C语言在类型转换上给了开发者很大的自由度，但这自由也埋着不少雷。写网络代码时多一份警惕，多看一眼参数长度和地址族，很多线上故障是可以提前避免的。希望这篇文章能帮你把IPv4和IPv6双栈这条路上的一些大坑提前填平，后面写代码时少走点弯路。