IPv6 · XB 现场笔记

AAAA 发布 IPv6 地址，不证明该地址可达

Thu, 30 Dec 2027 00:00:00 +0000

一条 AAAA 资源记录保存一个一百二十八位 IPv6 地址，A 记录则保存 IPv4 地址。同一个名称可以只有其中一类、同时拥有两类，或者在每类中包含多个地址。A 与 AAAA 属于不同记录集，因此可以使用不同 TTL。发布 AAAA 让地址能够通过 DNS 被发现，却不会替你创建接口、路由、监听套接字或可用应用；这些条件需要在实际服务路径上成立。

坏掉的样子

AAAA 查询成功之后，连接仍可能失败。发布的地址可能已经停用，服务可能只监听 IPv4，网络也可能缺少可用 IPv6 路由。两种地址族的防火墙与 TLS 配置也可能不同。只通过 IPv4 做可用性检查，会漏掉这些问题，而双栈用户可能正沿着公开的 IPv6 路径遭遇延迟或错误。记录存在与服务可用是两个需要分别观察的事实。

Happy Eyeballs 通过协调地址发现和连接尝试，减少部分双栈连接延迟，但它属于客户端算法，并不是 DNS 对所有客户端的保证。具体回退行为、截止时间和应用协议仍会影响结果。某个浏览器在一次测试中迅速改用 A 记录成功，不能推出错误 AAAA 对所有调用方无害。尤其对于没有相同行为的库、设备或后台任务，应验证其真实连接策略。

缺少 AAAA 也应准确描述。权威服务器可以对只有 A 的名称返回成功 DNS 状态，却没有 AAAA 数据，这通常称为 NODATA；它不同于表示名称不存在的 NXDOMAIN。仅有 A 的服务也不是在所有 IPv6-only 网络中都绝对不可达：具备相应基础设施时，DNS64 可以合成 AAAA，再通过 NAT64 访问 IPv4 服务器。不能忽略翻译网络这一明确反例。

快速验证

将脚本保存为 check-aaaa.py，准备 Docker 后执行 python3 check-aaaa.py。固定环境使用 BIND 9.18.49 和 dnspython 2.3.0。隔离网络具有可工作的 IPv6 回环接口，但没有外部路由。程序在 ::1 上启动真实 HTTP 监听，分别执行 DNS 查询和 IPv6 连接；它不向公网发布端口，也不依赖修改宿主网络来制造结果：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,socket,threading
records='dual 17 IN A 127.0.0.1\ndual 29 IN AAAA ::1\nv4-only 17 IN A 127.0.0.1\nbroken 29 IN AAAA 2001:db8::1234'
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=b'IPv6 response';self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
class V6Server(ThreadingHTTPServer):address_family=socket.AF_INET6
with lab(records) as (_,update,cache,queries),V6Server(('::1',0),Handler) as server:
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
 try:
 a=query('dual.lab.test.','A');aaaa=query('dual.lab.test.','AAAA')
 assert values(a)==['127.0.0.1'] and values(aaaa,'AAAA')==['::1']
 assert a.answer[0].ttl==17 and aaaa.answer[0].ttl==29
 address=values(aaaa,'AAAA')[0];assert len(socket.inet_pton(socket.AF_INET6,address))==16
 client=http.client.HTTPConnection(address,server.server_port,timeout=2)
 client.request('GET','/');reply=client.getresponse();body=reply.read();client.close()
 assert reply.status==200 and body==b'IPv6 response'
 only_a=query('v4-only.lab.test.');assert values(only_a)==['127.0.0.1']
 missing=query('v4-only.lab.test.','AAAA');assert missing.rcode()==0 and missing.answer==[]
 assert len(missing.authority)==1 and missing.authority[0].rdtype==dns.rdatatype.SOA
 broken=query('broken.lab.test.','AAAA');assert values(broken,'AAAA')==['2001:db8::1234']
 unreachable=socket.socket(socket.AF_INET6);unreachable.settimeout(.3)
 try:unreachable.connect(('2001:db8::1234',server.server_port));raise AssertionError('documentation address unexpectedly reachable')
 except OSError as error:failure=type(error).__name__
 finally:unreachable.close()
 print(json.dumps({'A':show(a),'AAAA_over_IPv4_DNS':show(aaaa),'IPv6_HTTP_status':reply.status,
 'AAAA_wire_address_bytes':16,'A_only_AAAA_query':show(missing),'published_but_unreachable':{'answer':show(broken),'connect_error':failure}},sort_keys=True))
 finally:server.shutdown();thread.join(timeout=2)
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

dual.lab.test 的 A 回答为 127.0.0.1，TTL 为十七秒；AAAA 回答为 ::1，TTL 为二十九秒。两个 DNS 查询都发送到 127.0.0.1 上的 IPv4 DNS 套接字。通过这个套接字收到 AAAA，直接说明记录所描述的地址族与传输 DNS 问答的地址族可以不同。要查询 IPv6 地址，并不要求本次 DNS 数据报本身必须使用 IPv6。

程序将 AAAA 文本转换成打包形式，检查长度为十六字节，再使用返回的 IPv6 地址请求本地 HTTP 服务。实测得到状态 200 和预期正文。这项验证证明选定地址上的 IPv6 回环连接可用，而不把记录存在当作应用验证。A 与 AAAA 的 TTL 对照也检查了不同记录集可以独立配置，不能由其中一类回答推断另一类的寿命。

