refactor(test): 把 test/host 顶层 25 个台架脚本按域收进 bench/

原来 test/host 一层混了三类东西:51 个主机侧单测模块目录、25 个台架驱动
与探针、若干专用目录。台架脚本平铺在顶层,与单测目录并列,看不出哪个是
「连板跑一次的」,也看不出加新脚本该往哪放。

现在按被验对象分域归档,单测模块目录一律不动(22 根 pre-commit 钩子逐个
点名它们,50 个运行器按固定层数推仓库根):

- bench/bench_defaults.py 台架连接默认值单一真源
- bench/ftp/ (10) FTP 功能、速率、鉴权、中止、完整性、背靠背复现
- bench/net/ (9) CH395F socket、keepalive 判死、挂机、复连压力、PASV、
  UDP 队列、链路时延对端
- bench/iec104/ (2) 主站客户端与它的离线样帧自检
- bench/wave/ (1) 录波段文件 PC 侧解码
- bench/screenlink/ (2) 屏板链路顶替与拉帧压测

顶层条目 78 -> 53。逐脚本作用、运行前置与「加新脚本往哪放」写在新建的
test/host/bench/README.md;test/host/README.md 增目录地图表,把原平铺的
网络/FTP 两节压成指针。

配套修正(移动后不修就会坏):
- 17 个脚本加上 bench/ 到 sys.path 的 bootstrap(sys.path[0] 是脚本自身
  目录,不补就 import bench_defaults 失败)
- cal/cal_write.py 本来就坏的(只插 cal/ 到自己 sys.path,import
  bench_defaults 直接 ModuleNotFoundError),补两段路径后可用
- e6_soak 与 wave_read 用 dirname 固定层数推仓库根,多两层后分别指向
  test/test 与 test/ci-artifacts(后者静默写错目录、不报错),层数已改对
- scripts/board_ui_nav.py 与 MDK-ARM 两个探针的 bench_defaults 搜索路径

