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 条断言。
839 lines
22 KiB
C
839 lines
22 KiB
C
/*
|
||
* 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;
|
||
}
|