查询 v4-only.lab.test 的 AAAA 时，返回 NOERROR、空回答区和权威区中的 SOA；名称本身仍有 A 记录。另一个名称 broken.lab.test 成功返回文档地址 2001:db8::1234，随后连接却在隔离环境里失败。这个对照有意把正向 DNS 数据和传输成功分开，同时不会把测试流量发送给真实外部主机，也不把预期失败描述成 DNS 查询失败。

沿每个已发布地址族检查服务

发布 IPv6 前，先确认监听、路由、访问规则和应用行为。既使用正常主机名身份测试，也检查各个公开端点。裸地址 HTTP 成功不能验证基于名称的证书和虚拟主机路由。本例只验证本地 HTTP，不证明公共 IPv6 连通性，也没有评估某个客户端的 Happy Eyeballs 实现。报告结果应限定在实际执行的路径上，避免用局部成功覆盖其他配置责任。

监控和部署记录应同时覆盖两个记录集。删除 AAAA 会改变新的权威回答，却不会撤回客户端已经缓存的地址；现有连接还有自己的生命周期。迁移时按计划保留旧 IPv6 服务重叠期，并比较权威数据与受影响客户端使用的递归解析器。发现旧连接时，要先确认应用是否重新解析，不能把所有仍在访问旧端点的流量都归因于 DNS 缓存。

最后，AAAA 是正向地址数据，即使有些描述把它叫作 IPv6 指针。反向查询使用 ip6.arpa 下的 PTR 记录，名称来自地址的十六进制半字节倒序。发布正向 AAAA 不会自动发布相应反向记录。正向查询、反向命名、地址选择与应用通信彼此相关，但配置和可观察结果不同，应按照服务真正需要的契约逐项检查。

来源

RFC 3596 DNS extensions for IPv6，AAAA 地址数据、DNS 传输独立性与 ip6.arpa 反向名称，已核验 2026-09-12。
RFC 6147 DNS64，合成 AAAA 记录以访问 IPv4 服务器，已核验 2026-09-12。
RFC 8305 Happy Eyeballs version 2，客户端地址选择与连接尝试，已核验 2026-09-12。

IPv6 路由器报告超大报文，由源端决定怎样适应路径

Wed, 06 Oct 2027 00:00:00 +0000

IPv6 路由器在向目的地转发报文时，不会替它进行分片。如果报文大于下一条链路所能承载的大小，路由器通常丢弃它，并发送 ICMPv6 Packet Too Big 反馈。源端随后可以调整报文大小，或在适当情况下通过 IPv6 分片扩展头发送分片；这些分片在目的端重组。明确各阶段由谁负责，是判断超大报文故障的基础。

坏掉的样子

假定路由器会自动拆开过大的 IPv6 包，会掩盖与大小相关的故障。相同地址与路由上，小 echo 可以成功，大 echo 却失败。端点本地接口可能支持原始大小，中间链路却不支持。应检查整条路径约束，不能仅因接口配置了 MTU 1500，就推断该大小能够端到端通过，也不能用一次小探测成功替代完整大小检查。

Packet Too Big 反馈缺失，会使经典发现更难学到这个限制。分片被过滤，或者其中一片丢失，也可能阻止正确重组。能够生成分片扩展头，不证明沿途策略都允许相应报文。不能把源端分片当作正确路径大小与必要控制流量的万能替代，它有自己的交付条件，需要通过对应流量验证，而不是只检查发送选项已经开启。

反方向也有自己的路径估计。请求发送端学到 MTU，不会自动教会响应端怎样发送较大回复。因此双向 echo 测试需要分别了解两个方向。TCP 分段还不同于 IP 分片：TCP 发送端学到限制后，可以构造更小的段，而不必把每个 IP 包再分片。应先确定观察的是哪一层的切分，避免看到多个包就统称为分片。

快速验证

将脚本保存为 check-ipv6-fragmentation.py，准备 Docker 后运行 python3 check-ipv6-fragmentation.py。此前实验使用 Python 3.11.16、iproute2 6.1.0、iputils ping 和 tcpdump 4.99.3，运行于 Linux 6.12.76；本轮未重跑网络实验，以下为保留的历史观察。NET_ADMIN 与 SYS_ADMIN 支持四个嵌套命名空间。两台路由器和两个端点使用新建 veth，不修改宿主接口或路由：

from pathlib import Path
from tempfile import TemporaryDirectory
import subprocess,json,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time
def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,process.stderr.read();return value
@contextmanager
def lab():
 with TemporaryDirectory(prefix='mtu-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc));stack.callback(run,'umount',str(proc))
 for name in ['client','r1','r2','target']:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False);ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in ['client','r1','r2','target']
 path=proc/'sys'/key.replace('.','/')
 ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r});p.write_text({str(value)!r});assert p.read_text().strip()=={str(value)!r}')
 yield root,stack,setting
