IP · XB 现场笔记

默认路由匹配最宽范围，不会挽救所有失败路径

Tue, 14 Sep 2027 00:00:00 +0000

IPv4 默认路由是前缀 0.0.0.0/0，匹配所有 IPv4 目的地，但具体程度最低。在已经选择的路由表中，更长的匹配前缀通常优先。默认路由不是一个“其他具体路径失败后再重试”的过程。路由策略决定相关表，最终路由描述怎样转发，而不保证完整往返一定成功。匹配范围与路径健康是两类不同属性。

坏掉的样子

没有默认路由的机器，仍能访问直连或明确路由覆盖的目的地；反过来，添加默认路由也不证明能够访问互联网。下一跳需要可达，转发与过滤要允许流量，回复还需要返回路径。显示一个网关，只满足契约的一部分。真正配置是否共同工作，应由实际应用通信证明，而不是从路由文件中有一行 default 就推导全部能力。

更具体的拒绝路由会胜过可工作的默认路由。Linux 的 unreachable 等路由类型，会有意停止匹配目的地的转发。选定网关的邻居查询失败，也不意味着内核自动寻找更健康、却更宽泛的路径。静态路由优先级和 metric 不是服务健康监控或自动故障转移机制，不能把配置顺序当成逐个尝试可用出口的流程。

返回路径错误尤其容易误导。客户端选中预期网关并把流量送往监听中的服务器，服务器却可能无法把回复路由回客户端。反复修改客户端默认路由，可能破坏其他正常目的地，却没有修复缺失的反向路径。将所有连接超时归因于发送方网关之前，应查看两个方向和真实源地址。请求能到与响应能回，需要分别成立。

快速验证

将脚本保存为 check-default-route.py，准备 Docker 后运行 python3 check-default-route.py。Python 3.11.16 和 iproute2 6.1.0 在一次性 Linux 容器内建立客户端、路由器、目标拓扑。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 routed(setting):
 wire('client','c0','router','r0',['10.201.1.2/30'],['10.201.1.1/30'])
 wire('router','r1','target','t0',['10.201.2.1/30'],['10.201.2.2/30'])
 setting('router','net.ipv4.ip_forward',1)
 ip('client','route','add','default','via','10.201.1.1')
 ip('target','route','add','default','via','10.201.2.1')
with lab(['client','router','target']) as (root,stack,setting):
 routed(setting);ip('client','route','delete','default')
 ip('target','addr','add','198.51.100.9/32','dev','lo');ip('router','route','add','198.51.100.9/32','via','10.201.2.2')
 daemon=server(stack,'target','198.51.100.9')
 connected=ns('client','ping','-n','-c','1','-W','1','10.201.1.1');assert connected.returncode==0
 missing=request('client','198.51.100.9');assert not missing['ok'] and missing['errno']==101
 ip('client','route','add','default','via','10.201.1.1')
 chosen=json.loads(ip('client','-j','route','get','198.51.100.9').stdout)[0];assert chosen['gateway']=='10.201.1.1'
 healthy=request('client','198.51.100.9');assert healthy['ok']
 ip('client','route','add','unreachable','198.51.100.9/32')
 specific=request('client','198.51.100.9');assert not specific['ok'] and specific['errno']==113
 ip('client','route','delete','unreachable','198.51.100.9/32')
 recovered=request('client','198.51.100.9');assert recovered['ok']
 ip('target','route','delete','default')
 bad_return=request('client','198.51.100.9');assert not bad_return['ok'] and bad_return['type']=='TimeoutError'
 assert json.loads(ip('client','-j','route','get','198.51.100.9').stdout)[0]['gateway']=='10.201.1.1'
 ip('target','route','add','default','via','10.201.2.1')
 final=request('client','198.51.100.9');assert final['ok']
 print(json.dumps({'connected_ping_without_default':0,'no_default':missing,'chosen_route':chosen,'with_default':healthy,
 'specific_unreachable_route':specific,'specific_removed':recovered,'missing_return_route':bad_return,'return_route_restored':final}))
