UDP · XB 现场笔记

UDP 保留数据报边界，恢复和时效由应用负责

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

UDP 在传输端点之间携带独立数据报，八字节首部包含来源端口、目的端口、长度和校验和字段。它不会加入 TCP 的可靠有序字节流或拥塞控制行为，让应用可以选择自己的交付策略，但不承诺所有负载下延迟都更低。应用确实需要某条内容时，丢失的数据报可能比建立连接的开销更昂贵，必须按完整请求过程评估。

坏掉的样子

发送成功不证明目标应用已经收到或处理消息。UDP 没有内建确认、重传、去重或顺序保证，因此超时不能告诉支付客户端操作是否发生。允许重试时，应用需要能够处理重复请求和结果不确定的协议，不能把没有响应直接解释成业务失败。消息是否到达、动作是否执行、结果是否持久化，也应具有不同含义。

即使本地路径健康，接收缓冲区也能制造失败。数据报大于本次调用提供的缓冲区时，内容可能截断，缺失后缀不会像字节流那样留给下一次读取。Linux 的 recvmsg 可以通过 MSG_TRUNC 报告这一情况。如果把缩短的字节当成完整命令或测量值，就可能在没有明显进程错误的情况下改变业务含义，因此必须检测协议要求的完整性。

UDP 没有内建拥塞控制，意味着应用承担责任，并不意味着可以无限制发送。需要根据部署选择发送节奏、拥塞行为、消息大小和截止时间。分片可能降低大数据报的交付稳健性，过了截止时间的数据也可能已经没有价值。QUIC 等协议能够在 UDP 之上提供可靠流，说明底层载体本身不能决定全部应用可靠性。

快速验证

将脚本保存为 check-udp.py，准备 Docker 后运行 python3 check-udp.py。固定 Python 3.11.16 Linux 容器没有外部网络路径和宿主端口发布。第一部分检查真实套接字接收语义；第二部分使用刻意编写的中继扣留、重复和重排消息，不声称测量自然发生的网络丢包。实验的每个故障输入都在代码中明确可见：

import json,subprocess,uuid
image="python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84"
program=r"""
import json,socket

with socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as sender,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as receiver:
 receiver.bind(('127.0.0.1',0));receiver.settimeout(.25);sender.settimeout(1);target=receiver.getsockname()
 sender.connect(target)
 for body in [b'A',b'BC',b'']:sender.send(body)
 boundaries=[receiver.recvfrom(16)[0] for _ in range(3)]
 assert boundaries==[b'A',b'BC',b'']
 sender.send(b'abcdefgh');data,ancillary,flags,peer=receiver.recvmsg(3)
 assert data==b'abc' and flags&socket.MSG_TRUNC
 try:receiver.recvfrom(16);raise AssertionError('truncated suffix survived')
 except TimeoutError:tail='discarded'
 sender.send(b'next');assert receiver.recvfrom(16)[0]==b'next'

 # A deliberate application relay changes delivery; this is not measured network loss.
 received=[];applied=[];seen=set();forwarded=[]
 with socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as relay,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as output:
 relay.bind(('127.0.0.1',0));relay.settimeout(1);output.settimeout(1)
 sender.connect(relay.getsockname())
 for seq in [1,2,3]:sender.send(str(seq).encode())
 inputs=[relay.recvfrom(16)[0] for _ in range(3)]
 for index in [2,0,0]:
 output.sendto(inputs[index],target);forwarded.append(int(inputs[index]))
 value=int(receiver.recvfrom(16)[0]);received.append(value)
 if value not in seen:seen.add(value);applied.append(value)
 assert received==[3,1,1] and applied==[3,1] and 2 not in seen
 try:receiver.recvfrom(16);raise AssertionError('missing message arrived by itself')
 except TimeoutError:no_retransmit=True
 print(json.dumps({'datagram_lengths':[len(x) for x in boundaries],'empty_datagram_is_message':boundaries[2]==b'',
 'short_buffer':data.decode(),'truncation_flag':bool(flags&socket.MSG_TRUNC),'unread_tail':tail,
 'relay_inputs':[int(x) for x in inputs],'relay_outputs':forwarded,'receiver':received,'deduplicated':applied,
 'missing_sequence':2,'no_automatic_retransmission_during_deadline':no_retransmit}))
"""
name='xbcatm-socket-'+uuid.uuid4().hex[:10]
try:
 result=subprocess.run(['docker','run','--rm','-i','--name',name,'--network','none',
 '--memory','128m','--pids-limit','64',image,'python3','-'],input=program,
 capture_output=True,text=True,timeout=60)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),ensure_ascii=False,sort_keys=True))