def topology(setting,ipv6=False):
 links=[('client','c0','r1','a0',1,2,1,1500),('r1','a1','r2','b0',2,1,2,1280),('r2','b1','target','t0',3,1,2,1500)]
 for left,left_if,right,right_if,network,left_host,right_host,mtu in links:
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,host in [(left,left_if,left_host),(right,right_if,right_host)]:
 run('ip','link','set',interface,'netns',name);ip(name,'link','set',interface,'mtu',str(mtu))
 address=f'2001:db8:{network}::{host}/64' if ipv6 else f'10.210.{network}.{host}/30'
 ip(name,'addr','add',address,'dev',interface,*(['nodad'] if ipv6 else []));ip(name,'link','set',interface,'up')
 family='-6' if ipv6 else '-4'
 for name in ['r1','r2']:setting(name,'net.ipv6.conf.all.forwarding' if ipv6 else 'net.ipv4.ip_forward',1)
 routes=[('client','default','2001:db8:1::1' if ipv6 else '10.210.1.1'),('target','default','2001:db8:3::1' if ipv6 else '10.210.3.1'),
 ('r1','2001:db8:3::/64' if ipv6 else '10.210.3.0/30','2001:db8:2::2' if ipv6 else '10.210.2.2'),
 ('r2','2001:db8:1::/64' if ipv6 else '10.210.1.0/30','2001:db8:2::1' if ipv6 else '10.210.2.1')]
 for name,destination,gateway in routes:ip(name,family,'route','add',destination,'via',gateway)
 if ipv6:
 deadline=time.monotonic()+4
 while any('tentative' in ip(name,'-6','address','show').stdout for name in ['client','r1','r2','target']):
 assert time.monotonic()<deadline,'IPv6 link-local DAD did not finish';time.sleep(.02)
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 result={}
 for item in json.loads(ns(name,'nft','-j','list','ruleset').stdout)['nftables']:
 rule=item.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:result[rule['comment']]=expression['counter']['packets']
 return result
def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'capture exited'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('capture did not become ready')
def captured(process,path):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3);assert process.returncode==0,diagnostic
 return run('tcpdump','-nn','-vv','-r',str(path)).stdout

with lab() as (root,stack,setting):
 topology(setting,ipv6=True);target='2001:db8:3::2'
 small=ns('client','ping','-6','-n','-c','1','-W','1','-s','32',target);assert small.returncode==0
 tap,path=capture(stack,root,'client','c0','ip6','too-big')
 large=ns('client','ping','-6','-n','-M','do','-s','1400','-c','1','-W','1',target,check=False)
 feedback=captured(tap,path);assert large.returncode!=0 and 'too big' in feedback.lower(),(large.stdout,large.stderr,feedback)
 route=ip('client','-6','route','get',target).stdout;assert 'mtu 1280' in route,route
 reverse=ns('target','ping','-6','-n','-M','do','-s','1400','-c','1','-W','1','2001:db8:1::2',check=False)
 reverse_route=ip('target','-6','route','get','2001:db8:1::2').stdout
 assert reverse.returncode!=0 and 'mtu 1280' in reverse_route,(reverse.stdout,reverse.stderr,reverse_route)
 tap,path=capture(stack,root,'client','c0','ip6 and src 2001:db8:1::2','source-fragments')
 fragmented=ns('client','ping','-6','-n','-M','dont','-s','2000','-c','1','-W','2',target,check=False)
 trace=captured(tap,path);assert fragmented.returncode==0,(fragmented.stdout,fragmented.stderr,trace)
 assert 'frag (' in trace and trace.count('frag (')>=2,trace
 refused=ns('client','ping','-6','-n','-M','do','-s','2000','-c','1','-W','1',target,check=False)
 assert refused.returncode!=0 and 'too long' in (refused.stdout+refused.stderr).lower(),(refused.stdout,refused.stderr)
 print(json.dumps({'small_echo':small.stdout,'oversize_before_learning':{'stdout':large.stdout,'stderr':large.stderr,'returncode':large.returncode},
 'packet_too_big_capture':feedback,'learned_route':route,'reverse_path_learning':reverse.stdout+reverse.stderr,'reverse_route':reverse_route,'source_fragmented_echo':fragmented.stdout,
 'source_side_fragment_capture':trace,'dont_fragment_after_learning':{'returncode':refused.returncode,'stdout':refused.stdout,'stderr':refused.stderr}}))
