Files
STM32F4-Base/App/protocol/iec104/iec104_net_mcu.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

657 lines
28 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 <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 的任何调用路径。 */
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;
}
}