finally:
 subprocess.run(['docker','rm','-f',name],capture_output=True,text=True,timeout=10)

三次发送分别包含 A、BC 和空载荷，三次接收得到长度一、二和零。每次读取消费一条数据报，没有把相邻发送合并成字节流。空结果是合法零长度消息，不代表发送方关闭连接。发送套接字使用 UDP connect 选定对端，这个接口调用不会把 UDP 变成 TCP，也不会凭空增加确认和重传机制。

接着发送八字节 abcdefgh，接收方只提供三字节缓冲区，得到 abc 和 MSG_TRUNC。之后读取超时，没有拿到 defgh；再发送新的 next 数据报，接收方能够取得完整新消息。这个正向对照说明旧尾部已经被丢弃，而不是接收套接字在第一次调用后完全失效。截断与后续新消息属于不同数据报生命周期。

中继先收到序号一、二、三，再有意转发三、一、一，省略二。下游真实套接字收到这个选定序列。应用用一个小集合过滤重复值，最终执行序号三和一，却没有恢复原始顺序，也没有重建缺失消息。去重只解决其中一项问题，不能把它当成完整可靠传输或业务事务协议。所需语义必须逐项明确。

之后接收方等待下一条数据报，直到达到截止时间，UDP 没有自动重传序号二。这里缺失由中继制造，不能把结果写成某条网络的可靠性统计。它提供可复现的输入模式，用来观察应用面对传输契约没有排除的交付情况时如何反应。程序行为、故障注入与实际网络测量，需要在结果解释中保持区分。

有意识地补上所需语义

实时测量可能丢弃旧样本并显示最新序号，文件传输则需要恢复缺失内容。应用确认可以表示已经收到，也可以表示操作结果已经持久化，但含义必须由协议定义。对有副作用动作增加重试前，应明确标识符范围、重试截止时间、去重保留期和进程重启行为。本例没有实现这些更完整的事务机制，不能直接承担相应承诺。

同时规划接收能力和单条数据报大小，并把截断、应用发现的缺失与格式错误分别记录。增加套接字队列，无法修复单次接收缓冲区太小的问题；提高发送速率也可能加重拥塞，而不是改善信息新鲜度。应测量多少有用消息在截止时间前到达，而不只统计本地发送调用接受了多少字节。两种数字反映的结果不同。

当消息模型符合所建协议，且缺失的保证都有明确负责机制时，UDP 才是合理选择。以真实端到端时延、失败恢复和资源消耗判断性能，而不是仅凭省略握手就宣称更快。保留边界能简化部分解析，但完整数据报始终不到达、重复到达或到得太迟时，应用仍须具有定义清楚且经过验证的行为。

来源

RFC 768 User Datagram Protocol，UDP 首部与交付属性，已核验 2026-09-12。
RFC 8085 UDP usage guidelines，拥塞控制、消息大小及应用责任，已核验 2026-09-12。
Linux udp(7)，数据报接收、截断及已连接 UDP 套接字，已核验 2026-09-12。

EDNS 宣告 UDP 容量，不保证沿途网络交付

Wed, 28 Oct 2026 00:00:00 +0000

