90cc9a7d99
把 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 名字的排除口径。
514 lines
21 KiB
C
514 lines
21 KiB
C
/*
|
||
* 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;
|
||
}
|