Files
STM32F4-Base/App/protocol/iec104/iec104_net_mcu.c
T
wandering1 1f51e8fa2f refactor(net): 单调时钟搬回时间模块,owner-only 入口补机器守卫
起因:104 适配层的 net 栈净增 5 个对外声明,其中 3 个是真新增。逐个查过:
net_pending_bytes / net_send_try 位置正确、不可替代(前者是 BSD FIONREAD 语义,
后者必须截到 NET_SEND_CHUNK_MAX 才不丢进度),保留不动;另外 2 个
net_accept_locked / net_drop_conn_locked 在更早的提交里只是把 static 去掉,
函数体一字未改,不是新函数。真正有问题的是三处:

一、net_mono_now_ms 放错层。这是"把 32 位 HAL_GetTick 扩成 64 位单调毫秒"的
时间工具,却挂在 socket 栈上。搬到 App/util/sys_clock,改名 sys_clock_mono_ms,
临界区保护读改写,零 NET 依赖(旧实现里的 owner 判定与非 owner 返回 0 语义
不再搬过来——时钟是纯读取,ABI 未要求)。

二、头注释把通用能力绑死到单个消费者。原文写"以下五个入口专供 netTask 内
IEC104 Net 后端使用",下一个读者要么不敢用、要么直接删掉。改写成通用
owner-only 能力描述,入口计数核准为 4。

三、两个 locked 函数没有任何 owner 校验,只在注释里写"必须在 netTask 上下文"。
而 net_accept_locked 函数体第一句就 net_poll() 跑真实 CH395F SPI 事务——别的
任务误调会与 netTask 抢同一根 SPI 总线,正是 TRAP-NET-14 的形态。两个函数头
各补 if (net_ctx_is_owner_task() == 0U) 守卫,非 owner 返回 NET_ERR_INVAL。

用户提出的关键疑问「项目里本来就有时间模块,用现成的不行吗」的答案是:
功能确实已搬进时间模块,但不能复用 sys_clock_get()。三条硬理由——
其一是单位,sys_clock_get() 内部整除 1000 返回 Unix 秒,而 104 退避常量
是毫秒级(TCP_SEND_RETRY_DELAY_MS = 10、TCP_ACCEPT_RETRY_DELAY_MS = 100),
拿秒比毫秒会把退避放大 1000 倍;其二是单调性,sys_clock_set() 第一句直接给
s_base_unix_secs 赋新值,SNTP 校时与 UI 改时都会调它,墙钟会跳变;其三是
语义,104 用 now_ms < at_ms 判退避是否到期,墙钟回拨会让重试长期不触发。
所以同一模块两个入口分工:sys_clock_get() 管墙钟 epoch 秒(可跳变,给日志
与文件时间戳),sys_clock_mono_ms() 管 64 位单调毫秒(只增不减,给定时器
与超时判定)。

测试:net_socket 677→683(新增 6 条守卫用例,删守卫变异必红)、
sys_clock 100→111(正常累加/回绕单调/不吞时间三类)、iec104_netmcu 13/13。
104 适配层改调 sys_clock_mono_ms 后,原先因旧函数被删而红的 netmcu runner
恢复全绿;host 侧新增 stub/sys_clock.h 替身(真头带 sd2506.h 依赖,主机编不了),
签名与真头逐字一致。

构建:0 Error(s), 0 Warning(s),Code 367584→367612(+28 B),RO/RW/ZI 全 0,
IRAM1 90.3%(阈值 92%)。+0 增量是符号级真抵消——sys_clock.o 新增
s_prev_lo/s_hi 共 8 B,net_socket.o 删掉同名两个 static 共 8 B。

文档:两份网络文档里 38 处写死的源码行号全部改成「文件路径 + 函数名」锚点
(那些行号本来就已随重构失效),owner 条目数 5→4;sys_clock 设计文档 §5
对外 API 表补 sys_clock_mono_ms 行,新增 §5.1 写清「墙钟 vs 单调:测超时该用
哪个」,§1 里「业务逻辑中基于真实时间的判定(定时、超时、调度等)」这句
会教人拿墙钟测超时的表述改成「墙钟不用于计时」。

门禁:net-handle 488 文件 0 违规 + selftest 42 条断言。
2026-11-19 00:38:09 +08:00

680 lines
29 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.
/* 模块名称: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 "sys_clock.h" /* IEC104_Net_Now_Ms:通用 64 位单调毫秒(从 net 栈搬出) */
#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(0 合法;失效值只认 NET_FD_INVALID) */
uint32_t net_gen; /* 成功 Listen 时的网络代次,跨代旧句柄一律失效 */
uint8_t role; /* slot_role_t */
} slot_t;
/* 槽位初值:fd 必须显式写成契约失效值,禁止依赖静态零初始化(0 是合法 fd)。
* 条目数必须等于 IEC104_MCU_MAP_SIZE(8)。 */
#define IEC104_SLOT_INIT { .handle = 0U, .fd = NET_FD_INVALID, \
.net_gen = 0U, .role = SLOT_FREE }
static slot_t s_slots[IEC104_MCU_MAP_SIZE] = {
IEC104_SLOT_INIT, IEC104_SLOT_INIT, IEC104_SLOT_INIT, IEC104_SLOT_INIT,
IEC104_SLOT_INIT, IEC104_SLOT_INIT, IEC104_SLOT_INIT, IEC104_SLOT_INIT,
};
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));
slot->fd = NET_FD_INVALID;
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));
slot->fd = NET_FD_INVALID;
}
/* 函数功能:分配一个新句柄值(单调递增、永不复用),必要时先整表作废重启。
* 参数:无。
* 返回值:新句柄(非 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));
for (uint32_t i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
s_slots[i].fd = NET_FD_INVALID;
}
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));
for (uint32_t i = 0U; i < IEC104_MCU_MAP_SIZE; ++i) {
s_slots[i].fd = NET_FD_INVALID;
}
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 = NET_FD_INVALID;
int 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]));
s_slots[i].fd = NET_FD_INVALID;
}
}
}
/* 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 == NET_FD_INVALID) {
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 的任何调用路径。 */
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));
slot->fd = NET_FD_INVALID;
return result(IEC104_NET_OK, 0, native_error);
}
uint64_t IEC104_Net_Now_Ms(void)
{
/* 单调时钟是纯读取,无 owner 概念:旧 net 栈版本的“非 owner 返 0 +
* NET_ERR_NOT_IN_NETTASK”语义已随函数搬到通用时钟模块并取消,本适配层
* 不再做上下文保护(ABI 未要求)。 */
return sys_clock_mono_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;
}
}