EDNS 通过 OPT 伪记录扩展 DNS，其中一项作用是让请求发送方宣告自己准备接收的 UDP 载荷大小，从而允许回答超过传统五百一十二字节 DNS 限制。这是 DNS 交换中的容量宣告，不是网络路径 MTU 发现协议，也不承诺所有中间设备都会交付相同大小的数据报。理解这一区别，才能准确解释大回答为何仍可能失败。

坏掉的样子

客户端宣告四千零九十六字节，不会强迫服务器发送同样大小的响应。服务器可以实施更小的发送上限；需要的回答放不下时，可以返回 TC，客户端仍需可工作的 TCP 路径。增加客户端数字，不能修复服务器有意采用较小预算的策略。应查看两端实际配置与返回内容，而不是把请求里出现的大数值当成双方已承诺一定使用的大小。

反过来，即使回答没有超过宣告容量，也可能在途中丢失。分片、隧道、包过滤和本地网络约束，与 DNS 参与者宣告的能力是不同因素。客户端若根本没有收到响应，也就可能看不到 TC 提示。载荷配置需要按互通性验证，不能当作越大越好的统一性能参数。一次超时无法仅凭宣告值就归因于某一台服务器或某个固定网络环节。

EDNS 还承载不能当作普通缓存记录解释的信息。OPT 是描述本次交换的伪记录，其字段编码载荷容量、版本、扩展响应码和标志；外形对应 TTL 的字段，并不是普通记录寿命。DNSSEC OK 标志 DO 用于请求相关 DNSSEC 数据，却不证明任何一方完成了验证。诊断工具若丢弃这些元信息，可能把不同故障简化成相同空回答。

快速验证

将脚本保存为 check-edns.py，准备 Docker 后执行 python3 check-edns.py。固定 BIND 9.18.49 权威运行在隔离回环网络，明确把 edns-udp-size 和 max-udp-size 都设为一千二百三十二。区域中分别准备四条和八条 TXT 的记录集，以便独立观察容量与截断。实验不依赖公网默认值，也不修改现有解析器的载荷策略：

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
import dns.flags
records='\n'.join(f'{name} 30 IN TXT "{i}-'+('x'*200)+'"' for name,count in [('medium',4),('large',8)] for i in range(count))
def ask(name,payload=None,version=0,flags=0):
 q=dns.message.make_query(name+'.lab.test.','TXT',use_edns=False)
 if payload is not None:q.use_edns(edns=version,ednsflags=flags,payload=payload)
 return dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
def description(response):return {'wire_bytes':len(response.to_wire()),'TC':bool(response.flags&dns.flags.TC),
 'rcode':dns.rcode.to_text(response.rcode()),'EDNS_version':response.edns,'advertised_payload':response.payload,
 'DO':bool(response.ednsflags&dns.flags.DO),'AD':bool(response.flags&dns.flags.AD),'answer_records':sum(len(rr) for rr in response.answer)}
with lab(records,extra='edns-udp-size 1232; max-udp-size 1232;') as (_,update,cache,queries):
 classic=ask('medium');extended=ask('medium',1232);capped=ask('large',4096);do=ask('medium',1232,flags=dns.flags.DO);version=ask('medium',1232,version=1)
 assert classic.flags&dns.flags.TC and len(classic.to_wire())<=512 and classic.edns==-1
 assert not extended.flags&dns.flags.TC and 512<len(extended.to_wire())<=1232 and len(values(extended,'TXT'))==4
 assert extended.edns==0 and extended.opt is not None
 assert capped.flags&dns.flags.TC and len(capped.to_wire())<=1232
 assert do.ednsflags&dns.flags.DO and not do.flags&dns.flags.AD
 assert not any(rr.rdtype==dns.rdatatype.RRSIG for rr in do.answer)
 assert version.rcode()==dns.rcode.BADVERS and version.edns==0
 full=dns.query.tcp(dns.message.make_query('large.lab.test.','TXT'),'127.0.0.1',port=1053,timeout=2)
 assert len(values(full,'TXT'))==8 and len(full.to_wire())>1232
 print(json.dumps({'without_EDNS':description(classic),'EDNS_1232':description(extended),'client_4096_server_1232':description(capped),
 'DO_on_unsigned_zone':description(do),'unsupported_version':description(version),'TCP_full':description(full)},sort_keys=True))