"""
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)

客户端使用 10.201.1.2，路由邻居为 10.201.1.1。目标位于路由器后的另一条链路，在回环接口拥有服务地址 198.51.100.9。路由器有到该服务的具体路由，目标起初具有返回默认路由。文档保留地址仅用于隔离拓扑，没有联系公网服务器。每项地址和下一跳都在脚本中明确配置，避免依赖宿主偶然存在的路由。

删除客户端默认路由后，ping 直连路由邻居仍成功，而连接远端 HTTP 服务得到 Linux ENETUNREACH，错误号一百零一。添加经 10.201.1.1 的默认路由后，查询选择该网关，真实 HTTP 请求返回状态二百。这同时说明原先已经存在的较窄连接能力，以及默认路由新增的路径，不能把“没有默认路由”统称为完全没有网络。

随后为 198.51.100.9 安装 unreachable /32 路由。默认路由仍在，相同连接却得到 EHOSTUNREACH，错误号一百一十三。删除具体路由后，HTTP 恢复。内核遵守更具体的拒绝指令，没有把错误当成改走默认网关的理由。这个对照直接纠正了“先尝试具体路由，失败再尝试默认”的错误理解。

接着脚本只移除目标服务器的默认路由。客户端查询仍指向 10.201.1.1，新 HTTP 请求却等待到超时；恢复目标默认路由后通信恢复。受控比较在客户端选择不变时隔离了返回路径依赖，比单侧路由列表或一次原因不明的 ping 失败更有说服力。修复对象由被改变的条件和恢复结果共同确定。

编辑默认路由前检查具体流量

记录源地址、目的地、相关策略规则、选中接口和网关。多接口或多路由表机器，可能根据来源、标记或路由域作出不同决策。诊断查询应采用应用相关输入。本例使用普通按目的地选路，没有声称重现每一种策略路由或多路径配置。命令输出只有连同查询条件一起保存，才适合与真实故障进行比较。

检查下一跳链路可达性、路由器转发决策，以及目标到真实来源的返回路由。NAT 或代理可能改变目标所看到的源地址。错误类型也能辅助定位：立即发生的本地网络不可达、明确主机拒绝路由，以及等待回复直至截止时间，是不同情况。事件证据应保留这些区别，避免把具有不同修复方式的现象压成同一个“网络不通”。

默认路由的价值，是概括主机无须逐一掌握的目的地。应有意配置它，验证例外，并在变更后测试代表性的完整往返。如果要求自动故障转移，需要有机制观察相关路径并适当更新路由。第二个网关条目或更优 metric 本身，不能证明已经具有这种行为。配置能够表达偏好，健康判断和动态切换还需要对应实现与证据。

来源

Linux ip-route(8)，默认路由、选路查询与 unreachable 路由类型，已核验 2026-09-12。
RFC 4632 CIDR，最长前缀匹配与具体路由优先，已核验 2026-09-12。
RFC 1812 IPv4 router requirements，IPv4 转发与目的地可达性，已核验 2026-09-12。

子网前缀影响直连路由，最终路径由路由表选择

Mon, 13 Sep 2027 00:00:00 +0000

IPv4 前缀长度表示地址中有多少前导位标识网络。对于 192.0.2.5/24，网段是 192.0.2.0/24，普通广播地址是 192.0.2.255。配置接口通常会建立相应直连路由，但前缀不是完整路由算法。内核还要依据路由策略与路由表，为具体目的地选择路径，不能只看地址是否位于某个网段就推断全部行为。

坏掉的样子

前缀太短，会让主机把原本远端的目的地当成直接相连。保留地址 192.0.2.5，却把 /24 改成 /16，就把 192.0.3.9 纳入直连范围。在真实以太网中，这种错误可能让主机尝试解析一个根本不在当前链路上的邻居。于是地址看起来正确，下一跳决策却已经改变；反复核对地址字符串本身无法发现问题。

“不在自己的子网就走默认网关”也不完整。更具体的路由可以选择其他网关或接口；在已经选择的路由表内，更长的匹配前缀优先。明确的主机路由甚至可以覆盖本来位于接口子网内的目的地。应检查实际查询结果，而不是仅凭接口地址重新猜测内核会怎么做。默认路由只处理没有更具体匹配的相应流量。

地址数量计算也需要上下文。普通 /24 的网络地址与定向广播地址通常不用于主机分配，但“减二”不是统一公式。RFC 3021 允许点到点 /31 链路的两个地址都用作端点，/32 则标识单个地址。这些规则解释地址语义，没有证明配置中的两端能够通过当前物理拓扑交换数据。可用地址集合和实际通信仍须区分。

快速验证

将脚本保存为 check-subnet.py，准备 Docker 后执行 python3 check-subnet.py。程序给固定 Python 镜像安装 iproute2 6.1.0，再只向一次性容器授予 NET_ADMIN；容器没有外部网络接入。脚本创建虚拟 dummy 接口并修改该容器的路由，不改变宿主接口、路由或生产网关。构建下载与运行时路由实验也处于不同阶段：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid

recipe='''FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84
RUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 && rm -rf /var/lib/apt/lists/*
'''
program=r'''
from ipaddress import IPv4Address,IPv4Interface,IPv4Network
import json,subprocess
def ip(*args):
 result=subprocess.run(['ip',*args],capture_output=True,text=True,timeout=3)
 assert result.returncode==0,result.stderr
 return result.stdout
def route(address):return json.loads(ip('-j','route','get',address))[0]
interface=IPv4Interface('192.0.2.5/24');network=interface.network
assert str(network.network_address)=='192.0.2.0' and str(network.broadcast_address)=='192.0.2.255'
assert IPv4Address('192.0.2.77') in network and IPv4Address('192.0.3.9') not in network
try:IPv4Network('192.0.2.5/24');raise AssertionError('host bits accepted in strict network')
except ValueError:strict_rejected=True
point_to_point=[str(a) for a in IPv4Network('192.0.2.0/31').hosts()]
assert point_to_point==['192.0.2.0','192.0.2.1']
ip('link','add','lab0','type','dummy');ip('link','set','lab0','up')
ip('address','add','192.0.2.5/24','dev','lab0');ip('route','add','default','via','192.0.2.1','dev','lab0')
ip('route','add','203.0.113.0/24','via','192.0.2.2','dev','lab0')
direct=route('192.0.2.77');specific=route('203.0.113.9');default=route('198.51.100.9');before=route('192.0.3.9')
assert direct['dev']=='lab0' and 'gateway' not in direct
assert specific['gateway']=='192.0.2.2' and default['gateway']==before['gateway']=='192.0.2.1'
ip('route','add','192.0.2.77/32','via','192.0.2.1','dev','lab0');overridden=route('192.0.2.77')
assert overridden['gateway']=='192.0.2.1'
ip('address','del','192.0.2.5/24','dev','lab0');ip('address','add','192.0.2.5/16','dev','lab0')
ip('route','replace','default','via','192.0.2.1','dev','lab0');wrong=route('192.0.3.9')
assert wrong['dev']=='lab0' and 'gateway' not in wrong
print(json.dumps({'interface':str(interface),'network':str(network),'broadcast':str(network.broadcast_address),
 'strict_host_bits_rejected':strict_rejected,'point_to_point_31_hosts':point_to_point,
 'connected':direct,'more_specific_route':specific,'default':default,'host_route_overrides_subnet':overridden,
 'destination_before_widening':before,'destination_after_wrong_16':wrong,'iproute_version':ip('-V').strip()}))
'''
name='xbcatm-subnet-'+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',
 '--memory','128m','--pids-limit','64',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)

Python 区分接口 192.0.2.5/24 与其网段 192.0.2.0/24。严格网络解析拒绝前者，因为主机位非零；/31 示例则列出 192.0.2.0 和 192.0.2.1 两个可用端点。这个计算确认地址集合，实验没有配置可工作的点到点链路，也没有测试这两个地址之间的转发。不能把库返回两个值，写成真实链路已经验证成功。

dummy 接口配置 192.0.2.5/24，默认路由经过 192.0.2.1；203.0.113.0/24 的具体路由经过 192.0.2.2。真实 ip route get 对 192.0.2.77 不选择网关，对 203.0.113.9 选择后者，对 198.51.100.9 选择默认网关。输出同时记录接口和首选源地址，让下一跳选择可以与本机发送身份一起检查。

添加经过 192.0.2.1 的 192.0.2.77/32 路由后，目标虽然仍属于直连 /24，查询却转而选择网关。这一受控覆盖说明子网归属与最终路由决策必须分开。选中的路由表对这个单独地址具有更具体指令，并不需要为了表达例外而更换接口地址。直接把“同网段”当成永远不经网关，会遗漏这种合法配置。

扩大前缀前，192.0.3.9 使用默认网关；保留 192.0.2.5、将 /24 替换为 /16 后，查询直接选择 dummy 接口，不再包含网关。脚本断言真实内核决策发生改变，没有声称成功交付数据、观察到 ARP 失败，或者虚拟接口之外存在可工作的路由器。实验验证选择逻辑，链路通信需要另外的环境和证据。

修改掩码前先检查真实路由

检查生效的地址与前缀、相关策略规则，以及失败目的地的路由查询。多接口系统重现路径时，还应包含预期源地址和其他策略输入。存在来源路由、标记或不同路由域时，仅按目的地查询可能不同于应用实际路径。应保留诊断上下文，不能拿另一个进程或另一种来源条件下的结果覆盖真实调用方。

在以太网中，区分解析目标自身的链路地址，还是解析选中网关的链路地址。网关需要符合配置的链路和路由规则，路由文件里出现一个看起来合理的数字还不够。确认选路之后，再比较邻居状态与真实报文交付。显示下一跳只说明计划怎样发送，不能证明下一跳已经收到、转发或允许该应用流量。

规划前缀变更时，应一起检查它将创建或移除的直连路由及受影响目的地。变更后验证代表性的本地、具体路由和默认路由流量。掩码是路由与地址解释的一项输入，不是独立可达性承诺。这个区别既能解释意外扩大链路范围，也能解释更具体路由有意建立的例外，而不把正常路径选择误判成地址配置错误。

来源

RFC 4632 CIDR，无类别前缀与最长匹配转发，已核验 2026-09-12。
RFC 3021 point-to-point /31 links，点到点 /31 链路两端地址的使用，已核验 2026-09-12。
Linux ip-route(8)，路由查询、下一跳及明确主机路由，已核验 2026-09-12。
Python 3.11 ipaddress，接口、网段及主机地址的区分，已核验 2026-09-12。

DHCP 只把地址租给你

Tue, 07 Sep 2027 00:00:00 +0000

DHCPv4 的动态分配把地址借给客户端一段租期。续租可以延长期限，到期则允许地址再次分配。DHCP 也支持其他分配策略，所以本文讨论的是有限期的动态租约，不把它说成协议唯一能够提供的配置。租期是使用地址的约定，不是设备对地址的永久所有权，也不是证明设备身份的凭据。

借用而非拥有地址

新初始化的客户端发现服务器、选择一份报价，再请求配置。确认后的租约记录允许使用地址的时间。租约数据库可以追踪分配，但不能保证所有机器都遵守协议：未受管理的静态地址、重叠地址池、服务器状态丢失或非法服务器，仍可能制造冲突。不能因为有集中租约表，就假定服务器永远知道整张网络里所有真实占用情况。

续约让租约保持存活

有限租期内，客户端通常在 T1 向原服务器请求续租；若到 T2 还没收到确认，则广播重绑请求，让其他合适的服务器也有机会回答。默认值分别是租期的一半与八分之七，服务器可以提供其他合法定时值。RFC 2131 建议在固定值附近加入随机变化，以减少客户端同步请求。因此默认比例不是必须原样保留的性能调优命令。

确认后的到期时刻按续租请求发送时间加上获准的新租期计算；后续 T1 和 T2 也应按更新后的租约计算，而不是继续沿最初入网时刻推进。续租通常保留地址，却不能保证设备在重启、换网或策略改变后永远得到同一地址。短租期让离场地址较快回收，也增加续租流量；长租期给客户端更多时间应对服务中断，却让已经离场的设备占用地址池更久。固定身份需求应明确配置分配策略。

过期即可回收

客户端可以主动释放地址，但正确运行不能依赖每台离场设备都发送 RELEASE。租约过期后，客户端必须停止使用地址并重新获取配置；服务器也可以重新分配这个地址。设备回来时可能拿到原地址，也可能获得不同地址，不能把换号写成必然结果。管理端删除绑定不会撤回客户端已经获得的租期，因此不能用盲目清空租约来代替冲突调查，否则可能主动制造重复分配。

坏掉的样子

地址池耗尽时，新发现请求可能收不到报价。NAK 则有特定含义，例如拒绝不适合当前网络的请求地址，不能把它统一解释成“地址池已满”。部分客户端在 DHCP 失败后配置 IPv4 链路本地地址，但这是另一种行为，也不能单凭它推断失败原因。先检查池容量、转发路径与服务器日志，再决定是否扩容或调整重试，避免把网络丢包当成地址不足。

租期过短会增加续租负载，并缩短客户端能够容忍服务器中断的时间。集中开机可能让流量聚集，却不意味着整个网络必然同步续租。应核对服务器实际下发的定时值和客户端重试方式，而不是只看名义租期。给新租约调长时间，也不会追溯性地延长之前已经确认的旧租约，观察窗口需要覆盖这部分过渡。

非法服务器可以给出错误网关或解析器。选择第一个报价只是客户端的一种可能策略，并非协议强制规定。服务器标识选项没有提供密码学认证，攻击者可以伪造；单独记住一个标识，并不能建立信任。交换机 DHCP snooping 等网络控制需要正确配置受信任端口和转发路径，才能限制回答来自哪里，不能用调短或调长定时器代替这个边界。

睡眠和计时处理可能暴露旧配置。设备醒来时若租约已经过期，必须先重新获取配置，不能继续占用地址，也不能假定自己只是进入 T2 重绑阶段。排查要结合租约已经经过的时间和实现日志；墙上时钟同步本身不能证明定时逻辑正确。地址冲突检测和 DECLINE 处理是另外的保障，不能因为租约表看起来正常就省略它们。

快速验证

把代码保存为 dhcp_lease_sim.py，运行 python3 dhcp_lease_sim.py。它只用标准库，通过虚拟时钟和简化的内存服务器检查租期算术与地址归属。单播和广播只是场景标签，没有发送网络报文，也没有实现完整客户端状态机。这里假定请求与确认瞬间完成，T2 取整秒；实际系统应读取服务器给出的值，不能把示例常量当作所有网络的固定设置。

"""Simulate a DHCP lease lifecycle on a virtual clock (stdlib only)."""
from __future__ import annotations

LEASE_TIME = 100
T1 = LEASE_TIME // 2 # 50: unicast renewal (RFC 2131 default)
T2 = int(LEASE_TIME * 0.875) # 87: broadcast rebinding (RFC 2131 default)


class DHCPServer:
 def __init__(self, pool):
 self.pool = list(pool)
 self.leases: dict[str, dict] = {} # ip -> {"client": id, "expiry": int}
 self.now = 0

 def _free_ip(self):
 for ip in self.pool:
 lease = self.leases.get(ip)
 if lease is None or lease["expiry"] <= self.now:
 return ip
 return None

 def discover_offer(self, client_id):
 """DISCOVER -> OFFER (no state change)."""
 ip = self._free_ip()
 assert ip is not None, f"t={self.now}: pool exhausted, no OFFER for {client_id}"
 return ip

 def request_ack(self, client_id, ip):
 """REQUEST -> ACK and bind the lease."""
 assert ip in self.pool, "requested address outside pool"
 lease = self.leases.get(ip)
 assert lease is None or lease["expiry"] <= self.now or lease["client"] == client_id, \
 f"t={self.now}: {ip} held by another client"
 self.leases[ip] = {"client": client_id, "expiry": self.now + LEASE_TIME}
 return {"ip": ip, "lease_time": LEASE_TIME, "t1": T1, "t2": T2,
 "expiry": self.now + LEASE_TIME}

 def renew(self, client_id, ip):
 """Extend a current lease; transport and client states are not modeled."""
 lease = self.leases.get(ip)
 if lease is None or lease["client"] != client_id or lease["expiry"] <= self.now:
 return False # expired: server already reclaimed
 lease["expiry"] = self.now + LEASE_TIME
 return True

 def tick(self, dt):
 self.now += dt
 # Reclaim expired leases so a new client can reuse them.
 for ip, lease in list(self.leases.items()):
 if lease["expiry"] <= self.now:
 del self.leases[ip]


def check(cond, msg):
 assert cond, msg


def main():
 server = DHCPServer(["192.168.1.10", "192.168.1.11"])
 # 1. DORA: client c1 joins.
 offered = server.discover_offer("c1")
 check(offered == "192.168.1.10", f"expected first free IP, got {offered}")
 ack = server.request_ack("c1", offered)
 check((ack["lease_time"], ack["t1"], ack["t2"]) == (100, 50, 87), f"bad timers: {ack}")
 check(ack["expiry"] == 100, f"expiry should be 0+100, got {ack['expiry']}")
 print(f"t={server.now}: c1 ACK {ack['ip']} lease=100 T1=50 T2=87 expiry=100")
 # 2. T1 unicast renewal at half lease.
 server.tick(T1) # now=50
 check(server.renew("c1", offered), "T1 renewal should be ACKed")
 check(server.leases[offered]["expiry"] == 150, "T1 must extend expiry to 50+100")
 print(f"t={server.now}: c1 T1 unicast renew OK expiry=150")
 # 3. Miss T1, rebind at T2 via broadcast.
 server.tick(T1) # now=100: renewed T1; pretend this attempt got no ACK
 server.tick(T2 - T1) # now=137: renewed T2, before expiry 150
 check(server.now == 50 + T2, "rebind must use renewed lease origin")
 check(server.renew("c1", offered), "T2 rebinding should be ACKed")
 check(server.leases[offered]["expiry"] == 237, "T2 must extend expiry to 137+100")
 print(f"t={server.now}: c1 T2 broadcast rebind OK expiry=237")
 # 4. Leave without renewing: expiry reclaims the address.
 server.tick(200) # now=337 > expiry 237
 check(offered not in server.leases, "expired lease must be reclaimed")
 offered2 = server.discover_offer("c2")
 check(offered2 == offered, f"reclaimed {offered} should be reused, got {offered2}")
 ack2 = server.request_ack("c2", offered2)
 check(ack2["expiry"] == server.now + LEASE_TIME, "new lease expiry must restart")
 # Stale renewal from the departed client must fail.
 check(not server.renew("c1", offered), "stale renewal after expiry must not be ACKed")
 print(f"t={server.now}: c1 expired, c2 ACK {ack2['ip']} expiry={ack2['expiry']}")
 print("PASS: discover/offer/request/ack, T1 renew, T2 rebind, expiry reclaim")


if __name__ == "__main__":
 main()

程序断言：服务器给出第一个空闲地址，ACK 携带 100 秒租期且 T1 为 50、T2 为 87，每次续约都从续约时刻重新计算完整租期，离场地址被回收并转租给第二个客户端，而旧客户端的过期续约会被拒绝。运行成功会看到四行带时间戳的日志，外加一行说明四个阶段都通过的 PASS。

旧版曾记录 macOS、Python 3.12 断言通过，但把时刻 107 的请求误标为 T2，此时续租后的 T2 应为 137。修正后在 Python 3.12.14 运行通过：日志时刻为 0、50、137、337，重绑后的到期时刻为 237。这验证算术修正，不替代真实服务器的报文、地址池和客户端到期行为检查。

来源

IETF：RFC 2131 DHCP，租约生命周期的权威定义：DISCOVER、OFFER、REQUEST、ACK 与 T1、T2 续约定时器，已核验 2027-08-15。
ISC：ISC DHCP，地址池管理、租约数据库与服务器运行说明，已核验 2027-08-15。
维基百科：动态主机配置协议，租约生命周期的通俗总览，已核验 2027-08-15。

IP · XB 现场笔记

默认路由匹配最宽范围，不会挽救所有失败路径

坏掉的样子

快速验证

编辑默认路由前检查具体流量

来源

子网前缀影响直连路由，最终路径由路由表选择

坏掉的样子

快速验证

修改掩码前先检查真实路由

来源

DHCP 只把地址租给你

借用而非拥有地址

续约让租约保持存活

过期即可回收

坏掉的样子

快速验证

延伸阅读

来源