"""
name='xbcatm-mtupath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN','--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

端点链路 MTU 为 1500，中间路由器链路为 1280。静态全局地址使用 nodad，设置过程同时明确等待自动生成的链路本地地址离开 tentative 状态。这个就绪检查避免把最初地址设置延迟误判成转发或 MTU 故障。实验没有声称验证重复地址检测算法本身，只是把网络准备完成作为后续比较的前置条件。

小 echo 往返首先成功。随后使用 do 策略发送 1400 字节 echo 载荷，加上基础 IPv6 与 ICMPv6 头后，形成 1448 字节报文。它适合源端接口，却超过中间链路。捕获显示原始请求和路由器返回的 Packet Too Big，报告 MTU 1280；客户端路由查询随后记录该值。这样能区分源端本来就拒绝发送，与中间路径发现更小限制。

目标向客户端发送对应的超大探测，也为反向路径学到 MTU 1280。这一步明确准备较大 echo 回复，不假定一个端点的缓存同时覆盖两个方向。两个失败发现探测都保留在输出中，包含路由器反馈和路由状态，让后续成功所依赖的设置可见。请求方向已经正确，不代表响应方向无需独立检查。

客户端接着用 dont 策略发送 2000 字节 echo 载荷，允许根据已知上限在源端分片。抓包位于客户端接口，并限定客户端源地址，在两台路由器处理之前，就看到了标识相同的两个分片。工具显示数据偏移为零和 1232 字节，分片数据长度合计 2008，包含 ICMPv6 头。这直接证明分片已由发送端产生，而非后来由路由器拆开。

目的端重组并完成大小正确的返回交换后，echo 成功。用 do 策略重复相同载荷，则得到本地 message-too-long 错误与 MTU 1280。结果区分了路由器报告此前未知瓶颈、发现后源端主动分片，以及已知较小上限后的本地拒绝。这些是不同失败和交付阶段，不应全都写成同一种“包太大所以网络不通”。

来源

RFC 8200 IPv6，源端分片、分片扩展头与目的端重组，已核验 2026-10-15。
RFC 8201 IPv6 Path MTU Discovery，Packet Too Big 反馈与各方向路径估计，已核验 2026-10-15。
Linux ping(8)，载荷大小与 do/dont 路径 MTU 策略，已核验 2026-10-15。

IPv6 文本规范化保留地址，端点上下文仍须另外处理

Mon, 30 Nov 2026 00:00:00 +0000

IPv6 地址包含一百二十八位，通常写成八组十六进制数字。文本可以省略组内前导零，并用一次 :: 代替连续全零组。这些规则缩短写法而不丢失地址。RFC 4291 定义有效形式，RFC 5952 推荐一致的显示与交换形式。语法是否有效，和拼写是否符合推荐规范，是相关但不同的问题，不能用一个判断替代另一个。

坏掉的样子

直接比较原始字符串，可能把同一个地址当成多个身份。大写字母、前导零和展开的零组都能改变文本，却不改变底层位值，从而拆散资产记录，或破坏应用原本想进行的地址比较。应先使用适合输入类型的库解析，再比较地址值。仅转换成小写，不会处理所有零组和压缩差异，因此不能称为完整规范化。

压缩本身也有限制。:: 最多出现一次，否则无法确定各个省略段的长度。推荐表示应压缩最长连续零组；长度相同时选择最前一组，并且不要压缩单个零字段。一般 IPv6 语法允许部分推荐显示规则不采用的写法。规范化工具应区分有效但非首选的形式与真正非法输入，而不是把两者都报告成相同错误。

地址也未必构成完整端点。URL 中的 IPv6 字面量需要括号，将地址内部冒号与端口分隔符区别开。链路本地目的地还可能需要区域标识，以选择正确接口范围。如果没有明确比较策略就删除区域，或把映射 IPv4 地址扁平化，可能丢失调用方建立正确连接所需的信息。字符串变短，不代表端点含义仍完整。

快速验证

将脚本保存为 check-ipv6-text.py，使用 Python 3.12 或更新版本执行 python3 check-ipv6-text.py。本轮用 Python 3.12.14 原样运行此脚本，只调用标准库解析，不产生网络流量。程序比较有效变体、拒绝错误输入并检查端点组成，没有配置示例地址、发送 IPv6 报文或证明这些地址具有可用路由。解析验证与网络可达性在这里明确分开：

from ipaddress import IPv6Address
from urllib.parse import urlsplit
import json

variants=['2001:0DB8:0000:0000:0000:ff00:0042:8329','2001:db8:0:0:0:ff00:42:8329','2001:db8::ff00:42:8329']
parsed=[IPv6Address(v) for v in variants];assert len(set(parsed))==1 and len(set(variants))==3
tie=IPv6Address('2001:0:0:1:0:0:1:1').compressed;assert tie=='2001::1:0:0:1:1'
single=IPv6Address('2001:db8::1:2:3:4:5').compressed;assert single=='2001:db8:0:1:2:3:4:5'
bad=[]
for text in ['2001::db8::1','2001:db8:1:2:3:4:5:6:7','2001:db8::gg','2001:db8::1/64']:
 try:IPv6Address(text);raise AssertionError('invalid address accepted')
 except ValueError:bad.append(text)
url=urlsplit('https://[2001:db8::1]:8443/health');assert IPv6Address(url.hostname)==IPv6Address('2001:db8::1') and url.port==8443
try:urlsplit('https://2001:db8::1:8443/health').port;raise AssertionError('unbracketed endpoint accepted')
except ValueError:bad_url=True
mapped=IPv6Address('::ffff:192.0.2.1');assert str(mapped.ipv4_mapped)=='192.0.2.1'
zone_a=IPv6Address('fe80::1%eth0');zone_b=IPv6Address('fe80::1%eth1')
assert zone_a!=zone_b and zone_a.packed==zone_b.packed
print(json.dumps({'variants':variants,'same_128_bits':len(set(parsed))==1,'normalized':str(parsed[0]),
 'leftmost_tie':tie,'single_zero_retained':single,'rejected':bad,'url_host':url.hostname,'url_port':url.port,
 'unbracketed_url_port_rejected':bad_url,'mapped_python_text':mapped.compressed,'mapped_ipv4':str(mapped.ipv4_mapped),
 'zone_scope_ids':[zone_a.scope_id,zone_b.scope_id],'same_bits_different_scopes':True}))

三种字符串表示同一地址，包括展开的大写形式 2001:0DB8:0000:0000:0000:ff00:0042:8329 与 2001:db8::ff00:42:8329。原始字符串集合有三项，解析后的地址集合只有一项，规范输出为后者。这个对照直接说明：如果应用身份指的是底层地址，原始拼写就不是可靠索引键，不能因为文字不同便建立多个独立对象。

对于 2001:0:0:1:0:0:1:1，两个零段等长，第一段被缩短，结果是 2001::1:0:0:1:1。有效输入 2001:db8::1:2:3:4:5 只省略一个零组，规范输出会恢复为 2001:db8:0:1:2:3:4:5。实验明确验证单零组规则，没有推荐凡是能够缩短字符串就进行压缩。规范化追求一致性，而不只是字符数量更少。

包含两个 ::、组数过多或非十六进制字符的输入都解析失败。结尾带 /64 的字符串也不能交给仅接受地址的构造器，因为它属于另一类输入。契约包含前缀时，应选择接口或网络解析器，不能悄悄删除后缀，只为让地址构造器接受。前缀是否允许、是否必须保留，应由字段含义明确决定。

带括号的 URL https://[2001:db8::1]:8443/health 能正确分离主机与端口；读取故意去掉括号的对应 URL 的端口时，程序抛出 ValueError。实验还识别 ::ffff:192.0.2.1 内的 IPv4 部分，本次 Python 3.12.14 构建的压缩输出为 ::ffff:192.0.2.1，而 ipv4_mapped 属性给出 192.0.2.1。这些结果说明被测解析器的行为，没有承诺所有运行时都对特殊地址采用完全相同格式。

fe80::1%eth0 与 fe80::1%eth1 的二进制地址字节相同，保留范围后却不相等。区域属于附加上下文，不在一百二十八位地址之内。实验没有联系这些接口，只检查表示方式能够保留差异，不证明任一带范围目标已经配置或可以访问。把纯地址用于比较时，应明确是否有意排除了这项连接信息。

存储文本前先确定比较契约

先决定字段保存地址、网络前缀、接口配置、URL，还是套接字端点，再选用对应解析器并保留必要组成。单独保留原始输入有助于解释配置错误，规范表示则便于一致显示与索引。解析或规范化都不会认证谁控制地址，也不会证明目标服务安全。它们解决表示和解释问题，不提供应用访问所需的全部信任属性。

关联日志或应用地址规则时，应记录如何处理映射 IPv4 和区域标识，并针对等价有效写法、非法输入和带上下文案例验证策略。目标是稳定解释预期端点，而不是把所有内容压成最短字符串。只有地址位值和周边连接上下文都明确保留，格式处理才不会在清理外观时悄悄改变调用方真正想表达的目的地。

来源

RFC 4291 IPv6 addressing，有效 IPv6 语法、压缩写法和嵌入 IPv4 地址，已核验 2026-10-15。
RFC 5952 IPv6 text representation，推荐的零压缩、等长选择和小写形式，已核验 2026-10-15。
RFC 3986 URI syntax，URI 中的 IP 字面量括号及端口分隔，已核验 2026-10-15。
Python 3.12 ipaddress，解析后的地址比较、映射地址与范围标识，已核验 2026-10-15。

IPv6 先用 ICMPv6 解析邻居，TCP 才能正常通信

Mon, 16 Nov 2026 00:00:00 +0000

以太网链路上的 IPv6 主机，需要先取得邻居的链路层目的地址，才能发送相应帧。邻居发现通过 ICMPv6 的邻居请求和邻居通告完成地址解析，同时还涵盖路由器发现、邻居可达性检测等超出 IPv4 ARP 的功能。把它简单理解为“地址更长的 ARP”，会掩盖配置 IPv6 网络时必须考虑的依赖关系，尤其是控制报文与应用通信之间的联系。

坏掉的样子

拥有有效 IPv6 地址和路由，不代表能够解析下一跳的以太网地址。如果必要的请求或通告被过滤，TCP 服务可以一直正常监听，客户端却在交换应用数据前就失败。只开放应用 TCP 端口，无法修复这个较低层依赖。排查时应把邻居表、相关 ICMPv6 流量和服务监听一起观察，不能只从端口是否开放判断整条路径。

缓存状态还可能隐藏错误。已有可用邻居条目的主机，在破坏性规则安装后可能继续通信；新客户端或条目失效之后，故障才暴露。反过来，STALE 状态也不自动意味着损坏：邻居发现可以利用已有链路地址，随后再检查可达性。应理解状态转换，不能要求每个正常条目永远显示 REACHABLE，否则会把正常缓存生命周期误判为故障。

另一类混淆，是在本地以太网段上解析远端应用服务器地址。目的地位于链路之外时，主机通常解析选中的下一跳路由器，而不是远端服务器。判断邻居表应出现哪个地址之前，需要先确认选路。捕获接口错误，或者已有缓存使本次无需重新发送请求，也能解释空白抓包结果，不能据此证明邻居发现根本没有发生。

快速验证

将脚本保存为 check-neighbor-discovery.py，准备 Docker 后运行 python3 check-neighbor-discovery.py。此前 Linux 实验使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3；本轮没有重跑网络实验，以下结果保留为历史观察。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间和临时 proc 挂载。两个端点通过新建 veth 相连，不修改宿主邻居表或防火墙规则：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def captured(process,path,ascii=False):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 result=run('tcpdump','-nn','-vv',*(['-A'] if ascii else []),'-r',str(path))
 return result.stdout

with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30','2001:db8:1::1/64'],['192.0.2.2/30','2001:db8:1::2/64'])
 server(stack,'target','2001:db8:1::2')
 ip('client','-4','neigh','flush','dev','c0');ip('target','-4','neigh','flush','dev','t0')
 arp_process,arp_file=capture(stack,root,'client','c0','arp','arp')
 ns('client','ping','-4','-n','-c','1','-W','1','192.0.2.2')
 arp=captured(arp_process,arp_file);assert 'ARP,' in arp and 'Request who-has' in arp and 'Reply' in arp,arp
 ip('client','-6','neigh','flush','dev','c0');ip('target','-6','neigh','flush','dev','t0')
 nd_process,nd_file=capture(stack,root,'client','c0','icmp6 or arp','nd')
 ns('client','ping','-6','-n','-c','1','-W','1','2001:db8:1::2')
 nd=captured(nd_process,nd_file)
 assert 'neighbor solicitation' in nd and 'neighbor advertisement' in nd and 'ARP,' not in nd,nd
 mac=json.loads(ip('target','-j','link','show','t0').stdout)[0]['address']
 neighbors=json.loads(ip('client','-6','-j','neigh','show','2001:db8:1::2').stdout)
 assert len(neighbors)==1 and neighbors[0]['lladdr']==mac
 healthy=request('client','2001:db8:1::2');assert healthy['ok']
 setting('client','net.ipv6.neigh.c0.retrans_time_ms',200);setting('client','net.ipv6.neigh.c0.mcast_solicit',3)
 nft('client','''table inet block_nd {
 chain input { type filter hook input priority 0; policy accept;
 icmpv6 type nd-neighbor-advert counter drop comment "blocked_advertisements"
 }
}
''')
 ip('client','-6','neigh','flush','dev','c0')
 failed=ns('client','ping','-6','-n','-c','1','-W','1','2001:db8:1::2',check=False);assert failed.returncode!=0
 broken=request('client','2001:db8:1::2');assert not broken['ok']
 blocked=counters('client');assert blocked['blocked_advertisements']>0
 failed_neighbors=json.loads(ip('client','-6','-j','neigh','show','2001:db8:1::2').stdout)
 assert failed_neighbors and all('lladdr' not in entry for entry in failed_neighbors)
 nft('client','delete table inet block_nd');ip('client','-6','neigh','flush','dev','c0')
 recovered=request('client','2001:db8:1::2');assert recovered['ok']
 print(json.dumps({'ipv4_arp_capture':arp,'ipv6_capture':nd,'resolved_neighbor':neighbors,'target_mac':mac,
 'healthy_http':healthy,'blocked_ping_exit':failed.returncode,'blocked_http':broken,'blocked_counters':blocked,
 'unresolved_neighbor':failed_neighbors,'recovered_http':recovered}))
"""
name='xbcatm-netpath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