"""
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)

不使用 EDNS 时，中等集合查询得到四百六十三字节的截断回答，只包含两条 TXT；宣告一千二百三十二字节后，四条完整记录以九百零四字节返回，TC 清除。脚本检查记录数量、消息长度和 EDNS 存在，证明这个具体回答跨过传统限制，同时仍在所选 UDP 预算内。它不是只看查询成功，就假定完整集合已经到达。

对于更大集合，客户端宣告四千零九十六，但服务器仍限制在一千二百三十二。实测响应只有四十三字节，设置 TC，没有回答记录；随后 TCP 查询取得全部八条，共一千七百五十二字节。截断回答不一定填满允许的缓冲区，记录分组和响应构造可能产生很短的“还需要完整交换”信号。因此响应短也不能直接等同于完整数据很少。

程序还对这个未签名区域发出带 DO 的查询。回答保留 DO，却没有 RRSIG，也没有表示认证数据的 AD 标志。这符合预期：请求 DNSSEC 数据不会凭空产生签名或信任链。实验分别记录各标志，不把出现 DO 的交换称为验证成功。需要判断认证状态时，应检查实际验证路径，而不是只找到了某个听起来与安全有关的位。

最后，查询宣告 EDNS 版本一，服务器返回 BADVERS，并指示支持版本零。库从完整消息中解码扩展响应码。这个失败对照将不支持的扩展版本，与名称不存在或普通成功空回答区分开，也说明解释扩展相关错误时应保留 OPT。仅查看基础响应头的一部分，可能无法还原服务器真正表达的错误种类。

测量实际交换，不假定统一默认值

记录客户端真实宣告、服务器配置、响应大小、标志和传输方式。不同软件版本和运维策略可能采用不同载荷值，一千二百三十二或四千零九十六都不是标准保证的统一默认。本例的较小值是明确实验配置。回环结果没有测量分片、远端路径 MTU 或公共解析性能，不能把局部可交付性直接外推到所有客户端网络。

诊断大回答失败时，通过同一预期端点比较小查询、较大 EDNS 查询和完整 TCP 查询。区分错误类别：TC 表示还需取得完整数据，BADVERS 表示扩展版本不一致，超时则不能直接指出哪一环丢包。保留足够响应信息，避免把这些不同故障压成“DNS 挂了”。只有分类准确，下一步检查的配置和网络路径才有明确对象。

使用部署实现支持的大小与重试策略，再从重要客户端网络验证。即使大多数观察到的回答都能放入 UDP，也应保留 TCP 访问。EDNS 改善扩展能力，并可能减少部分截断重试，但完整交付仍依赖传输行为、服务器限制和客户端对实际回答的处理。选择值之后，应通过真实结果确认效果，而不是只以配置项存在作为完成依据。

来源

RFC 6891 extension mechanisms for DNS，OPT、载荷容量宣告、扩展错误与 EDNS 版本处理，已核验 2026-09-12。
RFC 7766 DNS over TCP，TCP 仍然是必需的 DNS 传输方式，已核验 2026-09-12。
BIND 9.18.49 reference，edns-udp-size 与 max-udp-size 配置，已核验 2026-09-12。

UDP · XB 现场笔记

UDP 保留数据报边界，恢复和时效由应用负责

坏掉的样子

快速验证

有意识地补上所需语义

来源

EDNS 宣告 UDP 容量，不保证沿途网络交付

坏掉的样子

快速验证

测量实际交换，不假定统一默认值

延伸阅读

来源