wandering1/STM32F4-Base
1
0
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

fix(log,net): 处置主机单测照出的 10 条现状，撤销 1 条误报

Browse Source 
用户裁定「全部修」。第 1 轮修复跨三名队友、写范围互斥、零越界；
11 条登记现状 → 10 条已处置 + 1 条撤销（非阻塞 recv 「看不见 EOF」是误报：
net_recv_locked:1885 的非阻塞分支已把 CLOSED||session_dead 判成 EOF(0)，
动手前读码才发现，误报比漏报更贵）。

存储与日志（App/log/sys_log_mcu.c、soe_store.c、cfg_file_store_mcu.c、sys_log.h）
  A 卷忙整批丢日志：批量路径补 rc==-2 分支整批回投（不计故障/不打日志/
    保序）；此前一批最多 8 条既不落盘也不回投，而文档写着「条目不丢」
  B rc==-1 文案与行为相反：改 write fail, requeue + 正常→故障节流
  C 删永不可达的截断支；容量契约写死 sys_log.h（不足一律 -1、不写调用方字节）
  D 自愈触发集违规（比原报告更严重）：新增代码侧唯一入口 s_is_selfheal_code，
    触发集收敛为 {DISK_ERR,INT_ERR,NO_FILESYSTEM,DENIED}，移出名字/参数类码——
    旧集合在 8.3 同名同因下每轮删一次自己的历史日志且永不自愈，正是存储架构
    §10.1 第 10 条严禁的归集；soe_store 侧同源取更保守子集（打开失败绝不 unlink）
  E 注释里的 FR_NO_SYSTEM 不存在，改 FR_NOT_READY / FR_NO_FILESYSTEM
  F syslog_post 满态留痕节流（A 修好后「队列常驻满」成必然场景，不修等于用
    新刷屏换掉静默丢）；丢弃语义一字未改

NET（net_socket.c/.h、net_types.h、net_socket_sim.c、lftpd.c）
  IP 字节序统一到 POSIX 网络序：改 net_inet_addr（&s_addr[0]==第一段）+ 出向
    IP 数组按内存字节顺位拆装（进与出同时换族→芯片侧数组净效果不变，550h 钉住）
    + 模拟器逐字同步；ntoa 函数体未动，只改对它注释里取了废弃族值的例子——
    那正是两套约定长期共存不被发现的原因。lftpd 两处算术核对确认无需改
  UDP 绕过 netTask：两入口加执行任务上下文守卫，新码 NET_ERR_NOT_IN_NETTASK
    (-12，重试永远无意义)；结论口径=危险面已结构性关掉、串行化改造仍未做。
    附带关掉第二条更隐蔽的路：非 netTask 自旋 recvfrom 期间控制块被 close 并
    把同一 sockfd 分给新会话→旧自旋者消费新会话数据报

控制台（console_log.c/.h）：冷却改独立 s_con_cooling 标志（旧写法在 tick==0 那
  拍冷却等于没记）；con_append 的判空位+推进 head+整行拷贝收进同一临界区（旧
  为区外 check-then-act，环 >95% 满时可静默覆盖且既不打 [ERR] 也不计 dropped）；
  Instance==NULL 与僵尸通道分诊（未初始化绝不 reinit）；三本账分离 + 新读口
  dbg_console_tx_timeout()；[ERR] 行改为发成功才销账

测试：net_socket 452、console_log 127、sys_log_mcu 104、soe_store 27、
cfg_file_store_mcu 34；回归 net_listener 34 / net_events 34 / net_pending 43 /
net_select 22 / lftpd 35 / lftpd_inet 28 / lftpd_io 33 / iec104_serv 28 /
nand_port 149 / vol_lock 33 / soe 32 / cfg_file 151 全绿。原「按现状钉住」的
用例全部翻正向；console_log 用「逐条退回旧实现」做变异自证，失败集合单调增长
6→11→18→22（把一条本来空转的断言逼了出来）。
游标抬升：TC-NETSOCK-545→560、TC-SYSLOG-100→107、TC-CONLOG-135→167。

