Files
STM32F4-Base/test/host/iec104_netmcu/net_socket_fake.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

833 lines
20 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.
/*
* FAKE net_socket 实现 —— 见 net_socket_fake.h 的定位说明。
* 只服务 test/host/iec104_netmcu/,不进产品构建。
*/
#include "net_socket_fake.h"
#include <stdio.h>
#include <string.h>
/* fake_fd_t 定义见下方(fd_at 的前向声明在结构体之后)。 */
#define FAKE_MAX_FD 8
#define FAKE_RX_CAP 2048
#define FAKE_PEER_QUEUE 4
typedef struct {
int used;
int is_listener;
int listening;
int established;
int peer_fin;
int peer_reset;
int rx_len;
uint8_t rx[FAKE_RX_CAP];
/* 发送侧“内核还没接受”的暂存量:测试靠它验证“返回后改 buffer 不影响在途数据”。
* 真实驱动里这段数据已经进了芯片 FIFO,所以 fake 必须在 net_send 里就拷走。 */
int tx_pending;
uint8_t tx[FAKE_RX_CAP];
} fake_fd_t;
typedef struct {
uint8_t octet;
uint16_t port;
} fake_peer_t;
/* net_socket.h 在 NET_NO_OS 下不声明 fd_at;本 fake 的静态辅助函数保持该文件内私有。 */
static fake_fd_t *fd_at(int fd);
static uint16_t fake_recv_len(uint8_t sock);
static fake_fd_t fds[FAKE_MAX_FD];
static fake_peer_t peers[FAKE_PEER_QUEUE];
static int peer_count;
static uint32_t generation = 1;
/* 注意:板端 tick 源已由 net-cutover 钉为 HAL_GetTick(),fake 直接受控。
* N-2 口径:netTask 每轮调用 net_mono_now_ms() 采样一次 tick;这里模拟
* 两次采样之间的累计,不把“不调用就不丢时间”塞进用例。 */
static uint32_t tick_low;
static int fake_errno;
static uint8_t fake_owner = 1;
static uint64_t mono_ms;
static uint32_t mono_last;
static int mono_seeded;
static net_sock_t fake_socks[FAKE_MAX_FD];
/* net_socket.h 声明但后端可能查询这些轻量接口;fake 用内存状态回答。 */
int net_listener_armed(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && f->is_listener && (f->listening || f->established) ? 1 : 0;
}
int net_can_read(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
return f != NULL && (f->rx_len > 0 || f->peer_fin || f->peer_reset) ? 1 : 0;
}
static net_fake_send_mode_t send_mode;
static int send_mode_left;
static int send_short_limit;
static net_fake_accept_mode_t accept_mode;
static int accept_mode_left;
static net_fake_send_mode_t recv_mode;
static int recv_mode_left;
static int recv_len_degraded;
static int reuse_after_close = 1;
static net_fake_stats_t stats;
static fake_fd_t *fd_at(int fd)
{
if (fd < 0 || fd >= FAKE_MAX_FD) {
return NULL;
}
return fds[fd].used ? &fds[fd] : NULL;
}
static int alloc_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
return i;
}
}
return -1;
}
void net_fake_reset(void)
{
memset(fds, 0, sizeof(fds));
memset(peers, 0, sizeof(peers));
memset(&stats, 0, sizeof(stats));
peer_count = 0;
generation = 1;
tick_low = 0;
send_mode = FAKE_SEND_NORMAL;
send_mode_left = 0;
send_short_limit = 0;
accept_mode = FAKE_ACCEPT_NORMAL;
accept_mode_left = 0;
recv_mode = FAKE_SEND_NORMAL;
recv_mode_left = 0;
recv_len_degraded = 0;
reuse_after_close = 1;
fake_owner = 1;
fake_errno = 0;
mono_ms = 0;
mono_last = tick_low;
mono_seeded = 0;
memset(fake_socks, 0, sizeof(fake_socks));
/* 预置一个已监听 fd=3:所有用例都从“板端后端已经 Listen 成功”起步。 */
fds[3].used = 1;
fds[3].is_listener = 1;
fds[3].listening = 1;
}
int net_fake_peer_arrive(uint8_t last_octet, uint16_t port)
{
if (peer_count >= FAKE_PEER_QUEUE) {
return 0;
}
peers[peer_count].octet = last_octet;
peers[peer_count].port = port;
++peer_count;
return 1;
}
int net_fake_session_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
/* 单连接模型:accept 后监听 fd 自身就是会话 fd,所以不能排除 is_listener。 */
if (fds[i].used && fds[i].established) {
return i;
}
}
return -1;
}
int net_fake_listen_fd(void)
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used && fds[i].is_listener && fds[i].listening) {
return i;
}
}
return -1;
}
int net_fake_listener_armed(void)
{
int fd = net_fake_listen_fd();
return (fd >= 0 && net_listener_armed(fd) != 0) ? 1 : 0;
}
int net_fake_push_rx(const void *data, int len)
{
int fd = net_fake_session_fd();
fake_fd_t *f;
int room;
if (fd < 0 || len <= 0) {
return -1;
}
f = &fds[fd];
room = FAKE_RX_CAP - f->rx_len;
if (len > room) {
len = room;
}
memcpy(f->rx + f->rx_len, data, (size_t)len);
f->rx_len += len;
return len;
}
void net_fake_peer_fin(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_fin = 1;
}
}
void net_fake_peer_reset(void)
{
int fd = net_fake_session_fd();
if (fd >= 0) {
fds[fd].peer_reset = 1;
}
}
void net_fake_set_send_mode(net_fake_send_mode_t mode, int times, int short_limit)
{
send_mode = mode;
send_mode_left = times;
send_short_limit = short_limit;
}
void net_fake_set_accept_mode(net_fake_accept_mode_t mode, int times)
{
accept_mode = mode;
accept_mode_left = times;
}
void net_fake_set_recv_mode(net_fake_send_mode_t mode, int times)
{
recv_mode = mode;
recv_mode_left = times;
}
void net_fake_set_recv_len_degraded(int mode)
{
recv_len_degraded = mode;
}
void net_fake_set_reuse_after_close(int on)
{
reuse_after_close = on ? 1 : 0;
}
void net_generation_inc(void)
{
++generation;
/* 代次变化 = 芯片复位:监听退回未监听,等待外层重建。
* 注意:故意保留 established 状态——真实芯片复位后旧 fd 数值可能被新连接
* 复用,驱动层不会替上层做“代次校验”;那正是后端必须自己查代次的原因。 */
{
int i;
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (fds[i].used) {
fds[i].listening = 0;
}
}
}
peer_count = 0;
}
void net_fake_generation_inc(void)
{
net_generation_inc();
}
uint32_t net_get_generation(void)
{
return generation;
}
uint32_t net_fake_generation(void)
{
return net_get_generation();
}
void net_fake_set_tick(uint32_t tick)
{
tick_low = tick;
}
uint32_t net_fake_tick_low(void)
{
return tick_low;
}
void net_fake_set_owner(uint8_t owner)
{
fake_owner = owner ? 1U : 0U;
}
uint8_t net_fake_owner(void)
{
return fake_owner;
}
uint32_t HAL_GetTick(void)
{
return tick_low;
}
uint8_t net_ctx_is_owner_task(void)
{
return fake_owner;
}
int net_set_errno(int err)
{
fake_errno = err;
return err;
}
int net_get_errno(void)
{
return fake_errno;
}
uint16_t net_dynamic_port_next(void)
{
static uint16_t next = 49152U;
uint16_t out = next;
next = (uint16_t)(out == 65535U ? 49152U : out + 1U);
return out;
}
uint16_t net_htons(uint16_t hostshort)
{
return (uint16_t)((hostshort >> 8) | (hostshort << 8));
}
uint16_t net_ntohs(uint16_t netshort)
{
return net_htons(netshort);
}
uint32_t net_inet_addr(const char *cp)
{
unsigned a, b, c, d;
if (cp == NULL || sscanf_s(cp, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) {
return 0U;
}
if (a > 255U || b > 255U || c > 255U || d > 255U) {
return 0U;
}
/* 与产品同族:s_addr 的第 0 个内存字节 == 点分第一段(小端数值反转)。 */
return (uint32_t)(a | (b << 8) | (c << 16) | (d << 24));
}
char *net_inet_ntoa(uint32_t addr, char *buf)
{
unsigned a = addr & 0xFFU;
unsigned b = (addr >> 8) & 0xFFU;
unsigned c = (addr >> 16) & 0xFFU;
unsigned d = (addr >> 24) & 0xFFU;
if (buf != NULL) {
(void)_snprintf_s(buf, 16, 15, "%u.%u.%u.%u", a, b, c, d);
}
return buf;
}
net_sock_t *net_get_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_t *net_sock_raw(int sockfd)
{
if (sockfd < 0 || sockfd >= FAKE_MAX_FD) {
return NULL;
}
return &fake_socks[sockfd];
}
net_sock_state_t net_sock_state(int sockfd)
{
net_sock_t *s = net_sock_raw(sockfd);
return (s != NULL) ? s->state : NET_SOCK_STATE_CLOSED;
}
static void sync_sock(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
net_sock_t *s = net_sock_raw(sockfd);
if (f == NULL || s == NULL) {
return;
}
s->ch395_sock = (uint8_t)sockfd;
s->in_use = 1U;
if (f->established) {
s->state = NET_SOCK_STATE_ESTABLISHED;
} else if (f->is_listener && f->listening) {
s->state = NET_SOCK_STATE_LISTENING;
} else if (f->used) {
s->state = NET_SOCK_STATE_CREATED;
} else {
s->state = NET_SOCK_STATE_CLOSED;
s->in_use = 0U;
}
s->send_ready = 1U;
s->readable = (uint8_t)(f->rx_len > 0 || f->peer_fin || f->peer_reset);
s->remote_port = (uint16_t)(stats.last_peer_port);
if (f->established) {
memcpy(s->remote_ip_arr, stats.last_peer_ip, sizeof(s->remote_ip_arr));
}
}
int net_listen_locked(int sockfd)
{
int rc = net_listen(sockfd);
sync_sock(sockfd);
return rc;
}
int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
int rc = net_accept(sockfd, addr, addrlen);
sync_sock(sockfd);
if (rc >= 0 && addr != NULL && addrlen != NULL && *addrlen >= (int)sizeof(struct net_sockaddr_in)) {
struct net_sockaddr_in *in = (struct net_sockaddr_in *)(void *)addr;
in->sin_family = NET_AF_INET;
in->sin_port = net_htons(stats.last_peer_port);
memcpy(&in->sin_addr.s_addr, stats.last_peer_ip, sizeof(in->sin_addr.s_addr));
}
return rc;
}
int net_drop_conn_locked(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_drop_conn((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_close_sock(net_sock_t *p_sock)
{
int rc;
if (p_sock == NULL) {
return -1;
}
rc = net_close((int)p_sock->ch395_sock);
sync_sock((int)p_sock->ch395_sock);
return rc;
}
int net_send_sock(net_sock_t *p_sock, const void *buf, int len)
{
return net_send((int)p_sock->ch395_sock, buf, len, 0);
}
int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags)
{
return net_recv((int)p_sock->ch395_sock, buf, len, flags);
}
int net_pending_bytes(int sockfd)
{
fake_fd_t *f;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return -1;
}
f = fd_at(sockfd);
if (f == NULL || !f->established) {
net_set_errno(NET_ERR_BADF);
return -1;
}
++stats.recv_len_calls;
if (recv_len_degraded == 1) {
net_set_errno(NET_ERR_BUSY);
return -1;
}
return (int)fake_recv_len((uint8_t)sockfd);
}
int net_send_try(net_sock_t *p_sock, const void *buf, int len, int *sent)
{
int rc;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return NET_ERR_NOT_IN_NETTASK;
}
if (sent == NULL || p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
*sent = 0;
if (len > 1024) {
len = 1024;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc >= 0) {
*sent = rc;
return 0;
}
return rc;
}
uint64_t net_mono_now_ms(void)
{
uint32_t now = HAL_GetTick();
uint32_t delta;
if (fake_owner == 0U) {
net_set_errno(NET_ERR_NOT_IN_NETTASK);
return mono_ms;
}
if (!mono_seeded) {
mono_last = now;
mono_seeded = 1;
}
delta = now - mono_last;
mono_last = now;
mono_ms += (uint64_t)delta;
return mono_ms;
}
int net_send_locked(net_sock_t *p_sock, const void *buf, int len, TaskHandle_t caller)
{
int rc;
(void)caller;
if (p_sock == NULL || buf == NULL || len < 0) {
net_set_errno(NET_ERR_INVAL);
return NET_ERR_INVAL;
}
rc = net_send((int)p_sock->ch395_sock, buf, len, 0);
if (rc < 0) {
net_set_errno(NET_ERR_WOULDBLOCK);
}
return rc;
}
void net_fake_stats(net_fake_stats_t *out)
{
if (out != NULL) {
*out = stats;
}
}
void net_fake_stats_reset(void)
{
memset(&stats, 0, sizeof(stats));
}
/* 把 fake 内核中“已接受但尚未被对端取走”的字节拷给测试,验证 no-borrow。
* 返回可用长度;data 可为 NULL(只查询长度)。 */
int net_fake_copy_tx(uint8_t *data, int capacity)
{
int fd = net_fake_session_fd();
int n;
if (fd < 0) {
return -1;
}
n = fds[fd].tx_pending;
if (data != NULL && capacity > 0) {
int take = n < capacity ? n : capacity;
memcpy(data, fds[fd].tx, (size_t)take);
return take;
}
return n;
}
/* --------------------------- BSD 兼容面和 net_socket.h --------------------------- */
int net_socket(int domain, int type)
{
int i;
int fd;
(void)domain;
(void)type;
if (!reuse_after_close) {
/* 分配一个此前没用过的 fd,制造“旧整数被新会话复用”的对照。 */
for (i = 0; i < FAKE_MAX_FD; ++i) {
if (!fds[i].used) {
memset(&fds[i], 0, sizeof(fds[i]));
fds[i].used = 1;
sync_sock(i);
return i;
}
}
return -1;
}
fd = alloc_fd();
if (fd >= 0) {
sync_sock(fd);
}
return fd;
}
int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen)
{
(void)addr;
(void)addrlen;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_listen(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
if (f == NULL) {
return -1;
}
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen)
{
fake_fd_t *f = fd_at(sockfd);
(void)addr;
(void)addrlen;
++stats.accept_calls;
++stats.hardware_calls;
if (accept_mode_left > 0 || accept_mode != FAKE_ACCEPT_NORMAL) {
net_fake_accept_mode_t mode = accept_mode;
if (accept_mode_left > 0) {
--accept_mode_left;
}
if (accept_mode_left == 0) {
accept_mode = FAKE_ACCEPT_NORMAL;
}
switch (mode) {
case FAKE_ACCEPT_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_ACCEPT_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_ACCEPT_RESOURCE_LOW:
return NET_ERR_NOMEM;
default:
break;
}
}
if (f == NULL || !f->listening || peer_count == 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
/* 单连接模型的核心:交回的“客户端 fd”就是监听 fd 本身。 */
f->established = 1;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
stats.last_peer_ip[0] = 10;
stats.last_peer_ip[1] = 0;
stats.last_peer_ip[2] = 0;
stats.last_peer_ip[3] = peers[0].octet;
stats.last_peer_port = peers[0].port;
memmove(&peers[0], &peers[1], sizeof(peers[0]) * (size_t)(peer_count - 1));
--peer_count;
sync_sock(sockfd);
return sockfd;
}
int net_send(int sockfd, const void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int accepted;
(void)flags;
++stats.send_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (send_mode_left > 0 || send_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = send_mode;
if (send_mode_left > 0) {
--send_mode_left;
}
if (send_mode_left == 0) {
send_mode = FAKE_SEND_NORMAL;
}
switch (mode) {
case FAKE_SEND_SHORT:
accepted = len < send_short_limit ? len : send_short_limit;
if (accepted <= 0) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
break;
case FAKE_SEND_WOULDBLOCK:
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
case FAKE_SEND_BUSY:
++stats.busy_returns;
return NET_ERR_BUSY;
case FAKE_SEND_ZERO_OK:
return 0;
default:
accepted = len;
break;
}
} else {
accepted = len;
}
/* 拷贝语义:数据在调用返回前就已进“芯片”,调用方随后改 buffer 不得影响它。 */
if (f->tx_pending + accepted > FAKE_RX_CAP) {
accepted = FAKE_RX_CAP - f->tx_pending;
}
if (accepted > 0) {
memcpy(f->tx + f->tx_pending, buf, (size_t)accepted);
f->tx_pending += accepted;
stats.bytes_sent += accepted;
}
return accepted;
}
int net_recv(int sockfd, void *buf, int len, int flags)
{
fake_fd_t *f = fd_at(sockfd);
int take;
(void)flags;
++stats.recv_calls;
++stats.hardware_calls;
if (f == NULL || !f->established || buf == NULL || len <= 0) {
return NET_ERR_BADF;
}
if (f->peer_reset) {
return NET_ERR_CONNRESET;
}
if (recv_mode_left > 0 || recv_mode != FAKE_SEND_NORMAL) {
net_fake_send_mode_t mode = recv_mode;
if (recv_mode_left > 0) {
--recv_mode_left;
}
if (recv_mode_left == 0) {
recv_mode = FAKE_SEND_NORMAL;
}
if (mode == FAKE_SEND_WOULDBLOCK) {
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
if (mode == FAKE_SEND_BUSY) {
++stats.busy_returns;
return NET_ERR_BUSY;
}
}
if (f->rx_len == 0) {
if (f->peer_fin) {
return 0; /* EOF */
}
++stats.would_block_returns;
return NET_ERR_WOULDBLOCK;
}
take = len < f->rx_len ? len : f->rx_len;
memcpy(buf, f->rx, (size_t)take);
memmove(f->rx, f->rx + take, (size_t)(f->rx_len - take));
f->rx_len -= take;
return take;
}
int net_recv_nb(int sockfd, void *buf, int len)
{
return net_recv(sockfd, buf, len, 0);
}
int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms)
{
(void)timeout_ms;
return net_recv(sockfd, buf, len, 0);
}
int net_setblocking(int sockfd, int on)
{
(void)on;
return fd_at(sockfd) != NULL ? 0 : -1;
}
int net_close(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.close_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
if (f->is_listener) {
/* 真实板端:单连接模型下对监听 fd 调 net_close 会连监听一起毁掉。
* fake 如实模拟:返回成功但监听消失,同时留下违规计数供断言。 */
++stats.listen_closed_attempts;
memset(f, 0, sizeof(*f));
return 0;
}
memset(f, 0, sizeof(*f));
return 0;
}
int net_drop_conn(int sockfd)
{
fake_fd_t *f = fd_at(sockfd);
++stats.drop_conn_calls;
++stats.hardware_calls;
if (f == NULL) {
return -1;
}
/* 拆会话、保监听:监听 fd 自身保留,会话状态清零。 */
f->established = 0;
f->peer_fin = 0;
f->peer_reset = 0;
f->rx_len = 0;
f->tx_pending = 0;
f->listening = 1;
f->is_listener = 1;
sync_sock(sockfd);
return 0;
}
/* 板端后端需要的 32 位节拍源;签名以最终 plan.md / 后端源码为准。
* 当前先用无参形式提供测试可控 tick,后端若用 osKernelGetTickCount() 等
* 别的源,runner 通过 -D 重映射,用例不变。 */
uint32_t ch395f_get_tick_1ms(void)
{
return tick_low;
}
/* 驱动提供的接收队列长度查询(板端后端 Pending_Input 的数据来源)。
* 真实签名(Drivers/BSP/CH395F/ch395f.h:573):uint16_t ch395f_get_recv_len(uint8_t sock)。
* 降级模式返回 0 / 0xFFFF:后者模拟芯片异常,强制后端走 ERROR 契约。 */
static uint16_t fake_recv_len(uint8_t sock);
static uint16_t fake_recv_len(uint8_t sock)
{
fake_fd_t *f = fd_at((int)sock);
++stats.recv_len_calls;
if (f == NULL) {
return 0xFFFFU;
}
if (recv_len_degraded == 2) {
return 1U; /* 报小:每次只说 1 字节有界,剩余靠上层续收 */
}
if (recv_len_degraded == 1) {
return 0xFFFFU; /* 查询不可信:强制后端走 ERROR 降级路径 */
}
return (uint16_t)f->rx_len;
}