1f51e8fa2f
起因: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 条断言。
680 lines
29 KiB
C
680 lines
29 KiB
C
/* 模块名称: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;
|
||
}
|
||
}
|