脚本为两端配置 IPv4 与 IPv6 文档保留地址。首先捕获一次真实 IPv4 ARP 请求和回复，作为抓包配置有效的正向对照；然后清理客户端 IPv6 邻居缓存并发送 IPv6 echo 请求。第二段捕获包含邻居请求、邻居通告以及 echo 往返，没有 ARP 帧。这样的比较比“没有抓到 ARP，所以 IPv6 一定正常”更完整。

针对 2001:db8:1::2 的请求发往被请求节点组播地址 ff02::1:ff00:2。回复提供目标链路层地址，脚本将其与目标接口真实 MAC 以及客户端邻居条目比较。随后 HTTP 请求返回预期服务器身份。这把控制消息、学到的信息与应用结果连接起来，而不只是展示一组配置命令。MAC 由本次虚拟接口产生，不要求所有运行得到相同数值。

接着，客户端丢弃收到的邻居通告。它的缓存被清理，避免旧映射隐藏变更。为让测试在有限时间内结束，发现重传设置仅在客户端网络命名空间内缩短。此时 ping 失败，HTTP 得到 Linux EHOSTUNREACH，错误号一百一十三；邻居条目进入 FAILED，且没有解析出的链路地址。过滤计数器增长，证明通告确实到达丢弃规则。

删除该规则并清理失败条目后，HTTP 恢复成功。整个对照中，目标服务和地址保持不变，因此可以将结果归因于地址解析，而不是应用停止或缺少 TCP 放行规则。具体等待时间与报文数量受发现重试参数影响，所以示例检查失败状态和恢复结果，不把某一次执行时间规定成所有系统通用的超时。调整参数与清缓存都限定在实验环境内。