清理与标注:删掉 test/host/iec104/(旧自研协议层单测退役后只剩一个零引用
的 stub 桩头);文档里对 test/host/iec104 与 iec104_serv 的引用加上「已
删除/已不存在 2026-11-18」状态词。冻结历史证据(带日期戳的台架日志)与
编号别名登记表里的旧路径按原样保留。
This commit is contained in:
2026-11-18 12:46:03 +08:00
parent b584601174
commit 685a366890
70 changed files with 415 additions and 224 deletions
+146
View File
@@ -0,0 +1,146 @@
# -*- coding: utf-8 -*-
# Trustworthy abort/robustness probe for the production FTP path (no firmware probes).
#
# Scenario: client starts a STOR upload, sends part of the data, then ABORTS by
# resetting the data connection (SO_LINGER 0 -> RST), which is the common real-world
# pattern (user cancels an upload, client crashes, link drops). Then it checks:
# 1. the control channel still answers (NOOP on a fresh connection),
# 2. a FOLLOW-UP normal upload+download still passes the SHA-256 check,
# 3. the device's relisten actually happened (observable via a successful follow-up).
#
# Usage: ftp_abort_probe.py [--ip ..] [--port 21] [--rounds 10] [--send 8192] [--gap 2]
# [--graceful] [--check-abort]
# Output: TS <epoch> / ABORT <n> sent=<b> ctrl=<reply> alive=<yes|no> followup=<OK|FAIL:x>
# abort5xx=<OK|FAIL|-> (only with --check-abort: RST expects 4xx/5xx on the
# aborted STOR = no false 226 (TRAP-NET-18 hardening); graceful FIN expects 2xx
# = protocol boundary, still reported as success)
# SUMMARY rounds=<n> pass=<n> fail=<n>
# Exit 0 all rounds pass, 1 otherwise.
import argparse, hashlib, io, os, random, re, socket, struct, sys, time
from ftplib import FTP, all_errors
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
def log(m):
sys.stdout.write(m + "\n"); sys.stdout.flush()
def rd(sock):
try:
return sock.recv(4096).decode("latin1").strip()
except Exception:
return ""
def raw_login(ip, port, timeout=10.0):
s = socket.create_connection((ip, port), timeout=timeout)
rd(s) # 220 banner
# FTP auth is mandatory: anonymous login is rejected (530) -> use the factory default account
s.sendall(b"USER admin\r\n"); rd(s)
s.sendall(b"PASS admin\r\n"); rd(s)
s.sendall(b"TYPE I\r\n"); rd(s)
return s
def pasv_data_socket(ctl):
ctl.sendall(b"PASV\r\n")
r = rd(ctl)
m = re.search(r"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)", r)
if not m:
raise RuntimeError("PASV failed: " + r)
host = ".".join(m.group(i) for i in (1, 2, 3, 4))
port = (int(m.group(5)) << 8) | int(m.group(6))
return socket.create_connection((host, port), timeout=10.0)
def followup_ok(ip, port, size=4096):
"""normal upload + download + sha256 -> True/False"""
data = bytes(random.getrandbits(8) for _ in range(size))
want = hashlib.sha256(data).hexdigest()
try:
f = FTP(); f.connect(ip, port, timeout=15.0); f.login("admin", "admin")
f.storbinary("STOR /ab_ok.bin", io.BytesIO(data))
buf = bytearray(); f.retrbinary("RETR /ab_ok.bin", buf.extend)
try:
f.delete("/ab_ok.bin")
except all_errors:
pass
f.quit()
return hashlib.sha256(bytes(buf)).hexdigest() == want
except all_errors:
return False
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--ip", default=bench_defaults.DEVICE_IP)
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--rounds", type=int, default=10)
ap.add_argument("--send", type=int, default=8192, help="bytes sent before the RST")
ap.add_argument("--gap", type=float, default=2.0)
ap.add_argument("--graceful", action="store_true",
help="close the data connection with FIN instead of RST")
ap.add_argument("--check-abort", action="store_true",
help="also assert the aborted STOR's control reply: RST -> 4xx/5xx "
"(no false 226, TRAP-NET-18 hardening); graceful FIN -> 2xx (boundary)")
a = ap.parse_args()
npass = nfail = 0
for n in range(1, a.rounds + 1):
log("TS %d" % int(time.time()))
ctl_reply = "NA"
alive = "no"
try:
ctl = raw_login(a.ip, a.port)
ds = pasv_data_socket(ctl)
ctl.sendall(("STOR /ab%04d.bin\r\n" % n).encode())
ctl_reply = rd(ctl) # 150
chunk = bytes(random.getrandbits(8) for _ in range(a.send))
ds.sendall(chunk)
if a.graceful:
ds.shutdown(socket.SHUT_RDWR) # graceful FIN (client cancel)
else:
# abort: RST the data connection (linger 0)
ds.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", 1, 0))
ds.close()
time.sleep(0.5)
ctl_reply = rd(ctl) # 426/550/226
try:
ctl.sendall(b"QUIT\r\n"); rd(ctl)
except Exception:
pass
try:
ctl.close()
except Exception:
pass
except Exception as e:
ctl_reply = "EXC:%s" % type(e).__name__
# control-channel liveness on a fresh connection
try:
c2 = raw_login(a.ip, a.port)
c2.sendall(b"NOOP\r\n")
alive = "yes" if rd(c2).startswith("2") else "no"
c2.sendall(b"QUIT\r\n"); c2.close()
except Exception:
alive = "no"
fu = followup_ok(a.ip, a.port)
abort_ok = True
if a.check_abort:
code = ctl_reply[0] if (ctl_reply and ctl_reply[0].isdigit()) else "?"
# RST: device must report 4xx/5xx on the aborted STOR (450); graceful
# FIN still gets 226 (STOR has no length declaration - protocol boundary)
abort_ok = (code == "2") if a.graceful else (code in ("4", "5"))
ok = (alive == "yes" and fu and abort_ok)
npass += 1 if ok else 0
nfail += 0 if ok else 1
log("ABORT %d sent=%d ctrl=%s alive=%s followup=%s abort5xx=%s" %
(n, a.send, ctl_reply.replace("\r\n", "|")[:40], alive,
"OK" if fu else "FAIL", "OK" if abort_ok else "FAIL" if a.check_abort else "-"))
if a.gap > 0 and n < a.rounds:
time.sleep(a.gap)
log("SUMMARY rounds=%d pass=%d fail=%d" % (a.rounds, npass, nfail))
return 0 if nfail == 0 else 1
sys.exit(main())
+184
View File
@@ -0,0 +1,184 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""FTP 鉴权台架回归(需真机在线)
验证固件侧 lftpd 鉴权集成的完整行为矩阵(主机单测 test/host/ftp_auth 覆盖
不到的"协议接线"部分:命令门、530/331/230/550 响应码、跨会话锁定):
场景「匿名登录」(anonymous) → 期望 530 拒
场景「未登录直接 NLST」 → 期望 530(命令门)
场景「对用户名 + 错口令 ×5」 → 期望 530 ×5(并触发锁定)
T4 锁定窗内正确口令 → 期望 530(LOCKED,不算哈希)
T5 等待锁定期满后正确口令 → 期望 230(60s + 余量)
T6 登录后 NLST / STOR / RETR / DELE → 期望全通(出厂 write=1)
T7 会话结束重连、错口令一次 → 期望 530 且计数已清零(T5 成功清零)
注意:CH395F 单连接——每步用完必须 quit() 释放 socket,否则下一步连不上;
跑之前确保 UI 远程显示(7003)客户端未占用 socket(对时 :8888 已退役,
SNTP 只占 UDP 通道,与 TCP 单连接语义无关)。
用法(设备默认见 bench_defaults.DEVICE_IP,出厂口令 admin/admin):
& '.venv\\Scripts\\python.exe' test/host/ftp_auth_bench.py
改过口令: ... --pwd <新口令>
跳过 60s 锁定等待(只验锁定触发不验解锁): ... --skip-unlock
退出码:0=全部通过 / 1=任一失败 / 2=环境错误(连不上设备)
创建日期:2026-10-11
"""
import os
import argparse
import io
import socket
import sys
import time
from ftplib import FTP, error_perm
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
LOCK_WAIT_S = 62 # 固件锁定 60 s + 余量
def _try_login(host, port, timeout, user, pwd):
"""尝试一次登录;返回 (ok, code_or_exc)。失败不断言连接状态。
单连接 socket:上一次会话结束后 net 层 auto_relisten ~50 ms,但 accept
失败会走"毁监听→重建"路径(3 s 重试窗)→ connect 被拒时重试 3 次。
"""
f = FTP()
last_err = None
for attempt in range(3):
try:
time.sleep(0.5)
f.connect(host, port, timeout=timeout)
break
except (ConnectionRefusedError, socket.timeout, OSError) as e:
last_err = e
f = FTP()
else:
return None, repr(last_err), None
try:
try:
f.login(user, pwd)
return True, "230", f
except error_perm as e:
f.close()
return False, str(e), None
except (socket.timeout, OSError) as e:
return None, repr(e), None
def main(argv=None):
ap = argparse.ArgumentParser(description="FTP auth bench matrix")
ap.add_argument("--host", default=bench_defaults.DEVICE_IP)
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--timeout", type=int, default=15)
ap.add_argument("--user", default="admin")
ap.add_argument("--pwd", default="admin")
ap.add_argument("--skip-unlock", action="store_true",
help="不验 60s 解锁(省 1 分钟;锁定触发仍验)")
args = ap.parse_args(argv)
fails = []
def expect(name, cond, detail=""):
tag = "PASS" if cond else "FAIL"
print(" [%s] %s %s" % (tag, name, detail))
if not cond:
fails.append(name)
# ---- 场景「匿名登录被拒」----
ok, code, conn = _try_login(args.host, args.port, args.timeout, "anonymous", "x@x")
if ok is None:
print("[env] 连不上 %s:%d → %s" % (args.host, args.port, code))
return 2
expect("匿名登录 → 530", (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
# ---- 场景「未登录直接 NLST → 530(命令门)」----
time.sleep(0.5) # 单连接 socket:等 auto_relisten 沉降(~50 ms + 余量)
f = FTP()
f.connect(args.host, args.port, timeout=args.timeout)
try:
f.sendcmd("NLST")
expect("未登录 NLST → 530", False, "居然放行")
except error_perm as e:
expect("未登录 NLST → 530", str(e).startswith("530"), str(e))
except Exception as e: # noqa: BLE001
expect("未登录 NLST → 530", False, repr(e))
# ⚠ 必须 close:单连接模型下不关 = 占住 socket,后续步骤全被拒
# (2026-10-11 台架实测:QUIT 后不 close → 芯片视角旧连接仍 ESTABLISHED)
try:
f.quit()
except Exception: # noqa: BLE001
try:
f.close()
except Exception: # noqa: BLE001
pass
time.sleep(0.5)
# ---- 场景「错口令 ×5 → 530 ×5」----
for i in range(1, 6):
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, "wrong-pass-%d" % i)
expect("错口令 %d → 530" % i, (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
# ---- T4 锁定窗内正确口令 → 530 ----
ok, code, conn = _try_login(args.host, args.port, args.timeout, args.user, args.pwd)
expect("T4 锁定窗内对口令 → 530", (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
if args.skip_unlock:
print("[skip] 未验 60s 解锁(--skip-unlock)")
else:
# ---- T5 期满正确口令 → 230 ----
print(" [wait] 等锁定期满 %d s ..." % LOCK_WAIT_S)
time.sleep(LOCK_WAIT_S)
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, args.pwd)
expect("T5 期满对口令 → 230", ok is True, code)
if conn:
# ---- T6 登录后读写全通(出厂 write=1)----
try:
names = conn.nlst()
expect("T6a NLST", len(names) >= 0, "%d 项" % len(names))
payload = b"N19-auth-bench-" + b"X" * 500
conn.storbinary("STOR n19t.tmp", io.BytesIO(payload))
got = io.BytesIO()
conn.retrbinary("RETR n19t.tmp", got.write)
expect("T6b STOR/RETR 往返一致", got.getvalue() == payload)
conn.delete("n19t.tmp")
expect("T6c DELE", True)
except Exception as e: # noqa: BLE001
expect("T6 登录后读写", False, repr(e))
# ---- T7 成功已清零计数:本会话退出后错一次只算 1(不锁)----
conn.quit()
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, "one-wrong")
expect("T7 成功后错 1 次 → 530 且未锁(下次对口令可登)",
(ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, args.pwd)
expect("T7b 紧接对口令 → 230", ok is True, code)
if conn:
conn.quit()
print("\nVERDICT: %s (%d fail)" % ("PASS" if not fails else "FAIL", len(fails)))
return 0 if not fails else 1
if __name__ == "__main__":
sys.exit(main())
+256
View File
@@ -0,0 +1,256 @@
#!/usr/bin/env python3
"""
FTP 协议抓取工具 — 模拟 FTP Server,打印客户端每一条命令和交互细节
用法:python ftp_capture.py [--port 21]
需要管理员权限(Linux 无需,Windows 需要管理员权限绑定 21 端口)
"""
import socket
import threading
import sys
import os
import time
import struct
import re
HOST = "0.0.0.0"
PORT = 21
DATA_DIR = "ftp_capture_data"
def log(fmt, *args):
ts = time.strftime("%H:%M:%S", time.localtime())
msg = fmt % args if args else fmt
print(f"[{ts}] {msg}")
def recv_line(sock):
data = b""
while True:
ch = sock.recv(1)
if not ch:
return None
data += ch
if data.endswith(b"\r\n"):
return data
def send_line(sock, line):
sock.sendall((line + "\r\n").encode())
log(">>> %s", line)
class FtpHandler(threading.Thread):
def __init__(self, ctrl_sock, addr):
super().__init__(daemon=True)
self.ctrl = ctrl_sock
self.addr = addr
self.cwd = "/"
self.data_listener = None
self.data_port = 0
self.pasv_socket = None
def run(self):
log("=== New connection from %s:%d ===", *self.addr)
send_line(self.ctrl, "220 Service ready for new user.")
while True:
raw = recv_line(self.ctrl)
if raw is None:
log("=== Connection closed ===")
break
line = raw.decode(errors="replace").rstrip()
log("<<< %s", line)
parts = line.split()
cmd = parts[0].upper()
arg = parts[1] if len(parts) > 1 else None
try:
self.handle(cmd, arg)
except Exception as e:
log("!!! ERROR: %s", e)
send_line(self.ctrl, "550 Internal error.")
self.cleanup()
def handle(self, cmd, arg):
handler = getattr(self, f"cmd_{cmd}", None)
if handler:
handler(arg)
else:
send_line(self.ctrl, f"502 Command not implemented.")
def cmd_USER(self, arg):
send_line(self.ctrl, "230 User logged in, proceed.")
def cmd_PASS(self, arg):
send_line(self.ctrl, "230 User logged in, proceed.")
def cmd_FEAT(self, arg):
send_line(self.ctrl, "211-System status, or system help reply.")
send_line(self.ctrl, " EPSV")
send_line(self.ctrl, " PASV")
send_line(self.ctrl, " SIZE")
send_line(self.ctrl, " NLST")
send_line(self.ctrl, "211 System status, or system help reply.")
def cmd_PWD(self, arg):
send_line(self.ctrl, f'257 "{self.cwd}"')
def cmd_CWD(self, arg):
if arg == "." or arg == "/":
self.cwd = "/"
send_line(self.ctrl, "250 Requested file action okay, completed.")
else:
send_line(self.ctrl, "550 Requested action not taken.")
def cmd_TYPE(self, arg):
send_line(self.ctrl, "200 Command okay.")
def cmd_SYST(self, arg):
send_line(self.ctrl, "215 UNIX Type: L8")
def cmd_NOOP(self, arg):
send_line(self.ctrl, "200 Command okay.")
def cmd_QUIT(self, arg):
send_line(self.ctrl, "221 Service closing control connection.")
self.ctrl.close()
def cmd_SIZE(self, arg):
send_line(self.ctrl, "550 File unavailable.")
def cmd_PASV(self, arg):
"""创建 PASV 数据监听"""
self.cleanup_data()
pasv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
pasv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
pasv.bind(("0.0.0.0", 0))
pasv.listen(1)
self.pasv_socket = pasv
port = pasv.getsockname()[1]
p1, p2 = port >> 8, port & 0xFF
# 使用 127.0.0.1 本地环回避免防火墙问题
send_line(self.ctrl,
f"227 Entering Passive Mode (127,0,0,1,{p1},{p2}).")
log(" PASV listener on port %d (127.0.0.1:port)", port)
def cmd_EPSV(self, arg):
self.cleanup_data()
pasv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
pasv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
pasv.bind(("0.0.0.0", 0))
pasv.listen(1)
self.pasv_socket = pasv
port = pasv.getsockname()[1]
send_line(self.ctrl, f"229 Entering Extended Passive Mode (|||{port}|)")
log(" EPSV listener on port %d", port)
def cmd_LIST(self, arg):
send_line(self.ctrl, "150 File status okay; about to open data connection.")
conn = self.accept_data()
if conn:
log(" LIST: sending directory listing (empty)")
conn.sendall(b"-rw-rw-rw- 1 owner group 123 Jan 01 1970 test.txt\r\n")
conn.close()
log(" LIST: data closed")
send_line(self.ctrl, "226 Closing data connection.")
def cmd_NLST(self, arg):
self.cmd_LIST(arg)
def cmd_STOR(self, arg):
"""接收文件上传"""
size = 0
send_line(self.ctrl, "150 File status okay; about to open data connection.")
conn = self.accept_data()
if conn:
log(" STOR: receiving file '%s'...", arg)
data = b""
while True:
try:
chunk = conn.recv(4096)
if not chunk:
break
data += chunk
size += len(chunk)
except socket.timeout:
break
conn.close()
log(" STOR: received %d bytes, data closed", size)
else:
log(" STOR: data connection failed!")
send_line(self.ctrl, f"226 Closing data connection.")
def cmd_RETR(self, arg):
send_line(self.ctrl, "550 File unavailable.")
def cmd_DELE(self, arg):
send_line(self.ctrl, "250 Requested file action okay, completed.")
def accept_data(self):
"""接受数据连接(5秒超时)"""
if self.pasv_socket is None:
log(" ERROR: no PASV listener!")
return None
try:
self.pasv_socket.settimeout(5)
conn, addr = self.pasv_socket.accept()
log(" Data connection from %s:%d", *addr)
return conn
except socket.timeout:
log(" Data accept TIMEOUT (5s)")
return None
except Exception as e:
log(" Data accept ERROR: %s", e)
return None
def cleanup_data(self):
if self.pasv_socket:
try:
self.pasv_socket.close()
except:
pass
self.pasv_socket = None
def cleanup(self):
self.cleanup_data()
try:
self.ctrl.close()
except:
pass
def main():
import argparse
parser = argparse.ArgumentParser(description="FTP Protocol Capture")
parser.add_argument("--port", type=int, default=PORT,
help=f"FTP port (default {PORT}, may need admin)")
args = parser.parse_args()
# Windows 下低端口需要管理员权限
if sys.platform == "win32" and args.port < 1024:
import ctypes
if not ctypes.windll.shell32.IsUserAnAdmin():
log("WARNING: Port %d may need admin rights on Windows", args.port)
log(" Run as Administrator or use --port 2121")
os.makedirs(DATA_DIR, exist_ok=True)
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind((HOST, args.port))
server.listen(5)
log("FTP capture server on port %d", args.port)
log("Connect with MobaXterm/FileZilla and try operations")
log("=" * 50)
try:
while True:
conn, addr = server.accept()
FtpHandler(conn, addr).start()
except KeyboardInterrupt:
log("Stopped")
finally:
server.close()
if __name__ == "__main__":
main()
+121
View File
@@ -0,0 +1,121 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""E12:CH395F SPI 缓存区 TSL 时序 A/B 的字节级校验工作负载。
背景(E12):手册 §7.4 规定读写收发缓存区命令需在"长度与数据之间"留
TSL(读 0.4us / 写 0.2us)。本仓 ch395f_write_send_buf / ch395f_read_recv_buf
把命令头与数据打包进**同一 DMA 突发**(零间隔)。本脚本用 SHA-256 逐轮校验
"上传→回读"是否字节一致,为 A/B 提供灵敏判据:
- STOR(PC→设备)走设备 read_recv_buf(TSL 读 0.4us)
- RETR(设备→PC)走设备 write_send_buf(TSL 写 0.2us)
任一方向出现比特错位都会让 SHA 不匹配。
用法:
python ftp_integrity_test.py --rounds 20 --size 65536
python ftp_integrity_test.py --rounds 20 --size 65536 --tag A # 结果标记
判据:全部轮次 SHA-256 一致 = PASS;出现不一致则打印首个差异偏移,
并自动二次回读以区分"存储副本错(写路径/上传)"与"回读瞬时错(读路径)"。
"""
import os
import argparse
import hashlib
import io
import random
import sys
import time
from ftplib import FTP, error_perm
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
NAME = "e12a.bin" # 8.3 短名(FatFs FF_USE_LFN=0)
def sha(b: bytes) -> str:
return hashlib.sha256(b).hexdigest()
def first_diff(a: bytes, b: bytes):
n = min(len(a), len(b))
for i in range(n):
if a[i] != b[i]:
return i, a[i], b[i]
if len(a) != len(b):
return n, None, None
return None
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--host", default=bench_defaults.DEVICE_IP)
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--user", default="admin")
ap.add_argument("--pwd", default="admin")
ap.add_argument("--rounds", type=int, default=20)
ap.add_argument("--size", type=int, default=65536, help="每轮载荷字节数")
ap.add_argument("--seed", type=int, default=20261013)
ap.add_argument("--tag", default="", help="结果标记(A/B 分组)")
args = ap.parse_args()
rng = random.Random(args.seed)
ftp = FTP()
ftp.connect(args.host, args.port, timeout=20)
ftp.login(args.user, args.pwd)
ftp.set_pasv(True)
print(f"[E12{args.tag}] 已登录 {args.host}:{args.port} "
f"rounds={args.rounds} size={args.size}B", flush=True)
bad = 0
t_all = time.time()
for i in range(1, args.rounds + 1):
payload = rng.randbytes(args.size)
want = sha(payload)
t0 = time.time()
ftp.storbinary(f"STOR {NAME}", io.BytesIO(payload))
got = bytearray()
ftp.retrbinary(f"RETR {NAME}", got.extend)
got = bytes(got)
dt = time.time() - t0
if got == payload:
print(f" round {i:2d}/{args.rounds} OK "
f"size={len(got)}B sha={want[:16]} {dt:.2f}s "
f"({args.size / 1024 / max(dt, 1e-3):.0f} KB/s)", flush=True)
continue
bad += 1
fd = first_diff(got, payload)
print(f" round {i:2d}/{args.rounds} MISMATCH len={len(got)} want={len(payload)} "
f"first_diff={fd}", flush=True)
# 归因:二次回读
got2 = bytearray()
try:
ftp.retrbinary(f"RETR {NAME}", got2.extend)
got2 = bytes(got2)
if got2 == payload:
print(" → 二次回读一致:判为回读瞬时错(read 路径)", flush=True)
else:
print(f" → 二次回读仍不一致(sha2={sha(got2)[:16]}):"
f"判为存储副本错(write/上传路径)", flush=True)
except error_perm as e:
print(f" → 二次回读失败:{e}", flush=True)
ftp.quit() if False else ftp.close()
total = time.time() - t_all
print(f"[E12{args.tag}] 汇总:{args.rounds - bad}/{args.rounds} 轮字节一致"
f"({bad} 轮不一致),总耗时 {total:.1f}s", flush=True)
return 1 if bad else 0
if __name__ == "__main__":
sys.exit(main())
+130
View File
@@ -0,0 +1,130 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
LIST 完整性回归 —— 2026-10-22 起常驻
为什么需要:lftpd 的 send_list/send_nlst 原先把目录装进一块 static 1536 B 缓冲,装满就
break 并回 -1,cmd_list 据此回 **550**——目录一大,客户端拿到的是**静默截断**的清单外加
一个错误码,而清单看起来完全像"目录里就这些"。台架实测:30 条目的根目录只回了 24 条目
(1512 B),6 个文件凭空消失。设备目录清空后这个雷**再也暴露不出来**,所以需要本脚本
主动把目录撑过一块:造 N 个 8.3 短名小文件 → LIST 必须**全部列出**且完成回包是 226 →
逐个删掉还原。
判据(三条全过才 PASS):
1. N 个文件全部 STOR 成功(226)
2. LIST 全文里每个名字都在(少一个 = 截断回归)
3. LIST 的完成回包是 226 而不是 550(ftplib 在非 2xx 完成时会抛异常,正是这条)
清理:无论成败都逐个 DELE;删除失败会打 WARN(不影响判定,但会留残留文件要手清)。
用法:python ftp_list_fill_test.py [--host <设备IP>] [--files 26]
[--user admin] [--password admin]
注:--files 26 是按每行约 63 B 反推的下限(26×63 ≈ 1638 > 1536);目录本来就有
条目时更小也能触发,取 26 保证空目录也能越过一块。
"""
import os
import argparse
import io
import sys
from ftplib import FTP, all_errors
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
HOST = bench_defaults.DEVICE_IP
PORT = 21
# 设备无匿名通道:账号取 /config.ini 的 [ftp],出厂默认 admin/admin
USER = "admin"
PASSWORD = "admin"
PREFIX = "ZZFT"
PAYLOAD = b"filler\r\n"
def names_of(count):
# FatFs 只支持严格 8.3(FF_USE_LFN=0):8 字符主名 + 3 字符扩展名
return ["%s%02d.TXT" % (PREFIX, i) for i in range(count)]
def main():
ap = argparse.ArgumentParser(description="FTP LIST completeness regression")
ap.add_argument("--host", default=HOST)
ap.add_argument("--port", type=int, default=PORT)
ap.add_argument("--files", type=int, default=26,
help="how many probe files to create (default 26, see docstring)")
ap.add_argument("--user", default=USER)
ap.add_argument("--password", default=PASSWORD)
args = ap.parse_args()
names = names_of(args.files)
stored = []
checks = []
ftp = FTP()
try:
ftp.connect(args.host, args.port, timeout=15)
# connect() 已经把 220 欢迎读走了(ftplib 语义),这里不能再 getresp()
print("login:", ftp.login(args.user, args.password))
ftp.voidcmd("TYPE I")
print("\n[1] STOR %d 个探针文件" % args.files)
for name in names:
try:
ftp.storbinary("STOR " + name, io.BytesIO(PAYLOAD))
stored.append(name)
except all_errors as exc:
checks.append(("STOR " + name, False, str(exc)[:60]))
break
if len(stored) == args.files:
checks.append(("STOR all %d files" % args.files, True, "ok"))
print("[2] LIST 全文校验")
lines = []
trunc_err = None
try:
ftp.retrlines("LIST", lines.append)
except all_errors as exc:
# 完成回包不是 2xx(老 bug 的 550 就走这里)
trunc_err = str(exc)
listed = " ".join(lines).upper()
print(" 收到 %d 行 / %d 字节" % (len(lines), sum(len(x) + 2 for x in lines)))
checks.append(("LIST 完成回包 226(非 550)", trunc_err is None,
trunc_err or "ok"))
missing = [n for n in stored if n.upper() not in listed]
checks.append(("LIST 列出全部 %d 个新文件" % len(stored), not missing,
"缺 " + ",".join(missing) if missing else "ok"))
except all_errors as exc:
checks.append(("会话", False, str(exc)[:80]))
finally:
print("[3] 清理")
left = 0
for name in stored:
try:
ftp.delete(name)
except all_errors as exc:
left += 1
print(" WARN: DELE %s 失败: %s" % (name, str(exc)[:50]))
if left:
print(" WARN: %d 个残留文件需手工清" % left)
try:
ftp.quit()
except all_errors:
pass
print("\n" + "=" * 44)
ok_all = True
for label, ok, detail in checks:
ok_all = ok_all and ok
print(" [%s] %s%s" % ("PASS" if ok else "FAIL", label,
"" if ok or not detail else " - " + detail))
print("=" * 44)
print(">>> TEST PASSED <<<" if ok_all else ">>> TEST FAILED <<<")
return 0 if ok_all else 1
if __name__ == "__main__":
sys.exit(main())
+105
View File
@@ -0,0 +1,105 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""FTP 数据连接回归测试(D20 验证 + 日后回归)
背景(2026-09-22 台架实测 D20):同一 FTP 会话内**第二个数据连接必失败**
(425 Can't open data connection)。根因是单连接 Socket 复用时的"陈旧 DISCONNECT"
误判:上一条数据连接的 FIN/ACK 在 Socket 已复用为新连接之后才上报,新连接被
net 层当作"刚建立就断开"释放。修复见 net_socket.c handle_disconnect_event 的
陈旧事件甄别(回读芯片 TCP 状态,仍 ESTABLISHED 则丢弃该中断)。
本脚本在一个会话里连续做多次数据连接(LIST/NLST/STOR/RETR),并做大文件往返
内容校验;任一环节失败即退出码 1。
用法:
& '.venv\\Scripts\\python.exe' test/host/ftp_regression.py --host <设备IP>
"""
import os
import argparse
import io
import sys
import time
from ftplib import FTP
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
SMALL = b"D20-small-" + b"A" * 1017 # 1024B
BIG = bytes(((i * 7 + 3) & 0xFF) for i in range(32768)) # 32KB 模式数据
def main(argv=None):
ap = argparse.ArgumentParser(description="FTP data-connection regression (D20)")
ap.add_argument("--host", default=bench_defaults.DEVICE_IP, help="device IP")
ap.add_argument("--port", type=int, default=21, help="FTP control port")
ap.add_argument("--timeout", type=int, default=20, help="socket timeout (s)")
# 2026-10-11 起 FTP 强制鉴权:匿名登录被 530 拒;默认口令 admin/admin
# (出厂值,见 ftp_cfg.h),改过 [ftp] pwd_hash 后用这两个参数覆盖
ap.add_argument("--user", default="admin", help="FTP user ([ftp] user)")
ap.add_argument("--pwd", default="admin", help="FTP password")
args = ap.parse_args(argv)
results = []
def step(name, fn):
"""执行一步并记录结果;不抛异常,便于一次跑完全部步骤。"""
t0 = time.time()
try:
extra = fn()
dt = time.time() - t0
results.append((name, True, dt))
print(" %-16s OK %6.2fs %s" % (name, dt, extra if extra is not None else ""))
return True
except Exception as e: # noqa: BLE001
dt = time.time() - t0
results.append((name, False, dt))
print(" %-16s FAIL %6.2fs %s %s" % (name, dt, type(e).__name__, e))
return False
f = FTP()
print("[ftp] connecting %s:%d ..." % (args.host, args.port))
f.connect(args.host, args.port, timeout=args.timeout)
f.login(args.user, args.pwd)
print("[ftp] login ok: %s" % f.getwelcome())
# 同一会话内连续 8 次数据连接(含两次大文件)—— D20 的失败点是第 2 次
step("LIST #1", lambda: "%d lines" % len(f.nlst()))
step("STOR #2 1KB", lambda: f.storbinary("STOR d20s.tmp", io.BytesIO(SMALL)) or "226")
got = bytearray()
step("RETR #3 1KB", lambda: (f.retrbinary("RETR d20s.tmp", got.extend), "226")[1])
if bytes(got) != SMALL:
print(" !! RETR #3 content mismatch (%d bytes)" % len(got))
results.append(("RETR#3-content", False, 0.0))
else:
results.append(("RETR#3-content", True, 0.0))
step("LIST #4", lambda: "%d lines" % len(f.nlst()))
step("STOR #5 32KB", lambda: f.storbinary("STOR d20b.tmp", io.BytesIO(BIG)) or "226")
big = bytearray()
step("RETR #6 32KB", lambda: (f.retrbinary("RETR d20b.tmp", big.extend), "226")[1])
if bytes(big) != BIG:
print(" !! RETR #6 content mismatch (%d/%d bytes)" % (len(big), len(BIG)))
results.append(("RETR#6-content", False, 0.0))
else:
results.append(("RETR#6-content", True, 0.0))
step("LIST #7", lambda: "%d lines" % len(f.nlst()))
step("cleanup", lambda: (f.delete("d20s.tmp"), f.delete("d20b.tmp"), "deleted")[2])
step("QUIT", lambda: f.quit() or "221")
ok = sum(1 for _, good, _ in results if good)
print("[ftp] %d/%d steps passed" % (ok, len(results)))
return 0 if ok == len(results) else 1
if __name__ == "__main__":
sys.exit(main())
+280
View File
@@ -0,0 +1,280 @@
#!/usr/bin/env python3
"""
FTP 速度测试 — 上传/下载大文件,测量传输速度
用法:python ftp_speed_test.py --host <设备IP> [--size 512] [--port 21]
[--user admin] [--password admin]
"""
import socket
import sys
import time
import re
import argparse
import os
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
HOST = bench_defaults.DEVICE_IP
PORT = 21
# 设备侧 FTP 鉴权走 /config.ini 的 [ftp](user / pwd_hash),出厂默认 admin/admin;
# **没有匿名通道**(USER anonymous 一律回 530)。
USER = "admin"
PASSWORD = "admin"
FILE_SIZE_KB = 512 # 默认 512KB 测试文件
def log(msg, *args):
print(f" {msg % args if args else msg}")
def recv_line(sock, timeout=60.0):
data = b""
sock.settimeout(timeout)
while True:
try:
ch = sock.recv(1)
except socket.timeout:
return None
if not ch:
return data if data else None
data += ch
if data.endswith(b"\r\n"):
return data
def send_cmd(sock, cmd):
sock.sendall((cmd + "\r\n").encode())
time.sleep(0.1)
return recv_line(sock)
def connect_with_retry(host, port, timeout=15.0, attempts=6, delay=3.0):
"""连接控制通道(带重试)。
CH395F 单客户端复用:上一会话未 QUIT 就断开时,服务端可能仍在处理旧连接,
新连接会被 RST(WinError 10061);实测约 30s 后服务端丢弃旧会话并重新 listen。
注意不要用裸 TCP 探测端口(探测会占掉唯一会话)。
"""
last_err = None
for i in range(1, attempts + 1):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout)
try:
s.connect((host, port))
return s, None
except Exception as e:
last_err = e
try:
s.close()
except Exception:
pass
if i < attempts:
print(f" connect failed ({e}); retry {i}/{attempts - 1} in {delay:.0f}s "
f"(single-client: stale session blocks new connections)")
time.sleep(delay)
return None, last_err
def parse_pasv(resp):
m = re.search(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", resp.decode())
if m:
a, b, c, d, e, f = [int(x) for x in m.groups()]
return f"{a}.{b}.{c}.{d}", e * 256 + f
return None, None
def test_speed(host, port, size_kb, user, password):
total_bytes = size_kb * 1024
test_data = os.urandom(total_bytes)
test_name = "SPEEDTST.DAT" # 8.3 format
print(f"\n=== FTP Speed Test: {host}:{port}, {size_kb}KB file ===")
print(f" Test data: {total_bytes:,} bytes generated\n")
checks = []
def check(label, ok, detail=""):
checks.append((label, ok, detail))
mark = "PASS" if ok else "FAIL"
print(f" [{mark}] {label}{(' - ' + detail) if detail else ''}")
def finish(sock):
passed = all(ok for _, ok, _ in checks)
print("\n" + "=" * 40)
print("FTP Speed Test Summary:")
for label, ok, _ in checks:
print(f" [{'PASS' if ok else 'FAIL'}] {label}")
print("=" * 40)
if passed:
print(">>> TEST PASSED <<<")
else:
print(">>> TEST FAILED <<<")
print("=== Test Complete ===")
if sock:
try:
sock.close()
except Exception:
pass
return passed
# ---- Connect + Login ----
print("[Connect] Connecting...")
sock, err = connect_with_retry(host, port, timeout=60.0)
if sock is None:
print(f" CONNECT FAILED: {err}")
check("Connect", False, str(err))
return finish(None)
recv_line(sock) # 220
# 需要口令的服务器在 USER 之后回 331,直接放行的才回 230——两种都要接受
resp = send_cmd(sock, "USER " + user)
if not (resp and (resp.startswith(b"230") or resp.startswith(b"331"))):
check("Login USER (230/331)", False,
resp.decode(errors='replace').rstrip() if resp else "no resp")
print(" 提示:lftpd 按 /config.ini 的 [ftp] 段校验(user / pwd_hash),出厂默认 admin/admin;"
"设备没有匿名通道。口令被改过就用 --user/--password 传;连续 5 次失败会锁定 60 秒。")
return finish(sock)
resp = send_cmd(sock, "PASS " + password)
if not (resp and resp.startswith(b"230")):
check("Login PASS 230", False,
resp.decode(errors='replace').rstrip() if resp else "no resp")
print(" 提示:lftpd 按 /config.ini 的 [ftp] 段校验(user / pwd_hash),出厂默认 admin/admin;"
"设备没有匿名通道。口令被改过就用 --user/--password 传;连续 5 次失败会锁定 60 秒。")
return finish(sock)
check("Login (USER/PASS 230)", True)
send_cmd(sock, "TYPE I")
# ---- Upload ----
print("[UPLOAD] Connecting...")
resp = send_cmd(sock, "PASV")
if not resp:
check("PASV", False, "no response")
return finish(sock)
pasv_ip, pasv_port = parse_pasv(resp)
if pasv_port is None:
check("PASV parse", False, resp.decode())
return finish(sock)
check("PASV parse", True, f"{pasv_ip}:{pasv_port}")
data = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data.settimeout(60.0)
data.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # 关 Nagle,防 FIN 跑在数据前面
try:
data.connect((pasv_ip, pasv_port))
except Exception as e:
print(f" Data connect failed: {e}")
check("PASV data connect", False, str(e))
return finish(sock)
check("PASV data connect", True)
t0 = time.time()
send_cmd(sock, f"STOR {test_name}")
data.sendall(test_data)
data.shutdown(socket.SHUT_WR)
data.close()
resp = recv_line(sock, timeout=120.0)
t1 = time.time()
upload_time = t1 - t0
upload_speed = total_bytes / upload_time / 1024 if upload_time > 0 else 0
stor_code = resp[:3].decode() if resp else "???"
print(f" Sent: {total_bytes:,} / {total_bytes:,} bytes")
print(f" Time: {upload_time:.1f}s")
print(f" Speed: {upload_speed:.1f} KB/s")
print(f" Response: {resp.decode().rstrip() if resp else 'NONE'}")
upload_ok = (stor_code == "226")
check("STOR 226", upload_ok, f"{stor_code} up={upload_speed:.1f}KB/s")
if not upload_ok:
send_cmd(sock, "QUIT")
return finish(sock)
# ---- Download ----
time.sleep(3.0)
print("[DOWNLOAD] Connecting...")
resp = send_cmd(sock, "PASV")
if not resp:
check("RETR PASV", False, "no response")
return finish(sock)
pasv_ip, pasv_port = parse_pasv(resp)
if pasv_port is None:
check("RETR PASV parse", False, resp.decode())
return finish(sock)
data = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data.settimeout(60.0)
try:
data.connect((pasv_ip, pasv_port))
except Exception as e:
print(f" Data connect failed: {e}")
check("RETR data connect", False, str(e))
return finish(sock)
check("RETR data connect", True)
t0 = time.time()
send_cmd(sock, f"RETR {test_name}")
dl_data = b""
while True:
try:
chunk = data.recv(8192)
if not chunk:
break
dl_data += chunk
except socket.timeout:
break
data.close()
resp = recv_line(sock, timeout=120.0)
t1 = time.time()
download_time = t1 - t0
download_speed = len(dl_data) / download_time / 1024 if download_time > 0 else 0
print(f" Received: {len(dl_data):,} / {total_bytes:,} bytes")
print(f" Time: {download_time:.1f}s")
print(f" Speed: {download_speed:.1f} KB/s")
print(f" Response: {resp.decode().rstrip() if resp else 'NONE'}")
retr_ok = bool(resp) and resp.startswith(b"226")
check("RETR 226", retr_ok,
f"{resp[:3].decode() if resp else '???'} dl={download_speed:.1f}KB/s")
# Compare
print(f"\n[VERIFY]")
match = (len(dl_data) == total_bytes and dl_data == test_data)
if match:
print(f" *** MATCH! {total_bytes:,} bytes identical. ***")
else:
print(f" MISMATCH: sent={total_bytes}, got={len(dl_data)}")
if len(dl_data) != total_bytes:
print(f" Size mismatch!")
else:
for i in range(total_bytes):
if dl_data[i] != test_data[i]:
print(f" First diff at byte {i}")
break
check("Upload/Download MATCH", match,
f"up={total_bytes:,} dl={len(dl_data):,} up={upload_speed:.1f}KB/s dl={download_speed:.1f}KB/s")
# Cleanup
send_cmd(sock, f"DELE {test_name}")
send_cmd(sock, "QUIT")
return finish(sock)
def main():
parser = argparse.ArgumentParser(description="FTP Speed Test")
parser.add_argument("--host", default=HOST)
parser.add_argument("--port", type=int, default=PORT)
parser.add_argument("--size", type=int, default=FILE_SIZE_KB,
help=f"File size in KB (default {FILE_SIZE_KB})")
parser.add_argument("--user", default=USER, help=f"FTP user (default: {USER})")
parser.add_argument("--password", default=PASSWORD,
help="FTP password (default: the factory password)")
args = parser.parse_args()
success = test_speed(args.host, args.port, args.size, args.user, args.password)
sys.exit(0 if success else 1)
if __name__ == "__main__":
main()
+228
View File
@@ -0,0 +1,228 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
FTP Server 测试脚本 — 连接 STM32F4 上的 lftpd 服务器
用法:python ftp_test.py [--host <设备IP>] [--port 21] [--user admin] [--password admin]
"""
import os
import socket
import sys
import time
import argparse
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
HOST = bench_defaults.DEVICE_IP
PORT = 21
# 设备侧 FTP 鉴权走 /config.ini 的 [ftp](user / pwd_hash),出厂默认 admin/admin;
# **没有匿名通道**(USER anonymous 一律回 530)。
USER = "admin"
PASSWORD = "admin"
TIMEOUT = 10.0
def recv_line(sock):
"""读取 FTP 响应行(以 \r\n 结尾)"""
data = b""
sock.settimeout(TIMEOUT)
while True:
try:
ch = sock.recv(1)
except socket.timeout:
print(f"[TIMEOUT] after receiving: {data!r}")
return None
if not ch:
return data if data else None
data += ch
if data.endswith(b"\r\n"):
return data
def send_cmd(sock, cmd):
"""发送 FTP 命令并读取响应"""
print(f">>> {cmd}")
sock.sendall((cmd + "\r\n").encode())
time.sleep(0.1)
response = recv_line(sock)
if response:
print(f"<<< {response.decode(errors='replace').rstrip()}")
else:
print(f"<<< [NO RESPONSE / CONNECTION CLOSED]")
return response
def parse_pasv(response):
"""解析 PASV 227 响应,返回 (ip, port)"""
import re
m = re.search(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", response.decode())
if m:
a, b, c, d, e, f = [int(x) for x in m.groups()]
ip = f"{a}.{b}.{c}.{d}"
port = e * 256 + f
return ip, port
return None, None
def test_ftp(host, port, user, password):
print(f"=== FTP Test: {host}:{port} ===\n")
checks = [] # (label, ok, detail)
def check(label, ok, detail=""):
checks.append((label, ok, detail))
mark = "PASS" if ok else "FAIL"
print(f" [{mark}] {label}{(' - ' + detail) if detail else ''}")
# 1. Connect
print("[1] Connecting to control channel...")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(TIMEOUT)
try:
sock.connect((host, port))
print(f" Connected to {host}:{port}")
check("Connect", True)
except Exception as e:
print(f" CONNECT FAILED: {e}")
check("Connect", False, str(e))
return False
# 2. Read welcome
print("\n[2] Reading welcome banner...")
resp = recv_line(sock)
if resp:
print(f" {resp.decode(errors='replace').rstrip()}")
check("Welcome 220", resp.startswith(b"220"),
resp.decode(errors='replace').rstrip())
else:
print(" NO WELCOME BANNER")
check("Welcome 220", False, "no banner")
sock.close()
return False
# 3. Login
print("\n[3] Login...")
resp = send_cmd(sock, "USER " + user)
if not resp:
sock.close()
check("Login USER", False, "no response")
return False
resp = send_cmd(sock, "PASS " + password)
if not resp:
sock.close()
check("Login PASS", False, "no response")
return False
login_ok = b"230" in resp
check("Login (USER/PASS 230)", login_ok,
resp.decode(errors='replace').rstrip())
if not login_ok:
print(" 提示:lftpd 按 /config.ini 的 [ftp] 段校验(user / pwd_hash),出厂默认 admin/admin;"
"设备没有匿名通道。口令被改过就用 --user/--password 传;连续 5 次失败会锁定 60 秒。")
# 4. PWD
print("\n[4] PWD...")
resp = send_cmd(sock, "PWD")
pwd_ok = bool(resp) and resp.startswith(b"257")
check("PWD 257", pwd_ok,
resp.decode(errors='replace').rstrip() if resp else "no response")
# 5. PASV mode
print("\n[5] PASV...")
resp = send_cmd(sock, "PASV")
pasv_ip, pasv_port = (None, None)
if resp:
pasv_ip, pasv_port = parse_pasv(resp)
if pasv_port is None and resp and b"227" in resp:
# 227 响应但解析端口失败
pasv_port = None
if pasv_port is None:
# Try EPSV
print("\n[5b] Trying EPSV...")
resp = send_cmd(sock, "EPSV")
if resp and b"229" in resp:
import re
m = re.search(r"\(\|\|\|(\d+)\|\)", resp.decode())
if m:
pasv_port = int(m.group(1))
pasv_ip = host
print(f" EPSV: {pasv_ip}:{pasv_port}")
pasv_ok = pasv_port is not None
check("PASV/EPSV data port", pasv_ok,
f"{pasv_ip}:{pasv_port}" if pasv_ok else "no port")
# 6. LIST (correct PASV flow: connect data first, then send LIST)
if pasv_ok:
print(f" Data channel: {pasv_ip}:{pasv_port}")
print("\n[6] LIST...")
data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data_sock.settimeout(5.0)
try:
data_sock.connect((pasv_ip, pasv_port))
print(f" Data connected to {pasv_ip}:{pasv_port}")
resp = send_cmd(sock, "LIST")
list_open = bool(resp) and resp.startswith(b"150")
data = b""
while True:
try:
chunk = data_sock.recv(1024)
if not chunk:
break
data += chunk
except socket.timeout:
break
print(f" LIST result ({len(data)} bytes):")
print(data.decode(errors='replace'))
data_sock.close()
resp = recv_line(sock)
list_close = bool(resp) and resp.startswith(b"226")
print(f" LIST response: "
f"{resp.decode(errors='replace').rstrip() if resp else 'none'}")
list_ok = list_open and list_close
check("LIST 150->226", list_ok,
f"open={list_open} close={list_close} bytes={len(data)}")
except Exception as e:
print(f" LIST FAILED: {e}")
data_sock.close()
check("LIST 150->226", False, str(e))
else:
print(" Skipping LIST (no data port)")
# 7. QUIT
print("\n[7] QUIT...")
resp = send_cmd(sock, "QUIT")
quit_ok = bool(resp) and resp.startswith(b"221")
check("QUIT 221", quit_ok,
resp.decode(errors='replace').rstrip() if resp else "no response")
sock.close()
# Summary
passed = all(ok for _, ok, _ in checks)
print("\n" + "=" * 40)
print("FTP Test Summary:")
for label, ok, _ in checks:
print(f" [{'PASS' if ok else 'FAIL'}] {label}")
print("=" * 40)
if passed:
print(">>> TEST PASSED <<<")
else:
print(">>> TEST FAILED <<<")
print("=== Test Complete ===")
return passed
def main():
parser = argparse.ArgumentParser(description="FTP Server Test")
parser.add_argument("--host", default=HOST, help=f"FTP server IP (default: {HOST})")
parser.add_argument("--port", type=int, default=PORT, help=f"FTP server port (default: {PORT})")
parser.add_argument("--user", default=USER, help=f"FTP user (default: {USER})")
parser.add_argument("--password", default=PASSWORD,
help="FTP password (default: the factory password)")
args = parser.parse_args()
success = test_ftp(args.host, args.port, args.user, args.password)
sys.exit(0 if success else 1)
if __name__ == "__main__":
main()
+304
View File
@@ -0,0 +1,304 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
FTP 上传+下载测试脚本
用法:python ftp_up_dl_test.py --host <设备IP> [--user admin] [--password admin]
"""
import socket
import sys
import time
import re
import argparse
import os
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
HOST = bench_defaults.DEVICE_IP
PORT = 21
# 设备侧 FTP 鉴权走 /config.ini 的 [ftp](user / pwd_hash = SHA-256(user‖password)),
# 出厂默认 admin/admin;**没有匿名通道**(USER anonymous 一律回 530)。
USER = "admin"
PASSWORD = "admin"
TIMEOUT = 15.0
TEST_DATA = b"Hello from Python FTP test!\r\nThis is line 2.\r\nLine 3: " + b"ABCDEFGH" * 50 + b"\r\n"
def recv_line(sock, timeout=TIMEOUT):
data = b""
sock.settimeout(timeout)
while True:
try:
ch = sock.recv(1)
except socket.timeout:
print(f" [TIMEOUT] partial: {data[:80]!r}")
return None
if not ch:
return data if data else None
data += ch
if data.endswith(b"\r\n"):
return data
def send_cmd(sock, cmd, expect_code=None):
print(f" > {cmd}")
sock.sendall((cmd + "\r\n").encode())
time.sleep(0.15)
response = recv_line(sock)
if response:
text = response.decode(errors='replace').rstrip()
print(f" < {text}")
if expect_code and not text.startswith(str(expect_code)):
print(f" *** Expected {expect_code}, got: {text}")
return None
return response
print(" < [NO RESPONSE]")
return None
def connect_with_retry(host, port, timeout=TIMEOUT, attempts=6, delay=3.0):
"""连接控制通道(带重试)。
CH395F 是单客户端复用:上一会话未 QUIT 就断开时,服务端仍在处理旧连接,
新连接会被 RST(WinError 10061)。实测旧会话约 30s 后被服务端丢弃并重新
listen,故这里等一会儿重试即可,不要用裸 TCP 探测端口(探测本身会占掉
唯一会话)。
"""
last_err = None
for i in range(1, attempts + 1):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout)
try:
s.connect((host, port))
return s, None
except Exception as e:
last_err = e
try:
s.close()
except Exception:
pass
if i < attempts:
print(f" connect failed ({e}); retry {i}/{attempts - 1} in {delay:.0f}s "
f"(single-client: stale session blocks new connections)")
time.sleep(delay)
return None, last_err
def parse_pasv(resp):
m = re.search(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", resp.decode())
if m:
a, b, c, d, e, f = [int(x) for x in m.groups()]
return f"{a}.{b}.{c}.{d}", e * 256 + f
return None, None
def test_upload_download(host, port, user, password):
print(f"=== FTP Upload/Download Test: {host}:{port} user={user} ===\n")
checks = []
def check(label, ok, detail=""):
checks.append((label, ok, detail))
mark = "PASS" if ok else "FAIL"
print(f" [{mark}] {label}{(' - ' + detail) if detail else ''}")
def finish(sock):
passed = all(ok for _, ok, _ in checks)
print("\n" + "=" * 40)
print("FTP Upload/Download Summary:")
for label, ok, _ in checks:
print(f" [{'PASS' if ok else 'FAIL'}] {label}")
print("=" * 40)
if passed:
print(">>> TEST PASSED <<<")
else:
print(">>> TEST FAILED <<<")
print("=== Test Complete ===")
if sock:
try:
sock.close()
except Exception:
pass
return passed
# 1. Connect + Login
print("[1] Connect + Login")
sock, err = connect_with_retry(host, port)
if sock is None:
print(f" CONNECT FAILED: {err}")
check("Connect", False, str(err))
return finish(None)
recv_line(sock) # 220
# 需要口令的服务器在 USER 之后回 331,直接放行的才回 230——两种都要接受
resp = send_cmd(sock, "USER " + user)
if not (resp and (resp.startswith(b"230") or resp.startswith(b"331"))):
check("Login USER (230/331)", False,
resp.decode(errors="replace").rstrip() if resp else "no resp")
print(" 提示:lftpd 按 /config.ini 的 [ftp] 段校验(user / pwd_hash),出厂默认 admin/admin;"
"设备没有匿名通道。口令被改过就用 --user/--password 传;连续 5 次失败会锁定 60 秒。")
return finish(sock)
resp = send_cmd(sock, "PASS " + password)
if not (resp and resp.startswith(b"230")):
check("Login PASS 230", False,
resp.decode(errors="replace").rstrip() if resp else "no resp")
print(" 提示:lftpd 按 /config.ini 的 [ftp] 段校验(user / pwd_hash),出厂默认 admin/admin;"
"设备没有匿名通道。口令被改过就用 --user/--password 传;连续 5 次失败会锁定 60 秒。")
return finish(sock)
check("Login (USER/PASS 230)", True)
# 2. TYPE I (binary mode)
print("\n[2] Set binary mode")
resp = send_cmd(sock, "TYPE I")
type_ok = bool(resp) and resp.startswith(b"200")
check("TYPE I 200", type_ok)
# 3. PASV + STOR (upload)
print("\n[3] Upload: STOR up_test.dat")
resp = send_cmd(sock, "PASV")
if not resp:
check("PASV", False, "no response")
return finish(sock)
pasv_ip, pasv_port = parse_pasv(resp)
print(f" PASV: {pasv_ip}:{pasv_port}")
data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data_sock.settimeout(10.0)
try:
data_sock.connect((pasv_ip, pasv_port))
print(f" Data connected.")
except Exception as e:
print(f" Data connect FAILED: {e}")
check("PASV data connect", False, str(e))
return finish(sock)
check("PASV data connect", True, f"{pasv_ip}:{pasv_port}")
send_cmd(sock, "STOR up_test.dat")
total = 0
while total < len(TEST_DATA):
try:
n = data_sock.send(TEST_DATA[total:])
if n <= 0:
break
total += n
except Exception as e:
print(f" Send error: {e}")
break
print(f" Uploaded {total}/{len(TEST_DATA)} bytes.")
data_sock.shutdown(socket.SHUT_WR)
data_sock.close()
resp = recv_line(sock)
stor_ok = bool(resp) and resp.startswith(b"226") and total == len(TEST_DATA)
check("STOR 226 + bytes", stor_ok,
f"uploaded={total}/{len(TEST_DATA)} resp={resp.decode().rstrip() if resp else 'none'}")
# 4. PASV + LIST (verify)
print("\n[4] Verify: LIST")
resp = send_cmd(sock, "PASV")
if not resp:
check("LIST PASV", False, "no response")
return finish(sock)
pasv_ip, pasv_port = parse_pasv(resp)
data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data_sock.settimeout(10.0)
data_sock.connect((pasv_ip, pasv_port))
send_cmd(sock, "LIST")
data = b""
while True:
try:
chunk = data_sock.recv(4096)
if not chunk:
break
data += chunk
except socket.timeout:
break
print(f" LIST: {data.decode(errors='replace').rstrip() or '(empty directory)'}")
data_sock.close()
resp = recv_line(sock)
list_ok = bool(data) and b"UP_TEST.DAT" in data.upper()
check("LIST shows UP_TEST.DAT", list_ok,
resp.decode().rstrip() if resp else "no resp")
# 5. PASV + RETR (download)
time.sleep(1.0)
print("\n[5] Download: RETR up_test.dat")
resp = send_cmd(sock, "PASV")
if not resp:
check("RETR PASV", False, "no response")
return finish(sock)
pasv_ip, pasv_port = parse_pasv(resp)
data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
data_sock.settimeout(10.0)
try:
data_sock.connect((pasv_ip, pasv_port))
except Exception as e:
print(f" Data connect FAILED: {e}")
check("RETR data connect", False, str(e))
return finish(sock)
check("RETR data connect", True, f"{pasv_ip}:{pasv_port}")
send_cmd(sock, "RETR up_test.dat")
dl_data = b""
while True:
try:
chunk = data_sock.recv(4096)
if not chunk:
break
dl_data += chunk
except socket.timeout:
break
data_sock.close()
resp = recv_line(sock)
retr_ok = bool(resp) and resp.startswith(b"226")
check("RETR 226", retr_ok, resp.decode().rstrip() if resp else "no resp")
# Compare
print(f"\n[6] Compare")
print(f" Uploaded: {len(TEST_DATA)} bytes")
print(f" Downloaded: {len(dl_data)} bytes")
match = (dl_data == TEST_DATA)
if match:
print(f" *** MATCH! Upload/Download success. ***")
else:
print(f" *** MISMATCH! ***")
if dl_data:
print(f" First 80 bytes uploaded: {TEST_DATA[:80]!r}")
print(f" First 80 bytes downloaded: {dl_data[:80]!r}")
check("Upload/Download MATCH", match, f"up={len(TEST_DATA)} dl={len(dl_data)}")
# 7. DELE (delete test file)
print("\n[7] Cleanup: DELE up_test.dat")
resp = send_cmd(sock, "DELE up_test.dat")
dele_ok = bool(resp) and resp.startswith(b"250")
check("DELE 250", dele_ok, resp.decode().rstrip() if resp else "no resp")
# 8. QUIT
print("\n[8] QUIT")
resp = send_cmd(sock, "QUIT")
quit_ok = bool(resp) and resp.startswith(b"221")
check("QUIT 221", quit_ok, resp.decode().rstrip() if resp else "no resp")
return finish(sock)
def main():
parser = argparse.ArgumentParser(description="FTP Upload/Download Test")
parser.add_argument("--host", default=HOST)
parser.add_argument("--port", type=int, default=PORT)
parser.add_argument("--user", default=USER, help=f"FTP user (default: {USER})")
parser.add_argument("--password", default=PASSWORD,
help="FTP password (default: the factory password)")
args = parser.parse_args()
success = test_upload_download(args.host, args.port, args.user, args.password)
sys.exit(0 if success else 1)
if __name__ == "__main__":
main()
+84
View File
@@ -0,0 +1,84 @@
# relisten 沉降段原语化受阻的确定性复现:连续快速 STOR(无间隔),统计 425/超时失败次数
# 用法: python n30_repro.py [--host IP] [--user U --pwd P] [--n 10] [--size 1024]
# 退出码: 0=全部成功 / 1=有失败 / 2=连接错误
import os
import argparse
import io
import sys
from ftplib import FTP, error_temp, error_perm
# 台架连接默认值单一真源已随域归档到 test/host/bench/bench_defaults.py:
# Python 的 sys.path[0] 是**脚本自身所在目录**,本脚本在 bench/<域>/ 下直接
# `import bench_defaults` 会 ModuleNotFoundError —— 先把 bench/ 补进 sys.path。
_BENCH_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if _BENCH_DIR not in sys.path:
sys.path.insert(0, _BENCH_DIR)
import bench_defaults # noqa: E402 (台架连接默认值单一真源)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--host", default=bench_defaults.DEVICE_IP)
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--user", default=None, help="None=anonymous")
ap.add_argument("--pwd", default=None)
ap.add_argument("--n", type=int, default=10)
ap.add_argument("--size", type=int, default=1024)
args = ap.parse_args()
data = b"X" * args.size
fails = []
try:
f = FTP()
f.connect(args.host, args.port, timeout=15)
if args.user is None:
f.login("anonymous", "x@x")
else:
f.login(args.user, args.pwd)
f.voidcmd("TYPE I")
for i in range(args.n):
name = "n30_%02d.tmp" % i
try:
with io.BytesIO(data) as b:
f.storbinary("STOR " + name, b)
print("STOR #%02d OK" % (i + 1))
except (error_temp, error_perm, OSError, EOFError) as e:
print("STOR #%02d FAIL %r" % (i + 1, e))
fails.append(i + 1)
# 会话可能已重启:尝试重登继续计数
try:
f.quit()
except Exception:
pass
try:
f = FTP()
f.connect(args.host, args.port, timeout=15)
if args.user is None:
f.login("anonymous", "x@x")
else:
f.login(args.user, args.pwd)
f.voidcmd("TYPE I")
except Exception as e2:
print("re-login failed: %r" % e2)
break
# 清理
try:
for i in range(args.n):
try:
f.delete("n30_%02d.tmp" % i)
except Exception:
pass
f.quit()
except Exception:
pass
except Exception as e:
print("connect error: %r" % e)
return 2
print("RESULT: %d/%d failed %s" % (len(fails), args.n, fails))
return 1 if fails else 0
if __name__ == "__main__":
sys.exit(main())