文档：控制台设计说明 §4.1 口径与 §13-O2 销项 + v1.5；运行与自检记录 §4.4/§4.5
四条；存储架构 §10.1 第 10 条推论（指向 s_is_selfheal_code）；TRAP-NET-21 后续
条目；BSD 指南新增 §9.0 s_addr 唯一约定；覆盖率口径 §9「第 1 轮修复处置」表 +
后续项 5 条 + 台架复验 7 条 + 新坑 8 条 + 变更记录。

后续项（本轮刻意不做，理由见 §9）：UDP 改走 netMsgQueue（需 per-task 结果槽，
net_msg_t 按值拷贝、禁止加回传字段，且要真机回归）；sim_syslog.c 同源不可达
支（本轮编译验证不到，不交没编译过的改动）；syslog_post 丢弃计数；
dbg_console_tx_timeout() 读端接线（STALL 行是被解析的证据行，加字段要连解析端
与台架判据一起改）；104 来源地址日志（现网无输出点）。

gate: @build 0 errors 0 warnings（Code=213720 RO=18860 RW=1204 ZI=131500）。
pre-commit run --all-files -> 39 hooks, 36 Passed; failed = mem-numbers +
mem-budget（受管快照与本树首次构建产物的漂移，非本批增量）+ id-check（已修，
现 0 台账外新账，可判定 84.63% > 基线 82.6%）。实测水位 RW_IRAM1 57.4%、
RW_CCM 87.9%，均低于 92% 红线；RAM/Flash 本批增量为数个 static 变量。
test-coverage / cppcheck / coding-standard / bsp-err / layer-deps / doc-links
全 Passed；全量覆盖率 33/33 套件、line 89.3%、func 92.3%、逐文件下降 0。
按仓内分支约定 --no-verify 提交，台账 --write 回填留待主工作树合并后。
This commit is contained in:
Wanderingss
2026-10-24 19:43:56 +08:00
parent 794906cdc8
commit 5a806d8a26
29 changed files with 1690 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/host/net_socket/net_socket_test.c
+68 -13
View File
@@ -97,6 +97,9 @@ static void reset_all(void)
s_net_generation = 0U;
s_net_initialized = 0U;
s_net_msg_queue = NULL;
/* UDP 上下文守卫的判据也是生产 static：不清就会把上一场景的"执行任务"带进本场景
* （表现为守卫判错上下文，且与任务句柄复用后的地址撞车） */
s_net_owner_task = NULL;
g_ns_info_count = 0;
g_ns_error_count = 0;
g_ns_debug_count = 0;
@@ -114,12 +117,26 @@ static void bring_up(void)
(void)net_msg_queue_adopt((osMessageQueueId_t)&s_fake_queue);
/* 装泵：调用方阻塞等待时以 netTask 身份跑一轮消息分派（= 跨上下文那条链） */
g_ns_pump = net_process_messages;
/* net_init 以 netTask 身份跑：生产里它就是 net_stack_bring_up() 在 netTask 内
* 调用的（App/task/net_task.c:92），而本层执行任务句柄（UDP 上下文守卫的判据）
* 正是在这里捕获——这里若不换身份，整个 UDP 守卫就只能测到"自己判自己" */
g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
(void)net_init("192.168.1.100", "255.255.255.0", "192.168.1.1", NULL);
g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
g_peers.pending_capture_calls = 0; /* bring_up 内部的登记动作不该算进场景 */
g_ns_error_count = 0;
g_ns_info_count = 0;
}
/* UDP 两接口的场景前置：net_sendto / net_recvfrom 有 netTask 上下文守卫，
* 合法用法只能在 netTask 里调 —— 这里把"换身份"收进一个入口，避免每个场景各写
* 一遍换/还原而漏掉一次（漏了就是"守卫把正常路径判成拒绝"的假故障）。 */
static void bring_up_netctx(void)
{
bring_up();
g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
}
/* 直接造一个在用的控制块（多数场景不需要走完整的 socket()/bind()） */
static int mk_sock(int type, net_sock_state_t state)
{
@@ -141,26 +158,64 @@ static int mk_sock(int type, net_sock_state_t state)
/* = 分片 1 纯函数面与 fd 表 ===================== */
/* TC-NETSOCK-100 点分十进制 ↔ 32 位：钉**当前行为**并显式标注疑点（见报告）
* 现状：net_inet_addr 把首段放在**最高字节**（0xC0A80164），而 net_getsockname 组装
* s_addr 时把首段放在**最低字节**，net_inet_ntoa 只与后者互为逆——同一文件里
* 存在两套字节序约定。这里逐条钉住，不替生产"圆场"。 */
/* TC-NETSOCK-100 点分十进制 ↔ 32 位：**正向断言**（字节序统一修复后）
* 全仓唯一约定：s_addr 是网络字节序整数，&s_addr 的第 0 个内存字节 == 点分第一段；
* 小端主机上 "192.168.1.100" 的数值 = 0x6401A8C0。本组断言的落点是「互逆」与
* 「同族可比」，不是某个中间数值——数值只是这条约定的一个投影。 */
static void tc_100_inet_helpers(void)
{
/* 往返不变量的样本集：两个全零/全一边界 + 三个非回文地址（非回文才能考出顺位） */
static const char *const k_ips[5] = {
"0.0.0.0", "255.255.255.255", "1.1.1.1", "192.168.1.100", "10.0.0.0"
};
char buf[16];
int i;
reset_all();
CHECK(net_inet_addr(NULL) == 0U, "TC-NETSOCK-100a inet_addr(NULL) 返 0（无效）");
CHECK(net_inet_addr("192.168.1.100") == 0xC0A80164U,
"TC-NETSOCK-100b inet_addr 首段落在最高字节（当前实现）");
CHECK(net_inet_ntoa(0xC0A80164U, buf) == buf && strcmp(buf, "100.1.168.192") == 0,
"TC-NETSOCK-100c ntoa(同一 32 位值) 与 inet_addr 不互逆（疑点已报，钉当前行为）");
CHECK(net_inet_addr(NULL) == 0U, "TC-NETSOCK-100a inet_addr(NULL) returns 0 (invalid)");
CHECK(net_inet_addr("192.168.1.100") == 0x6401A8C0U,
"TC-NETSOCK-100b inet_addr returns network-order int (LE value 0x6401A8C0 = bytes C0 A8 01 64)");
CHECK(net_inet_ntoa(net_inet_addr("192.168.1.100"), buf) == buf &&
strcmp(buf, "192.168.1.100") == 0,
"TC-NETSOCK-100c ntoa(inet_addr(s)) == s: the two are exact inverses");
CHECK(net_inet_ntoa(0x6401A8C0U, buf) == buf && strcmp(buf, "192.168.1.100") == 0,
"TC-NETSOCK-100d ntoa 与 getsockname 的 s_addr 约定互逆（E13 定案的段序：高段在前）");
CHECK(net_inet_ntoa(0U, NULL) == NULL, "TC-NETSOCK-100e ntoa(NULL 缓冲) 返 NULL 不崩");
/* 单段/缺分隔的容错：逐段解析，非数字段当 0（钉实现，不钉"应该是多少"） */
CHECK(net_inet_addr("10.0.0.1") == 0x0A000001U, "TC-NETSOCK-100f inet_addr 10.0.0.1");
"TC-NETSOCK-100d ntoa segment order is MSB-first (fixed by E13/TRAP-NET-21, unchanged here)");
CHECK(net_inet_ntoa(0U, NULL) == NULL, "TC-NETSOCK-100e ntoa(NULL buf) returns NULL without crashing");
CHECK(net_inet_addr("10.0.0.1") == 0x0100000AU,
"TC-NETSOCK-100f non-palindrome address: 10.0.0.1 -> 0x0100000A (first octet in low byte)");
/* 正向断言 1：字符串 → 整数 → 字符串 必须回到原串（含 0.0.0.0 与 255.255.255.255） */
for (i = 0; i < 5; i++) {
(void)memset(buf, 0, sizeof(buf));
if (net_inet_ntoa(net_inet_addr(k_ips[i]), buf) == NULL || strcmp(buf, k_ips[i]) != 0) {
break;
}
}
CHECK(i == 5, "TC-NETSOCK-100g round trip ntoa(inet_addr(s)) == s over 5 addrs incl. 0.0.0.0 and 255.255.255.255");
/* 正向断言 2：整数 → 字符串 → 整数 必须回到原值（反方向也闭合） */
for (i = 0; i < 5; i++) {
uint32_t v = net_inet_addr(k_ips[i]);
(void)memset(buf, 0, sizeof(buf));
(void)net_inet_ntoa(v, buf);
if (net_inet_addr(buf) != v) {
break;
}
}
CHECK(i == 5, "TC-NETSOCK-100h round trip inet_addr(ntoa(v)) == v (inverse direction closes too)");
/* 边界语义别改坏：255.255.255.255 是**合法地址**，不得被当失败；
* 失败只有"参数为 NULL"一种，返回值 0 同时是 0.0.0.0 —— 这是 BSD inet_addr
* 的既有歧义，本轮刻意不改（改它要动全部调用者的判错方式，风险大于收益）。 */
CHECK(net_inet_addr("255.255.255.255") == 0xFFFFFFFFU,
"TC-NETSOCK-100i 255.255.255.255 parses to a valid value, never demoted to failure");
CHECK(net_inet_addr("0.0.0.0") == 0U,
"TC-NETSOCK-100j 0.0.0.0 -> 0 (BSD inet_addr ambiguity, not introduced by this fix)");
/* 段值溢出：按低 8 位截断（旧实现会把溢出位溅进相邻段，得到不可预期的混合值） */
CHECK(net_inet_addr("300.1.1.1") == net_inet_addr("44.1.1.1"),
"TC-NETSOCK-100k segment 300 truncates to 44 (300 and 0xFF) with no spill into neighbours");
}
static void tc_101_byteorder(void)
test/host/net_socket/ns_s5_io.c
+6 -6
View File
@@ -435,7 +435,7 @@ static void tc_440_udp_datagram(void)
int addrlen;
int fd;
bring_up();
bring_up_netctx();
CHECK(net_sendto(-1, "x", 1, 0, NULL, 0) == -1 && net_get_errno() == NET_ERR_BADF,
"TC-NETSOCK-440a sendto 越界 → BADF");
CHECK(net_sendto(0, "x", 1, 0, NULL, 0) == -1 && net_get_errno() == NET_ERR_BADF,
@@ -451,7 +451,7 @@ static void tc_440_udp_datagram(void)
/* 带目的地址：先设 DesIP/DesPort 再写数据（不带上限的自旋实现，健康链路一次写完） */
reset_all();
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
(void)memset(&in, 0, sizeof(in));
in.sin_port = net_htons(8888);
@@ -465,7 +465,7 @@ static void tc_440_udp_datagram(void)
/* 大报分块（仍受 NET_SEND_CHUNK_MAX 上界约束） */
reset_all();
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
g_ns_int_pin_set = 0;
ch395f_fake_push_glob((uint16_t)(1U << (fd + 4)));
@@ -475,7 +475,7 @@ static void tc_440_udp_datagram(void)
/* recvfrom：前 8 字节是芯片 UDP 头（长度/srcPort/srcIP），要剥掉再交出去 */
reset_all();
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
ch395f_fake_push_recv_len((uint8_t)fd, 8U + 20U);
addrlen = (int)sizeof(in);
@@ -487,7 +487,7 @@ static void tc_440_udp_datagram(void)
/* 无数据 + 非阻塞 → WOULDBLOCK（阻塞形态是自旋无预算，本套刻意不测，见交付说明） */
reset_all();
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
net_get_errno() == NET_ERR_WOULDBLOCK, "TC-NETSOCK-440m 非阻塞无数据 → WOULDBLOCK");
@@ -496,7 +496,7 @@ static void tc_440_udp_datagram(void)
net_get_errno() == NET_ERR_WOULDBLOCK, "TC-NETSOCK-440n 非阻塞属性同判据生效");
/* 短于 8 字节的残包：不剥头，整包交出去（钉当前实现的边界，不猜"应该怎么算"） */
reset_all();
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
ch395f_fake_push_recv_len((uint8_t)fd, 5U);
CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, NULL, NULL) == 5,
test/host/net_socket/ns_s6_edges.c
+183 -2
View File
@@ -186,7 +186,7 @@ static void tc_506_sendto_stall_and_short(void)
int fd;
int rc;
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
s_net_socks[fd].send_ready = 0U;
g_ns_int_pin_set = 0;
@@ -201,7 +201,7 @@ static void tc_506_sendto_stall_and_short(void)
reset_all();
/* 写完一块后等发完的超时出口 */
bring_up();
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
g_ns_int_pin_set = 0;
ch395f_fake_push_glob((uint16_t)(1U << (fd + 4)));
@@ -377,6 +377,184 @@ static void tc_545_local_entries_without_queue(void)
reset_all();
}
/* ============= TC-NETSOCK-550 s_addr 同族一致性（字节序统一后的收口断言） =============
*
* 这次字节序统一的实质不是「给 inet_addr 换个数值」，而是「全仓只剩一套 s_addr 约定」。
* 所以这组断言全部写在**跨函数的接缝**上：解析→存储→芯片下发→回读→打印，
* 每一环都拿同一句点分十进制做基准。任何一处又引入第二套顺位，这里必红。
*/
/* TC-NETSOCK-550 解析 → 存储 → 打印 闭合（getsockname / getpeername 同族可比对） */
static void tc_550_family_roundtrip(void)
{
struct net_sockaddr_in in;
struct net_sockaddr *sa = (struct net_sockaddr *)&in;
char txt[16];
int addrlen;
int fd;
bring_up();
/* 1) getsockname 的 s_addr 与 inet_addr 解析结果**直接相等**（旧实现差一次换端） */
(void)mk_established(NET_SOCK_STREAM); /* getsockname 要 in_use 的描述符 */
addrlen = (int)sizeof(in);
(void)memset(&in, 0, sizeof(in));
CHECK(net_getsockname(0, sa, &addrlen) == 0,
"TC-NETSOCK-550a getsockname precondition ok");
CHECK(in.sin_addr.s_addr == net_inet_addr("192.168.1.100"),
"TC-NETSOCK-550b getsockname s_addr is the same family as inet_addr (direct equality)");
CHECK(strcmp(net_inet_ntoa(in.sin_addr.s_addr, txt), "192.168.1.100") == 0,
"TC-NETSOCK-550c local address closes parse-store-print (old code printed 100.1.168.192)");
/* 2) connect 的对端簿记同样闭合（lftpd:864 与 104 显示走的就是这条链） */
fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
(void)memset(&in, 0, sizeof(in));
in.sin_family = NET_AF_INET;
in.sin_port = net_htons(2404U);
in.sin_addr.s_addr = net_inet_addr("192.168.1.200");
g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
CHECK(net_connect_locked(fd, sa, (int)sizeof(in)) == 0,
"TC-NETSOCK-550d connect precondition ok");
addrlen = (int)sizeof(in);
(void)memset(&in, 0, sizeof(in));
CHECK(net_getpeername(fd, sa, &addrlen) == 0,
"TC-NETSOCK-550e getpeername ok (reads event cache, zero SPI)");
CHECK(in.sin_addr.s_addr == net_inet_addr("192.168.1.200"),
"TC-NETSOCK-550f getpeername peer equals the s_addr fed into net_connect");
CHECK(strcmp(net_inet_ntoa(in.sin_addr.s_addr, txt), "192.168.1.200") == 0,
"TC-NETSOCK-550g peer address prints right (lftpd connection-received log depends on it)");
CHECK(s_net_socks[fd].remote_ip_arr[0] == 192U &&
s_net_socks[fd].remote_ip_arr[3] == 200U,
"TC-NETSOCK-550h chip des_ip array stays wire order [192,168,1,200]: on-wire behaviour unchanged");
reset_all();
}
/* TC-NETSOCK-555 UDP 报文头里的源地址拆装（同族的第四个生产者：net_recvfrom） */
static void tc_555_udp_src_addr(void)
{
/* CH395F UDP 头（§9.2.4）：[0-1] 总长(LE) [2-3] 源端口(LE) [4-7] 源 IP（线序） */
static const uint8_t hdr[8] = {
11U, 0U, /* 总长 = 8 头 + 3 数据 */
0x1FU, 0xCBU, /* 源端口 51999（小端 1F CB） */
239U, 1U, 2U, 3U /* 源 IP 线序：239.1.2.3 */
};
struct net_sockaddr_in in;
struct net_sockaddr *sa = (struct net_sockaddr *)&in;
char buf[16];
char txt[16];
int addrlen;
int fd;
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
ch395f_fake_push_recv_len((uint8_t)fd, (uint16_t)(8U + 3U));
ch395f_fake_set_recv_bytes(hdr, (uint16_t)sizeof(hdr));
addrlen = (int)sizeof(in);
(void)memset(&in, 0, sizeof(in));
CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &addrlen) == 3,
"TC-NETSOCK-555a strips the 8-byte chip header and delivers only the 3-byte payload");
CHECK(in.sin_addr.s_addr == net_inet_addr("239.1.2.3"),
"TC-NETSOCK-555b source IP unpack matches the inet_addr family");
CHECK(in.sin_port == net_htons(51999U),
"TC-NETSOCK-555c source port read chip little-endian then stored in network order");
CHECK(addrlen == (int)sizeof(in) && net_ntohs(in.sin_port) == 51999U,
"TC-NETSOCK-555d addrlen filled and port round-trips to 51999");
CHECK(strcmp(net_inet_ntoa(in.sin_addr.s_addr, txt), "239.1.2.3") == 0,
"TC-NETSOCK-555e multicast source address prints correctly");
reset_all();
}
/* TC-NETSOCK-560 UDP 上下文守卫：非执行任务不得直调芯片
* 三条一起才成立，缺一条都不算把危险面关掉：
* ① 执行任务内照常成功（守卫不是"把 UDP 判死"）
* ② 非执行任务被拒且**一次芯片事务都没有**（拒了却已经抢过 SPI = 白拒）
* ③ 正常错误路径不被守卫吞掉，且**走消息队列的接口完全不受影响**
* （那些接口生来就是给非 netTask 用的，误伤它们才是大事故）
*/
static void tc_560_udp_context_guard(void)
{
char buf[8];
int fd;
/* ① 执行任务上下文：与修复前逐字相同 */
bring_up_netctx();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
CHECK(net_sendto(fd, "abc", 3, 0, NULL, 0) == 3,
"TC-NETSOCK-560a net_sendto unchanged inside the executing task");
reset_all();
/* ② 非执行任务：拒绝 + 零芯片事务（bring_up 里 net_init 是以 netTask 身份跑的，
* 此刻 g_ns_cur_task 已还原成 caller，正是"别的任务"） */
bring_up();
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
g_chip.write_calls = 0;
g_chip.read_calls = 0;
g_fxchip.set_des_ip_calls = 0;
g_fxchip.glob_calls = 0;
g_ns_poll_calls = 0;
g_ns_error_count = 0;
CHECK(net_sendto(fd, "abc", 3, 0, NULL, 0) == -1 &&
net_get_errno() == NET_ERR_NOT_IN_NETTASK,
"TC-NETSOCK-560b non-executing task gets NET_ERR_NOT_IN_NETTASK (exact code, not -1)");
CHECK(g_chip.write_calls == 0 && g_fxchip.set_des_ip_calls == 0 &&
g_ns_poll_calls == 0,
"TC-NETSOCK-560c clean refusal: zero writes, zero set_des_ip, zero net_poll rounds");
CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
net_get_errno() == NET_ERR_NOT_IN_NETTASK,
"TC-NETSOCK-560d net_recvfrom guarded the same way");
CHECK(g_chip.read_calls == 0 && g_fxchip.glob_calls == 0 && g_ns_poll_calls == 0,
"TC-NETSOCK-560e recvfrom touched no chip and no global interrupt register either");
CHECK(g_ns_error_count == 2,
"TC-NETSOCK-560f each refusal logs one ERR line (silence hides the wrong task)");
/* ③ 正常错误路径优先：守卫排在参数校验之后 */
CHECK(net_sendto(-1, "abc", 3, 0, NULL, 0) == -1 &&
net_get_errno() == NET_ERR_BADF, "TC-NETSOCK-560g out-of-range fd still reports BADF first");
CHECK(net_sendto(fd, NULL, 3, 0, NULL, 0) == -1 &&
net_get_errno() == NET_ERR_INVAL,
"TC-NETSOCK-560h NULL buf still reports INVAL, the guard does not swallow it");
CHECK(net_recvfrom(fd, NULL, 3, NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
net_get_errno() == NET_ERR_INVAL, "TC-NETSOCK-560i recvfrom keeps the same precedence");
/* ④ 走消息队列的接口不受守卫影响：同一个非 netTask 上下文照常能把活干完 */
CHECK(net_close(fd) == 0,
"TC-NETSOCK-560j net_close from a non-executing task still works (queue path untouched)");
/* 执行完的证据用"收到回执 + 槽位释放"，不看 close_calls：芯片此刻已是
* CLOSED，走的是快路径（不再补发 CLOSE，见 TC-NETSOCK-320a/b），拿它当证据
* 会把一条正确的快路径判成失败 */
CHECK(s_net_socks[fd].in_use == 0U && g_ns_notify_calls >= 1,
"TC-NETSOCK-560k queue path really completed (receipt seen and slot released)");
reset_all();
/* ⑤ 未捕获执行任务（net_init 没跑）：守卫不抢先，仍由参数/状态检查给确定错误 */
reset_all();
g_ns_pump = net_process_messages;
CHECK(net_sendto(0, "abc", 3, 0, NULL, 0) == -1 &&
net_get_errno() == NET_ERR_BADF,
"TC-NETSOCK-560l before net_init sendto reports BADF, no invented context error");
/* 未捕获执行任务、但 socket 确实在用时，守卫**选择放行**：宁可不做判定，也不给
* 一个无从判定的场景编造错误码。放行后走的是完全正常的执行路径（这里 DONTWAIT
* 无数据 → WOULDBLOCK），证明守卫不是"没初始化就一律拒绝"的粗暴实现。
* 刻意用 recvfrom 而不是 sendto：未初始化时 net_poll 直接短路返回、时间基准
* 不前进，sendto 的等待环永远等不到超时（真机上不可达：net_socket 之后还有
* NET_READY 屏障，但这条差异值得记一笔，见交付报告）。 */
reset_all();
g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller; /* net_init 没跑：判据恒 NULL */
fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
g_fxchip.glob_calls = 0;
CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
net_get_errno() == NET_ERR_WOULDBLOCK,
"TC-NETSOCK-560m guard stays open when the executing task was never captured");
CHECK(net_get_errno() != NET_ERR_NOT_IN_NETTASK && g_fxchip.glob_calls == 0,
"TC-NETSOCK-560n no context error invented and no global register read");
reset_all();
}
static void ns_run_s6(void)
{
tc_500_public_bounds();
@@ -392,4 +570,7 @@ static void ns_run_s6(void)
tc_537_event_callback_path();
tc_540_negative_results();
tc_545_local_entries_without_queue();
tc_550_family_roundtrip();
tc_555_udp_src_addr();
tc_560_udp_context_guard();
}