区分邻居发现、地址配置和身份验证

脚本使用静态 IPv6 地址，并在设置时关闭重复地址检测。它验证的是邻居解析，没有验证无状态地址自动配置、路由器通告处理或重复地址检测。这些功能需要各自的观测和策略审阅。通过这个小实验，不能证明生产网络的所有 ICMPv6 依赖都已经满足；RFC 4890 提供了更广泛运行环境中的过滤要求，配置策略时仍须结合实际角色。

通告携带一个 MAC 地址，也不应被当作经过认证的地址归属证明。协议中的本地链路检查限制了消息来源范围，却不会使同一链路上的每个节点都可信。诊断时记录接口、选中的下一跳、邻居状态、过滤规则及对应应用结果，才能把未解析邻居与无关服务故障区分开。解决控制层依赖之后，仍应通过实际应用请求确认通信已经恢复。

来源

RFC 4861 Neighbor Discovery，请求、通告、地址解析与可达性状态，已核验 2026-10-15。
Linux ip-neighbour(8)，查看与清理 IPv6 邻居条目，已核验 2026-10-15。
RFC 4890 ICMPv6 filtering，保留 IPv6 网络依赖的 ICMPv6 功能，已核验 2026-10-15。

双栈地址排序与最终成功的连接选择是不同步骤

