简介:这份资源是北京邮电大学大二下学期计算机网络课程设计的DNS服务器实验压缩包,面向正在学习计网、需要完成课程设计或希望深入理解域名系统原理的本科生。实验围绕DNS的层次结构、A记录与AAAA记录等常见记录类型、递归与迭代查询流程、权威服务器与缓存服务器分工,以及基于UDP 53端口的DNS协议通信展开,要求用C语言实现查询解析与中继转发逻辑。包内共4个文件,包含2个txt文本、1个h头文件和1个c源文件,压缩包约9KB,其中源文件与头文件承载核心代码框架,文本文件则用于存放DNS中继配置与域名映射数据。目前已有166人学习下载。通过该实验,读者可掌握套接字编程、DNS报文格式解析与服务器配置方法,并借助dig或nslookup等工具验证解析正确性,是理解互联网域名解析机制、提升网络编程能力的一份完整实践材料。
1. 从零手写一个 DNS 服务器:BUPT 大二下计网课设到底在考什么
如果你在 BUPT 读大二下,看到「计网课程设计」这几个字,大概率会先愣一下——这学期刚学完 TCP/IP 分层、IP 编址、路由算法,课本翻到最后一章 DNS 也就两页纸,结果课设直接让你实现一个 DNS 服务器。很多同学第一反应是去搜「计网课程设计案例源码」,想找个现成的交差,但真到验收的时候老师随口一问「迭代查询和递归查询区别在哪」「为什么 DNS 主要跑在 UDP 上」,答不上来照样翻车。
这个实验的核心不是让你写一个能解析 www.baidu.com 的玩具,而是逼你把 DNS 协议从报文格式到查询流程完整走一遍。你需要理解域名是怎么被切成分层结构的、资源记录有哪几种类型、客户端和服务器之间那几十个字节的报文到底长什么样。做完之后你会发现,平时浏览器里毫秒级完成的域名解析,背后是一套设计得极其精巧的分布式数据库系统。
这篇文章面向三类人:正在做这个课设但不知道从哪下手的同学、想提前预习 DNS 协议的学弟学妹、以及工作中需要排查 DNS 问题但没系统学过协议本身的工程师。我会从报文格式讲起,一步步带你用 Python 实现一个能响应标准 dig 查询的 DNS 服务器,包括 UDP 和 TCP 两种传输方式、A 记录和 CNAME 记录的解析、以及本地缓存和上游转发。全程可复现,代码直接能跑。
2. DNS 报文格式拆解:12 字节头部和三种字段编码
2.1 为什么 DNS 报文设计成这个样子
DNS 报文是二进制格式,不是文本协议。这一点和 HTTP 完全不同,也是很多人第一次抓包看不懂的原因。整个报文由头部(Header)和四个可变长区域组成:Question、Answer、Authority、Additional。头部固定 12 字节,后面每个区域的格式取决于具体的记录类型。
先看头部这 12 个字节,它被分成 6 个字段,每个字段 2 字节:
| 字段名 | 长度 | 含义 |
|---|---|---|
| Transaction ID | 2 字节 | 事务 ID,客户端生成,服务器原样返回,用来匹配请求和响应 |
| Flags | 2 字节 | 标志位,包含 QR、Opcode、AA、TC、RD、RA、RCODE 等 |
| QDCOUNT | 2 字节 | Question 区域的记录数,通常为 1 |
| ANCOUNT | 2 字节 | Answer 区域的记录数 |
| NSCOUNT | 2 字节 | Authority 区域的记录数 |
| ARCOUNT | 2 字节 | Additional 区域的记录数 |
Flags 字段是理解 DNS 行为的关键。它 16 个 bit 从高到低依次是:QR(1 bit,0 表示查询,1 表示响应)、Opcode(4 bit,0 表示标准查询)、AA(1 bit,权威应答)、TC(1 bit,截断标志)、RD(1 bit,期望递归)、RA(1 bit,递归可用)、Z(3 bit,保留)、RCODE(4 bit,响应码,0 表示无错误,3 表示域名不存在)。
我一般会建议先把这个表格背下来,因为后面写代码解析报文时,每一个 bit 都要手动处理。Python 的 struct 模块可以帮你做字节和整数之间的转换,但位运算还是得自己写。
2.2 域名的编码方式:标签序列
DNS 报文里域名不是用点号分隔的字符串直接存的,而是用一种叫「标签序列」的编码。比如 www.example.com 会被编码成:
3www7example3com0
每个标签前面加一个字节表示长度,最后用 0 字节结尾。这样设计的好处是解析时不需要扫描整个字符串找点号,直接按长度跳转就行。同时它还支持压缩指针——如果报文中某个域名和前面出现过的域名有相同的后缀,可以用 0xC0 开头的两字节指针指向前面出现的位置,避免重复存储。
写代码时编码函数大概长这样:
def encode_domain(domain):
"""将域名编码为 DNS 标签序列格式"""
parts = domain.strip('.').split('.')
result = b''
for part in parts:
# 每个标签前加一个字节表示长度
result += bytes([len(part)]) + part.encode('ascii')
# 最后加一个 0 字节表示根域名
result += b'\x00'
return result
这个函数把 www.example.com 转成 \x03www\x07example\x03com\x00 。注意长度字节最大只能是 63,因为标签长度用 6 个 bit 表示,这也是为什么单个域名标签不能超过 63 个字符。整个域名的总长度不能超过 255 字节,这是协议硬性限制。
解码函数要处理压缩指针的情况,稍微复杂一点:
def decode_domain(data, offset):
"""从报文中解码域名,返回(域名, 新偏移量)"""
labels = []
original_offset = offset
jumped = False
while True:
length = data[offset]
if length == 0:
offset += 1
break
# 高两位为 11 表示压缩指针
if (length & 0xC0) == 0xC0:
if not jumped:
original_offset = offset + 2
pointer = ((length & 0x3F) << 8) | data[offset + 1]
offset = pointer
jumped = True
else:
offset += 1
labels.append(data[offset:offset + length].decode('ascii'))
offset += length
return '.'.join(labels), (original_offset if jumped else offset)
这里有个容易踩的坑:压缩指针可能指向的位置本身又包含压缩指针,所以要用循环处理。另外记录原始偏移量是为了返回正确的下一个字段位置,不然解析完域名后偏移量就乱了。
2.3 资源记录的四种类型和 RDATA 格式
Answer、Authority、Additional 三个区域里放的都是资源记录(Resource Record),格式统一为:NAME、TYPE、CLASS、TTL、RDLENGTH、RDATA。NAME 是域名(可能带压缩指针),TYPE 是记录类型(A=1,NS=2,CNAME=5,SOA=6,AAAA=28 等),CLASS 通常为 1 表示 IN(Internet),TTL 是缓存存活时间(秒),RDLENGTH 是 RDATA 的长度,RDATA 是具体数据。
A 记录的 RDATA 是 4 字节 IPv4 地址,直接存二进制。CNAME 记录的 RDATA 是一个域名,需要用前面说的标签序列编码。NS 记录的 RDATA 也是域名。SOA 记录比较复杂,包含主域名服务器、管理员邮箱、序列号、刷新间隔、重试间隔、过期时间、最小 TTL 七个字段。
写响应报文时,我一般会先构造一个空的 Answer 列表,然后根据查询类型填充。比如查询 A 记录,就构造一条 TYPE=1 的记录;查询 CNAME,就构造 TYPE=5 的记录。RDLENGTH 要根据 RDATA 的实际长度填写,这个字段错了整个报文就废了。
注意:TTL 字段是 4 字节无符号整数,单位是秒。课设里如果做本地缓存,TTL 决定了缓存条目多久过期。实际生产环境中 TTL 通常设 300 到 86400 秒,但课设里设 60 秒方便测试。
3. 用 Python 实现 UDP 查询响应:从 socket 到 dig 验证
3.1 最小可运行服务器的骨架
DNS 主要跑在 UDP 上,端口 53。为什么用 UDP 而不是 TCP?因为 DNS 查询通常很小,一个报文就能装下,UDP 无连接的特性省去了三次握手开销,速度快。当然域名响应超过 512 字节时会截断,这时候客户端会用 TCP 重试,这是后话。
先搭一个最小的 UDP 服务器骨架:
import socket
import struct
def parse_header(data):
"""解析 DNS 报文头部,返回字典"""
tid, flags, qd, an, ns, ar = struct.unpack('!HHHHHH', data[:12])
return {
'tid': tid,
'flags': flags,
'qdcount': qd,
'ancount': an,
'nscount': ns,
'arcount': ar
}
def build_response(tid, question, answers):
"""构造 DNS 响应报文"""
# QR=1, AA=1, RD=1, RA=1, RCODE=0
flags = 0x8580
header = struct.pack('!HHHHHH', tid, flags, 1, len(answers), 0, 0)
return header + question + b''.join(answers)
def main():
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('0.0.0.0', 5353)) # 课设里用 5353 避免和系统 DNS 冲突
print('DNS server listening on 0.0.0.0:5353')
while True:
data, addr = sock.recvfrom(512)
header = parse_header(data)
# 解析 Question 区域
offset = 12
domain, offset = decode_domain(data, offset)
qtype, qclass = struct.unpack('!HH', data[offset:offset+4])
offset += 4
question = data[12:offset]
print(f'Query: {domain} type={qtype} from {addr}')
# 构造响应
answers = []
if qtype == 1: # A 记录
answers.append(build_a_record(domain, '127.0.0.1'))
response = build_response(header['tid'], question, answers)
sock.sendto(response, addr)
if __name__ == '__main__':
main()
这段代码里 0x8580 是标志位,拆开看: 1000 0101 1000 0000 ,QR=1(响应),Opcode=0000(标准查询),AA=1(权威应答),TC=0(未截断),RD=1(期望递归),RA=1(递归可用),RCODE=0000(无错误)。这个值可以直接抄,但你要知道每一位的含义,验收时老师可能会问。
3.2 构造 A 记录和 CNAME 记录
build_a_record 函数负责把域名和 IP 地址打包成资源记录格式:
def build_a_record(domain, ip):
"""构造一条 A 记录"""
name = encode_domain(domain)
rtype = struct.pack('!H', 1) # TYPE = A
rclass = struct.pack('!H', 1) # CLASS = IN
ttl = struct.pack('!I', 60) # TTL = 60 秒
rdata = socket.inet_aton(ip) # 4 字节 IP
rdlength = struct.pack('!H', len(rdata))
return name + rtype + rclass + ttl + rdlength + rdata
CNAME 记录类似,只是 TYPE=5,RDATA 是编码后的目标域名:
def build_cname_record(domain, target):
"""构造一条 CNAME 记录"""
name = encode_domain(domain)
rtype = struct.pack('!H', 5) # TYPE = CNAME
rclass = struct.pack('!H', 1)
ttl = struct.pack('!I', 60)
rdata = encode_domain(target)
rdlength = struct.pack('!H', len(rdata))
return name + rtype + rclass + ttl + rdlength + rdata
注意 CNAME 记录和 A 记录不能同时存在于同一个域名下,这是 DNS 协议的规定。如果一个域名有 CNAME,那它就不能有其他任何类型的记录。课设里如果要做 CNAME 链式解析,需要在服务器端递归查到最终的 A 记录再返回。
3.3 用 dig 命令验证你的服务器
写完服务器后,用 dig 验证是最直接的方式:
# 查询 A 记录
dig @127.0.0.1 -p 5353 www.example.com A
# 查询 CNAME 记录
dig @127.0.0.1 -p 5353 alias.example.com CNAME
# 查看完整响应报文
dig @127.0.0.1 -p 5353 www.example.com A +noall +answer +comments
如果 dig 返回 status: NOERROR 并且 ANSWER SECTION 里有你构造的记录,说明基本功能通了。如果返回 status: SERVFAIL 或者超时,先检查端口是否监听、防火墙是否拦截、报文长度是否超过 512 字节。
我踩过的一个坑是: dig 默认会设置 RD 位(期望递归),如果你的服务器不支持递归但返回的 RA 位是 1, dig 可能会困惑。课设里如果只做本地解析,把 RA 设为 0 更诚实。另外 dig 默认查询 A 记录,如果要查其他类型必须显式指定。
提示:Windows 上用
nslookup测试时,需要加-port=5353参数,而且nslookup对非标准端口支持不如dig友好。建议在 WSL 或 Linux 虚拟机里用dig做验证。
4. 递归查询与缓存:让服务器真正能解析外网域名
4.1 递归查询和迭代查询的区别
课设如果只做本地 hosts 文件式的解析,那太简单了。真正有意思的是让你的 DNS 服务器能解析任意域名,比如 www.google.com 。这就涉及到递归查询和迭代查询的区别。
递归查询是客户端对服务器说「你帮我查到底,给我最终答案」。迭代查询是服务器对服务器说「你告诉我下一步该问谁」。你的 DNS 服务器对客户端提供递归服务,但对上游 DNS 服务器发起迭代查询。
流程是这样的:客户端问你的服务器 www.example.com 的 A 记录,你的服务器先查本地缓存,没有的话就问根域名服务器( . ),根服务器返回 .com 的 NS 记录;你再问 .com 的服务器,它返回 example.com 的 NS 记录;你再问 example.com 的服务器,它返回最终的 A 记录。整个过程你的服务器要发多次查询,每次都是迭代的。
课设里如果不想实现完整的迭代逻辑,可以简化成「转发模式」:把所有查询转发给一个上游 DNS(比如 8.8.8.8),拿到结果后缓存并返回给客户端。这样代码量少很多,但原理上你要能说清楚两者的区别。
4.2 实现转发和本地缓存
转发模式的代码大概长这样:
import time
cache = {} # {domain: (ip, expire_time)}
def forward_query(data, upstream='8.8.8.8'):
"""把原始查询报文转发给上游 DNS,返回响应"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(3)
sock.sendto(data, (upstream, 53))
try:
response, _ = sock.recvfrom(512)
return response
except socket.timeout:
return None
finally:
sock.close()
def handle_query(data, addr):
"""处理客户端查询,优先查缓存"""
header = parse_header(data)
offset = 12
domain, offset = decode_domain(data, offset)
qtype, qclass = struct.unpack('!HH', data[offset:offset+4])
# 查缓存
cache_key = (domain, qtype)
if cache_key in cache:
ip, expire = cache[cache_key]
if time.time() < expire:
print(f'Cache hit: {domain}')
# 用缓存的 IP 构造响应
question = data[12:offset+4]
answers = [build_a_record(domain, ip)]
return build_response(header['tid'], question, answers)
# 缓存未命中,转发给上游
response = forward_query(data)
if response:
# 解析响应中的 A 记录并缓存
# 这里简化处理,实际需要完整解析 Answer 区域
pass
return response
缓存的关键是 TTL。上游返回的响应里每条记录都有 TTL,你应该用这个值来决定缓存多久。课设里为了测试方便,可以统一设 60 秒。缓存要设上限,不然长时间运行内存会爆,简单做法是用字典加过期清理,或者用 functools.lru_cache 配合时间戳。
4.3 处理 TCP 查询和报文截断
UDP 报文最大 512 字节,超过这个长度 DNS 服务器会设置 TC 位(截断标志),客户端看到 TC=1 就会用 TCP 重试。课设里如果只做 UDP,遇到大响应(比如很多条 A 记录)就会出问题。完整的实现需要同时监听 TCP 53 端口。
TCP 上的 DNS 报文格式和 UDP 一样,只是前面多了 2 字节的长度前缀。服务器先读 2 字节得到报文长度,再读对应长度的数据。响应也是先写 2 字节长度,再写报文内容。
def handle_tcp_client(conn):
"""处理 TCP DNS 查询"""
# 读 2 字节长度前缀
length_data = conn.recv(2)
if len(length_data) < 2:
return
msg_length = struct.unpack('!H', length_data)[0]
data = b''
while len(data) < msg_length:
chunk = conn.recv(msg_length - len(data))
if not chunk:
break
data += chunk
# 处理查询(和 UDP 逻辑相同)
response = process_query(data)
# 写响应,前面加 2 字节长度
conn.sendall(struct.pack('!H', len(response)) + response)
课设验收时老师可能会用 dig +tcp 来测试你的 TCP 支持。如果只实现了 UDP,这个测试就会失败。建议一开始就把 TCP 和 UDP 都写上,代码复用度很高,多出来的工作量不大。
注意:TCP 连接要设置超时,不然恶意客户端占着连接不放会耗尽服务器资源。课设里设 5 秒超时足够了。
5. 课设验收避坑指南:五个让程序翻车的细节
5.1 字节序搞反导致 IP 地址变成乱码
现象 : dig 返回的 A 记录 IP 地址是 1.0.0.127 而不是 127.0.0.1 。
原因 : socket.inet_aton 返回的是网络字节序(大端),但如果你手动用 struct.pack 打包整数,默认用的是本机字节序(小端),两者混用就会颠倒。
解决 :统一用 struct.pack('!I', ...) 或者 socket.inet_aton ,不要混用。解析时用 socket.inet_ntoa 而不是手动解包。
5.2 压缩指针解析死循环
现象 :服务器收到某个查询后卡死,CPU 占用 100%。
原因 :解析压缩指针时,如果指针指向的位置又包含指向自己的指针,就会无限循环。
解决 :加一个跳转次数上限,比如最多跳 10 次就报错返回。正常 DNS 报文的压缩指针不会超过这个深度。
5.3 响应报文超过 512 字节被截断
现象 : dig 显示 Truncated, retrying in TCP ,但你的服务器没有 TCP 监听,客户端一直重试直到超时。
原因 :UDP 响应超过 512 字节时没有设置 TC 位,或者设置了 TC 位但没有 TCP 服务。
解决 :构造响应后检查长度,超过 512 字节就设置 TC 位并截断 Answer 区域。同时实现 TCP 监听,让客户端能重试成功。
5.4 事务 ID 不匹配导致客户端丢弃响应
现象 : dig 一直显示 connection timed out; no servers could be reached ,但服务器日志显示已经发送了响应。
原因 :响应报文里的事务 ID 和请求不一致,客户端认为这不是自己要的响应,直接丢弃。
解决 :构造响应时务必把请求头部的事务 ID 原样复制过去。 struct.unpack 解析出来的 tid 直接传给 build_response 。
5.5 端口 53 被系统 DNS 占用
现象 :服务器启动时报 Address already in use 。
原因 :Linux 上 systemd-resolved 或者 dnsmasq 已经占用了 53 端口。
解决 :课设里直接用 5353 或其他高端口,测试时用 dig @127.0.0.1 -p 5353 指定端口。如果非要用 53 端口,先停掉系统 DNS 服务,但这样会影响你正常上网,不推荐。
6. 进阶技巧:用 Wireshark 抓包对比你的实现和真实 DNS
做完基本功能后,怎么验证你的实现和真实 DNS 服务器行为一致?最直接的方法是用 Wireshark 抓包对比。先抓一次 dig @8.8.8.8 www.baidu.com 的报文,再抓一次 dig @127.0.0.1 -p 5353 www.baidu.com 的报文,逐字段对比。
重点看几个地方:Flags 字段的 AA 位——真实 DNS 对缓存命中返回时 AA=0,对权威记录返回时 AA=1;你的实现如果统一设 AA=1,虽然功能上没问题,但严格来说不准确。RD 和 RA 位——客户端设 RD=1,服务器如果支持递归就设 RA=1。RCODE——域名不存在时返回 3(NXDOMAIN),而不是 0。
另一个进阶方向是支持 EDNS0(Extension Mechanisms for DNS)。传统 DNS 报文限制 512 字节,EDNS0 允许客户端声明更大的缓冲区(比如 4096 字节),这样大响应就不需要走 TCP 了。EDNS0 通过在 Additional 区域添加一条 OPT 记录实现,TYPE=41。课设里如果做了这个,验收时绝对是加分项。
我一般还会建议加一个简单的日志功能,把每次查询的域名、类型、来源 IP、是否命中缓存、响应时间记下来。这样调试时一目了然,验收时也能展示你的服务器确实在工作。日志格式不用复杂,一行一条就行:
import datetime
def log_query(domain, qtype, addr, cached, elapsed):
"""记录查询日志"""
timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
cache_status = 'HIT' if cached else 'MISS'
print(f'[{timestamp}] {addr[0]}:{addr[1]} {domain} type={qtype} {cache_status} {elapsed:.2f}ms')
最后说一个我自己的习惯:每写完一个模块,先用 dig 手动测一遍,再用 Python 的 dnspython 库写自动化测试脚本跑一遍。 dnspython 可以构造各种边界情况的查询,比如超长域名、不存在的类型、畸形报文,比手动测效率高得多。课设验收前跑一遍自动化测试,能提前发现 80% 的问题。
希望帮到你。
456



被折叠的 条评论
为什么被折叠?



