feat(iec104): 把 104 骨架完整迁到 MCU 板端并在台架跑通总召

把 IEC104 从模拟器端整体搬到板端:协议栈原先由独立 iec104Task 驱动,
现在改为 netTask 单 owner 的 threadless 驱动,退役独立任务。

驱动与后端:
- 新增 iec104_net_mcu.c/.h,实现 IEC104_Net.h 的 11 个 ABI 函数,
  用槽表加单调句柄映射 net_socket 的单 fd 模型;CLIENT 拆除只走
  net_drop_conn_locked,绝不 net_close 监听 fd。
- net_socket 增 5 个 owner-only 接口(net_accept_locked、
  net_drop_conn_locked、net_pending_bytes、net_send_try、
  net_mono_now_ms)。
- iec104_serv.c 重写为 iec104_serv_net_tick(),在 netTask 1ms 主循环
  里驱动 core;无 osDelay/阻塞调用,喂狗是第一句。
- Src/freertos.c 删除 iec104Task 三件套,对应栈水位探针表项同步删除。

内存:目标板 192KB SRAM 装不下 vendor 默认容量档,按实测裁剪到
skeleton 档(TCP 缓冲、业务池、SOE 256->128、值槽密集化),
RW_IRAM1 118,408 B / 90.3%,留 2,178 B 余量。

台架修复(只在真硬件暴露):
- SNTP s_ctx.fd 零初始化后为 0,而 net fd 0 是合法槽位下标,
  首次代次变化时误 net_close(0) 关掉 ftpTask 的监听槽,导致 104
  连接被 FTP 的 220 banner 抢走;改为显式 .fd = -1。
- Accept 幂等:单 fd 模型下 vendor 每轮重试 Accept 会拿到同一 fd,
  后端改为会话在役时返 WOULD_BLOCK,Close 不再清槽。

验证:
- Keil 全量重建 0 error 0 warning,uvprojx 零抖动。
- 模拟器真实 TCP 13/13、transport 10/10。
- netmcu 后端单测 13/13(新增 N12)。
- 台架 serial-boot-test required 全中;板端 2404 总召 129 帧收到
  59 遥信(53 有源、全 IV)+ 16 双点 + 30 遥测(PT1 三相非零、
  UN/频率/温度按未标定置 IV)、遥控选择执行全否定、校时 COT 7。
- 期间顺带修正 UI 漂移自检文案、.serialtest required 陈旧项、
  coding-standard 对 vendor 与外部 ABI 名字的排除口径。