Wed, 04 Nov 2026 00:00:00 +0000

发现 A 与 AAAA 记录，只提供可能的目的地，本身不会选出成功连接。地址排序、源地址选择、路由以及应用连接算法都会参与结果。RFC 6724 描述默认源地址和目的地址选择规则，应用仍可作自己的选择。如果程序只请求 IPv4，那么在任何双栈连接策略开始工作前，它就已经缩小了候选范围。解释行为时，应先确认实际调用方请求了什么。

坏掉的样子

地址偏好不是应用健康探测。某个 IPv6 目的地可能符合本地策略和路由条件，远端服务却已经停止，或者更后面的网络跳点会丢包，因此优先候选仍可能失败。如果假定操作系统已经测试了返回列表中每个端点，就会忽略连接截止时间和尝试其他地址的必要性。查询成功只能证明获得候选信息，不能代替服务通信结果。

RFC 6724 的规则是按顺序比较条件，并不是对网络成本或速度打一个总分。相关属性包括可用性、作用域、策略标签、优先顺序和匹配前缀，但它们不测量应用响应时间。目的地址选择还应与路由表最长前缀匹配区分：后者决定已选目的地的数据包如何发送。混用这两个阶段，会把主机偏好错误解释成已经知道整条路径延迟最低。

Happy Eyeballs 属于另一层，通过协调地址发现和错开连接尝试，减少某个地址族出问题时的等待。按顺序逐个尝试地址的客户端，并不自动实现该算法。立即拒绝连接与静默丢弃连接尝试，可能造成非常不同的等待时间，即使最后都能通过 IPv4 成功。不能只看最终用了另一个地址族，就把过程统称为相同的快速竞速机制。

快速验证

将脚本保存为 check-address-selection.py，准备 Docker 后执行 python3 check-address-selection.py。固定环境使用 glibc 2.36、Python 3.11，以及提供 DNS 的 BIND 9.18.49 和 dnsmasq 2.90。两个真实 HTTP 监听分别使用 IPv4 与 IPv6 回环，端口相同。实验没有公网路径，因此观察到的排序明确属于这个本地环境，不作为所有客户端的默认承诺：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import socket,threading
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=self.server.server_address[0].encode();self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
class V6Server(ThreadingHTTPServer):address_family=socket.AF_INET6
with lab('dual 30 IN A 127.0.0.1\ndual 30 IN AAAA ::1') as (_,update,cache,queries):
 cache(port=53)
 Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\noptions timeout:1 attempts:1\n')
 nss=Path('/etc/nsswitch.conf');nss.write_text(re.sub(r'^hosts:.*$','hosts: dns',nss.read_text(),flags=re.M))
 servers=[];threads=[]
 try:
 for server_class,address in [(ThreadingHTTPServer,'127.0.0.1'),(V6Server,'::1')]:
 server=server_class((address,0 if not servers else servers[0].server_port),Handler)
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start();servers.append(server);threads.append(thread)
 port=servers[0].server_port;v6=servers[1]
 def candidates(family=socket.AF_UNSPEC):return socket.getaddrinfo('dual.lab.test',port,family,socket.SOCK_STREAM)
 addresses=candidates();assert {r[0] for r in addresses}=={socket.AF_INET,socket.AF_INET6}
 assert addresses[0][0]==socket.AF_INET6
 assert {r[0] for r in candidates(socket.AF_INET)}=={socket.AF_INET}
 assert {r[0] for r in candidates(socket.AF_INET6)}=={socket.AF_INET6}
 def request():
 with socket.create_connection(('dual.lab.test',port),timeout=1) as stream:
 chosen={'family':stream.family.name,'peer':stream.getpeername()[0],'source':stream.getsockname()[0]}
 stream.sendall(b'GET / HTTP/1.0\r\nHost: dual.lab.test\r\n\r\n');data=b''
 while True:
 part=stream.recv(4096)
 if not part:break
 data+=part
 assert b' 200 ' in data.split(b'\r\n',1)[0] and data.endswith(chosen['peer'].encode());return chosen
 first=request();assert first['family']=='AF_INET6'
 v6.shutdown();v6.server_close();assert values(query('dual.lab.test.','AAAA'),'AAAA')==['::1']
 with socket.socket(socket.AF_INET6) as forced:
 forced.settimeout(1)
 try:forced.connect(('::1',port));raise AssertionError('closed IPv6 listener accepted a connection')
 except OSError as error:failure=type(error).__name__
 assert candidates()[0][0]==socket.AF_INET6
 second=request();assert second['family']=='AF_INET'
 print(json.dumps({'candidate_order':[{'family':socket.AddressFamily(r[0]).name,'address':r[4][0]} for r in addresses],
 'both_listeners_healthy':first,'forced_IPv6_after_stop':failure,'sequential_client_after_IPv6_stop':second,
 'AAAA_still_published':True},sort_keys=True))
 finally:
 for server in servers:server.shutdown();server.server_close()
 for thread in threads:thread.join(timeout=2)
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

