Files
STM32F4-Base/test/host/iec104_netmcu/netmcu_test.c
T
wandering1 90cc9a7d99 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 名字的排除口径。
2026-11-18 10:29:18 +08:00

514 lines
21 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* 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;
}