This commit is contained in:
2026-11-18 10:29:18 +08:00
parent 2e9272cc8a
commit 90cc9a7d99
125 changed files with 7463 additions and 5335 deletions
+96
View File
@@ -0,0 +1,96 @@
# 板端 IEC104 Net 后端隔离契约测试矩阵
## 交接说明(最终交付状态)
- **这组测试证明什么**:针对 `App/protocol/iec104/iec104_net_mcu.c`(被测 SHA256 `08ca22b9d61ec86181973ab97d7fab68ec8f0ecbf944bfd758e1546a80dc8b35`)的真实后端,在 fake net 层上证明 IEC104 Net ABI 契约:同 fd 语义下 Close 不毁监听、Pending_Input 精确/降级有界续收、Send 短写且不借用 buffer、Now_Ms 跨 32 位 tick 回绕单调、网络代次与句柄失效、断链重连、非 owner 入口拒绝、两句柄模型下代次重建后的监听存活(armed==1)与无 ABA、以及单 fd 会话的 Accept 一次性语义(已有 CLIENT/CLIENT_EOF 槽时 WOULD_BLOCK、零芯片事务、Close 后释放;旧语义"re-Accept 再发新句柄"已实测导致板端拆活连接,2026-11-18 台架)。最终实测:文本级静态 2/2、静态 checker 变异自测 `real_rc=0 mutant_rc=1`、动态 12/12(`real backend passed 12/12`)。
- **这组测试不证明什么**:fake net 层只是按产品头语义实现,不是真实 CH395F 驱动或板端电路;**CH395F 板端行为未验**(同 fd 语义待板端确认);**core / TcpServer 集成未验**(完整 STARTDT 建链为 NOT_RUN);netTask 队列/临界区与板端时序未验;MCU WCET / 性能未测;真实后端编译期坏变体未做,历史 TEST DOUBLE B1~B7 仅证明 harness 有效性;S1/S2 是文本级静态检查,不覆盖宏展开或函数指针间接调用。禁止据此写“板端已验证”。
- **一条命令复现**(仓库根执行):`python test/host/iec104_netmcu/check_static_selftest.py && python test/host/iec104_netmcu/check_static.py && python test/host/iec104_netmcu/run_netmcu_tests.py && git diff --check -- test/host/iec104_netmcu`
- **产物在哪里**:本目录 `test/host/iec104_netmcu/`;最终动态证据 `results/real/{build.log,run.log,report.json}`,静态证据 `results/static/report.json`,静态 checker 变异自测 `results/static_mutant/{report.json,selftest.txt,iec104_net_mcu_BAD.c}`,历史 TEST DOUBLE 证据 `results/report.json` 与 `results/{good,B1..B7}/`。所有文件未提交、未改产品/供应商源码;第二步 serv 重写后待命做 `iec104_serv_net_tick` 针对性核查。
## 状态与边界
- 被测对象:`App/protocol/iec104/iec104_net_mcu.c`(真实板端 Net 后端,net-cutover 所有)对 `IEC104_Net.h` 的实现。
- 测试替身:`net_socket_fake.{h,c}` 按产品 `Drivers/BSP/NET/net_socket.h` 声明模拟 `net_*` owner 出口(包括 `net_send_try` / `net_pending_bytes` / `net_mono_now_ms` / `net_accept_locked` / `net_drop_conn_locked` / `net_ctx_is_owner_task` 等),并受控注入单连接同 fd、短写 / WOULD_BLOCK / BUSY / RETRY_LATER、EOF / RST、网络代次变化、句柄非复用、芯片接收队列长度与 32 位 tick 回绕。绝不调用真实 CH395F 或 Windows socket。
- **CH395F 同 fd 语义(fake 已如实建模,板端仍待验证)**:`net_accept` / `net_accept_locked` 返回**监听 socket 自身**(`net_socket_fake.c:629-643` 的 `return sockfd;`),并为同一 fake fd 置 `established=1`;`net_close` 对监听 fd 会**真实销毁监听**并递增 `listen_closed_attempts`(`net_socket_fake.c:760-777`),而 `net_drop_conn` 只拆会话、保留监听(`net_socket_fake.c:779-797`)。因此 fake 不是 Winsock 式独立 fd 语义,N1/N8 断言的“Close 不毁监听”确实在同 fd 规则下判定;但这只是 fake 忠实模拟,**CH395F 实际行为仍待板端验证**。
- 本目录不进 `MDK-ARM/*.uvprojx`,不碰产品构建;只在主机侧用 MSVC 编译运行。
- 证据边界:这是 **真实后端 + fake net 层** 的 Net ABI 隔离证据,不等于完整 `iec104_core` / `TcpServer` 链路,不等于板端 CH395F / netTask 时序,也不是 MCU WCET。完整 STARTDT 建链流程仍为 NOT_RUN。
- Lead 三条口径:① `Now_Ms` = N-2(owner 周期采样),只测回绕后单调,不测“不调用也不漏记”;② `Pending_Input` 精确:RX=7 报 7、RX=0 报 0,不谎报 1/0;③ `Send` 返回后不借用 buffer:每次用不同源 buffer,返回即覆写,再断言 fake 内核中字节未被破坏。
- 已知平台偏离:CH395F 无 `setsockopt`,`App/protocol/iec104/iec104_net_mcu.h` 注释已入档;恒无 Nagle 视作平台事实,**不以 NODELAY 作为 OK 条件**。plan.md 的入档由 net-cutover 负责。
## 静态源码检查(先于动态用例)
| 编号 | 检查 | 判据 | 实测 |
|---|---|---|---|
| S1 | `IEC104_Net_Close` 的 CLIENT/CLIENT_EOF 分支不含 `net_close_sock` | 花括号范围机械匹配,非肉眼 | PASS,源文件 582-588 行 |
| S2 | `IEC104_Net_Recv` 的 `rc==0` EOF 分支只改角色,不含任何 close/drop 调用 | 花括号范围机械匹配 | PASS,源文件 408-414 行 |
静态检查源文件 SHA256:`08ca22b9d61ec86181973ab97d7fab68ec8f0ecbf944bfd758e1546a80dc8b35`;`results/static/report.json` 记录逐项 `source_lines` / `evidence` / `passed`。
**S1/S2 覆盖面(重要)**:这是**文本级**静态检查——用花括号范围匹配特定分支,断言其中不出现 `net_close_sock` 等标识符;它覆盖直接调用形态,**不做语法树/控制流分析**,宏展开、函数指针或间接调用形态不在覆盖范围。不得把 S1/S2 PASS 表述为“所有关监听路径均不存在”。
静态判据自身有效性有降级证据:`check_static_selftest.py` 在 `results/static_mutant/iec104_net_mcu_BAD.c` 中把 `net_close_sock` 注入真实 Close 的 CLIENT 分支,断言 `check_static.py` 对该副本返回 `passed 1/2`(S1 失败)且 RC≠0,同时对真实源文件仍 `2/2` RC0。实测:`static-checker selftest: real_rc=0 mutant_rc=1`;证据 `results/static_mutant/{report.json,selftest.txt,iec104_net_mcu_BAD.c}`。产品源文件未改。
## 动态用例矩阵
共 **12 个命名用例**(N2 拆为 N2a/N2b 两个 case,但同属一个 N2 测试函数;`report.json` 的 `case_count=12`、`case_names` 与 `case_count_basis` 与此一致)。
| 编号 | 用例 | 关键断言 | 实测 |
|---|---|---|---|
| N1 | Close 会话不影响监听 | 逻辑 client handle ≠ listener handle;Close(client) 后 `listen_closed_attempts==0`、`drop_conn_calls>=1`,同一 listener 可再 Accept | PASS |
| N2a | Pending_Input 精确值 | RX=7 → `available==7`;排空后 RX=0 → `available==0` | PASS |
| N2b | 接收队列查询降级/报小不藏数据 | 300B 在哨兵/报小模式下仍全部交付,不死循环、不提前结束 | PASS |
| N3 | Send 短写推进 + 零借用 | 20B 分多次推进;20 个不同源 buffer 返回后均涂 `0xEE`;fake 内核仍为涂改前 `0x41..0x54` | PASS |
| N4 | Now_Ms 跨 32 位回绕单调 | tick `0xFFFFFFF0 → 0xFFFFFFFF → 0`;64 位值严格递增,回绕差值 1ms | PASS |
| N5 | 网络代次变化使旧句柄失效 | 旧 client 的 Send/Recv/Pending/Accept 均 ERROR/BADF;旧 client Close 幂等 OK 且 `hardware_calls` 零增长;无 Init 的新 Listen 可用 | PASS |
| N6 | fd 复用 / 陈旧句柄不串味 | Close 后旧 client handle 读写 ERROR、重复 Close 幂等;新 client handle 不同且可收发;监听从未被关 | PASS |
| N7 | 断链重连(Net 层) | RST → Recv ERROR → Close(client) → listener 仍活 → 新 client handle → Send OK;**完整 STARTDT 仍 NOT_RUN** | PASS(Net 层) |
| N8 | Close 后同一 listener 再 Accept | 第二次 Accept 成功;`listen_closed_attempts==0` 机器断言;listener fd 仍活 | PASS |
| N9 | 非 netTask 上下文拒绝 | 所有入口 `ERROR + NET_ERR_INVAL`;`available` / `ready_events` 输出不变;`hardware_calls` 零增长、无死锁 | PASS |
| N10 | 代次切换的两句柄模型(戊+不变量) | h_client ≠ h_listener;代次推进后两句柄均失效;旧 client Close 幂等 OK 且 `hardware_calls` 不增、`listen_closed_attempts==0`;代次推进后旧 listener 已失效(`armed==0`),**重建 Listen 后 `net_fake_listener_armed()==1` 正向断言**;不调 Init 重建 h3 严格 >旧句柄(无 ABA);新 client Send OK | PASS |
| N11 | 单 fd 会话的 Accept 一次性语义(2026-11-18 台架事故修复证据) | 已有 CLIENT 槽时第 2 次 Accept 返回 `IEC104_NET_WOULD_BLOCK`、client 出参不变;`drop_conn_calls` / `hardware_calls` 均**不增**(闸为纯 RAM,零芯片事务);`listen_closed_attempts==0`;`armed==1`;**H1 正向证明**:库手里的首个 client 句柄仍能命中 CLIENT 槽并 Send OK、会话 fd 不变且与监听槽同 fd(旧代码 memset 旧槽会让 H1 悬空 → BADF → Drop_Client,这是"STARTDT 无回应 + 20~33ms EOF"的第一击);Close 旧 client 后新 Accept 成功(无永久静默拒连) | PASS |
| N12 | 会话在役时 Wait 不报假 ACCEPT(重复 Accept 引擎闸) | 无会话时 `IEC104_Net_Wait(ACCEPT)` 报 READY;会话在役后 `ready_events` **不含** `IEC104_NET_EVENT_ACCEPT`(`net_listener_armed` 对 ESTABLISHED 恒返 1,不挡则库每轮误判可接入、重复调 Accept);Close 后恢复报 READY(非永久静默拒接) | PASS |
> 两句柄模型(net-cutover 第三轮定案):LISTEN 槽 handle 在监听生命周期内不变,Accept 另起 CLIENT 槽与新 handle;不再翻转监听槽 role。这正是 N8 / N10 / N11 的判据来源。
> N11 原语义("re-Accept 再发新句柄、只 memset 旧槽")已实测导致板端拆活连接,两层伤害:① 第 2 次 Accept 的 `memset(client_slot)` 清掉库仍持有的 H1 槽 → `slot_by_handle(H1)` 失败 → STARTDT_ACT 的 Send 报 BADF → Drop_Client(第一击,解释了 STARTDT 无回应 + 20~33ms EOF);② 即便不清槽而另开 H2,库仍在 `IEC104_TcpServer.c:1606` Close(client) 把与监听同 fd 的会话拆掉(第二击)。现行语义 = Accept 一次性硬闸(已有当前代次 CLIENT/CLIENT_EOF 槽一律 WOULD_BLOCK,含 EOF 收尾窗口,先纯 RAM 判后碰芯片)+ Wait 侧 ACCEPT 就绪闸(N12),Close 后自动释放。这是防止同根因复发的行为证据。
## 坏变体与注入有效性
- **TEST DOUBLE 阶段(历史 harness-validity 证据,不是产品证据)**:`netmcu_stub_test.c` + `stub_iec104_netmcu.c` 的 B1~B7 全部变红:`good 7/7`;`B1..B7 red 7/7`。注入点:B1 Close 误用 net_close、B2 Pending 降级谎报 0、B3 Send 借用 buffer、B4 tick 强转、B5 忽略代次、B6 陈旧 Close 误关、B7 重连沿用 startup_ack。原始逐变体日志保留在 `results/good/` 与 `results/B1/`~`results/B7/`。
- **真实后端阶段**:B1~B7 宏依赖 TEST DOUBLE,不适用于真实后端,标记 **NOT_RUN**;真实后端的文本级静态面由 S1/S2 + `check_static_selftest.py` 覆盖,行为面由 N1~N12 覆盖。不得把 TEST DOUBLE 的 7/7 红当成真实后端坏变体结果。
## 测试发现的问题(独立验收追溯)
| 时间 | 后端 SHA256 | 发现 | 处置 |
|---|---|---|---|
| 2026-11-17 23:20+ | `bc7154e5…`(第三轮两句柄初版,620 行) | 首次真实后端跑 N9:`Recv/Pending_Input/Send/Wait` 四入口缺 owner 闸,非 owner + 无效句柄返回 BADF/OK 而非 `ERROR+NET_ERR_INVAL` | net-cutover 补 owner 闸(最终 `08ca22b9…`,620 行),复测 PASS |
| 2026-11-17 23:22+ | `08ca22b9…` 前夕 | N10 初版断言暴露:重建 Listen 若走 `Init` 会重置句柄计数,产生 ABA 风险;测试改为**不调 Init** 的 `listen_only()` 并断言 h3 严格大于旧句柄 | 后端保持单调递增句柄实现,复测 PASS |
| 2026-11-17 23:26+ | `08ca22b9…` | 按 protocol-review/lead 补 A7 正向断言时发现 fake 的 `generation_inc` 会清掉旧监听 armed(芯片复位语义),“stale 后、重建前 armed==1”不成立;断言改为 stale 后 armed==0、重建后 armed==1 | 测试口径修正,非后端缺陷;复测 PASS |
## 复现命令与最终实测输出
仓库根执行(最终后端 SHA256 `08ca22b9d61ec86181973ab97d7fab68ec8f0ecbf944bfd758e1546a80dc8b35`):
```
python test/host/iec104_netmcu/check_static.py
python test/host/iec104_netmcu/check_static_selftest.py
python test/host/iec104_netmcu/run_netmcu_tests.py
```
实测输出:
```
static source sha256=08ca22b9d61ec86181973ab97d7fab68ec8f0ecbf944bfd758e1546a80dc8b35
S1: Close CLIENT/CLIENT_EOF branch contains no net_close_sock 582-588 passed=True
S2: Recv EOF branch only changes role; no close/drop call 408-414 passed=True
static passed 2/2
static-checker selftest: real_rc=0 mutant_rc=1
real: build_rc=0 run_rc=0 note= failed_cases=[]
real backend passed 12/12
```
`git diff --check -- test/host/iec104_netmcu` 无输出(RC0)。`results/real/build.log` / `results/real/run.log` 是逐条原始日志,`results/real/report.json` 记录被测源文件哈希、测试源文件哈希、case count = 13、失败用例列表、NOT_RUN 项与已知偏离。`results/static/report.json` 与 `results/static_mutant/report.json` 记录静态正向/变异结果。
## 证据口径
- 动态 13/13 + 文本级静态 2/2 + 静态 checker 变异自测 1 red 只证明:真实 Net 后端在 fake net 层上的 ABI 契约、两个文本级静态不变量,以及 N11 单 fd Accept 一次性语义(WOULD_BLOCK + 零芯片事务 + H1 仍有效 + Close 后释放)与 N12 Wait 侧 ACCEPT 就绪闸(会话在役不报假 ACCEPT、Close 后恢复)。
- 未证明 / NOT_RUN:完整 IEC104 STARTDT 业务链路、真实 CH395F 同 fd 行为(fake 忠实模拟但板端未验)、netTask 队列/临界区、板端时序与 MCU WCET、真实后端编译期坏变体、宏/函数指针间接调用形态的静态覆盖。不得写“板端已验证”。
+114
View File
@@ -0,0 +1,114 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Static acceptance checks for App/protocol/iec104/iec104_net_mcu.c.
S1: IEC104_Net_Close CLIENT/CLIENT_EOF branch must not contain net_close_sock.
S2: IEC104_Net_Recv rc==0 EOF branch must not call close/drop on the session.
Both checks use brace matching from the exact branch header, not line guesses.
"""
import hashlib
import json
import os
import re
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
SRC = os.path.join(ROOT, "App", "protocol", "iec104", "iec104_net_mcu.c")
OUT = os.path.join(HERE, "results", "static")
def sha256(path):
h = hashlib.sha256()
with open(path, "rb") as fh:
h.update(fh.read())
return h.hexdigest()
def brace_span(text, brace_pos):
assert text[brace_pos] == "{", "not a brace"
depth = 0
i = brace_pos
while i < len(text):
c = text[i]
if c == "{":
depth += 1
elif c == "}":
depth -= 1
if depth == 0:
return brace_pos, i + 1
i += 1
raise ValueError("unbalanced brace")
def func_body(text, name):
m = re.search(r"\b" + re.escape(name) + r"\s*\([^;{]*\)\s*\{", text)
if m is None:
raise ValueError("function not found: " + name)
start = text.index("{", m.start())
return brace_span(text, start)
def branch_body(text, span, needle):
a, b = span
pos = text.find(needle, a, b)
if pos < 0:
raise ValueError("branch not found: " + needle)
brace = text.index("{", pos)
assert brace < b
return brace_span(text, brace)
def main(src_path=None, report_path=None):
src_path = src_path or SRC
report_path = report_path or OUT
os.makedirs(report_path, exist_ok=True)
with open(src_path, "r", encoding="utf-8") as fh:
text = fh.read()
checks = []
close_span = func_body(text, "IEC104_Net_Close")
client_branch = branch_body(text, close_span,
"if (slot->role == SLOT_CLIENT || slot->role == SLOT_CLIENT_EOF)")
body = text[client_branch[0]:client_branch[1]]
checks.append({
"id": "S1",
"description": "Close CLIENT/CLIENT_EOF branch contains no net_close_sock",
"passed": "net_close_sock" not in body,
"source_lines": [text.count("\n", 0, client_branch[0]) + 1,
text.count("\n", 0, client_branch[1]) + 1],
"evidence": "\n".join(text[client_branch[0]:client_branch[1]].splitlines()[:3]),
})
recv_span = func_body(text, "IEC104_Net_Recv")
eof_branch = branch_body(text, recv_span, "if (rc == 0)")
eof_body = text[eof_branch[0]:eof_branch[1]]
forbidden = [tok for tok in ["net_close_sock", "net_drop_conn_locked",
"net_close(", "net_drop_conn("] if tok in eof_body]
checks.append({
"id": "S2",
"description": "Recv EOF branch only changes role; no close/drop call",
"passed": not forbidden,
"source_lines": [text.count("\n", 0, eof_branch[0]) + 1,
text.count("\n", 0, eof_branch[1]) + 1],
"evidence": eof_body.strip(),
})
report = {
"source": src_path,
"source_sha256": sha256(src_path),
"checks": checks,
"passed": sum(1 for c in checks if c["passed"]),
"total": len(checks),
}
with open(os.path.join(report_path, "report.json"), "w", encoding="utf-8") as fh:
json.dump(report, fh, ensure_ascii=False, indent=2)
print("static source sha256={}".format(report["source_sha256"]))
for c in checks:
print("{}: {} {}-{} passed={}".format(c["id"], c["description"],
c["source_lines"][0], c["source_lines"][1],
c["passed"]))
if not c["passed"]:
print(" evidence: {}".format(c["evidence"].replace("\n", " | ")))
print("static passed {}/{}".format(report["passed"], report["total"]))
return 0 if report["passed"] == report["total"] else 1
if __name__ == "__main__":
raise SystemExit(main())
@@ -0,0 +1,48 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Self-test the static checker against a deliberately BAD source copy.
Generates a copy of the real backend with `net_close_sock` injected into the
IEC104_Net_Close CLIENT branch, runs check_static.py.main() on the copy, and
asserts S1 fails there while the real source still passes. The product source
is never edited; the mutant stays under results/static_mutant/.
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import check_static # noqa: E402
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
SRC = check_static.SRC
OUT = os.path.join(HERE, "results", "static_mutant")
MUTANT = os.path.join(OUT, "iec104_net_mcu_BAD.c")
NEEDLE = " client_slot_drop(slot);\n return result(IEC104_NET_OK, 0, native_error);\n }\n /* LISTEN 分支"
def main():
os.makedirs(OUT, exist_ok=True)
with open(SRC, "r", encoding="utf-8") as fh:
text = fh.read()
assert text.count(NEEDLE) == 1, "Close CLIENT branch marker not unique"
bad = text.replace(
NEEDLE,
" (void)net_close_sock(net_get_sock(slot->fd)); /* BAD mutant */\n" + NEEDLE,
1,
)
assert bad != text, "mutant injection did not change the copy"
with open(MUTANT, "w", encoding="utf-8", newline="\n") as fh:
fh.write(bad)
real_rc = check_static.main()
mutant_rc = check_static.main(MUTANT, OUT)
with open(os.path.join(OUT, "selftest.txt"), "w", encoding="utf-8") as fh:
fh.write("real_rc={}\nmutant_rc={}\n".format(real_rc, mutant_rc))
fh.write("real source: {}\nmutant: {}\n".format(SRC, MUTANT))
print("static-checker selftest: real_rc={} mutant_rc={}".format(real_rc, mutant_rc))
return 0 if real_rc == 0 and mutant_rc != 0 else 1
if __name__ == "__main__":
raise SystemExit(main())
+832
View File
@@ -0,0 +1,832 @@
/*
* FAKE net_socket 实现 —— 见 net_socket_fake.h 的定位说明。
* 只服务 test/host/iec104_netmcu/,不进产品构建。
*/
#include "net_socket_fake.h"
#include <stdio.h>
#include <string.h>
/* fake_fd_t 定义见下方(fd_at 的前向声明在结构体之后)。 */
#define FAKE_MAX_FD 8
#define FAKE_RX_CAP 2048
#define FAKE_PEER_QUEUE 4
typedef struct {
int used;
int is_listener;
int listening;
int established;
int peer_fin;
int peer_reset;
int rx_len;
uint8_t rx[FAKE_RX_CAP];
/* 发送侧“内核还没接受”的暂存量:测试靠它验证“返回后改 buffer 不影响在途数据”。
* 真实驱动里这段数据已经进了芯片 FIFO,所以 fake 必须在 net_send 里就拷走。 */
int tx_pending;
uint8_t tx[FAKE_RX_CAP];
} fake_fd_t;
typedef struct {
uint8_t octet;
uint16_t port;
} fake_peer_t;
/* net_socket.h 在 NET_NO_OS 下不声明 fd_at;本 fake 的静态辅助函数保持该文件内私有。 */
static fake_fd_t *fd_at(int fd);
static uint16_t fake_recv_len(uint8_t sock);
static fake_fd_t fds[FAKE_MAX_FD];
static fake_peer_t peers[FAKE_PEER_QUEUE];
static int peer_count;
static uint32_t generation = 1;
/* 注意:板端 tick 源已由 net-cutover 钉为 HAL_GetTick(),fake 直接受控。
* N-2 口径:netTask 每轮调用 net_mono_now_ms() 采样一次 tick;这里模拟
* 两次采样之间的累计,不把“不调用就不丢时间”塞进用例。 */
static uint32_t tick_low;
static int fake_errno;
static uint8_t fake_owner = 1;
static uint64_t mono_ms;
static uint32_t mono_last;
static int mono_seeded;
static net_sock_t fake_socks[FAKE_MAX_FD];
/* net_socket.h 声明但后端可能查询这些轻量接口;fake 用内存状态回答。 */
int net_listener_armed(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && f->is_listener && (f->listening || f->established) ? 1 : 0;
}
int net_can_read(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && (f->rx_len > 0 || f->peer_fin || f->peer_reset) ? 1 : 0;
}
static net_fake_send_mode_t send_mode;
static int send_mode_left;
static int send_short_limit;
static net_fake_accept_mode_t accept_mode;
static int accept_mode_left;
static net_fake_send_mode_t recv_mode;
static int recv_mode_left;
static int recv_len_degraded;
static int reuse_after_close = 1;
static net_fake_stats_t stats;
static fake_fd_t *fd_at(int fd)
{
if (fd < 0 || fd >= FAKE_MAX_FD) {
return NULL;
}
return fds[fd].used ? &fds[fd] : NULL;
}
static int alloc_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
return i;
}
}
return -1;
}
void net_fake_reset(void)
{
memset(fds, 0, sizeof(fds));
memset(peers, 0, sizeof(peers));
memset(&stats, 0, sizeof(stats));
peer_count = 0;
generation = 1;
tick_low = 0;
send_mode = FAKE_SEND_NORMAL;
send_mode_left = 0;
send_short_limit = 0;
accept_mode = FAKE_ACCEPT_NORMAL;
accept_mode_left = 0;
recv_mode = FAKE_SEND_NORMAL;
recv_mode_left = 0;
recv_len_degraded = 0;
reuse_after_close = 1;
fake_owner = 1;
fake_errno = 0;
mono_ms = 0;
mono_last = tick_low;
mono_seeded = 0;
memset(fake_socks, 0, sizeof(fake_socks));
/* 预置一个已监听 fd=3:所有用例都从“板端后端已经 Listen 成功”起步。 */
fds[3].used = 1;
fds[3].is_listener = 1;
fds[3].listening = 1;
}
int net_fake_peer_arrive(uint8_t last_octet, uint16_t port)
{
if (peer_count >= FAKE_PEER_QUEUE) {
return 0;
}
peers[peer_count].octet = last_octet;
peers[peer_count].port = port;
++peer_count;
return 1;
}
int net_fake_session_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
/* 单连接模型:accept 后监听 fd 自身就是会话 fd,所以不能排除 is_listener。 */
if (fds[i].used && fds[i].established) {
return i;
}
}
return -1;
}
int net_fake_listen_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used && fds[i].is_listener && fds[i].listening) {
return i;
}
}
return -1;
}
int net_fake_listener_armed(void)
{
int fd = net_fake_listen_fd();
return (fd >= 0 && net_listener_armed(fd) != 0) ? 1 : 0;
}
int net_fake_push_rx(const void *data, int len)
{
int fd = net_fake_session_fd();
fake_fd_t *f;
int room;
if (fd < 0 || len <= 0) {
return -1;
}
f = &fds[fd];
room = FAKE_RX_CAP - f->rx_len;
if (len > room) {
len = room;
}
memcpy(f->rx + f->rx_len, data, (size_t)len);
f->rx_len += len;
return len;
}
void net_fake_peer_fin(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_fin = 1;
}
}
void net_fake_peer_reset(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_reset = 1;
}
}
void net_fake_set_send_mode(net_fake_send_mode_t mode, int times, int short_limit)
{
send_mode = mode;
send_mode_left = times;
send_short_limit = short_limit;
}
void net_fake_set_accept_mode(net_fake_accept_mode_t mode, int times)
{
accept_mode = mode;
accept_mode_left = times;
}
void net_fake_set_recv_mode(net_fake_send_mode_t mode, int times)
{
recv_mode = mode;
recv_mode_left = times;
}
void net_fake_set_recv_len_degraded(int mode)
{
recv_len_degraded = mode;
}
void net_fake_set_reuse_after_close(int on)
{
reuse_after_close = on ? 1 : 0;
}
void net_generation_inc(void)
{
++generation;
/* 代次变化 = 芯片复位:监听退回未监听,等待外层重建。
* 注意:故意保留 established 状态——真实芯片复位后旧 fd 数值可能被新连接
* 复用,驱动层不会替上层做“代次校验”;那正是后端必须自己查代次的原因。 */
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used) {
fds[i].listening = 0;
}
}
}
peer_count = 0;
}
void net_fake_generation_inc(void)
{
net_generation_inc();
}
uint32_t net_get_generation(void)
{
return generation;
}
uint32_t net_fake_generation(void)
{
return net_get_generation();
}
void net_fake_set_tick(uint32_t tick)
{
tick_low = tick;
}
uint32_t net_fake_tick_low(void)
{
return tick_low;
}
void net_fake_set_owner(uint8_t owner)
{
fake_owner = owner ? 1U : 0U;
}
uint8_t net_fake_owner(void)
{
return fake_owner;
}
uint32_t HAL_GetTick(void)
{
return tick_low;
}
uint8_t net_ctx_is_owner_task(void)
{
return fake_owner;
}
int net_set_errno(int err)
{
fake_errno = err;
return err;
}
int net_get_errno(void)
{
return fake_errno;
}
uint16_t net_dynamic_port_next(void)
{
static uint16_t next = 49152U;
uint16_t out = next;
next = (uint16_t)(out == 65535U ? 49152U : out + 1U);
return out;
}
uint16_t net_htons(uint16_t hostshort)
{
return (uint16_t)((hostshort >> 8) | (hostshort << 8));
}
uint16_t net_ntohs(uint16_t netshort)
{
return net_htons(netshort);
}
uint32_t net_inet_addr(const char *cp)
{
unsigned a, b, c, d;
if (cp == NULL || sscanf_s(cp, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) {
return 0U;
}
if (a > 255U || b > 255U || c > 255U || d > 255U) {
return 0U;
}
/* 与产品同族:s_addr 的第 0 个内存字节 == 点分第一段(小端数值反转)。 */
return (uint32_t)(a | (b << 8) | (c << 16) | (d << 24));
}
char *net_inet_ntoa(uint32_t addr, char *buf)
{
unsigned a = addr & 0xFFU;
unsigned b = (addr >> 8) & 0xFFU;
unsigned c = (addr >> 16) & 0xFFU;
unsigned d = (addr >> 24) & 0xFFU;
if (buf != NULL) {
(void)_snprintf_s(buf, 16, 15, "%u.%u.%u.%u", a, b, c, d);
}
return buf;
}
net_sock_t *net_get_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_t *net_sock_raw(int sockfd)
{
if (sockfd < 0 || sockfd >= FAKE_MAX_FD) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_state_t net_sock_state(int sockfd)
{
net_sock_t *s = net_sock_raw(sockfd);
return (s != NULL) ? s->state : NET_SOCK_STATE_CLOSED;
}
static void sync_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
net_sock_t *s = net_sock_raw(sockfd);
if (f == NULL || s == NULL) {
return;
}
s->ch395_sock = (uint8_t)sockfd;
s->in_use = 1U;
if (f->established) {
s->state = NET_SOCK_STATE_ESTABLISHED;
} else if (f->is_listener && f->listening) {
s->state = NET_SOCK_STATE_LISTENING;
} else if (f->used) {
s->state = NET_SOCK_STATE_CREATED;
} else {
s->state = NET_SOCK_STATE_CLOSED;
s->in_use = 0U;
}
s->send_ready = 1U;
s->readable = (uint8_t)(f->rx_len > 0 || f->peer_fin || f->peer_reset);
s->remote_port = (uint16_t)(stats.last_peer_port);
if (f->established) {
memcpy(s->remote_ip_arr, stats.last_peer_ip, sizeof(s->remote_ip_arr));
}
}
int net_listen_locked(int sockfd)
{
int rc = net_listen(sockfd);
sync_sock(sockfd);
return rc;
}
int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
int rc = net_accept(sockfd, addr, addrlen);
sync_sock(sockfd);
if (rc >= 0 && addr != NULL && addrlen != NULL && *addrlen >= (int)sizeof(struct net_sockaddr_in)) {
struct net_sockaddr_in *in = (struct net_sockaddr_in *)(void *)addr;
in->sin_family = NET_AF_INET;
in->sin_port = net_htons(stats.last_peer_port);
memcpy(&in->sin_addr.s_addr, stats.last_peer_ip, sizeof(in->sin_addr.s_addr));
}
return rc;
}
int net_drop_conn_locked(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_drop_conn((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_close_sock(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_close((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_send_sock(net_sock_t *p_sock, const void *buf, int len)
{
return net_send((int)p_sock->ch395_sock, buf, len, 0);
}
int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags)
{
return net_recv((int)p_sock->ch395_sock, buf, len, flags);
}
int net_pending_bytes(int sockfd)
{
fake_fd_t *f;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return -1;
}
f = fd_at(sockfd);
if (f == NULL || !f->established) {
net_set_errno(NET_ERR_BADF);
return -1;
}
++stats.recv_len_calls;
if (recv_len_degraded == 1) {
net_set_errno(NET_ERR_BUSY);
return -1;
}
return (int)fake_recv_len((uint8_t)sockfd);
}
int net_send_try(net_sock_t *p_sock, const void *buf, int len, int *sent)
{
int rc;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return NET_ERR_NOT_IN_NETTASK;
}
if (sent == NULL || p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
*sent = 0;
if (len > 1024) {
len = 1024;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc >= 0) {
*sent = rc;
return 0;
}
return rc;
}
uint64_t net_mono_now_ms(void)
{
uint32_t now = HAL_GetTick();
uint32_t delta;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return mono_ms;
}
if (!mono_seeded) {
mono_last = now;
mono_seeded = 1;
}
delta = now - mono_last;
mono_last = now;
mono_ms += (uint64_t)delta;
return mono_ms;
}
int net_send_locked(net_sock_t *p_sock, const void *buf, int len, TaskHandle_t caller)
{
int rc;
(void)caller;
if (p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc < 0) {
net_set_errno(NET_ERR_WOULDBLOCK);
}
return rc;
}
void net_fake_stats(net_fake_stats_t *out)
{
if (out != NULL) {
*out = stats;
}
}
void net_fake_stats_reset(void)
{
memset(&stats, 0, sizeof(stats));
}
/* 把 fake 内核中“已接受但尚未被对端取走”的字节拷给测试,验证 no-borrow。
* 返回可用长度;data 可为 NULL(只查询长度)。 */
int net_fake_copy_tx(uint8_t *data, int capacity)
{
int fd = net_fake_session_fd();
int n;
if (fd < 0) {
return -1;
}
n = fds[fd].tx_pending;
if (data != NULL && capacity > 0) {
int take = n < capacity ? n : capacity;
memcpy(data, fds[fd].tx, (size_t)take);
return take;
}
return n;
}
/* --------------------------- BSD 兼容面和 net_socket.h --------------------------- */
int net_socket(int domain, int type)
{
int i;
int fd;
(void)domain;
(void)type;
if (!reuse_after_close) {
/* 分配一个此前没用过的 fd,制造“旧整数被新会话复用”的对照。 */
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
sync_sock(i);
return i;
}
}
return -1;
}
fd = alloc_fd();
if (fd >= 0) {
sync_sock(fd);
}
return fd;
}
int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen)
{
(void)addr;
(void)addrlen;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_listen(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return -1;
}
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
fake_fd_t *f = fd_at(sockfd);
(void)addr;
(void)addrlen;
++stats.accept_calls;
++stats.hardware_calls;
if (accept_mode_left > 0 || accept_mode != FAKE_ACCEPT_NORMAL) {
net_fake_accept_mode_t mode = accept_mode;
if (accept_mode_left > 0) {
--accept_mode_left;
}
if (accept_mode_left == 0) {
accept_mode = FAKE_ACCEPT_NORMAL;
}
switch (mode) {
case FAKE_ACCEPT_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_ACCEPT_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_ACCEPT_RESOURCE_LOW:
return NET_ERR_NOMEM;
default:
break;
}
}
if (f == NULL || !f->listening || peer_count == 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
/* 单连接模型的核心:交回的“客户端 fd”就是监听 fd 本身。 */
f->established = 1;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
stats.last_peer_ip[0] = 10;
stats.last_peer_ip[1] = 0;
stats.last_peer_ip[2] = 0;
stats.last_peer_ip[3] = peers[0].octet;
stats.last_peer_port = peers[0].port;
memmove(&peers[0], &peers[1], sizeof(peers[0]) * (size_t)(peer_count - 1));
--peer_count;
sync_sock(sockfd);
return sockfd;
}
int net_send(int sockfd, const void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int accepted;
(void)flags;
++stats.send_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (send_mode_left > 0 || send_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = send_mode;
if (send_mode_left > 0) {
--send_mode_left;
}
if (send_mode_left == 0) {
send_mode = FAKE_SEND_NORMAL;
}
switch (mode) {
case FAKE_SEND_SHORT:
accepted = len < send_short_limit ? len : send_short_limit;
if (accepted <= 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
break;
case FAKE_SEND_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_SEND_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_SEND_ZERO_OK:
return 0;
default:
accepted = len;
break;
}
} else {
accepted = len;
}
/* 拷贝语义:数据在调用返回前就已进“芯片”,调用方随后改 buffer 不得影响它。 */
if (f->tx_pending + accepted > FAKE_RX_CAP) {
accepted = FAKE_RX_CAP - f->tx_pending;
}
if (accepted > 0) {
memcpy(f->tx + f->tx_pending, buf, (size_t)accepted);
f->tx_pending += accepted;
stats.bytes_sent += accepted;
}
return accepted;
}
int net_recv(int sockfd, void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int take;
(void)flags;
++stats.recv_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (f->peer_reset) {
return NET_ERR_CONNRESET;
}
if (recv_mode_left > 0 || recv_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = recv_mode;
if (recv_mode_left > 0) {
--recv_mode_left;
}
if (recv_mode_left == 0) {
recv_mode = FAKE_SEND_NORMAL;
}
if (mode == FAKE_SEND_WOULDBLOCK) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
if (mode == FAKE_SEND_BUSY) {
++stats.busy_returns;
return NET_ERR_BUSY;
}
}
if (f->rx_len == 0) {
if (f->peer_fin) {
return 0; /* EOF */
}
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
take = len < f->rx_len ? len : f->rx_len;
memcpy(buf, f->rx, (size_t)take);
memmove(f->rx, f->rx + take, (size_t)(f->rx_len - take));
f->rx_len -= take;
return take;
}
int net_recv_nb(int sockfd, void *buf, int len)
{
return net_recv(sockfd, buf, len, 0);
}
int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms)
{
(void)timeout_ms;
return net_recv(sockfd, buf, len, 0);
}
int net_setblocking(int sockfd, int on)
{
(void)on;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_close(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.close_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
if (f->is_listener) {
/* 真实板端:单连接模型下对监听 fd 调 net_close 会连监听一起毁掉。
* fake 如实模拟:返回成功但监听消失,同时留下违规计数供断言。 */
++stats.listen_closed_attempts;
memset(f, 0, sizeof(*f));
return 0;
}
memset(f, 0, sizeof(*f));
return 0;
}
int net_drop_conn(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.drop_conn_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
/* 拆会话、保监听:监听 fd 自身保留,会话状态清零。 */
f->established = 0;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
/* 板端后端需要的 32 位节拍源;签名以最终 plan.md / 后端源码为准。
* 当前先用无参形式提供测试可控 tick,后端若用 osKernelGetTickCount() 等
* 别的源,runner 通过 -D 重映射,用例不变。 */
uint32_t ch395f_get_tick_1ms(void)
{
return tick_low;
}
/* 驱动提供的接收队列长度查询(板端后端 Pending_Input 的数据来源)。
* 真实签名(Drivers/BSP/CH395F/ch395f.h:573):uint16_t ch395f_get_recv_len(uint8_t sock)。
* 降级模式返回 0 / 0xFFFF:后者模拟芯片异常,强制后端走 ERROR 契约。 */
static uint16_t fake_recv_len(uint8_t sock);
static uint16_t fake_recv_len(uint8_t sock)
{
fake_fd_t *f = fd_at((int)sock);
++stats.recv_len_calls;
if (f == NULL) {
return 0xFFFFU;
}
if (recv_len_degraded == 2) {
return 1U; /* 报小:每次只说 1 字节有界,剩余靠上层续收 */
}
if (recv_len_degraded == 1) {
return 0xFFFFU; /* 查询不可信:强制后端走 ERROR 降级路径 */
}
return (uint16_t)f->rx_len;
}
+136
View File
@@ -0,0 +1,136 @@
/*
* FAKE net_socket —— 板端 IEC104 Net 后端(iec104_net_mcu.c)的隔离契约测试替身。
*
* 定位:这不是产品实现,只在 test/host/iec104_netmcu/ 下被测试单元链接。
* 它按 Drivers/BSP/NET/net_socket.h 的**对外语义**实现 net_* 子集,
* 把 CH395F 侧的全部不确定性变成测试可控的开关。
*
* 被仿真的真实约束(每条都对应 MATRIX.md 里至少一个用例):
* 1. 单连接模型:net_accept() 交回的“客户端 fd”就是监听 fd 自身(同一整数);
* 对监听 fd 调 net_close() 会连监听一起毁掉 —— fake 里监听 fd 的
* net_close 直接返回 -1 并置 fault_listen_closed,让违规可被判红。
* 拆除会话的正解是 net_drop_conn()(保留监听、异步重建)。
* 2. net_send/net_recv/net_accept 均可短写 / WOULD_BLOCK / BUSY(RETRY)。
* 3. 接收侧没有 FIONREAD;“内核接收队列字节数”由 ch395f_get_recv_len() 等价
* 接口提供,fake 用 net_fake_recv_len() 暴露同一个值,并支持“降级”模式
* (返回 0 或未定义值),用于验证 Pending_Input 的降级契约。
* 4. 网络代次:net_generation_inc() 之后旧 fd 一律 NET_ERR_BADF(模拟芯片
* 复位/重连后句柄失效),新 listen 拿到新 fd。
* 5. 32 位节拍:net_fake_tick() 是板端 tick 的低 32 位,测试可直接把它
* 摆到 0xFFFFFFFF 验证回绕扩展。
*
* 未实现(故意):UDP、事件回调、net_select 的就绪判定细节、FreeRTOS 队列。
* 板端后端若调用这些,链接期会直接失败 —— 这正是我们要知道的“后端越界”。
*/
#ifndef NET_SOCKET_FAKE_H
#define NET_SOCKET_FAKE_H
#include <stdint.h>
#include "net_types.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ---------------------------- 控制面(仅测试用) ---------------------------- */
/* net_socket.h 的真实声明由产品头文件提供;本 fake 的 .c 通过产品 include 路径包含它。 */
#include "net_socket.h"
/* reset 到“干净上电”:无监听、无会话、无在途数据;监听 fd 由后端的
* IEC104_Net_Listen → net_socket/bind/listen 创建(单连接模型下这个整数
* 会同时充当客户端句柄)。 */
void net_fake_reset(void);
/* 建一个待接入的客户端(对端 10.0.0.x)。false = 队列已满。 */
int net_fake_peer_arrive(uint8_t last_octet, uint16_t port);
/* 往当前会话的接收队列灌数据(模拟对端已发出的字节)。 */
int net_fake_push_rx(const void *data, int len);
/* 模拟对端关闭(有序 FIN)。下一次 recv 在排空后返回 0。 */
void net_fake_peer_fin(void);
/* 模拟对端 RST(异常断链)。 */
void net_fake_peer_reset(void);
/* 控制下一次(或此后 n 次)net_send 的行为。 */
typedef enum {
FAKE_SEND_NORMAL = 0, /* 有多少收多少 */
FAKE_SEND_SHORT, /* 只收 short_limit 字节,其余留待下次 */
FAKE_SEND_WOULDBLOCK, /* 返回 NET_ERR_WOULDBLOCK,不接受任何字节 */
FAKE_SEND_BUSY, /* 返回 NET_ERR_BUSY(RETRY 语义) */
FAKE_SEND_ZERO_OK /* 返回 0 字节但 net_send 视为成功(OK 但零进度) */
} net_fake_send_mode_t;
void net_fake_set_send_mode(net_fake_send_mode_t mode, int times, int short_limit);
/* 控制下一次 net_accept 的行为。 */
typedef enum {
FAKE_ACCEPT_NORMAL = 0,
FAKE_ACCEPT_WOULDBLOCK,
FAKE_ACCEPT_BUSY, /* RETRY */
FAKE_ACCEPT_RESOURCE_LOW /* RETRY_LATER:芯片 socket 池暂缺 */
} net_fake_accept_mode_t;
void net_fake_set_accept_mode(net_fake_accept_mode_t mode, int times);
/* recv 侧故障注入:下一次 recv 返回 WOULD_BLOCK / BUSY。 */
void net_fake_set_recv_mode(net_fake_send_mode_t mode, int times);
/* 接收队列长度的“降级”契约:0 = 精确值;1 = 芯片查不到(返回 0xFFFF 哨兵),
* 2 = 恒返回小值 1(报小,但仍有数据;上层须有界续收而非一次即停)。
* 裸 0 与“真的空”不可区分,所以 fake 用 0xFFFF 表达“查询不可信”。 */
void net_fake_set_recv_len_degraded(int mode);
/* 网络代次:模拟芯片复位/重连。旧 fd 一律 NET_ERR_BADF;本 fake 直接调用
* 产品 net_socket.h 声明的 net_generation_inc() 递增代次,不做另一套计数器。 */
void net_fake_generation_inc(void);
uint32_t net_fake_generation(void);
/* 32 位 tick(板端节拍低 32 位)。 */
void net_fake_set_tick(uint32_t tick_low);
uint32_t net_fake_tick_low(void);
/* 执行上下文开关:1 = netTask owner(默认),0 = 非 owner。
* N9 用它验证后端每个入口自己拒绝,且底层硬件面零访问。 */
void net_fake_set_owner(uint8_t owner);
uint8_t net_fake_owner(void);
/* 观测:测试用来断言后端“没干坏事”。 */
typedef struct {
int listen_closed_attempts; /* 对监听 fd 调 net_close 的次数(必须始终 0) */
int close_calls;
int drop_conn_calls;
int accept_calls;
int send_calls;
int recv_calls;
int recv_len_calls;
int would_block_returns; /* 所有接口返回 WOULD_BLOCK 的累计 */
int busy_returns; /* 所有接口返回 BUSY 的累计 */
int bytes_sent; /* 实际被内核接受的字节数 */
int hardware_calls; /* 任何 net_* 底层动作计数(N9 必须零增长) */
uint8_t last_peer_ip[4]; /* 最近一次 accept 交出的对端 IP */
uint16_t last_peer_port;
} net_fake_stats_t;
void net_fake_stats(net_fake_stats_t *out);
void net_fake_stats_reset(void);
/* 当前会话 fd(未接入时为 -1)。同一时刻只允许一个会话(单连接模型)。 */
int net_fake_session_fd(void);
int net_fake_listen_fd(void);
/* close 后是否允许 fd 复用(默认 1;B6 的假后端会关掉它来制造复用)。 */
void net_fake_set_reuse_after_close(int on);
/* 读取 fake 内核已接受的发送字节(验证 Send 不借用调用方 buffer)。 */
int net_fake_copy_tx(uint8_t *data, int capacity);
/* 直接读取 fake 监听 armed 状态(= net_listener_armed 的同源状态)。 */
int net_fake_listener_armed(void);
#ifdef __cplusplus
}
#endif
#endif /* NET_SOCKET_FAKE_H */
+300
View File
@@ -0,0 +1,300 @@
/*
* IEC104 Net MCU 后端隔离契约测试 runner。
* 编译:假 net_socket + TEST DOUBLE 假后端 + 本文件;坏变体由 -DNETMCU_BAD=Bx 注入。
* 所有结果只证明 fake 契约与测试有效性,不证明产品实现。
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "IEC104_Net.h"
#include "net_socket_fake.h"
#include "stub_iec104_netmcu.h"
#ifndef NETMCU_BAD
#define NETMCU_BAD 0
#endif
static int failures;
static const char *current_case;
#define CHECK(cond, msg) do { \
if (!(cond)) { \
printf(" FAIL %s: %s\n", current_case, msg); \
++failures; \
} \
} while (0)
static IEC104_NetSocket_t setup_listen(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Init(NULL) == IEC104_NET_OK, "Init");
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK, "Listen");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
static IEC104_NetSocket_t setup_accept(IEC104_NetSocket_t listener, uint8_t octet)
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(net_fake_peer_arrive(octet, 40000U + octet) == 1, "peer arrive");
CHECK(IEC104_Net_Accept(listener, &client, &peer, NULL) == IEC104_NET_OK, "Accept");
CHECK(peer.port == (uint16_t)(40000U + octet), "peer port");
return client;
}
static void N1_close_keeps_listener(void)
{
IEC104_NetSocket_t l, c;
net_fake_stats_t st;
current_case = "N1";
stub_reset();
l = setup_listen(24001);
c = setup_accept(l, 11);
CHECK(c == l, "single-connection same fd");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "Close session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener never net_close'd");
CHECK(st.drop_conn_calls >= 1, "net_drop_conn used");
CHECK(net_fake_listen_fd() >= 0, "listener survives");
(void)setup_accept(l, 12);
net_fake_stats(&st);
CHECK(st.accept_calls >= 2, "second Accept works");
CHECK(st.listen_closed_attempts == 0, "still no listener close");
}
static void drain_input(IEC104_NetSocket_t client, size_t expected, int degraded)
{
uint8_t buf[128];
size_t total = 0;
int rounds = 0;
while (total < expected && rounds++ < 256) {
uint32_t available = 0xFFFFFFFFU;
IEC104_NetResult_t pr = IEC104_Net_Pending_Input(client, &available, NULL);
size_t budget;
IEC104_NetIoResult_t r;
if (pr == IEC104_NET_OK && available == 0 && degraded == 0) {
/* 精确契约下的 OK/0 才表示“此刻真的空”;降级场景不接受此捷径。 */
break;
}
if (degraded == 2 || pr == IEC104_NET_ERROR) {
/* 报小/不可信:退回完整缓冲,逼出有界续收而不把数据永久藏住。 */
available = (uint32_t)sizeof(buf);
}
budget = available > sizeof(buf) ? sizeof(buf) : available;
r = IEC104_Net_Recv(client, buf, budget);
if (r.result == IEC104_NET_OK) {
total += r.transferred;
} else if (r.result == IEC104_NET_EOF) {
break;
} else {
/* WOULD_BLOCK/RETRY:有界继续,不据此重算超时。 */
}
}
CHECK(total == expected, "all bytes delivered");
}
static void N2_pending_input(void)
{
IEC104_NetSocket_t l, c;
static const uint8_t data[300] = {0};
current_case = "N2a";
stub_reset();
l = setup_listen(24002);
c = setup_accept(l, 21);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B");
drain_input(c, sizeof(data), 0);
current_case = "N2b";
stub_reset();
l = setup_listen(24003);
c = setup_accept(l, 22);
/* 精确契约:不谎报 0/1——RX 有 7 字节报 7,RX 空报 0。 */
{
uint32_t n = 0xFFFFFFFFU;
static const uint8_t seven[7] = {1, 2, 3, 4, 5, 6, 7};
CHECK(net_fake_push_rx(seven, 7) == 7, "queue 7B exact probe");
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 7,
"Pending_Input exact 7");
{
uint8_t tmp[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, tmp, sizeof(tmp));
CHECK(rr.result == IEC104_NET_OK && rr.transferred == 7, "drain 7B exact probe");
}
n = 0xFFFFFFFFU;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 0,
"Pending_Input exact 0 (empty)");
}
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B degraded");
net_fake_set_recv_len_degraded(1); /* 内核仍有 300B,但驱动只报不可信哨兵 */
drain_input(c, sizeof(data), 1);
/* 报小:每次只报 1 字节,仍不能让剩余数据永久藏住;独立重灌一遍。 */
stub_reset();
l = setup_listen(24009);
c = setup_accept(l, 23);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B under-report");
net_fake_set_recv_len_degraded(2);
drain_input(c, sizeof(data), 2);
}
static void N3_send_short_write(void)
{
IEC104_NetSocket_t l, c;
uint8_t bufs[20][20]; /* 每次 Send 用不同 buffer;返回后立刻涂改刚用过的那块 */
uint8_t sent[64];
net_fake_stats_t st;
size_t i, off = 0;
int rounds = 0;
current_case = "N3";
stub_reset();
l = setup_listen(24004);
c = setup_accept(l, 31);
for (i = 0; i < sizeof(bufs) / sizeof(bufs[0]); ++i) {
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
bufs[i][k] = (uint8_t)(0x41 + k);
}
}
net_fake_set_send_mode(FAKE_SEND_SHORT, 2, 3);
while (off < sizeof(bufs[0]) && rounds++ < 20) {
IEC104_NetIoResult_t r = IEC104_Net_Send(c, bufs[rounds - 1] + off,
sizeof(bufs[0]) - off);
if (r.result == IEC104_NET_OK) { off += r.transferred; }
/* 调用方返回后立刻整块覆写:后端若借用指针,下次就会发出 0xEE。 */
memset(bufs[rounds - 1], 0xEE, sizeof(bufs[0]));
}
CHECK(off == sizeof(bufs[0]), "short-write progressed to completion");
net_fake_stats(&st);
CHECK(st.bytes_sent == (int)sizeof(bufs[0]), "kernel accepted all bytes");
CHECK(net_fake_copy_tx(sent, (int)sizeof(sent)) == (int)sizeof(bufs[0]),
"fake kernel holds all 20 bytes");
{
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
CHECK((unsigned char)sent[k] == (unsigned char)(0x41 + k),
"in-flight bytes match pre-mutation payload");
}
}
}
static void N4_now_ms_wrap(void)
{
uint64_t a, b, c;
current_case = "N4";
stub_reset();
(void)IEC104_Net_Init(NULL);
net_fake_set_tick(0xFFFFFFF0U);
a = IEC104_Net_Now_Ms();
net_fake_set_tick(0xFFFFFFFFU);
b = IEC104_Net_Now_Ms();
net_fake_set_tick(0x00000000U);
c = IEC104_Net_Now_Ms();
CHECK(b > a, "monotonic before wrap");
CHECK(c > b, "monotonic across 0xFFFFFFFF -> 0");
CHECK((int)(c - b) == 1, "one tick = one ms across wrap");
}
static void N5_generation_invalidates(void)
{
IEC104_NetSocket_t l, c;
uint8_t b[4] = {1, 2, 3, 4};
uint32_t gen0;
current_case = "N5";
stub_reset();
l = setup_listen(24005);
c = setup_accept(l, 51);
gen0 = net_fake_generation();
net_fake_generation_inc();
CHECK(net_fake_generation() == gen0 + 1, "generation bumped");
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(c, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR, "old handle invalid");
CHECK(rr.transferred == 0, "old handle transferred zero");
}
/* 代次变化后旧句柄 Send/Recv 都必须被拒绝。 */
{
char rb[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, rb, sizeof(rb));
CHECK(rr.result == IEC104_NET_ERROR, "old handle recv invalid");
CHECK(rr.transferred == 0, "old handle recv transferred zero");
}
net_fake_set_tick(0x00000010U);
CHECK(IEC104_Net_Now_Ms() > 0, "clock still works");
/* 重建:Init + Listen + Accept 新 peer */
stub_reset();
l = setup_listen(24006);
c = setup_accept(l, 52);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"new handle usable after reset");
}
static void N6_fd_reuse_no_cross_talk(void)
{
IEC104_NetSocket_t l, c1;
uint8_t b[4] = {9, 9, 9, 9};
net_fake_stats_t st;
current_case = "N6";
stub_reset();
l = setup_listen(24007);
c1 = setup_accept(l, 61);
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "close first session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener intact after close");
CHECK(net_fake_listen_fd() >= 0, "listener fd alive");
/* 单连接模型下 fd 数值会被复用:陈旧句柄不得再读写“空会话”。 */
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_ERROR,
"stale handle cannot write after close");
{
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c1, (char[8]){0}, 8);
CHECK(rr.result == IEC104_NET_ERROR || rr.transferred == 0,
"stale handle cannot read after close");
}
/* 陈旧句柄重复 Close 必须幂等 no-op,不得把复用后的监听毁掉。 */
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "stale close is idempotent");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "stale close never touches listener");
CHECK(net_fake_listen_fd() >= 0, "listener alive after stale close");
/* 新会话仍能接入并收发。 */
c1 = setup_accept(l, 62);
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_OK,
"new session usable after stale close");
}
static void N7_reconnect_startdt(void)
{
IEC104_NetSocket_t l, c;
current_case = "N7";
stub_reset();
l = setup_listen(24008);
c = setup_accept(l, 71);
stub_link_send_startdt(c);
stub_link_push_con();
CHECK(stub_link_ready(c) == 1, "STARTDT/STARTDT CON first session");
/* RST -> Recv 返回 ERROR;Close 会话;重新接入 */
net_fake_peer_reset();
CHECK(IEC104_Net_Recv(c, (char[8]){0}, 8).result == IEC104_NET_ERROR, "RST observed");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close broken session");
CHECK(stub_link_ready(c) == 0, "reconnect starts with no stale STARTDT");
c = setup_accept(l, 72);
CHECK(c != IEC104_NET_INVALID_SOCKET, "re-accepted");
stub_link_send_startdt(c);
stub_link_push_con();
CHECK(stub_link_ready(c) == 1, "STARTDT link rebuilt after reconnect");
}
int main(void)
{
printf("=== IEC104 Net MCU fake-contract tests (bad=%d) ===\n", NETMCU_BAD);
N1_close_keeps_listener();
N2_pending_input();
N3_send_short_write();
N4_now_ms_wrap();
N5_generation_invalidates();
N6_fd_reuse_no_cross_talk();
N7_reconnect_startdt();
printf("=== IEC104 Net MCU fake-contract tests: %d failures ===\n", failures);
return failures ? 1 : 0;
}
+513
View File
@@ -0,0 +1,513 @@
/*
* IEC104 Net MCU backend isolation contract tests.
* Builds the REAL App/protocol/iec104/iec104_net_mcu.c against a fake net layer.
* This is host-only evidence for the Net ABI, not full core/TcpServer or hardware.
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "IEC104_Net.h"
#include "net_socket_fake.h"
#ifndef NETMCU_BAD
#define NETMCU_BAD 0
#endif
static int failures;
static const char *current_case;
#define CHECK(cond, msg) do { \
if (!(cond)) { \
printf(" FAIL %s: %s\n", current_case, msg); \
++failures; \
} \
} while (0)
static IEC104_NetSocket_t setup_listen(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Init(NULL) == IEC104_NET_OK, "Init");
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK, "Listen");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
/* 不重新 Init:代次切换后的重建只调 Listen(Init 会重置句柄计数,掩盖 ABA)。 */
static IEC104_NetSocket_t listen_only(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK,
"Listen without Init");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
static IEC104_NetSocket_t setup_accept(IEC104_NetSocket_t listener, uint8_t octet)
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(net_fake_peer_arrive(octet, (uint16_t)(40000U + octet)) == 1, "peer arrive");
CHECK(IEC104_Net_Accept(listener, &client, &peer, NULL) == IEC104_NET_OK, "Accept");
CHECK(peer.port == (uint16_t)(40000U + octet), "peer port");
return client;
}
static void N1_close_keeps_listener(void)
{
IEC104_NetSocket_t l, c;
net_fake_stats_t st;
current_case = "N1";
net_fake_reset();
l = setup_listen(24001);
c = setup_accept(l, 11);
CHECK(c != l, "logical client handle differs from listener");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "Close session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener never net_close'd");
CHECK(st.drop_conn_calls >= 1, "net_drop_conn used");
CHECK(net_fake_listen_fd() >= 0, "listener survives");
(void)setup_accept(l, 12);
net_fake_stats(&st);
CHECK(st.accept_calls >= 2, "second Accept works");
CHECK(st.listen_closed_attempts == 0, "still no listener close");
}
static void drain_input(IEC104_NetSocket_t client, size_t expected, int degraded)
{
uint8_t buf[128];
size_t total = 0;
int rounds = 0;
while (total < expected && rounds++ < 256) {
uint32_t available = 0xFFFFFFFFU;
int ne = 0;
IEC104_NetResult_t pr = IEC104_Net_Pending_Input(client, &available, &ne);
size_t budget;
IEC104_NetIoResult_t r;
if (pr == IEC104_NET_OK && available == 0 && degraded == 0) {
break;
}
if (degraded == 2 || pr == IEC104_NET_ERROR) {
available = (uint32_t)sizeof(buf);
}
budget = available > sizeof(buf) ? sizeof(buf) : available;
if (budget == 0U) {
budget = sizeof(buf);
}
r = IEC104_Net_Recv(client, buf, budget);
if (r.result == IEC104_NET_OK) {
total += r.transferred;
} else if (r.result == IEC104_NET_EOF) {
break;
}
}
CHECK(total == expected, "all bytes delivered");
}
static void N2_pending_input(void)
{
IEC104_NetSocket_t l, c;
static const uint8_t data[300] = {0};
current_case = "N2a";
net_fake_reset();
l = setup_listen(24002);
c = setup_accept(l, 21);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B");
drain_input(c, sizeof(data), 0);
current_case = "N2b";
net_fake_reset();
l = setup_listen(24003);
c = setup_accept(l, 22);
{
uint32_t n = 0xFFFFFFFFU;
static const uint8_t seven[7] = {1, 2, 3, 4, 5, 6, 7};
CHECK(net_fake_push_rx(seven, 7) == 7, "queue 7B exact probe");
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 7,
"Pending_Input exact 7");
{
uint8_t tmp[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, tmp, sizeof(tmp));
CHECK(rr.result == IEC104_NET_OK && rr.transferred == 7, "drain 7B exact probe");
}
n = 0xFFFFFFFFU;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 0,
"Pending_Input exact 0 (empty)");
}
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B degraded");
net_fake_set_recv_len_degraded(1);
drain_input(c, sizeof(data), 1);
net_fake_reset();
l = setup_listen(24009);
c = setup_accept(l, 23);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B under-report");
net_fake_set_recv_len_degraded(2);
drain_input(c, sizeof(data), 2);
}
static void N3_send_short_write(void)
{
IEC104_NetSocket_t l, c;
uint8_t bufs[20][20];
uint8_t sent[64];
net_fake_stats_t st;
size_t i, off = 0;
int rounds = 0;
current_case = "N3";
net_fake_reset();
l = setup_listen(24004);
c = setup_accept(l, 31);
for (i = 0; i < sizeof(bufs) / sizeof(bufs[0]); ++i) {
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
bufs[i][k] = (uint8_t)(0x41 + k);
}
}
net_fake_set_send_mode(FAKE_SEND_SHORT, 2, 3);
while (off < sizeof(bufs[0]) && rounds++ < 20) {
IEC104_NetIoResult_t r = IEC104_Net_Send(c, bufs[rounds - 1] + off,
sizeof(bufs[0]) - off);
if (r.result == IEC104_NET_OK) {
off += r.transferred;
}
memset(bufs[rounds - 1], 0xEE, sizeof(bufs[0]));
}
CHECK(off == sizeof(bufs[0]), "short-write progressed to completion");
net_fake_stats(&st);
CHECK(st.bytes_sent == (int)sizeof(bufs[0]), "kernel accepted all bytes");
CHECK(net_fake_copy_tx(sent, (int)sizeof(sent)) == (int)sizeof(bufs[0]),
"fake kernel holds all 20 bytes");
{
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
CHECK((unsigned char)sent[k] == (unsigned char)(0x41 + k),
"in-flight bytes match pre-mutation payload");
}
}
}
static void N4_now_ms_wrap(void)
{
uint64_t a, b, c;
current_case = "N4";
net_fake_reset();
(void)IEC104_Net_Init(NULL);
net_fake_set_tick(0xFFFFFFF0U);
a = IEC104_Net_Now_Ms();
net_fake_set_tick(0xFFFFFFFFU);
b = IEC104_Net_Now_Ms();
net_fake_set_tick(0x00000000U);
c = IEC104_Net_Now_Ms();
CHECK(b > a, "monotonic before wrap");
CHECK(c > b, "monotonic across 0xFFFFFFFF -> 0");
CHECK((int)(c - b) == 1, "one tick = one ms across wrap");
}
static void N5_generation_invalidates(void)
{
IEC104_NetSocket_t l, c;
uint8_t b[4] = {1, 2, 3, 4};
current_case = "N5";
net_fake_reset();
l = setup_listen(24005);
c = setup_accept(l, 51);
net_fake_generation_inc();
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(c, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client Send ERROR/BADF");
}
{
char rb[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, rb, sizeof(rb));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client Recv ERROR/BADF");
}
{
uint32_t n = 0;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_ERROR,
"stale client Pending_Input ERROR");
CHECK(n == 0, "Pending failure leaves output unchanged");
}
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(l, &client, &peer, NULL) == IEC104_NET_ERROR,
"stale listener Accept ERROR");
CHECK(client == IEC104_NET_INVALID_SOCKET, "failed Accept output untouched");
}
{
net_fake_stats_t before, after;
net_fake_stats(&before);
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "stale Close idempotent OK");
net_fake_stats(&after);
CHECK(after.listen_closed_attempts == before.listen_closed_attempts,
"stale Close touches no hardware");
CHECK(after.hardware_calls == before.hardware_calls,
"stale Close makes no net_* call");
}
/* 新 Listen 清掉过期槽,新建监听可用。 */
l = setup_listen(24006);
c = setup_accept(l, 52);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"new generation handle usable");
}
static void N6_fd_reuse_no_cross_talk(void)
{
IEC104_NetSocket_t l, c1, c2;
uint8_t b[4] = {9, 9, 9, 9};
net_fake_stats_t st;
current_case = "N6";
net_fake_reset();
l = setup_listen(24007);
c1 = setup_accept(l, 61);
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "close first session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener intact after close");
CHECK(net_fake_listen_fd() >= 0, "listener fd alive");
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_ERROR,
"stale handle cannot write after close");
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "stale close is idempotent");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "stale close never touches listener");
c2 = setup_accept(l, 62);
CHECK(c2 != c1, "new client handle differs from stale one");
CHECK(IEC104_Net_Send(c2, b, sizeof(b)).result == IEC104_NET_OK,
"new session usable after stale close");
}
static void N7_reconnect_net_layer(void)
{
IEC104_NetSocket_t l, c, c2;
uint8_t b[2] = {0x68, 0x04};
current_case = "N7";
net_fake_reset();
l = setup_listen(24008);
c = setup_accept(l, 71);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"first session sends");
net_fake_peer_reset();
CHECK(IEC104_Net_Recv(c, b, sizeof(b)).result == IEC104_NET_ERROR, "RST observed");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close broken session");
CHECK(net_fake_listen_fd() >= 0, "listener survives RST close");
c2 = setup_accept(l, 72);
CHECK(c2 != c, "new client handle after reconnect");
CHECK(IEC104_Net_Send(c2, b, sizeof(b)).result == IEC104_NET_OK,
"new session sends after reconnect");
}
static void N8_close_preserves_listener(void)
{
IEC104_NetSocket_t l, c, c2;
net_fake_stats_t st;
current_case = "N8";
net_fake_reset();
l = setup_listen(24010);
c = setup_accept(l, 81);
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "first Close");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "first Close never net_close'd listener");
CHECK(net_fake_listen_fd() >= 0, "listener alive after first Close");
c2 = setup_accept(l, 82); CHECK(c2 != IEC104_NET_INVALID_SOCKET, "second Accept on same listener succeeded");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "machine counter still zero");
CHECK(net_fake_listen_fd() >= 0, "same physical listener still alive");
}
static void N9_non_owner_rejected(void)
{
IEC104_NetSocket_t l = IEC104_NET_INVALID_SOCKET;
IEC104_NetSocket_t c = IEC104_NET_INVALID_SOCKET;
IEC104_NetSocket_t bad = (IEC104_NetSocket_t)1U;
uint16_t bound = 0;
IEC104_NetPeer_t peer;
uint8_t buf[4] = {1, 2, 3, 4};
uint32_t available = 0;
uint32_t ready = 0xFFFFFFFFU;
net_fake_stats_t before, after;
int ne = 0;
current_case = "N9";
net_fake_reset();
net_fake_set_owner(0U); /* 本测试进程 = 明确非 owner 上下文 */
CHECK(IEC104_Net_Init(&ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Init rejects non-owner");
CHECK(IEC104_Net_Listen("0.0.0.0", 24011, &l, &bound, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && l == IEC104_NET_INVALID_SOCKET && bound == 0,
"Listen rejects non-owner with outputs unchanged");
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(bad, &c, &peer, &ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Accept rejects non-owner");
{
IEC104_NetIoResult_t rr = IEC104_Net_Recv(bad, buf, sizeof(buf));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_INVAL,
"Recv rejects non-owner");
}
CHECK(IEC104_Net_Pending_Input(bad, &available, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && available == 0,
"Pending_Input rejects non-owner, output unchanged");
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(bad, buf, sizeof(buf));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_INVAL,
"Send rejects non-owner");
}
CHECK(IEC104_Net_Wait(bad, bad, IEC104_NET_EVENT_READ, 0U, &ready, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && ready == 0xFFFFFFFFU,
"Wait rejects non-owner, output unchanged");
net_fake_stats(&before);
CHECK(IEC104_Net_Close(bad, &ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Close rejects non-owner");
net_fake_stats(&after);
CHECK(after.hardware_calls == before.hardware_calls, "zero hardware access");
net_fake_set_owner(1U);
}
static void N10_generation_two_handles(void)
{
IEC104_NetSocket_t h1, h2, h3;
uint8_t b[4] = {1, 2, 3, 4};
net_fake_stats_t before, after;
current_case = "N10";
net_fake_reset();
h1 = setup_listen(24012);
h2 = setup_accept(h1, 91);
CHECK(h2 != h1, "client handle differs from listener handle");
net_fake_generation_inc();
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(h2, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client handle rejected after generation change");
}
{
IEC104_NetSocket_t c = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(h1, &c, &peer, NULL) == IEC104_NET_ERROR,
"stale listener handle rejected after generation change");
}
net_fake_stats(&before);
CHECK(IEC104_Net_Close(h2, NULL) == IEC104_NET_OK, "stale client Close idempotent OK");
net_fake_stats(&after);
CHECK(after.hardware_calls == before.hardware_calls,
"stale client Close touches no hardware");
CHECK(after.listen_closed_attempts == 0,
"stale client Close never closes listener (absolute zero)");
/* 正向断言:代次推进后旧监听资源已随芯片复位失效;此时不得靠旧 fd
* 继续 armed。下一行重建后的 armed==1 才是 A7 要的“监听资源存活”。 */
CHECK(net_fake_listener_armed() == 0,
"stale generation cleared old listener before rebuild");
/* 新代次重建监听;旧槽已在 Listen 内清掉。故意不调 Init(Init 会重置
* 句柄计数),因此 h3 必须严格大于旧句柄,证明没有 ABA 复用。 */
h3 = listen_only(24013);
CHECK(h3 > h1 && h3 > h2, "new listener handle is fresh, not ABA-reused");
CHECK(net_fake_listener_armed() == 1,
"rebuilt listener is armed (net_listener_armed == 1)");
net_fake_stats(&after);
CHECK(after.listen_closed_attempts == 0,
"listener_closed_attempts is explicitly zero after rebuild");
CHECK(IEC104_Net_Send(setup_accept(h3, 92), b, sizeof(b)).result == IEC104_NET_OK,
"new generation client works");
}
/* 正向证明库手里的首个 client 句柄 H1 仍有效:Send 成功 + 会话 fd 未变
* (H1 若被 memset 悬空,Send 会走 find_client 失败返回 ERROR+NET_ERR_BADF)。 */
static void check_client_handle_live(IEC104_NetSocket_t client, int fd_before)
{
uint8_t b[1] = { 'x' };
CHECK(IEC104_Net_Send(client, b, sizeof(b)).result == IEC104_NET_OK,
"H1 handle still resolves to live CLIENT slot after refused re-Accept");
CHECK(net_fake_session_fd() == fd_before, "H1 session fd unchanged");
}
static void N11_accept_is_one_shot_until_client_closed(void)
{
IEC104_NetSocket_t h1, client, second;
IEC104_NetPeer_t peer;
net_fake_stats_t before, after;
int fd_before;
current_case = "N11";
net_fake_reset();
h1 = setup_listen(24014);
client = setup_accept(h1, 93);
fd_before = net_fake_session_fd();
/* 台架 2026-11-18 定案:单 fd 下 net_accept_locked 对 ESTABLISHED 幂等
* 成功,库的 4 次预算循环会再调 Accept 并把刚发的句柄当"多余客户端"
* Close(同 fd → 拆掉活连接)。新语义:同一会话只交付一次,第二次
* Accept 必须 WOULD_BLOCK,且不发任何芯片事务、不拆旧会话。 */
memset(&peer, 0, sizeof(peer));
net_fake_stats(&before);
second = IEC104_NET_INVALID_SOCKET;
CHECK(IEC104_Net_Accept(h1, &second, &peer, NULL) == IEC104_NET_WOULD_BLOCK,
"second Accept returns WOULD_BLOCK (one-shot per session)");
CHECK(second == IEC104_NET_INVALID_SOCKET, "second Accept leaves client output untouched");
net_fake_stats(&after);
CHECK(after.drop_conn_calls == before.drop_conn_calls,
"second Accept never drops the live same-fd session");
CHECK(after.hardware_calls == before.hardware_calls,
"gate is pure RAM: no chip transaction when a session exists");
CHECK(after.listen_closed_attempts == 0, "listener still intact");
CHECK(net_fake_listener_armed() == 1, "listener still armed");
/* 旧槽仍有效:正向三条 —— H1 能命中 CLIENT 槽并 Send 成功、会话 fd 不变、
* 与监听槽同 fd(库两句柄模型的 fd 契约)。H1 若被旧 memset 段清掉,
* Send 会 find_client 失败返回 ERROR+NET_ERR_BADF,这条立即红。 */
check_client_handle_live(client, fd_before);
CHECK(net_fake_session_fd() == net_fake_listen_fd(),
"H1 still shares listener fd (no new session fd allocated)");
/* Close 旧会话后闸自动释放:下一次 Accept 仍能接入,不会永久静默拒连。 */
CHECK(IEC104_Net_Close(client, NULL) == IEC104_NET_OK, "close old client OK");
second = setup_accept(h1, 94);
CHECK(second != IEC104_NET_INVALID_SOCKET && second != client,
"new client accepted after old client closed (no permanent lockout)");
}
static void N12_wait_reports_no_accept_while_session_active(void)
{
IEC104_NetSocket_t l, c;
uint32_t ready = 0xFFFFFFFFU;
current_case = "N12";
net_fake_reset();
l = setup_listen(24015);
/* 会话在役前:armed 监听应如实报 ACCEPT 就绪(现网新连接可接入)。 */
CHECK(IEC104_Net_Wait(l, IEC104_NET_INVALID_SOCKET, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait before session OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) != 0U,
"ACCEPT ready reported when no client session exists");
/* 会话在役后:net_listener_armed 对 ESTABLISHED 恒返 1,旧实现每轮报
* 假 ACCEPT → 库每轮再调 Accept(重复 Accept 引擎);新闸必须如实报
* "无接入需求",这样即使 Accept 侧闸缺失也不再触发重复接入。 */
c = setup_accept(l, 95);
ready = 0xFFFFFFFFU;
CHECK(IEC104_Net_Wait(l, c, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait during session OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) == 0U,
"ACCEPT NOT ready while client session active (single fd is data channel)");
/* Close 后释放:再次 Wait 应恢复 ACCEPT 就绪,证明不是永久静默拒接。 */
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close session OK");
ready = 0xFFFFFFFFU;
CHECK(IEC104_Net_Wait(l, IEC104_NET_INVALID_SOCKET, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait after close OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) != 0U,
"ACCEPT ready again after session closed");
}
int main(void)
{
printf("=== IEC104 Net MCU real-backend contract tests (bad=%d) ===\n", NETMCU_BAD);
N1_close_keeps_listener();
N2_pending_input();
N3_send_short_write();
N4_now_ms_wrap();
N5_generation_invalidates();
N6_fd_reuse_no_cross_talk();
N7_reconnect_net_layer();
N8_close_preserves_listener();
N9_non_owner_rejected();
N10_generation_two_handles();
N11_accept_is_one_shot_until_client_closed();
N12_wait_reports_no_accept_while_session_active();
printf("=== IEC104 Net MCU real-backend contract tests: %d failures ===\n", failures);
return failures ? 1 : 0;
}
@@ -0,0 +1,44 @@
{
"scope": "REAL backend App/protocol/iec104/iec104_net_mcu.c + fake net layer; host-only isolation evidence, not full core/TcpServer/hardware",
"backend_sha256": "4d6b8d9e8ed3404372f274d99c16bc87a06fecbee8db0b30b044b24d0562d73d",
"sources": {
"MATRIX.md": "e8c913cac2a852173f052ce806a3da101a272e2a4dff8751499fdcf39788deab",
"net_socket_fake.h": "d597375d1186b4801b4dc859401b6f3f0c9d1110efda37d0a9e73b810d7a8cd0",
"net_socket_fake.c": "8eb9ea5ed195b38e2f4993ac021ad19afa40464ff03de73628d3a795350a631e",
"netmcu_test.c": "09c203941c41fbb543580f45192c1604b984daaeb10135548756d4e42e8ebe02",
"check_static.py": "8f08695a6c6bffec6047558b5b6d0aff0c7393665853357d1176f61b1aac1132"
},
"case_count": 13,
"case_count_basis": "13 named cases; N2a/N2b are two cases in one N2 test function",
"case_names": [
"N1",
"N2a",
"N2b",
"N3",
"N4",
"N5",
"N6",
"N7",
"N8",
"N9",
"N10",
"N11",
"N12"
],
"result": {
"build_rc": 0,
"run_rc": 0,
"failures": 0,
"failed_cases": [],
"note": ""
},
"bad_variants": "NOT_RUN for real backend; TEST DOUBLE B1..B7 evidence retained in results_stub/report.json",
"not_run": [
"full IEC104 STARTDT over core/TcpServer",
"board CH395F",
"MCU timing/WCET"
],
"known_deviations": [
"NODELAY: App/protocol/iec104/iec104_net_mcu.h comment; CH395F has no setsockopt, treated as always no-Nagle and NOT an OK condition"
]
}
@@ -0,0 +1,28 @@
{
"source": "D:\\Code\\DTU Code\\STM32F4-Base\\.agents\\worktrees\\dsh-d2fd6422-281a\\App\\protocol\\iec104\\iec104_net_mcu.c",
"source_sha256": "4d6b8d9e8ed3404372f274d99c16bc87a06fecbee8db0b30b044b24d0562d73d",
"checks": [
{
"id": "S1",
"description": "Close CLIENT/CLIENT_EOF branch contains no net_close_sock",
"passed": true,
"source_lines": [
615,
621
],
"evidence": "{\n /* CLIENT 分支:只拆本客户端会话、清 CLIENT 槽,监听槽的 handle/fd/\n * net_gen/role 一概不动(库侧 listen_socket 是固定值,必须始终有效)。"
},
{
"id": "S2",
"description": "Recv EOF branch only changes role; no close/drop call",
"passed": true,
"source_lines": [
435,
441
],
"evidence": "{\n /* 只读 EOF 事实:槽角色保持 CLIENT_EOF,绝不置回 LISTEN——\n * 否则紧随其后的 Close 会落到 LISTEN 分支真关监听(不可逆事故)。 */\n slot->role = SLOT_CLIENT_EOF;\n out.result = IEC104_NET_EOF;\n return out;\n }"
}
],
"passed": 2,
"total": 2
}
@@ -0,0 +1,657 @@
/* 模块名称:IEC 60870-5-104 板端 Net 后端(netTask 单 owner) */
/*
* 模块功能:实现 App/protocol/iec60870/104/IEC104_Net.h 的全部导出 ABI,
* 底层走 Drivers/BSP/NET/net_socket.h 的 net_* 接口。
* 适用平台:STM32F407ZGTx + CH395F;只在 netTask 上下文中调用(threadless)。
* 创建日期:2026-11-17(task-18 板端网络割接)
*
* Verification scope (ASCII note): this is the ONLY 104 component NOT built
* or exercised by the simulator; the simulator provides the same ABI via
* sim/iec104_sim.c. This file is verified ONLY by fake-net tests (12/12) plus
* code review; CH395F on-board behaviour remains UNPROVEN.
*
* 三条硬纪律:
* 1. 零阻塞:不投 netMsgQueue、不用 osWaitForever、不睡任务通知、不帮忙 pump;
* 2. 零借用:所有 Send 在返回前数据已交给 net 层/芯片,不缓存调用方指针;
* 3. 同 fd 映射:CH395F 单连接模型下 net_accept() 返回监听 fd 自己,
* CLIENT 的 Close 只调 net_drop_conn_locked(拆会话保监听),
* 本文件的 CLIENT 分支里不存在任何关闭监听 fd 的路径。
*
* 句柄设计(Lead 2026-11-17 裁定):IEC104_NetSocket_t 只有 uintptr_t 一个整数,
* 无法携带 session 身份,因此采用「单调递增句柄值 + 8 项映射表,句柄永不复用」:
* 每次 Listen/Accept 成功都分配新的 handle 值,旧 handle 永远不会再次出现在表中。
* 连续 3 次 listen/close 后旧 handle 必然查表失败,构造性反例自证见 MATRIX N6。
*
* 代次不变量(task-18 定案):后端槽的有效性只由
* `slot->net_gen == net_get_generation()` 判定;网络初始化(net_stack_bring_up)
* 复位芯片并清空 net 层控制块后,旧句柄一律失效,后端绝不向跨代次的 fd
* 发任何硬件操作(包括 net_close_sock)。net_generation_inc 只在 net_init
* 成功、芯片已复位之后调用,因此"代次已变"即代表"旧 fd 已不存在"。
*
* fd 归属规则(三个 P1 的共同根因,任何资源操作前先回答"这个 fd 此刻代表谁"):
* 1. 监听 fd 在任何时刻只被 LISTEN 槽引用,LISTEN 槽 handle 终身不变;
* 2. Accept 成功的瞬间该 fd 语义从"监听"变为"数据通道",旧 client 槽同时
* 失效——必须**只清槽不 drop_conn**,因为此刻同 fd 已是新连接的
* ESTABLISHED,drop 会拆掉刚接进来的新连接;
* 3. 任何 net_drop_conn_locked 调用前必须确认"该 fd 当前仍属于我要拆的
* 那个会话",仅凭 fd 状态是 ESTABLISHED 不足以判定归属。同一 fd 在不同
* 时刻分属不同代次/会话,跨代旧槽的 fd 号可能已复用,绝不能对它操作。
*/
#include "IEC104_Net.h"
#include "net_socket.h"
#include <string.h>
/* 映射表容量 = net 层 fd 数上限(NET_MAX_SOCKETS=8)。 */
#define IEC104_MCU_MAP_SIZE 8U
typedef enum {
SLOT_FREE = 0,
SLOT_LISTEN,
SLOT_CLIENT,
SLOT_CLIENT_EOF
} slot_role_t;
typedef struct {
uintptr_t handle; /* 0 = 空闲;非 0 单调,不复用 */
int fd; /* net 层 fd,同 fd 模型下 LISTEN/CLIENT 相同 */
uint32_t net_gen; /* 成功 Listen 时的网络代次,跨代旧句柄一律失效 */
uint8_t role; /* slot_role_t */
} slot_t;
static slot_t s_slots[IEC104_MCU_MAP_SIZE];
static uintptr_t s_next_handle = 1U;
static uint8_t s_inited;
/* rx_bytes 唯一后端计数:Recv 返回 OK 时按 transferred 累加,饱和 0xFFFFFFF0。 */
static uint32_t s_rx_bytes;
#define STAT_SAT 0xFFFFFFF0u
/* 函数功能:把「ABI 返回码 + 底层 errno」打包成一次返回,顺带回写可选的原生错误出参。
* 参数:code ABI 返回码;native_error 底层 errno(仅出参用);out 原生错误出参,可传 NULL。
* 返回值:原样返回 code(便于 `return result(...)` 单行收尾,避免各处重复写 out 判空)。 */
static IEC104_NetResult_t result(IEC104_NetResult_t code, int native_error, int *out)
{
if (out != NULL) {
*out = native_error;
}
return code;
}
/* 函数功能:32 位饱和加法,用于接收字节数累加(到达上限后钉住,绝不回绕成小数)。
* 参数:value 被累加的计数器;delta 本次增量。
* 返回值:无(只改 *value)。 */
static void sat_add(uint32_t *value, uint32_t delta)
{
/* 先判 *value 已达上限,再做差值比较:保证 STAT_SAT - *value 不会下溢,
* delta 无论多大都只会把计数钉在饱和值,绝不回绕成小数。 */
if (*value >= STAT_SAT || delta >= STAT_SAT - *value) {
*value = STAT_SAT;
} else {
*value += delta;
}
}
/* 句柄查表:同时校验 owner、初始化状态、句柄存在、role 与网络代次。
* 失败一律返回 NULL,不触碰任何硬件/连接。
* 槽内 net_gen 是句柄有效性的唯一代次来源:网络自愈使 net_generation_inc()
* 递增后,所有旧槽的代次一次性过期,无需全局基线(也避免"重建依赖 find"的
* 循环依赖)。
* 两句柄模型(task-18 第三轮):监听槽与客户端槽是**两个独立槽**。监听槽
* role 恒为 LISTEN、handle 在整段监听生命周期内不变(库侧 server->listen_socket
* 在 Listen 后固定,不会随会话更新);每次 Accept 另起一个 CLIENT 槽、分新
* handle。绝不翻转监听槽的 role,否则库的 Close(listen)/Wait(ACCEPT) 会失联。 */
static slot_t *find_role(uintptr_t handle, uint8_t role)
{
uint32_t i;
uint32_t gen = net_get_generation();
if (s_inited == 0U || handle == 0U || handle == IEC104_NET_INVALID_SOCKET ||
net_ctx_is_owner_task() == 0U) {
return NULL;
}
for (i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
slot_t *slot = &s_slots[i];
if (slot->handle == handle && slot->role == role &&
slot->net_gen == gen) {
return slot;
}
}
return NULL;
}
/* 客户端句柄查表:CLIENT 与 CLIENT_EOF 都算命中。EOF 后库仍可能排空待发
* 应答(Prepare_Output 在 rx_eof 下先发完再 Drop),Send 必须在 EOF 状态下
* 仍可用,不能因 role=CLIENT_EOF 就报 BADF。 */
static slot_t *find_client(uintptr_t handle)
{
slot_t *slot = find_role(handle, SLOT_CLIENT);
if (slot == NULL) {
slot = find_role(handle, SLOT_CLIENT_EOF);
}
return slot;
}
/* 取空闲槽(handle==0 且 role==FREE)。只判 handle==0 会把刚 Close(listen)
* memset 过的监听槽误当空闲并覆盖,导致 Accept 把监听资源吃掉。 */
static slot_t *slot_alloc_free(void)
{
uint32_t i;
for (i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
if (s_slots[i].handle == 0U && s_slots[i].role == SLOT_FREE) {
return &s_slots[i];
}
}
return NULL;
}
/* 找当前仍挂着的客户端槽(CLIENT 或 CLIENT_EOF),供 Accept 防重入清理。
* 只认当前代次:跨代旧槽的 fd 号可能已复用,对它调 net_sock_state/drop_conn
* 会违反文件头的 fd 归属规则。 */
static slot_t *client_slot_find_any(void)
{
uint32_t i;
uint32_t gen = net_get_generation();
for (i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
if ((s_slots[i].role == SLOT_CLIENT || s_slots[i].role == SLOT_CLIENT_EOF) &&
s_slots[i].net_gen == gen) {
return &s_slots[i];
}
}
return NULL;
}
/* 函数功能:拆掉一个客户端槽——**只拆会话、保监听**。
* 参数:slot 要拆除的客户端槽(必须是 SLOT_CLIENT / SLOT_CLIENT_EOF)。
* 返回值:无。
*
* drop_conn 的 APP_ASSERT 要求 ESTABLISHED/CONNECTING;先判状态,EOF/DISCONNECT
* 等其它状态只清槽、跳过拆除(auto_relisten 已接管)。本函数绝不触碰监听槽、
* 绝不调 net_close_sock。Accept 与 Close(client) 共用同一套拆除逻辑,
* 避免两份实现漂移。 */
static void client_slot_drop(slot_t *slot)
{
int state;
/* 代次自锁:跨代槽的 fd 号可能已被复用,绝不能对它做任何硬件读取/拆除。 */
if (slot->net_gen != net_get_generation()) {
memset(slot, 0, sizeof(*slot));
return;
}
state = net_sock_state(slot->fd);
if (state == NET_SOCK_STATE_ESTABLISHED || state == NET_SOCK_STATE_CONNECTING) {
net_sock_t *sock = net_get_sock(slot->fd);
if (sock != NULL) {
(void)net_drop_conn_locked(sock);
}
}
/* 只清客户端槽;监听槽的 handle/fd/net_gen/role 原地不动。 */
memset(slot, 0, sizeof(*slot));
}
/* 函数功能:分配一个新句柄值(单调递增、永不复用),必要时先整表作废重启。
* 参数:无。
* 返回值:新句柄(非 0,且一定不在任何现存槽中)。
*
* UINTPTR_MAX 前保留一个溢出保护窗口,届时整表作废并重新开始——运行 2^32 次
* 接入远大于设备寿命,仅作防御。 */
static uintptr_t handle_new(void)
{
uintptr_t h = s_next_handle;
if (h >= (uintptr_t)(UINTPTR_MAX - IEC104_MCU_MAP_SIZE)) {
memset(s_slots, 0, sizeof(s_slots));
h = 1U;
}
s_next_handle = h + 1U;
return h;
}
IEC104_NetResult_t IEC104_Net_Init(int *native_error)
{
if (net_ctx_is_owner_task() == 0U) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
/* Init 是运行期起点:net_stack_bring_up 已先 net_init(芯片硬复位 +
* net 层 s_net_socks 全清)后递增代次,上一运行期的底层 fd 已不存在。
* 这里只清后端映射表、不向任何旧 fd 发 net_close_sock——fd 号可能已被
* 复用,误关会打掉新会话。不变量见本文件头。 */
memset(s_slots, 0, sizeof(s_slots));
s_next_handle = 1U;
s_rx_bytes = 0U;
s_inited = 1U;
return result(IEC104_NET_OK, 0, native_error);
}
void IEC104_Net_Cleanup(void)
{
/* 不关 socket:调用方(TcpServer)负责先 Close 自己持有的句柄。 */
s_inited = 0U;
}
int IEC104_Net_Invalid_Argument_Error(void)
{
return NET_ERR_INVAL;
}
IEC104_NetResult_t IEC104_Net_Listen(
const char *bind_address, uint16_t port, IEC104_NetSocket_t *listener,
uint16_t *bound_port, int *native_error)
{
int fd, rc, addrlen;
uint32_t i;
uint32_t ip;
struct net_sockaddr_in addr;
slot_t *slot = NULL;
if (s_inited == 0U || bind_address == NULL || listener == NULL ||
bound_port == NULL || net_ctx_is_owner_task() == 0U) {
*listener = IEC104_NET_INVALID_SOCKET;
*bound_port = 0U;
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
*listener = IEC104_NET_INVALID_SOCKET;
*bound_port = 0U;
/* 代次闸(网络自愈):net_stack_bring_up 先 net_init(芯片硬复位、
* net 层 s_net_socks 清零)后 net_generation_inc;旧槽的 fd 已不存在,
* 且 fd 号可能被本次重建复用。这里只清表、绝不向旧 fd 发硬件关闭,
* 避免误伤同号的新 socket。清表后旧句柄一律 find 失败;重建不依赖
* Close 成功,serv tick 直接强制重起 core。不变量见本文件头。 */
{
uint32_t gen = net_get_generation();
for (i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
if (s_slots[i].handle != 0U && s_slots[i].net_gen != gen) {
memset(&s_slots[i], 0, sizeof(s_slots[i]));
}
}
}
/* CH395F 单宿主:只接受数字 IPv4;net_inet_addr 把 "0.0.0.0" 也解析成 0。 */
ip = net_inet_addr(bind_address);
if (ip == 0U && strcmp(bind_address, "0.0.0.0") != 0) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
if (fd < 0) {
return result(IEC104_NET_ERROR, net_get_errno(), native_error);
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = NET_AF_INET;
addr.sin_port = net_htons(port);
addr.sin_addr.s_addr = ip;
addrlen = (int)sizeof(addr);
rc = net_bind(fd, (const struct net_sockaddr *)&addr, addrlen);
if (rc == 0) {
/* 公开 net_listen() 是队列版,在 netTask 内自等死锁;用 owner 出口。 */
rc = net_listen_locked(fd);
}
if (rc != 0) {
int code = net_get_errno();
(void)net_close_sock(net_get_sock(fd));
return result(IEC104_NET_ERROR, (code < 0) ? code : NET_ERR, native_error);
}
(void)net_setblocking(fd, 0);
slot = slot_alloc_free();
if (slot == NULL) {
(void)net_close_sock(net_get_sock(fd));
return result(IEC104_NET_ERROR, NET_ERR_NOMEM, native_error);
}
slot->handle = handle_new();
slot->fd = fd;
slot->net_gen = net_get_generation();
slot->role = SLOT_LISTEN;
*listener = slot->handle;
*bound_port = port;
return result(IEC104_NET_OK, 0, native_error);
}
IEC104_NetResult_t IEC104_Net_Accept(
IEC104_NetSocket_t listener, IEC104_NetSocket_t *client,
IEC104_NetPeer_t *peer, int *native_error)
{
slot_t *slot = find_role(listener, SLOT_LISTEN);
struct net_sockaddr_in addr;
int addrlen = (int)sizeof(addr);
int rc;
char ip_text[16];
slot_t *client_slot;
if (client == NULL || peer == NULL) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
*client = IEC104_NET_INVALID_SOCKET;
if (slot == NULL) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
/* 单 fd 模型的 accept 一次性语义(2026-11-18 板端实测事故,两层伤害,必读):
* ① net 层 net_accept_locked 对 ESTABLISHED 的监听 fd 幂等返回成功
* (net_socket.c:1391 只在 state != ESTABLISHED 才进 WOULDBLOCK 分支);
* ② 库 Accept_Clients 的 4 次预算循环(IEC104_TcpServer.c:330/:1563)
* 在第 2..4 次迭代跳过 client_socket != INVALID 的全部前置判据
* (:1570-1578),直接再调本函数,随后按"多余客户端"关掉它
* (:1605-1607)。
* 若在这里再发新句柄,会连环受伤:第 1 次 Accept 交付 H1,库在 :1670
* 记住它;第 2 次进来若清/重分配 H1 所在槽,H1 立即悬空(slot_by_handle
* 返回 NULL,STARTDT_ACT 的 Send(H1) 报 NET_ERR_BADF → Drop_Client,
* 这是"STARTDT 一点回应都没有 + 20~33ms EOF"的第一击);即便不清旧槽而是
* 另开 H2,库仍会在 :1606 Close(client) 把与监听同 fd 的会话拆掉(第二击)。
* 因此同一会话只交付一次:当前代次已有 CLIENT/CLIENT_EOF 槽时一律
* WOULD_BLOCK(库对该码的处理是 accept_pending=0、本轮正常返回,
* :1583-1588),绝不用 RETRY_LATER(那会 Pause_Accept 100ms)。
* 【位置】闸放在 net_listener_armed 之前:client_slot_find_any 是纯 RAM
* 判断,保证会话已存在时一次芯片事务都不发(armed 之后紧跟的
* net_accept_locked 会 net_poll() 走 SPI)。
* 【EOF 窗口】client_slot_find_any 同时认 SLOT_CLIENT_EOF:EOF 之后、
* 库 Drop_Client 之前那段收尾窗口同样必须挡住,否则新连接会被旧会话
* 收尾拆掉。
* 【残留保险】即便异常路径真留下槽,下一次 core start 的 IEC104_Net_Init()
* 会 memset 整张 s_slots 表,不会永久静默拒连。 */
if (client_slot_find_any() != NULL) {
return result(IEC104_NET_WOULD_BLOCK, 0, native_error);
}
/* accept 门控:未 armed 时直接 WOULD_BLOCK,不做任何芯片访问。 */
if (net_listener_armed(slot->fd) == 0) {
return result(IEC104_NET_WOULD_BLOCK, 0, native_error);
}
memset(&addr, 0, sizeof(addr));
rc = net_accept_locked(slot->fd, (struct net_sockaddr *)&addr, &addrlen);
if (rc < 0) {
int code = net_get_errno();
if (code == NET_ERR_WOULDBLOCK) {
return result(IEC104_NET_WOULD_BLOCK, code, native_error);
}
if (code == NET_ERR_NOMEM || code == NET_ERR_BUSY) {
return result(IEC104_NET_RETRY_LATER, code, native_error);
}
return result(IEC104_NET_RETRY, code, native_error);
}
/* 单连接模型:rc == listener fd(监听槽的 fd 原地转为数据通道)。
* 监听槽 role 恒为 LISTEN、handle 不变;本次连接另起 CLIENT 槽。
* 单 fd 下库可能重复 Accept,一次性闸在上面:此处不得清理既有槽——
* 旧槽可能是库正持有的句柄(清掉即悬空),故原"先清旧槽再分配"段已删。 */
client_slot = slot_alloc_free();
if (client_slot == NULL) {
/* 槽耗尽(理论上:8 槽内 1 监听 + 至多 1 客户端不应到这):按资源暂缺
* 退回,让库暂停接入 100 ms 后重试;本次不建会话,不碰芯片。 */
return result(IEC104_NET_RETRY_LATER, NET_ERR_NOMEM, native_error);
}
memset(peer, 0, sizeof(*peer));
/* net_accept_locked 把 addrlen 回写为实际结构长度(IPv4 = sizeof(net_sockaddr_in)),
* 不是调用前的容量。按最小可用长度判,不再用 >= sizeof(addr) 把真实值挡掉。 */
if (addrlen >= (int)(sizeof(addr.sin_family) + sizeof(addr.sin_port) +
sizeof(addr.sin_addr)) &&
addr.sin_family == NET_AF_INET) {
(void)net_inet_ntoa(addr.sin_addr.s_addr, ip_text);
/* 点分串最长 15 字符 + NUL,固定 16 字节缓冲足够 */
(void)memcpy(peer->address, ip_text, sizeof(peer->address));
peer->port = net_ntohs(addr.sin_port);
}
/* CLIENT 槽与监听槽同 fd、同代次(Accept 不换代次);独立 handle 使库的
* listen_socket/client_socket 两个字段各自稳定,互不覆盖。 */
client_slot->handle = handle_new();
client_slot->fd = slot->fd;
client_slot->net_gen = slot->net_gen;
client_slot->role = SLOT_CLIENT;
/* CH395F 无 Nagle 开关(net 层没有 setsockopt 面),硬件即无延迟确认策略;
* 不以 NODELAY 作为接入 OK 条件,也不假装设置成功。 */
*client = client_slot->handle;
return result(IEC104_NET_OK, 0, native_error);
}
IEC104_NetIoResult_t IEC104_Net_Recv(
IEC104_NetSocket_t socket_handle, void *data, size_t capacity)
{
IEC104_NetIoResult_t out;
slot_t *slot;
net_sock_t *sock;
int rc, code;
out.result = IEC104_NET_ERROR;
out.transferred = 0U;
out.native_error = 0;
/* 非 owner 上下文是调用契约违规(本后端 threadless,只允许 netTask),
* 与"句柄无效"分开报 ERROR+NET_ERR_INVAL,禁止下游据此碰芯片。 */
if (net_ctx_is_owner_task() == 0U) {
out.native_error = NET_ERR_INVAL;
return out;
}
if (data == NULL || capacity == 0U || capacity > 0x7FFFFFFFu) {
out.native_error = NET_ERR_INVAL;
return out;
}
slot = find_client(socket_handle);
if (slot == NULL) {
out.native_error = (s_inited == 0U) ? NET_ERR_INVAL : NET_ERR_BADF;
return out;
}
sock = net_get_sock(slot->fd);
if (sock == NULL) {
out.native_error = NET_ERR_BADF;
return out;
}
rc = net_recv_sock(sock, data, (int)capacity, NET_MSG_DONTWAIT);
if (rc > 0) {
out.result = IEC104_NET_OK;
out.transferred = (size_t)rc;
sat_add(&s_rx_bytes, (uint32_t)rc);
return out;
}
if (rc == 0) {
/* 只读 EOF 事实:槽角色保持 CLIENT_EOF,绝不置回 LISTEN——
* 否则紧随其后的 Close 会落到 LISTEN 分支真关监听(不可逆事故)。 */
slot->role = SLOT_CLIENT_EOF;
out.result = IEC104_NET_EOF;
return out;
}
code = net_get_errno();
if (code == NET_ERR_WOULDBLOCK) {
out.result = IEC104_NET_WOULD_BLOCK;
out.native_error = code;
return out;
}
if (code == NET_ERR_BUSY || code == NET_ERR_CONNRESET) {
out.result = IEC104_NET_RETRY;
out.native_error = code;
return out;
}
out.native_error = (code < 0) ? code : NET_ERR;
return out;
}
IEC104_NetResult_t IEC104_Net_Pending_Input(
IEC104_NetSocket_t socket_handle, uint32_t *available, int *native_error)
{
slot_t *slot;
int len;
if (net_ctx_is_owner_task() == 0U) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
if (available == NULL) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
slot = find_client(socket_handle);
if (slot == NULL) {
return result(IEC104_NET_ERROR, NET_ERR_BADF, native_error);
}
len = net_pending_bytes(slot->fd);
if (len < 0) {
/* 精确失败:查不到就是查不到,不谎报 0/1,由 TcpServer 按 EOF 收口。 */
return result(IEC104_NET_ERROR, net_get_errno(), native_error);
}
*available = (uint32_t)len;
return result(IEC104_NET_OK, 0, native_error);
}
IEC104_NetIoResult_t IEC104_Net_Send(
IEC104_NetSocket_t socket_handle, const void *data, size_t length)
{
IEC104_NetIoResult_t out;
slot_t *slot;
net_sock_t *sock;
int sent = 0, rc, code;
out.result = IEC104_NET_ERROR;
out.transferred = 0U;
out.native_error = 0;
if (net_ctx_is_owner_task() == 0U) {
out.native_error = NET_ERR_INVAL;
return out;
}
if (length > 0x7FFFFFFFu) {
out.native_error = NET_ERR_INVAL;
return out;
}
slot = find_client(socket_handle);
if (slot == NULL) {
out.native_error = NET_ERR_BADF;
return out;
}
/* ABI 允许 OK + transferred=0(无进展)。库当前不会主动传 0,
* 但 0 长度调用按"无数据可发、无原生错误"返回,避免误判成发送失败。 */
if (length == 0U) {
out.result = IEC104_NET_OK;
return out;
}
sock = net_get_sock(slot->fd);
if (sock == NULL) {
out.native_error = NET_ERR_BADF;
return out;
}
rc = net_send_try(sock, data, (int)length, &sent);
if (rc == 0) {
/* OK + 0 或短写均按实际 transferred 上报,由库按 remaining_bytes 续发;
* 后端绝不从 Send 次数或短写推断帧完成/帧失败。 */
out.result = IEC104_NET_OK;
out.transferred = (size_t)sent;
return out;
}
code = (rc < 0) ? net_get_errno() : NET_ERR;
if (code == NET_ERR_WOULDBLOCK) {
out.result = IEC104_NET_WOULD_BLOCK;
out.native_error = code;
return out;
}
out.native_error = code;
return out;
}
IEC104_NetResult_t IEC104_Net_Wait(
IEC104_NetSocket_t listener, IEC104_NetSocket_t client, uint32_t interest,
uint32_t timeout_ms, uint32_t *ready_events, int *native_error)
{
slot_t *listen_slot;
slot_t *client_slot;
net_sock_t *sock;
uint32_t ready = 0U;
(void)timeout_ms;
if (net_ctx_is_owner_task() == 0U) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
if (ready_events == NULL || (interest & ~(IEC104_NET_EVENT_ACCEPT |
IEC104_NET_EVENT_READ | IEC104_NET_EVENT_WRITE)) != 0U) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
*ready_events = 0U;
if ((interest & IEC104_NET_EVENT_ACCEPT) != 0U) {
listen_slot = find_role(listener, SLOT_LISTEN);
/* 会话在役时不报 ACCEPT 就绪:net_listener_armed 对 ESTABLISHED 恒返 1
* (net_socket.c:1543-1545,单 fd 模型下监听 fd 已转数据通道),若不挡,
* 库 Wait_For_Events(:1992) 每轮收到假 ACCEPT → Process(:1897) 每轮
* accept_pending=1 → 每轮再调 Accept。Accept 侧虽已有一次性闸,
* 但这里挡掉才能让"无接入需求"这一事实如实上报。 */
if (listen_slot != NULL && client_slot_find_any() == NULL &&
net_listener_armed(listen_slot->fd) != 0) {
ready |= IEC104_NET_EVENT_ACCEPT;
}
}
if ((interest & (IEC104_NET_EVENT_READ | IEC104_NET_EVENT_WRITE)) != 0U) {
client_slot = find_client(client);
sock = (client_slot != NULL) ? net_get_sock(client_slot->fd) : NULL;
if (sock != NULL) {
if ((interest & IEC104_NET_EVENT_READ) != 0U &&
(net_can_read(client_slot->fd) != 0 || client_slot->role == SLOT_CLIENT_EOF)) {
ready |= IEC104_NET_EVENT_READ;
}
/* WRITE 就绪:net 层没有 net_can_write() 公开函数,沿用 net_select.c 的
* 同源判据直读公开结构 net_sock_t.send_ready(send_ready 为 1 表示芯片
* 发送 FIFO 可再写一块)。这是已知耦合:字段改名/搬迁需同步本处。 */
if ((interest & IEC104_NET_EVENT_WRITE) != 0U && sock->send_ready != 0U) {
ready |= IEC104_NET_EVENT_WRITE;
}
}
}
*ready_events = ready;
/* 纯查询:sleep 责任在 netTask 主循环;timeout 0 / UINT32_MAX alike 立即返回。
* 库的 Wait_For_Events 用 Now_Ms 自行计算 timer_expired,不依赖本函数阻塞。 */
return result(IEC104_NET_OK, 0, native_error);
}
/* 按句柄值找槽(不判 role、不判代次——Close 需要先拿到槽再由判据分流)。
* 两句柄模型下 listen 与 client 各有独立 handle,这里只做值匹配。 */
static slot_t *slot_by_handle(uintptr_t handle)
{
uint32_t i;
for (i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
if (s_slots[i].handle == handle) {
return &s_slots[i];
}
}
return NULL;
}
IEC104_NetResult_t IEC104_Net_Close(
IEC104_NetSocket_t socket_handle, int *native_error)
{
slot_t *slot;
if (socket_handle == IEC104_NET_INVALID_SOCKET || socket_handle == 0U) {
return result(IEC104_NET_OK, 0, native_error);
}
if (net_ctx_is_owner_task() == 0U) {
return result(IEC104_NET_ERROR, NET_ERR_INVAL, native_error);
}
slot = slot_by_handle(socket_handle);
/* 陈旧/代次不匹配的 Close:幂等 OK,绝不触碰硬件。 */
if (slot == NULL || slot->role == SLOT_FREE || net_get_generation() != slot->net_gen) {
return result(IEC104_NET_OK, 0, native_error);
}
if (slot->role == SLOT_CLIENT || slot->role == SLOT_CLIENT_EOF) {
/* CLIENT 分支:只拆本客户端会话、清 CLIENT 槽,监听槽的 handle/fd/
* net_gen/role 一概不动(库侧 listen_socket 是固定值,必须始终有效)。
* 本分支内不存在关闭监听 fd 的任何调用路径。 */
(void)net_close_sock(net_get_sock(slot->fd)); /* BAD mutant */
client_slot_drop(slot);
return result(IEC104_NET_OK, 0, native_error);
}
/* LISTEN 分支:仅库 TcpServer_Close / Init 失败清理会走到这里。
* 真关监听 fd 并清整个槽(若尚有客户端槽,先按 CLIENT 语义拆掉,
* 避免监听关了却留下无主的 client 槽)。 */
{
slot_t *client_slot = client_slot_find_any();
if (client_slot != NULL) {
client_slot_drop(client_slot);
}
{
net_sock_t *sock = net_get_sock(slot->fd);
if (sock != NULL) {
(void)net_close_sock(sock);
}
}
}
memset(slot, 0, sizeof(*slot));
return result(IEC104_NET_OK, 0, native_error);
}
uint64_t IEC104_Net_Now_Ms(void)
{
return net_mono_now_ms();
}
/* 函数功能:导出后端只读统计(当前只有接收字节数)。
* 参数:rx_bytes 出参,接收 Recv 成功时的 transferred 累加值(饱和 0xFFFFFFF0);可传 NULL。
* 返回值:无。
*
* apdu_tx / tx_fail 的帧级计数在 iec104_core_status_t 中,不从 Send 调用推断。 */
void iec104_net_mcu_stats(uint32_t *rx_bytes)
{
if (rx_bytes != NULL) {
*rx_bytes = s_rx_bytes;
}
}
@@ -0,0 +1,28 @@
{
"source": "D:\\Code\\DTU Code\\STM32F4-Base\\.agents\\worktrees\\dsh-d2fd6422-281a\\test\\host\\iec104_netmcu\\results\\static_mutant\\iec104_net_mcu_BAD.c",
"source_sha256": "87bf283ec6b61ac14a0de3ab0f8a0352db4c62f03d4ea4479db36f9e0c546719",
"checks": [
{
"id": "S1",
"description": "Close CLIENT/CLIENT_EOF branch contains no net_close_sock",
"passed": false,
"source_lines": [
615,
622
],
"evidence": "{\n /* CLIENT 分支:只拆本客户端会话、清 CLIENT 槽,监听槽的 handle/fd/\n * net_gen/role 一概不动(库侧 listen_socket 是固定值,必须始终有效)。"
},
{
"id": "S2",
"description": "Recv EOF branch only changes role; no close/drop call",
"passed": true,
"source_lines": [
435,
441
],
"evidence": "{\n /* 只读 EOF 事实:槽角色保持 CLIENT_EOF,绝不置回 LISTEN——\n * 否则紧随其后的 Close 会落到 LISTEN 分支真关监听(不可逆事故)。 */\n slot->role = SLOT_CLIENT_EOF;\n out.result = IEC104_NET_EOF;\n return out;\n }"
}
],
"passed": 1,
"total": 2
}
@@ -0,0 +1,4 @@
real_rc=0
mutant_rc=1
real source: D:\Code\DTU Code\STM32F4-Base\.agents\worktrees\dsh-d2fd6422-281a\App\protocol\iec104\iec104_net_mcu.c
mutant: D:\Code\DTU Code\STM32F4-Base\.agents\worktrees\dsh-d2fd6422-281a\test\host\iec104_netmcu\results\static_mutant\iec104_net_mcu_BAD.c
+117
View File
@@ -0,0 +1,117 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Build and run the REAL IEC104 Net MCU backend against the fake net layer.
Host-only isolation evidence for the IEC104_Net ABI (N1..N9). This is not a
full core/TcpServer run and not hardware evidence. The TEST DOUBLE B1..B7
evidence stays in results_stub/report.json.
"""
import hashlib
import json
import os
import subprocess
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
sys.path.insert(0, os.path.join(ROOT, "test", "host", "common"))
from unit_test_harness import locate_toolchain # noqa: E402
OUT = os.path.join(HERE, "results")
def sha256(path):
h = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(65536), b""):
h.update(chunk)
return h.hexdigest()
def run_real(cl, inc, lib):
work = os.path.join(OUT, "real")
os.makedirs(work, exist_ok=True)
objdir = os.path.join(work, "obj")
os.makedirs(objdir, exist_ok=True)
exe = os.path.join(work, "netmcu_test.exe")
sources = [
os.path.join(HERE, "netmcu_test.c"),
os.path.join(HERE, "net_socket_fake.c"),
os.path.join(ROOT, "App", "protocol", "iec104", "iec104_net_mcu.c"),
]
env = dict(os.environ)
env["INCLUDE"] = os.pathsep.join(inc + [
os.path.join(ROOT, "App", "protocol", "iec60870", "104"),
os.path.join(ROOT, "App", "protocol", "iec60870", "common"),
os.path.join(ROOT, "App", "protocol", "iec104"),
os.path.join(ROOT, "Drivers", "BSP", "NET"),
os.path.join(HERE, "stub"),
os.path.join(ROOT, "test", "host", "net_socket", "stub"),
HERE,
])
env["LIB"] = os.pathsep.join(lib)
env["PATH"] = os.path.dirname(cl) + os.pathsep + env.get("PATH", "")
flags = ["/nologo", "/std:c11", "/W3", "/WX", "/utf-8"]
objs = []
build_log = os.path.join(work, "build.log")
with open(build_log, "wb") as log:
for src in sources:
obj = os.path.join(objdir, os.path.basename(src) + ".obj")
p = subprocess.run([cl] + flags + ["/Fo" + obj, "/c", src],
env=env, cwd=HERE, capture_output=True)
log.write((p.stdout + p.stderr).decode("utf-8", "replace").encode("utf-8"))
if p.returncode != 0:
return {"build_rc": p.returncode, "run_rc": None, "note": "compile error"}
objs.append(obj)
p = subprocess.run([cl, "/nologo", "/Fe" + exe] + objs,
env=env, cwd=HERE, capture_output=True)
log.write((p.stdout + p.stderr).decode("utf-8", "replace").encode("utf-8"))
if p.returncode != 0:
return {"build_rc": p.returncode, "run_rc": None, "note": "link error"}
r = subprocess.run([exe], env=env, cwd=work, capture_output=True)
with open(os.path.join(work, "run.log"), "wb") as f:
f.write(r.stdout + r.stderr)
text = (r.stdout + r.stderr).decode("utf-8", "replace")
fail_lines = [ln for ln in text.splitlines() if ln.strip().startswith("FAIL ")]
return {"build_rc": 0, "run_rc": r.returncode,
"failures": len(fail_lines),
"failed_cases": sorted(set(
ln.split()[1].rstrip(":") for ln in fail_lines if len(ln.split()) > 1)),
"note": ""}
def main():
os.makedirs(OUT, exist_ok=True)
cl, inc, lib = locate_toolchain()
if not cl:
print("[ENV] MSVC toolchain not found")
return 2
res = run_real(cl, inc, lib)
print("real: build_rc={} run_rc={} note={} failed_cases={}".format(
res["build_rc"], res["run_rc"], res["note"], res.get("failed_cases", [])))
report = {
"scope": "REAL backend App/protocol/iec104/iec104_net_mcu.c + fake net layer; host-only isolation evidence, not full core/TcpServer/hardware",
"backend_sha256": sha256(os.path.join(
ROOT, "App", "protocol", "iec104", "iec104_net_mcu.c")),
"sources": {f: sha256(os.path.join(HERE, f)) for f in [
"MATRIX.md", "net_socket_fake.h", "net_socket_fake.c",
"netmcu_test.c", "check_static.py"]},
"case_count": 13,
"case_count_basis": "13 named cases; N2a/N2b are two cases in one N2 test function",
"case_names": ["N1", "N2a", "N2b", "N3", "N4", "N5", "N6", "N7", "N8", "N9", "N10", "N11", "N12"],
"result": res,
"bad_variants": "NOT_RUN for real backend; TEST DOUBLE B1..B7 evidence retained in results_stub/report.json",
"not_run": ["full IEC104 STARTDT over core/TcpServer", "board CH395F", "MCU timing/WCET"],
"known_deviations": ["NODELAY: App/protocol/iec104/iec104_net_mcu.h comment; CH395F has no setsockopt, treated as always no-Nagle and NOT an OK condition"],
}
with open(os.path.join(OUT, "report.json"), "w", encoding="utf-8") as f:
json.dump(report, f, indent=2, ensure_ascii=False)
if res["build_rc"] != 0 or res["run_rc"] is None:
return 1
print("real backend passed {}/{}".format(
13 - len(res.get("failed_cases", [])), 13))
return 0 if res["run_rc"] == 0 else 1
if __name__ == "__main__":
sys.exit(main())
+7
View File
@@ -0,0 +1,7 @@
/* Host-only FreeRTOS.h shim; includes the net_socket test stub types. */
#ifndef NETMCU_FREERTOS_STUB_SHIM_H
#define NETMCU_FREERTOS_STUB_SHIM_H
#include "../../net_socket/stub/FreeRTOS.h"
#endif /* NETMCU_FREERTOS_STUB_SHIM_H */
+13
View File
@@ -0,0 +1,13 @@
/*
* Host-only RTOS type stub for test/host/iec104_netmcu/.
* Not part of any MCU build. Only supplies the cmsis_os2 type referenced by
* Drivers/BSP/NET/net_socket.h when NET_NO_OS is not defined.
*/
#ifndef NETMCU_CMSIS_OS2_STUB_H
#define NETMCU_CMSIS_OS2_STUB_H
#include <stdint.h>
typedef void *osMessageQueueId_t;
#endif /* NETMCU_CMSIS_OS2_STUB_H */
+7
View File
@@ -0,0 +1,7 @@
/* Host-only task.h shim; includes the net_socket test stub declarations. */
#ifndef NETMCU_TASK_STUB_SHIM_H
#define NETMCU_TASK_STUB_SHIM_H
#include "../../net_socket/stub/task.h"
#endif /* NETMCU_TASK_STUB_SHIM_H */
@@ -0,0 +1,431 @@
/*
* 测试替身(TEST DOUBLE),不是产品实现!见 stub_iec104_netmcu.h 顶部说明。
* 真实板端后端落地后,本文件不再参与链接。
*/
#include "stub_iec104_netmcu.h"
#include "net_socket_fake.h"
#include <string.h>
uint16_t ch395f_get_recv_len(uint8_t sock);
static int snprintf_local(char *buf, size_t len, const char *fmt, unsigned v);
/* 假后端自己持有的“会话身份”:单连接模型下 fd 数值会被复用,
* 必须用独立 session 号 + 网络代次校验,不能只认 fd 整数。 */
typedef struct {
uint32_t generation;
uint32_t session;
int initialized;
int listening;
int connected;
IEC104_NetSocket_t listener;
IEC104_NetSocket_t client;
uint32_t last_tick;
uint64_t now_ms;
int startup_ack;
uint32_t sent_i_frames;
uint32_t recv_i_frames;
} stub_state_t;
static stub_state_t s;
static int native_err;
/* B3 用:跨用例残留的借用指针会在 N3 之后悬空,stub_reset 必须清掉。 */
static const void *g_borrowed;
static size_t g_borrow_len;
static int gen_stale(void)
{
#if defined(NETMCU_BAD) && NETMCU_BAD == 5
/* 坏变体 B5:不检查代次。 */
(void)s;
return 0;
#else
return net_fake_generation() != s.generation;
#endif
}
static void err(int n) { native_err = n; }
void stub_reset(void)
{
net_fake_reset();
memset(&s, 0, sizeof(s));
g_borrowed = NULL;
g_borrow_len = 0;
native_err = 0;
}
IEC104_NetResult_t IEC104_Net_Init(int *native_error)
{
err(0);
s.initialized = 1;
s.generation = net_fake_generation();
if (native_error) {
*native_error = 0;
}
return IEC104_NET_OK;
}
void IEC104_Net_Cleanup(void)
{
s.initialized = 0;
}
int IEC104_Net_Invalid_Argument_Error(void)
{
return NET_ERR_INVAL;
}
IEC104_NetResult_t IEC104_Net_Listen(const char *bind_address, uint16_t port,
IEC104_NetSocket_t *listener,
uint16_t *bound_port, int *native_error)
{
int fd;
struct net_sockaddr_in addr;
(void)bind_address;
if (!s.initialized || listener == NULL || bound_port == NULL) {
err(NET_ERR_INVAL);
if (native_error) { *native_error = native_err; }
*listener = IEC104_NET_INVALID_SOCKET;
*bound_port = 0;
return IEC104_NET_ERROR;
}
fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
if (fd < 0) {
err(NET_ERR_NOMEM);
if (native_error) { *native_error = native_err; }
*listener = IEC104_NET_INVALID_SOCKET;
*bound_port = 0;
return IEC104_NET_ERROR;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = NET_AF_INET;
addr.sin_port = NET_HTONS(port);
addr.sin_addr.s_addr = NET_INADDR_ANY;
if (net_bind(fd, (const struct net_sockaddr *)&addr, (int)sizeof(addr)) != 0 ||
net_listen(fd) != 0) {
net_close(fd);
err(NET_ERR_INVAL);
if (native_error) { *native_error = native_err; }
*listener = IEC104_NET_INVALID_SOCKET;
*bound_port = 0;
return IEC104_NET_ERROR;
}
s.listening = 1;
s.listener = (IEC104_NetSocket_t)fd;
s.generation = net_fake_generation();
err(0);
*listener = s.listener;
*bound_port = port;
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
IEC104_NetResult_t IEC104_Net_Accept(IEC104_NetSocket_t listener,
IEC104_NetSocket_t *client,
IEC104_NetPeer_t *peer, int *native_error)
{
int rc;
struct net_sockaddr_in addr;
int addrlen = (int)sizeof(addr);
net_fake_stats_t st;
if (listener != s.listener || client == NULL || peer == NULL || !s.listening) {
err(NET_ERR_INVAL);
if (native_error) { *native_error = native_err; }
*client = IEC104_NET_INVALID_SOCKET;
return IEC104_NET_ERROR;
}
memset(&addr, 0, sizeof(addr));
rc = net_accept((int)listener, (struct net_sockaddr *)&addr, &addrlen);
if (rc < 0) {
if (rc == NET_ERR_NOMEM) {
err(rc);
if (native_error) { *native_error = rc; }
*client = IEC104_NET_INVALID_SOCKET;
return IEC104_NET_RETRY_LATER;
}
if (rc == NET_ERR_BUSY) {
err(rc);
if (native_error) { *native_error = rc; }
*client = IEC104_NET_INVALID_SOCKET;
return IEC104_NET_RETRY;
}
err(rc);
if (native_error) { *native_error = rc; }
*client = IEC104_NET_INVALID_SOCKET;
return IEC104_NET_WOULD_BLOCK;
}
/* 单连接模型:rc == listener,客户端和监听是同一个整数。 */
s.client = (IEC104_NetSocket_t)rc;
s.connected = 1;
s.session++;
s.generation = net_fake_generation();
s.startup_ack = 0;
s.sent_i_frames = 0;
s.recv_i_frames = 0;
net_fake_stats(&st);
memset(peer, 0, sizeof(*peer));
{
uint32_t ip = NET_NTOHL(st.last_peer_ip[0] << 24 |
st.last_peer_ip[1] << 16 |
st.last_peer_ip[2] << 8 |
st.last_peer_ip[3]);
(void)ip;
/* IPv4 点分十进制,来自 fake stats 的 10.0.0.x */
int n = snprintf_local(peer->address, sizeof(peer->address), "10.0.0.%u",
(unsigned)st.last_peer_ip[3]);
(void)n;
}
peer->port = st.last_peer_port;
err(0);
if (native_error) { *native_error = 0; }
*client = s.client;
return IEC104_NET_OK;
}
static int snprintf_local(char *buf, size_t len, const char *fmt, unsigned v)
{
char tmp[32];
unsigned x = v;
int i = 0;
while (x > 0) { tmp[i++] = (char)('0' + (x % 10)); x /= 10; }
if (i == 0) { tmp[i++] = '0'; }
size_t pos = 0;
while (i > 0 && pos + 1 < len) { buf[pos++] = tmp[--i]; }
buf[pos < len ? pos : len - 1] = '\0';
(void)fmt;
return (int)pos;
}
IEC104_NetIoResult_t IEC104_Net_Recv(IEC104_NetSocket_t h, void *data, size_t capacity)
{
IEC104_NetIoResult_t r;
char buf[2048];
int rc;
r.result = IEC104_NET_ERROR; r.transferred = 0; r.native_error = 0;
if (h != s.client || !s.connected || data == NULL || capacity == 0 || gen_stale()) {
r.native_error = gen_stale() ? NET_ERR_BADF : NET_ERR_INVAL;
return r;
}
if (capacity > sizeof(buf)) { capacity = sizeof(buf); }
rc = net_recv_nb((int)h, buf, (int)capacity);
if (rc > 0) {
memcpy(data, buf, (size_t)rc);
r.result = IEC104_NET_OK;
r.transferred = (size_t)rc;
s.recv_i_frames++;
return r;
}
if (rc == 0) { r.result = IEC104_NET_EOF; return r; }
if (rc == NET_ERR_WOULDBLOCK) { r.result = IEC104_NET_WOULD_BLOCK; r.native_error = rc; return r; }
if (rc == NET_ERR_BUSY) { r.result = IEC104_NET_RETRY; r.native_error = rc; return r; }
r.native_error = rc;
return r;
}
IEC104_NetResult_t IEC104_Net_Pending_Input(IEC104_NetSocket_t h,
uint32_t *available, int *native_error)
{
uint16_t n;
if (h != s.client || !s.connected || available == NULL || gen_stale()) {
err(gen_stale() ? NET_ERR_BADF : NET_ERR_INVAL);
if (native_error) { *native_error = native_err; }
return IEC104_NET_ERROR;
}
n = ch395f_get_recv_len((uint8_t)h);
#if defined(NETMCU_BAD) && NETMCU_BAD == 2
/* 坏变体 B2:把“降级为不可信/报小”当成“没有更多数据”——上层一次收满
* 可用长度就结束,把内核里剩余字节永久藏住。 */
if (n == 0xFFFFU) {
*available = 0;
err(0);
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
#endif
if (n == 0xFFFFU) {
err(NET_ERR_BUSY);
if (native_error) { *native_error = native_err; }
return IEC104_NET_ERROR;
}
*available = (uint32_t)n;
err(0);
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
IEC104_NetIoResult_t IEC104_Net_Send(IEC104_NetSocket_t h, const void *data, size_t length)
{
IEC104_NetIoResult_t r;
int rc;
r.result = IEC104_NET_ERROR; r.transferred = 0; r.native_error = 0;
if (h != s.client || !s.connected || data == NULL || length == 0 || gen_stale()) {
r.native_error = gen_stale() ? NET_ERR_BADF : NET_ERR_INVAL;
return r;
}
#if defined(NETMCU_BAD) && NETMCU_BAD == 3
/* 借用调用方 buffer:下一次 Send 仍从旧指针读。测试已把旧 buffer
* 整块涂成 0xEE,于是重发内容被污染。 */
if (g_borrowed != NULL) {
rc = net_send((int)h, g_borrowed, (int)g_borrow_len, 0);
g_borrowed = NULL;
g_borrow_len = 0;
} else {
rc = net_send((int)h, data, (int)length, 0);
if (length > 3) {
g_borrowed = data;
g_borrow_len = length;
}
}
#else
rc = net_send((int)h, data, (int)length, 0);
#endif
if (rc >= 0) {
r.result = IEC104_NET_OK;
r.transferred = (size_t)rc;
s.sent_i_frames++;
return r;
}
if (rc == NET_ERR_WOULDBLOCK) { r.result = IEC104_NET_WOULD_BLOCK; r.native_error = rc; return r; }
if (rc == NET_ERR_BUSY) { r.result = IEC104_NET_RETRY; r.native_error = rc; return r; }
r.native_error = rc;
return r;
}
IEC104_NetResult_t IEC104_Net_Wait(IEC104_NetSocket_t listener,
IEC104_NetSocket_t client, uint32_t interest,
uint32_t timeout_ms, uint32_t *ready_events,
int *native_error)
{
uint32_t ready = 0;
(void)listener; (void)client; (void)timeout_ms;
if (ready_events == NULL) {
err(NET_ERR_INVAL);
if (native_error) { *native_error = native_err; }
return IEC104_NET_ERROR;
}
if ((interest & IEC104_NET_EVENT_ACCEPT) && net_fake_listen_fd() >= 0) {
net_fake_stats_t st;
net_fake_stats(&st);
/* 简化:fake 用 peer 队列非空近似“有连接待接入”。 */
ready |= IEC104_NET_EVENT_ACCEPT;
(void)st;
}
if ((interest & IEC104_NET_EVENT_READ) && net_can_read((int)s.client)) {
ready |= IEC104_NET_EVENT_READ;
}
if ((interest & IEC104_NET_EVENT_WRITE) && s.connected) {
ready |= IEC104_NET_EVENT_WRITE;
}
*ready_events = ready;
err(0);
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
IEC104_NetResult_t IEC104_Net_Close(IEC104_NetSocket_t h, int *native_error)
{
int rc;
if (h == IEC104_NET_INVALID_SOCKET) {
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
#if defined(NETMCU_BAD) && NETMCU_BAD == 1
/* 坏变体 B1:把会话 Close 直接映射为 net_close,单连接模型下连监听一起毁掉。 */
rc = net_close((int)h);
if (h == s.listener) { s.listening = 0; s.connected = 0; s.client = IEC104_NET_INVALID_SOCKET; }
#elif defined(NETMCU_BAD) && NETMCU_BAD == 6
/* 坏变体 B6:第二次 Close(陈旧句柄)错误地调用 net_close,毁掉监听。
* 正确实现应记住“会话已拆”,重复 Close 是幂等 no-op。 */
if (h == s.listener || h == s.client) {
if (s.connected) {
rc = net_drop_conn((int)h);
s.connected = 0;
s.client = IEC104_NET_INVALID_SOCKET;
} else {
rc = net_close((int)h); /* BUG: 已关闭仍去 close 监听 */
s.listening = 0;
}
} else {
rc = net_close((int)h);
}
#else
/* 正确语义:客户端句柄就是监听 fd,只能拆会话、不能 close 监听;
* 重复 Close 幂等。 */
if (h == s.listener || h == s.client) {
if (s.connected) {
rc = net_drop_conn((int)h);
s.connected = 0;
s.client = IEC104_NET_INVALID_SOCKET;
} else {
rc = 0; /* 会话已拆,no-op */
}
} else {
rc = net_close((int)h);
}
#endif
#if defined(NETMCU_BAD) && NETMCU_BAD == 7
/* 坏变体 B7:断链后不清空 STARTDT 建链状态,旧确认被误用到新会话。 */
#else
/* 正确语义:会话拆除后链路状态归零,重连必须重新 STARTDT。 */
if (rc == 0) {
s.startup_ack = 0;
}
#endif
if (rc < 0) {
err(rc);
if (native_error) { *native_error = rc; }
return IEC104_NET_ERROR;
}
err(0);
if (native_error) { *native_error = 0; }
return IEC104_NET_OK;
}
uint64_t IEC104_Net_Now_Ms(void)
{
uint32_t now = net_fake_tick_low();
uint32_t delta;
if (!s.initialized) {
IEC104_Net_Init(NULL);
}
delta = (uint32_t)(now - s.last_tick);
s.now_ms += (uint64_t)delta;
s.last_tick = now;
#if defined(NETMCU_BAD) && NETMCU_BAD == 4
/* 坏变体 B4:强转低 32 位,回绕时倒退。 */
return (uint64_t)now;
#else
return s.now_ms;
#endif
}
void stub_link_send_startdt(IEC104_NetSocket_t client)
{
static const uint8_t start[] = { 0x68, 0x04, 0x07, 0x00, 0x00, 0x00 };
(void)client;
(void)IEC104_Net_Send(s.client, start, sizeof(start));
}
void stub_link_push_con(void)
{
static const uint8_t con[] = { 0x68, 0x04, 0x0b, 0x00, 0x00, 0x00 };
(void)net_fake_push_rx(con, sizeof(con));
}
int stub_link_ready(IEC104_NetSocket_t client)
{
char buf[32];
IEC104_NetIoResult_t r = IEC104_Net_Recv(client, buf, sizeof(buf));
#if defined(NETMCU_BAD) && NETMCU_BAD == 7
/* 坏变体 B7:断链重连后仍沿用旧 startup_ack,把旧确认当新会话已建链。 */
(void)r;
return s.startup_ack;
#else
if (r.result == IEC104_NET_OK && r.transferred >= 6 &&
buf[0] == (char)0x68 && buf[2] == (char)0x0b) {
s.startup_ack = 1;
}
return s.startup_ack;
#endif
}
@@ -0,0 +1,26 @@
/*
* 测试替身(TEST DOUBLE),不是产品实现!
* ============================================================
* 本文件实现一个“最小假后端”,它只按 IEC104_Net.h 的接口签名和
* test/host/iec104_netmcu/MATRIX.md 的期望语义走通,用来验证本套 runner
* 和坏变体注入是否有效。真实板端后端由 net-cutover 单独实现;
* 真实后端落地后,runner 应换链接它的对象文件再判,不得把这里的绿灯
* 解读为“产品代码已验证”。
*
* 坏变体由编译期 -DNETMCU_BAD=Bx 注入,每个变体只故意破坏一个契约点,
* 用来证明对应用例能把它判红。
*/
#ifndef STUB_IEC104_NETMCU_H
#define STUB_IEC104_NETMCU_H
#include "IEC104_Net.h"
/* 假后端内部测试驱动辅助(仅 runner 使用)。 */
void stub_reset(void);
/* 模拟断链重连后的 STARTDT 交换;返回 1 = 链路已重建。 */
void stub_link_send_startdt(IEC104_NetSocket_t client);
void stub_link_push_con(void);
int stub_link_ready(IEC104_NetSocket_t client);
#endif