对 dual.lab.test 使用 AF_UNSPEC 调用 getaddrinfo，同时得到 ::1 和 127.0.0.1，实测 IPv6 在前。分别限定 AF_INET 或 AF_INET6 后，只返回相应地址族。这些调用确定当前进程的真实候选列表，而不是假定两次独立 A 与 AAAA 查询的输出天然组成统一顺序。地址族参数本身，就是连接选择之前的重要输入条件。

两个监听都健康时，Python 的 socket.create_connection 连接到 ::1。程序记录选中对端和本地源地址，再发送真实 HTTP 请求，检查监听回显的身份。这样将候选偏好与成功连接关联，同时保留源地址、目的地址和应用响应三个不同观察。不能只根据 DNS 首项，就宣称已经证明流量实际通过了那个地址族。

随后停止并关闭 IPv6 监听。DNS 仍发布 ::1，getaddrinfo 也仍把 IPv6 放在第一项；强制 IPv6 连接得到 ConnectionRefusedError。正常 Python 连接助手却能通过 127.0.0.1 成功，收到 IPv4 监听响应。按序尝试可以到达后面的可用候选，并不要求 DNS 排序随服务故障改变。真正完成选择的是客户端的连接处理过程。

本地路径上的拒绝立即发生。实验没有制造黑洞，没有测量互联网回退延迟，也没有执行完整 Happy Eyeballs 实现。它证明的是：服务可用性变化时，本地地址偏好可以不变，连接算法必须把候选列表转化成最终成功或失败。对于静默丢包、多个候选和不同截止时间，仍需依据实际客户端另外测量，不能外推这里的等待表现。

修改全局策略前先检查真实调用方

确认应用给 getaddrinfo 的地址族和标志、运行时是否缓存结果，以及它如何尝试候选项。有些应用采用不同解析库，或自己实现连接竞速。命令行工具重现查询，只有在相关选择与失败进程一致时才具有直接可比性。尤其不能用一个主动竞速的浏览器成功，覆盖另一个按序等待的后台客户端所遇到的延迟问题。

把选中的源地址、目的地址、连接时间和错误一起观察。DNS 成功后连接被拒绝，与沿路超时的调查方向不同。按实际服务身份和协议验证每个公开地址族。IPv4 端点健康，不证明 IPv6 端点具有相同路由、访问规则、证书或应用配置。监控只检查其中一条路径时，很容易遗漏另一类用户正在遭遇的问题。

部署确实需要策略变化时，应有意识地实施，并验证真实调用方效果。RFC 6724 允许管理策略，但全局改变偏好不能代替修复已经发布却损坏的服务。同样，删除 AAAA 只改变未来发现，缓存记录和已有连接仍可能继续存在。端点调整应一起规划这些寿命，而不是把改一个优先级或删一条记录当作立即切断所有旧流量。

将排序视为当前主机和进程的证据，不是全部客户端的保证。完整诊断应说明候选集合、本地选择策略、实际连接尝试以及最终成功对端。分开这些阶段，才能解释双栈行为，而不虚构“第一项必然健康”或“每个客户端都会竞速两个地址族”的承诺。实际实现与观察到的请求路径，应共同决定对外描述的连接行为。

来源

RFC 6724 default address selection，源地址与目的地址选择规则以及策略覆盖，已核验 2026-09-12。
RFC 8305 Happy Eyeballs version 2，跨地址族错开启动连接尝试，已核验 2026-09-12。
Python 3.11 socket documentation，getaddrinfo 地址族与 create_connection 尝试行为，已核验 2026-09-12。

IPv6 · XB 现场笔记

AAAA 发布 IPv6 地址，不证明该地址可达

坏掉的样子

快速验证

沿每个已发布地址族检查服务

延伸阅读

来源

IPv6 路由器报告超大报文，由源端决定怎样适应路径

坏掉的样子

快速验证

推荐分片之前，先诊断大小与方向

来源

IPv6 文本规范化保留地址，端点上下文仍须另外处理

坏掉的样子

快速验证

存储文本前先确定比较契约

来源

IPv6 先用 ICMPv6 解析邻居，TCP 才能正常通信

坏掉的样子

快速验证

区分邻居发现、地址配置和身份验证

来源

双栈地址排序与最终成功的连接选择是不同步骤

坏掉的样子

快速验证

修改全局策略前先检查真实调用方

延伸阅读

来源