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

839 lines
22 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 "sys_clock.h" /* 声明本文件提供的 sys_clock_mono_ms 替身,签名漂移即编译期暴露 */
#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 口径:通用时钟 sys_clock_mono_ms() 由 netTask 每轮采样一次 tick;这里模拟
* 两次采样之间的累计,不把“不调用就不丢时间”塞进用例。函数体语义与生产
* App/util/sys_clock.c 的 sys_clock_mono_ms 一致(32 位增量累加 + 跨 0xFFFFFFFF
* 自然回绕),但本 fake 无临界区(单线程宿主)、无 owner 概念。 */
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)
{
/* 测试代码:假对象域校验用裸区间判据(契约 C4/C6 允许),生产判据不得照抄 */
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 NET_FD_INVALID; /* 契约 C5:分配失败返回失效值(不是随便一个负号) */
}
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 NET_FD_INVALID; /* 契约 C5:无会话 = 失效值 */
}
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 NET_FD_INVALID;
}
int net_fake_listener_armed(void)
{
int fd = net_fake_listen_fd();
return (fd != NET_FD_INVALID && 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)
{
/* 测试代码:假对象域校验用裸区间判据(契约 C4),不是生产判据 */
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;
}
/* sys_clock_mono_ms 的测试替身:被测 iec104_net_mcu.c 通过 sys_clock.h 调它。
* 语义对齐生产 App/util/sys_clock.c 的 sys_clock_mono_ms:32 位 HAL_GetTick
* 增量累加成 64 位单调量,跨 0xFFFFFFFF→0 由无符号减法自然回绕;纯读取,
* 不做 owner 校验(旧 net 栈时钟的 NET_ERR_NOT_IN_NETTASK 语义已搬迁取消)。 */
uint64_t sys_clock_mono_ms(void)
{
uint32_t now = HAL_GetTick();
uint32_t delta;
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 == NET_FD_INVALID) {
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 NET_FD_INVALID;
}
fd = alloc_fd();
if (fd != NET_FD_INVALID) {
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) {
/* 契约 C6:越界 / 未分配 fd 的关闭必须失败 */
return NET_FD_INVALID;
}
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;
}