From 78ea81aecbff107a5079e9f165400433863cc453 Mon Sep 17 00:00:00 2001 From: Wanderingss <1624155937@qq.com> Date: Fri, 25 Sep 2026 15:00:36 +0800 Subject: [PATCH] =?UTF-8?q?net=5Fsocket.c=20=E5=85=A8=E9=83=A8=2059=20?= =?UTF-8?q?=E4=B8=AA=E5=87=BD=E6=95=B0=E4=BD=93=E6=B3=A8=E9=87=8A=E6=94=B9?= =?UTF-8?q?=E4=B8=BA=E9=80=90=E8=A1=8C=E9=A3=8E=E6=A0=BC=EF=BC=88=E7=BA=AF?= =?UTF-8?q?=E6=B3=A8=E9=87=8A=E6=94=B9=E5=8A=A8=EF=BC=8C=E6=9E=84=E5=BB=BA?= =?UTF-8?q?=200/0=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Drivers/BSP/NET/net_socket.c | 1445 ++++++++++++++++++++++++---------- 1 file changed, 1039 insertions(+), 406 deletions(-) diff --git a/Drivers/BSP/NET/net_socket.c b/Drivers/BSP/NET/net_socket.c index 3ceced37..8a0870cf 100644 --- a/Drivers/BSP/NET/net_socket.c +++ b/Drivers/BSP/NET/net_socket.c @@ -45,9 +45,9 @@ static uint16_t s_dynamic_port = 49152; /* 动态端口分配起始 static volatile uint32_t s_net_generation = 0; /* 网络代次号：网络重建完成时递增（服务据此重建监听） */ /* - * 消息队列 - 线程安全核心 - * 外部任务通过 net_send/net_recv/net_close 等 API 将请求放入队列， - * netTask 调用 net_process_messages() 串行处理所有 CH395F 操作 + * 消息队列（线程安全核心） + * 外部任务经 net_send/net_recv/net_close 等公开 API 投递请求 + * netTask 调 net_process_messages() 串行处理所有 CH395F 操作 * 由 CubeMX 在 MX_FREERTOS_Init()（osKernelInitialize 之后）中创建 */ extern osMessageQueueId_t netMsgQueueHandle; /* CubeMX 生成的消息队列句柄 */ @@ -78,12 +78,12 @@ static void net_relisten_retry_tick(void); static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen); static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int addrlen); -/* L3 pending 化（一期，E-02 结构演进）：阻塞等待 = 挂起请求 + 主循环节拍完成。 - * "无数据 + 阻塞等待"不再自旋占用 netTask：登记 pending 后立即返回， +/* L3 pending 化（一期，E-02 结构演进）：阻塞等待 = 挂起请求 + 主循环节拍完成 + * "无数据 + 阻塞等待"不再自旋占用 netTask：登记 pending 后立即返回 * net_pending_tick（与 D10 重监听重试同节奏，net_process_messages 开头每轮调用） - * 按 ①数据 ②到点 ③断连 顺序检查完成条件并通知调用方（语义逐项对齐旧自旋循环）； - * 关闭/网络重建/陈旧重同步走显式 settle/cancel 路径（取消必通知，调用方永不挂死）。 - * 公开 API 返回契约不变：>0 字节数 / 0 EOF / -1 错误（错误码经通知值回传）。 + * 按 ①数据 ②到点 ③断连 顺序检查完成条件并通知调用方（语义逐项对齐旧自旋循环） + * 关闭/网络重建/陈旧重同步走显式 settle/cancel 路径（取消必通知，调用方永不挂死） + * 公开 API 返回契约不变：>0 字节数 / 0 EOF / -1 错误（错误码经通知值回传） */ #define NET_PENDING_REGISTERED 0x70000000 /* 内部哨兵：pending 已登记（分派跳过即时通知；取值不与字节数空间冲突） */ #define NET_PENDING_WATCHDOG_MS 1000U /* 看门狗：到点后 1s 仍未了结 = 完成逻辑缺位 → 强制了结 + 错误日志 */ @@ -168,11 +168,11 @@ static bool s_mac_is_zero(const uint8_t *p_mac) { * bit3=1: DISCONNECT/TIMEOUT 时不自动清空缓冲区，由软件排空数据后手动关闭 */ ch395f_set_fun_para(0x09); - /* 设置 TCP MSS（维持 1024；512 裕量方案未采纳，当年支撑该决策的台架判据不可信、 - * 已随 TC-NET-604 结案为非缺陷一并撤回（2026-09-23，见 Trap 21）） - * 手册(§5.45)：CH395F 内部缓冲共 48 块 × 512B = 24KB。下方为 8 个 Socket 各分配 6 块 - * （接收 4 块=2KB + 发送 2 块=1KB），块布局固定（与 MSS 解耦，ch395f.h）。 - * MSS=1024 为满足布局的最大值（接收=2×MSS）；真值源为 ch395f.h 的 CH395F_TCP_MSS。 */ + /* 设置 TCP MSS：维持 1024（512 裕量方案未采纳，当年支撑它的台架判据不可信， + * 已随 TC-NET-604 结案为非缺陷一并撤回（2026-09-23，见 Trap 21）） */ + /* 手册(§5.45)：内部缓冲共 48 块 × 512B = 24KB，每 Socket 分配 6 块（接收 4 块 = 2KB + 发送 2 块 = 1KB） */ + /* 块布局固定（与 MSS 解耦）；MSS=1024 为满足布局的最大值（接收 = 2×MSS）， + * 真值源为 ch395f.h 的 CH395F_TCP_MSS */ ch395f_set_tcp_mss(CH395F_TCP_MSS); /* 设置 TCP 重传参数（必须在 INIT_CH395 之前调用；P0-a：周期 500→200ms。 @@ -221,16 +221,13 @@ static bool s_mac_is_zero(const uint8_t *p_mac) { ch395f_set_mac_addr((uint8_t *)mac); } - /* 多 Socket 模式：为 Socket 0~7 各分配独立收发缓冲（必须在 OPEN_SOCKET 之前） - * 手册(§5.45)：CH395F 内部缓冲共 48 块 × 512B = 24KB；芯片上电默认仅给 Socket 0~3 - * 分配（每 Socket 接收 8 块/发送 4 块），Socket 4~7 为 NULL，故用到 8 个 Socket 必须重分配。 - * 单 Socket 块数为固定布局（ch395f.h，2026-09-22 起与 MSS 解耦）：接收 CH395F_RECV_BLOCKS(=4 块=2KB)、 - * 发送 CH395F_SEND_BLOCKS(=2 块=1KB)，每 Socket 共 6 块，用满 48 块： - * blocks_per_socket = CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS - * recv_start = i * blocks_per_socket， send_start = recv_start + CH395F_RECV_BLOCKS - * Socket 7 占块 42~47，恰好用尽 0~47，互不重叠。 - * 注：此布局以手册 §5.45（48×512B）为准；若实际芯片为其它缓冲规格需重新核算。 - * Trap 01：先配数据 Socket 1~7，再配监听 Socket 0。 */ + /* 多 Socket 模式：为 Socket 0~7 各分配独立收发缓冲（必须在 OPEN_SOCKET 之前） */ + /* 手册(§5.45)：48 块 × 512B = 24KB；上电芯片默认仅给 Socket 0~3 分配（接收 8 / 发送 4 块） */ + /* Socket 4~7 为 NULL，用到 8 个 Socket 必须重分配；单 Socket 块数为固定布局（ch395f.h，2026-09-22 起与 MSS 解耦） */ + /* 每 Socket 6 块：接收 CH395F_RECV_BLOCKS(=4 块=2KB) + 发送 CH395F_SEND_BLOCKS(=2 块=1KB)，用满 48 块 */ + /* recv_start = i×6，send_start = recv_start+4；Socket 7 占块 42~47，恰好用尽 0~47，互不重叠 */ + /* 布局以手册 §5.45 为准；若实际芯片为其它缓冲规格需重新核算 */ + /* Trap 01：先配数据 Socket 1~7，再配监听 Socket 0 */ uint8_t blocks_per_socket = (uint8_t)(CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS); for (int i = NET_MAX_SOCKETS - 1; i >= 0; i--) { uint8_t recv_start = (uint8_t)(i * blocks_per_socket); @@ -250,27 +247,62 @@ static bool s_mac_is_zero(const uint8_t *p_mac) { /* * 函数功能：取网络代次号 * 入口参数：无 + * 出口参数：无 * 返回值：代次号（每次网络重建完成递增） uint32_t * 限定条件：无 * 函数说明：见 net_socket.h 同名函数说明 */ uint32_t net_get_generation(void) { + /* 直接返回当前代次号（只读，无需锁） */ return s_net_generation; } /* * 函数功能：递增网络代次号（网络重建完成、对外可用时调用） * 入口参数：无 + * 出口参数：无 * 返回值：无 * 限定条件：net_init() 成功且 PHY/链路就绪后调用（当前仅 net_stack_bring_up） * 函数说明：见 net_socket.h 同名函数说明 */ void net_generation_inc(void) { + /* 代次号 +1：各 TCP 服务检测到代次变化后重建监听（配置变更免重启生效） */ s_net_generation++; } +#if defined(NET_BENCH_CMD_LOG) +/* + * 函数功能：台架 Bench 芯片命令序列日志（每条真实 SPI 命令记一行，排障用） + * 入口参数：tag - 命令类别 (P=poll全局中断 R=recv S=send C=close + * A=accept L=listen N=connect U=relisten M=其他) char + * sock - CH395F socket 号 int + * detail - 结果/中断状态 int + * 出口参数：无 + * 返回值：无 + * 限定条件：NET_BENCH_CMD_LOG 启用（2026-09-22 排障台架工具，默认关）；netTask 上下文 + * 函数说明：格式 netcmd: fd= t= d=<距上条命令 tick 间隔> + * x=；台架专用，实验后回退 + */ +static uint32_t s_bench_prev_tick = 0U; +static uint8_t s_bench_prev_valid = 0U; + +static void net_bench_cmd_log(char tag, int sock, int detail) { + /* 当前 tick（命令时间戳） */ + uint32_t now = (uint32_t)xTaskGetTickCount(); + /* 距上一条命令的 tick 间隔（首条命令记 0） */ + uint32_t delta = (s_bench_prev_valid != 0U) ? (now - s_bench_prev_tick) : 0U; + /* 更新"上一条命令"记录，供下次计算间隔 */ + s_bench_prev_tick = now; + s_bench_prev_valid = 1U; + /* 台架日志：命令类别 + fd + tick + 间隔 + 结果/中断状态 */ + DBG_INFO("netcmd: %c fd=%d t=%u d=%u x=%d", tag, sock, now, delta, detail); +} +#endif + /* * 函数功能：轮询 CH395F 中断状态，更新 Socket 连接状态并处理事件 + * 入口参数：无 + * 出口参数：无 * 返回值：本次轮询中发生事件的 Socket 数量 int >= 0 * 限定条件：s_net_initialized == 1；必须在 netTask 上下文中调用 * 函数说明：1. GPIO 轮询 CH395F INT# 引脚电平（低电平有效），无需 EXTI 中断 @@ -278,23 +310,6 @@ void net_generation_inc(void) { * 3. 处理连接/断开/数据接收/发送完成/超时等事件，更新 Socket 状态机 * 4. RECV 中断为电平触发，每次 net_poll() 只处理一批中断，避免主循环饿死 */ -#if defined(NET_BENCH_CMD_LOG) -/* Bench：芯片命令序列日志（2026-09-22 排障台架工具，默认关；netTask 上下文）。 - * 每个真实 SPI 命令点一行：tag=命令类别（P=poll全局中断 R=recv S=send C=close - * A=accept L=listen N=connect U=relisten M=其他），fd=socket，t=FreeRTOS tick， - * d=距上一条命令的 tick 间隔，x=结果/中断状态。台架专用，实验后回退。 */ -static uint32_t s_bench_prev_tick = 0U; -static uint8_t s_bench_prev_valid = 0U; - -static void net_bench_cmd_log(char tag, int sock, int detail) { - uint32_t now = (uint32_t)xTaskGetTickCount(); - uint32_t delta = (s_bench_prev_valid != 0U) ? (now - s_bench_prev_tick) : 0U; - s_bench_prev_tick = now; - s_bench_prev_valid = 1U; - DBG_INFO("netcmd: %c fd=%d t=%u d=%u x=%d", tag, sock, now, delta, detail); -} -#endif - int net_poll(void) { /* 本次轮询累计发生的事件数（连接/断开/接收/发送/超时各计 1） */ int event_count = 0; @@ -305,21 +320,15 @@ int net_poll(void) { return 0; } - /* - * 采用 do-while(0) 实现“单次批处理”： - * 本函数每被调用一次只读取并处理一批中断，处理完立即返回，不循环等待， - * 避免 RECV 电平中断导致主循环（如 echo）饿死。 - * 循环体内部用 break 提前退出（INT# 无效或无中断时）。 - */ + /* do-while(0) "单次批处理"：每次调用只读取并处理一批中断，处理完立即返回，不循环等待 */ + /* 避免 RECV 电平中断导致主循环（如 echo）饿死 */ + /* 循环体内部用 break 提前退出（INT# 无效或无中断时） */ do { uint16_t int_status; - /* - * GPIO 轮询 INT# 引脚：低电平有效（有中断待处理）。 - * 采用 GPIO 轮询而非 EXTI 边沿中断，仅当 INT# 为低电平时才读取状态，减少不必要 SPI 事务。 - * 若 INT# 为高（无效），直接退出本次轮询。 - */ + /* GPIO 轮询 INT# 引脚：低电平有效（有中断待处理），仅当低电平时才读取状态，减少不必要 SPI 事务 */ + /* 采用 GPIO 轮询而非 EXTI 边沿中断；若 INT# 为高（无效），直接退出本次轮询 */ if (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_SET) { break; } @@ -400,12 +409,9 @@ int net_poll(void) { } } - /* - * 处理完本批中断后退出 do-while(0)： - * CH395F 的 RECV 中断为电平触发，只要接收缓冲区仍有数据就保持 INT# 低电平， - * 若此处继续循环会反复处理 RECV 中断，导致主循环中的应用代码（如 echo 回显）得不到执行。 - * 因此每次 net_poll() 只处理“一批”，剩余数据由主循环/recv 逻辑在后续轮询中读取。 - */ + /* 处理完本批中断后退出 do-while(0)：RECV 中断为电平触发，只要缓冲仍有数据 INT# 就保持低 */ + /* 若继续循环会反复处理 RECV 中断，饿死主循环中的应用代码（如 echo 回显） */ + /* 因此每次 net_poll() 只处理“一批”，剩余数据在后续轮询中读取 */ } while (0); /* 返回本次累计发生的事件数量（0 表示无事件） */ @@ -414,80 +420,107 @@ int net_poll(void) { /* * 函数功能：芯片/本层 socket 状态周期对账（Trap 22 丢中断自愈） + * 入口参数：无 + * 出口参数：无 + * 返回值：无 * 限定条件：netTask 上下文（由 net_process_messages 每轮调用） - * 函数说明：芯片在快速复连场景会丢 CONNECT/DISCONNECT 中断；丢事件后本层无法靠事件 - * 自愈——典型：对端连接一直占着单连接监听的"后备"（芯片 TCP 仍 ESTABLISHED）， - * 后续 SYN 全被拒，而应用因未收到 DISCONNECT 仍以为有客户端（永不调用 accept， - * 事件驱动自愈无路可走）。故周期回读芯片状态，修正三类失同步： - * ① 本层 ESTABLISHED 而芯片已无连接 → 按断开处理（应用读到 EOF 后自动重监听） - * ② 本层 LISTENING 而芯片已完成握手 → 补做 standalone accept（复用 handle_connect_event） - * ③ 本层 LISTENING 而芯片监听已消失 → 重建监听（net_relisten_try） - * **去抖 + 冷却**：单次状态读可能落在"刚 open/listen 尚未生效"的瞬态 - * （2026-09-23 实测：无去抖时监听被反复重建直至放弃），故同一失配需连续 - * NET_RECONCILE_STABLE_N 次才动手；同一 socket 动手后冷却 NET_RECONCILE_COOLDOWN_MS。 - * 周期 NET_RECONCILE_PERIOD_MS；每次每在用 socket 一条状态命令，开销可忽略。 + * 函数说明：1. 芯片在快速复连场景会丢 CONNECT/DISCONNECT 中断；丢事件后本层无法靠事件自愈 + * 2. 典型：对端连接占着单连接监听的"后备"（芯片 TCP 仍 ESTABLISHED），后续 SYN 全被拒 + * 3. 应用因未收到 DISCONNECT 仍以为有客户端，永不调用 accept，事件驱动自愈无路可走 + * 4. 故周期回读芯片状态，修正三类失同步： + * 5. ① 本层 ESTABLISHED 而芯片已无连接 → 按断开处理（应用读到 EOF 后自动重监听） + * 6. ② 本层 LISTENING 而芯片已完成握手 → 补做 standalone accept（复用 handle_connect_event） + * 7. ③ 本层 LISTENING 而芯片监听已消失 → 重建监听（net_relisten_try） + * 8. 单次状态读可能落在"刚 open/listen 尚未生效"的瞬态 + * 9. 同一失配需连续 NET_RECONCILE_STABLE_N 次才动手（2026-09-23 实测：无去抖时监听被反复重建直至放弃） + * 10. 同一 socket 动手后冷却 NET_RECONCILE_COOLDOWN_MS，防去抖成风暴 + * 11. 周期 NET_RECONCILE_PERIOD_MS；每次每在用 socket 一条状态命令，开销可忽略 */ #define NET_RECONCILE_PERIOD_MS 200U /* 对账周期 */ #define NET_RECONCILE_STABLE_N 2U /* 连续失配次数（去抖，≈400ms） */ #define NET_RECONCILE_COOLDOWN_MS 1000U /* 同一 socket 两次动手的最小间隔（防抖成风暴） */ static void net_reconcile_tick(void) { + /* 上次对账轮的时刻（tick） */ static uint32_t s_last = 0U; - static uint8_t s_bad[NET_MAX_SOCKETS]; /* 连续失配计数（去抖） */ - static uint32_t s_cool[NET_MAX_SOCKETS]; /* 冷却到期时刻 */ + /* 连续失配计数（去抖） */ + static uint8_t s_bad[NET_MAX_SOCKETS]; + /* 冷却到期时刻 */ + static uint32_t s_cool[NET_MAX_SOCKETS]; + /* 当前 tick */ uint32_t now = HAL_GetTick(); + /* Socket 循环索引 */ int i; + /* 未到对账周期（200ms）：直接返回，省 SPI 命令 */ if ((uint32_t)(now - s_last) < NET_RECONCILE_PERIOD_MS) { return; } + /* 更新本轮起始时刻 */ s_last = now; for (i = 0; i < NET_MAX_SOCKETS; i++) { + /* 取控制块（直接数组下标，无需越界判断） */ net_sock_t *p_sock = &s_net_socks[i]; + /* 芯片侧状态两字节：[0]=socket 状态，[1]=TCP 状态 */ uint8_t st[2] = {0, 0}; + /* 失同步类型：1=连接已失 2=握手已成丢中断 3=监听已失 */ int bad = 0; + /* 仅对在用的 ESTABLISHED/LISTENING socket 对账，其余清零去抖计数 */ if ((p_sock->in_use == 0U) || ((p_sock->state != NET_SOCK_STATE_ESTABLISHED) && (p_sock->state != NET_SOCK_STATE_LISTENING))) { s_bad[i] = 0U; continue; } + /* 读芯片侧两字节状态（每 socket 一条 SPI 命令） */ ch395f_get_socket_status((uint8_t)i, st); + /* ① 本层 ESTABLISHED 而芯片已无连接 → 按断开处理 */ if ((p_sock->state == NET_SOCK_STATE_ESTABLISHED) && ((st[0] == CH395F_SOCKET_CLOSED) || (st[1] == CH395F_TCP_CLOSED))) { - bad = 1; /* 芯片已无连接而本层以为还连着 */ + bad = 1; } else if ((p_sock->state == NET_SOCK_STATE_LISTENING) && (st[1] == CH395F_TCP_ESTABLISHED)) { - bad = 2; /* 芯片已完成握手而无 CONNECT 中断 */ + /* ② 本层 LISTENING 而芯片已完成握手（丢 CONNECT 中断）→ 补做 accept */ + bad = 2; } else if ((p_sock->state == NET_SOCK_STATE_LISTENING) && ((st[0] == CH395F_SOCKET_CLOSED) || (st[1] != CH395F_TCP_LISTEN))) { - bad = 3; /* 芯片监听已消失（异常关闭） */ + /* ③ 本层 LISTENING 而芯片监听已消失 → 重建监听 */ + bad = 3; } + /* 无失同步：清零计数，转下一 socket */ if (bad == 0) { s_bad[i] = 0U; continue; } + /* 累加连续失配计数（封顶至去抖门槛） */ if (s_bad[i] < NET_RECONCILE_STABLE_N) { s_bad[i]++; } + /* 去抖未满或处于冷却期：本轮不动手 */ if ((s_bad[i] < NET_RECONCILE_STABLE_N) || ((int32_t)(now - s_cool[i]) < 0)) { - continue; /* 去抖未满，或处于冷却期：本轮不动手 */ + continue; } + /* 动手前：清失配计数并置冷却到期时刻（1s） */ s_bad[i] = 0U; s_cool[i] = now + NET_RECONCILE_COOLDOWN_MS; if (bad == 1) { + /* 类型①：按断开处理（应用读到 EOF 后自动重监听） */ DBG_INFO("sock%d reconcile: chip closed (sock=0x%02X tcp=0x%02X) -> disconnect", i, st[0], st[1]); - handle_disconnect_event(p_sock); /* 内置陈旧事件甄别 + 状态迁移 + 事件派发 */ + /* 复用断开状态机（含陈旧事件甄别 + 状态迁移 + 事件派发） */ + handle_disconnect_event(p_sock); } else if (bad == 2) { + /* 类型②：补做 standalone accept */ DBG_INFO("sock%d reconcile: connection completed w/o CONNECT irq -> accept", i); - handle_connect_event(p_sock); /* 补做 standalone accept 簿记 */ + /* 复用 CONNECT 事件的簿记路径 */ + handle_connect_event(p_sock); } else { + /* 类型③：重建监听（单次尝试，失败进 D10 重试队列） */ DBG_INFO("sock%d reconcile: listen lost (sock=0x%02X tcp=0x%02X) -> relisten", i, st[0], st[1]); (void)net_relisten_try(p_sock); @@ -499,200 +532,167 @@ static void net_reconcile_tick(void) { * 函数功能：netTask 主循环核心 —— 自愈 tick 宿主 + 消息队列分派器。每轮 * 先跑三个非阻塞自愈 tick（D10 重监听 / L3 挂起 recv / * Trap 22 状态对账），再非阻塞排空队列按 msg.type 分派到 _locked 实现。 + * 入口参数：无 + * 出口参数：无 * 返回值：无（void）；消息结果经 xTaskNotify 通知值回传（成功=字节数/描述符， * 失败=具体错误码），调用方 net_wait_result 拾取，对外统一 -1。 * 限定条件：必须在 netTask 上下文中调用（独占 CH395F 与 s_net_socks 访问权）； * 由 net_task.c 在 net_stack_bring_up 之后每次 1ms 循环调用。 - * 函数说明：1. 三个自愈 tick 均非阻塞（绝不 osDelay 忙等，netTask 永不冻结）， - * 先于消息分派执行： - * - net_relisten_retry_tick（D10）：断连后按 30ms - * （NET_RELISTEN_RETRY_MS）节拍重试 open+listen，2s - * （NET_RELISTEN_DEADLINE_MS）总时限到期放弃留痕；本 fd - * 有在途挂起 recv 时跳过（L3 保险）； - * - net_pending_tick（L3）：按节拍了结挂起 recv（数据/到点/ - * 断连）；到点后 1s（NET_PENDING_WATCHDOG_MS）未了结 → - * 强制了结 + DBG_ERROR 留痕； - * - net_reconcile_tick（Trap 22）：每 200ms - * （NET_RECONCILE_PERIOD_MS）对账，连续 2 次失配去抖 + - * 1s 冷却，三类失同步自愈。 - * 2. net_msg_t 按值入队，netTask 侧副本调用方不可见 → 结果只能搭 - * 任务通知值回传；32 位整体即结果，不做位域压缩。 - * 3. RECV 特例：无数据+阻塞 → 登记 pending 哨兵 - * NET_PENDING_REGISTERED（0x70000000），do_notify=0，回执 - * 推迟到 net_pending_tick 完成时。 + * 函数说明：1. 三个自愈 tick 均非阻塞（绝不 osDelay 忙等，netTask 永不冻结），先于消息分派执行 + * 2. net_relisten_retry_tick（D10）：断连后按 30ms + * （NET_RELISTEN_RETRY_MS）节拍重试 open+listen；2s（NET_RELISTEN_DEADLINE_MS） + * 总时限到期放弃留痕 + * 3. D10：本 fd 有在途挂起 recv 时跳过（L3 保险） + * 4. net_pending_tick（L3）：按节拍了结挂起 recv（数据/到点/断连） + * 5. L3 看门狗：到点后 1s（NET_PENDING_WATCHDOG_MS）未了结 → 强制了结 + DBG_ERROR 留痕 + * 6. net_reconcile_tick（Trap 22）：每 200ms（NET_RECONCILE_PERIOD_MS）对账 + * 7. 对账以连续 2 次失配去抖 + 1s 冷却，自愈三类失同步 + * 8. net_msg_t 按值入队，netTask 侧副本调用方不可见 → 结果只能搭任务通知值回传 + * 9. 32 位整体即结果，不做位域压缩 + * 10. RECV 特例：无数据+阻塞 → 登记 pending 哨兵 NET_PENDING_REGISTERED（0x70000000） + * 11. RECV 特例 do_notify=0，回执推迟到 net_pending_tick 完成时 */ void net_process_messages(void) { net_msg_t msg; + /* 队列句柄未就绪（net_init 未完成）：直接返回 */ if (netMsgQueueHandle == NULL) { return; } - /* D10：待重试的自动重监听（Trap 09 沉降后重开），非阻塞、每轮最多一次尝试。 - * 放在消息处理之前：断连后即使没有任何应用消息，监听器也能自主恢复。 - * L3：挂起 recv 的完成检查同位（两 tick 共享主循环节拍，均为 O(每 fd) 非阻塞）。 */ + /* 三个非阻塞自愈 tick 置于消息处理之前：断连后即使无应用消息，监听器也能自主恢复 */ + /* D10 重监听重试（Trap 09）：沉降后重开芯片监听器 */ net_relisten_retry_tick(); + /* L3 挂起 recv 完成检查：数据到达 / 到点 / 断连时通知调用方 */ net_pending_tick(); - net_reconcile_tick(); /* Trap 22：芯片/本层状态周期对账（丢中断自愈） */ + /* Trap 22 状态对账：周期回读芯片状态，自愈丢失的中断 */ + net_reconcile_tick(); - /* 队列排空：超时 0 非阻塞取，直到本轮队列为空。do_notify=1 表示 - * 本条消息需要即时回执；=0 只出现在 RECV 挂起登记（返回哨兵 - * NET_PENDING_REGISTERED）——回执推迟到 net_pending_tick 完成检查 - * 发出，避免把"登记成功"误当成处理结果通知调用方。 */ + /* 队列排空：超时 0 非阻塞取，每条处理一轮，直到本轮队列为空 */ while (osMessageQueueGet(netMsgQueueHandle, &msg, NULL, 0) == osOK) { + /* 默认处理完即发即时回执；RECV 挂起登记时置 0（回执推迟到 + * net_pending_tick 完成检查，避免"登记成功"被误报为处理结果） */ int do_notify = 1; switch (msg.type) { case NET_MSG_SEND: { - /* TCP send：由 net_send_locked 真正写 CH395F。 - * - net_get_sock 返回 NULL（fd 越界/已 close）→ NET_ERR_BADF - * - 状态非 ESTABLISHED → NET_ERR_NOTCONN - * - 否则按硬件发送缓冲上限（NET_SEND_CHUNK_MAX=1KB）分块 - * 写入并等待 send_ready（SEND_OK 中断），单块停滞 - * NET_SEND_TIMEOUT_MS(1s) 超时；中途断连立即失败 CONNRESET - * （不白等满超时）。 - * 返回实际写入字节数；短写会 DBG_ERROR 留痕，调用方须校验 - * 返回值而非只看非负。成功=字节数、失败=-1（errno 随通知值 - * 回传）。 */ + /* 取控制块；NULL = fd 越界或已关闭 */ net_sock_t *p_sock = net_get_sock(msg.sockfd); if (p_sock == NULL) { + /* 描述符无效 → BADF，结果 -1 */ s_net_errno = NET_ERR_BADF; msg.result = -1; } else if (p_sock->state != NET_SOCK_STATE_ESTABLISHED) { + /* 未建立连接（或已断开）→ NOTCONN */ s_net_errno = NET_ERR_NOTCONN; msg.result = -1; } else { + /* 真正写入芯片：1KB/块等 SEND_OK 中断，单块停滞 1s 超时， + * 中途断连立即 CONNRESET；短写留痕，调用方须检查返回值 */ msg.result = net_send_locked(p_sock, msg.buf, msg.len); } break; } case NET_MSG_RECV: { - /* TCP/UDP recv：由 net_recv_locked 走三条出口—— - * ① 数据已就绪 → 快速 SPI 读出，返回字节数（即时回执）； - * ② 无数据 + NET_MSG_DONTWAIT → CLOSED 态按对端关闭返回 0 - * （触发 auto_relisten），否则 NET_ERR_WOULDBLOCK(-1) - * （即时回执）； - * ③ 无数据 + 阻塞等待 → 登记挂起请求并返回哨兵 - * NET_PENDING_REGISTERED（每 fd 至多一个，禁止覆盖—— - * 覆盖会丢失前一次调用方的通知使其永久挂死； - * caller==NULL 或调用者本身是 netTask 时拒绝登记， - * 防"自等自通知"死锁）：本条消息 do_notify=0 不发即时 - * 回执，完成（数据/30s 默认超时或 msg.timeout_ms 指定 - * 预算/断连/显式取消 close、resync、网络重建）由 - * net_pending_tick 按主循环节拍以字节数/0/负错误码通知 - * caller。挂起期间 msg.buf 指针须保持有效（net_pending - * 只存指针不拷贝数据）。 */ + /* 取控制块；NULL = fd 越界或已关闭 */ net_sock_t *p_sock = net_get_sock(msg.sockfd); if (p_sock == NULL) { + /* 描述符无效 → BADF，结果 -1 */ s_net_errno = NET_ERR_BADF; msg.result = -1; } else { - /* L3：无数据 + 阻塞等待 = 登记挂起请求（netTask 零占用）， - * 完成由 net_pending_tick 按主循环节拍通知调用方 */ + /* 三条出口：数据就绪 → 即时 SPI 读出；DONTWAIT 无数据 → 0（对端关闭） + * / WOULDBLOCK；阻塞无数据 → 登记挂起请求（哨兵，netTask 零占用） */ msg.result = net_recv_locked(p_sock, msg.buf, msg.len, msg.flags, msg.timeout_ms, msg.caller); if (msg.result == NET_PENDING_REGISTERED) { - do_notify = 0; /* 挂起已登记：不发即时回执，完成时才通知 */ + /* 挂起已登记：不发即时回执，完成时才通知（防"登记成功"误报为结果） */ + do_notify = 0; } } break; } case NET_MSG_CLOSE: { - /* TCP close：先了结本 fd 的挂起 recv（排空可读数据或 - * NET_ERR_CONNRESET 取消——必通知，防等待中调用方永久挂死）， - * 再 ch395f_close_socket、轮询等芯片回 CLOSED（≤500ms）并 - * 排空残留中断、memset 控制块、清 D10 待重试与 L3 挂起状态。 - * fd 越界/已关闭 → NET_ERR_BADF；成功返回 0。 - * 单连接模型注意：监听 fd 断开后 auto_relisten 会自动恢复 - * 监听，EOF 时应用层**不要**对监听 fd 发 close（会毁掉端口 - * → 连接永拒），仅独立数据 fd 才 close。 */ + /* 取控制块；NULL = fd 越界或已关闭 */ net_sock_t *p_sock = net_get_sock(msg.sockfd); if (p_sock == NULL) { + /* 描述符无效 → BADF，结果 -1 */ s_net_errno = NET_ERR_BADF; msg.result = -1; } else { + /* 先了结本 fd 挂起 recv（排空或取消，必通知），再关芯片侧 Socket； + * 单连接模型监听 fd 断开后自动恢复监听，应用不得对它在 EOF 时 close */ msg.result = net_close_locked(p_sock); } break; } case NET_MSG_CONNECT: { - /* TCP connect（异步，返回成功即已下发 CONNECT 命令）：保存 - * 远端 IP/端口（msg.addr/addrlen 由公开 API net_connect 的 - * memcpy 填入）→ open 失败 3 次重试（Trap 09，每次失败先 - * close 再重试）→ 清本 Socket 残留中断（防上一条连接遗留 - * DISCONNECT 误判）→ 下发 TCP CONNECT → 状态置 CONNECTING - * 等待 CONNECT 中断（net_poll 维护状态与事件）。失败 NET_ERR_BUSY/ - * INVAL 返回 -1；成功返回 0，调用方须轮询 net_sock_state() - * 等 ESTABLISHED 后才是可用连接。 */ + /* 保存对端地址（公开 API 已 memcpy 入 msg.addr）并配置芯片： + * open（失败重试 3 次）+ 源/目的端口 + 目的 IP，清残留中断， + * 下发 TCP CONNECT 并置 CONNECTING（异步，CONNECT 中断后才成立） */ msg.result = net_connect_locked(msg.sockfd, (const struct net_sockaddr *)&msg.addr, msg.addrlen); break; } case NET_MSG_LISTEN: { - /* TCP listen：仅 BOUND/CREATED 态的 TCP 流 socket 允许。 - * open+TCP_LISTEN 失败 3 次重试（Trap 09）→ 状态置 - * LISTENING、auto_relisten=1、清各 Socket 及全局历史中断 - *（防残留/伪中断在监听刚生效时误触发连接/断开事件）。成功 - * 返回 0；失败 NET_ERR_INVAL/BUSY 返回 -1。单连接模型下该 - * fd 后续即数据通道（g_client==g_listen），断开后自动重监听 - *（模拟 BSD 监听常驻，应用层无需手动重建）。 */ + /* 芯片侧 open + TCP_LISTEN（失败重试 3 次），置 LISTENING 并启用 + * auto_relisten（断开后自动重监听，模拟 BSD 监听常驻）；单连接模型下 + * 该 fd 后续即数据通道本身（g_client==g_listen） */ msg.result = net_listen_locked(msg.sockfd); break; } case NET_MSG_ACCEPT: { - /* accept：入参经 net_msg_t 的 buf/len 字段携带（公开 API - * net_accept 将 addr 指针与 addrlen 填入 msg.buf/msg.len； - * addrlen>0 且 buf 非 NULL 时，net_accept_locked 通过局部 - * 变量指针回填对端地址长度 sizeof(net_sockaddr_in)）。 - * 单连接：状态 ESTABLISHED 即有可接受连接 → 返回同一 fd - *（监听 Socket 自身已转为数据通道）；非 ESTABLISHED → - * CLOSED+auto_relisten 先非阻塞尝试恢复监听，最终 - * NET_ERR_WOULDBLOCK(-1)。失败返回具体错误码。 */ + /* 对端地址指针与长度经 msg.buf/msg.len 字段携带（公开 API net_accept 填入） */ struct net_sockaddr *p_addr = (struct net_sockaddr *)msg.buf; int addrlen = msg.len; + /* 仅在调用方给出有效 addr 且 addrlen>0 时，成功后回填对端地址长度 */ int *p_addrlen = (p_addr != NULL && addrlen > 0) ? &addrlen : NULL; + /* 单连接：ESTABLISHED 即有可接受连接（返回同一 fd，监听 Socket + * 自身已转数据通道）；否则先尝试恢复监听，仍无则 WOULDBLOCK */ msg.result = net_accept_locked(msg.sockfd, p_addr, p_addrlen); break; } case NET_MSG_RESYNC_LISTEN: { + /* 取控制块；NULL = fd 越界或已关闭 */ net_sock_t *p_sock = net_get_sock(msg.sockfd); if (p_sock == NULL) { + /* 描述符无效 → BADF，结果 -1 */ s_net_errno = NET_ERR_BADF; msg.result = -1; } else if (p_sock->state != NET_SOCK_STATE_ESTABLISHED) { /* 非 ESTABLISHED（LISTENING/CLOSED 等）：两侧已一致，无需动作 */ msg.result = 0; } else { - /* 陈旧 ESTABLISHED：芯片已静默回收 Socket 回监听（无 DISCONNECT - * 中断，2026-09-22 台架实证）→ 仅修 MCU 侧状态。严禁发芯片 - * close/重监听命令——会摧毁芯片侧仍健康的监听器 → 连接永拒 - * （run8 实证 170s 拒绝）。新连接的 CONNECT 中断会把两侧重新同步。 */ + /* 陈旧 ESTABLISHED：芯片已静默回收连接（无 DISCONNECT 中断， + * 2026-09-22 台架实证）→ 仅修 MCU 侧状态；严禁发芯片 + * close/重监听命令（会摧毁芯片侧仍健康的监听器 → 端口永拒， + * run8 实证 170s 拒绝）；新连接的 CONNECT 中断会把两侧重新同步 */ p_sock->state = NET_SOCK_STATE_LISTENING; - net_pending_cancel(msg.sockfd, NET_ERR_CONNRESET); /* L3：死连接上的挂起 recv 立即取消（必通知） */ + /* 取消本 fd 在死连接上的挂起 recv（必通知，防调用方挂死） */ + net_pending_cancel(msg.sockfd, NET_ERR_CONNRESET); + /* 仅修正 MCU 侧状态，不发芯片命令，直接返回成功 */ msg.result = 0; } break; } case NET_MSG_RELISTEN: { + /* 取控制块；NULL = fd 越界或已关闭 */ net_sock_t *p_sock = net_get_sock(msg.sockfd); if (p_sock == NULL) { + /* 描述符无效 → BADF，结果 -1 */ s_net_errno = NET_ERR_BADF; msg.result = -1; } else { - /* 无条件芯片侧重监听（单次尝试 + 非阻塞重试，见 net_relisten_try）： - * 芯片侧已监听 → 首次 open 失败 → 登记重试（下一次 netTask 轮询 - * 到点再来，不再 osDelay(500) 忙等）；芯片侧已关闭 → 首次即成。 - * 两种陈旧场景都收敛到"芯片监听器确定在位"。 */ + /* 无条件芯片侧重监听：单次尝试，失败登记非阻塞重试 + * （芯片已在监听 → 下一轮到点再来；两种陈旧场景都收敛到"芯片监听器在位"） */ msg.result = net_relisten_try(p_sock); } break; } default: - /* 未知消息类型（枚举闭合，正常不应触发）：置通用错误码 - * NET_ERR、结果 -1，保证通知值永远有效——调用方通过 - * net_wait_result 拿到的是本条消息的确定结果，而非 - * 上一条消息的残留值。 */ + /* 未知消息类型（枚举闭合，正常不应触发）：置通用错误码与结果 -1， + * 保证通知值恒为本条消息的确定结果（无上一条残留） */ s_net_errno = NET_ERR; msg.result = -1; break; @@ -700,27 +700,30 @@ void net_process_messages(void) { #if defined(NET_BENCH_CMD_LOG) { + /* 台架构建：每条消息留一行命令日志（R/S/C/A/L/N/M） */ char bench_tag = (msg.type == NET_MSG_RECV) ? 'R' : (msg.type == NET_MSG_SEND) ? 'S' : (msg.type == NET_MSG_CLOSE) ? 'C' : (msg.type == NET_MSG_ACCEPT) ? 'A' : (msg.type == NET_MSG_LISTEN) ? 'L' : (msg.type == NET_MSG_CONNECT) ? 'N' : 'M'; + /* 记录命令类型、fd 与结果（负错误码）供台架判读 */ net_bench_cmd_log(bench_tag, msg.sockfd, (int)msg.result); } #endif - /* 结果回传：成功=字节数/描述符；失败=具体错误码（如 NET_ERR_WOULDBLOCK）。 - * 注意消息体按值拷入队列——调用方看不到 netTask 对 msg 的修改，结果只能搭 - * 通知值这趟车带回；**整个 32 位都是结果**（若压入序列号等高 16 位标签， - * 单次结果上限会被压到 32767，而 TEST_BUF_SIZE=32768 等调用点会溢出为负）。 - * L3：挂起 recv（do_notify=0）不发即时回执，由 net_pending_tick 完成时通知。 */ + /* 结果回传：消息体按值拷入队列，调用方看不到 netTask 对 msg 的修改 + * → 只能搭 32 位任务通知值回来（整体即结果：位域会把上限压到 + * 32767，TEST_BUF_SIZE=32768 会溢出为负） */ if (do_notify != 0) { + /* 成功：结果的 32 位原值（字节数 / 描述符） */ uint32_t notify_val = (uint32_t)msg.result; + /* 失败：携带具体错误码（如 NET_ERR_WOULDBLOCK；errno 未置位时回退通用 NET_ERR） */ if (msg.result < 0) { notify_val = (uint32_t)((s_net_errno != 0) ? s_net_errno : NET_ERR); } + /* 覆盖式写入通知值：调用方零等待拾取即得最新回执 */ xTaskNotify(msg.caller, notify_val, eSetValueWithOverwrite); } } @@ -729,24 +732,25 @@ void net_process_messages(void) { /* * 函数功能：结果等待（两段式，防丢失通知；结果按 32 位原值回传） * 入口参数：kind = 操作简称；sockfd = Socket（两者仅用于调试留痕，避免未用参数告警） + * 出口参数：无 * 返回值：netTask 回传的结果（成功=字节数/描述符；失败=负错误码） - * 函数说明：① 零等待先拾取：落在"入队→等待入口"间隙的通知已在任务通知值里， - * 若只做单段阻塞等待就会错过它（2026-09-22 台架实证）； - * ② **清除掩码必须全 1**：xTaskNotifyWait 以位掩码清值，传 0 = 不清除 - * → 上一次调用的结果残留、被后续每次零等待重读成"本次结果" - * （run3~run11 的 L7 挂死/整段错位的真正根因）； - * ③ **必须以返回值（pdTRUE/pdFALSE）判定是否已落地**，不能判 `v != 0`： - * 合法的 0 结果（recv 返回 0 = 对端关闭）会被误判成"无通知"而进入 - * 阻塞等待 → 永久挂死； - * ④ 通知值 32 位整体作为结果（不切分位域），保证 TEST_BUF_SIZE=32768 - * 这类大单次收发不被截断； - * ⑤ **禁止在本路径加逐调用日志**（曾加 pick/block 两行：占日志 98.6%， - * 115200 下冲掉 [LAT] 证据行、并让 wait-idle 永远判不出空闲； - * run14 实证）。诊断需求请在 [LAT] 段报告侧做聚合。 + * 限定条件：netTask 上下文（消息分派路径内部使用，非公开 API） + * 函数说明：1. 零等待先拾取："入队→等待入口"间隙内的通知已在任务通知值里， + * 单段阻塞等待会错过它（2026-09-22 台架实证） + * 2. 清除掩码必须全 1：xTaskNotifyWait 以位掩码清值，传 0 = 不清除 + * 3. 否则上次结果残留、被每次零等待重读成"本次结果"（run3~run11 L7 挂死/整段错位的真正根因） + * 4. 必须以返回值（pdTRUE/pdFALSE）判定是否已落地，不能判 v != 0 + * 5. 合法的 0 结果（recv 0 = 对端关闭）会被误判成"无通知" → 阻塞等待 → 永久挂死 + * 6. 通知值 32 位整体作为结果（不切分位域），保证 TEST_BUF_SIZE=32768 这类大单次收发不被截断 + * 7. 禁止在本路径加逐调用日志：曾加 pick/block 两行，占日志 98.6%， + * 115200 下冲掉 [LAT] 证据行、并让 wait-idle 永远判不出空闲（run14 实证） + * 8. 诊断需求请在 [LAT] 段报告侧做聚合 */ static int net_wait_result(const char *kind, int sockfd) { + /* 32 位结果值（任务通知值整体） */ uint32_t v = 0U; + /* kind/sockfd 仅供调用链调试留痕，函数体不直接使用 */ (void)kind; (void)sockfd; @@ -765,38 +769,54 @@ static int net_wait_result(const char *kind, int sockfd) { * 函数功能：创建 Socket，分配空闲 Socket 控制块并初始化状态 * 入口参数：domain - 地址族，仅支持 NET_AF_INET int * type - SOCK_STREAM(TCP) 或 SOCK_DGRAM(UDP) int + * 出口参数：无 * 返回值：Socket 描述符 (0~7)，失败返回 -1 int * 限定条件：net_init() 已调用成功；s_net_initialized == 1 * 函数说明：自动分配一个空闲的 Socket 控制块（in_use=0），初始化为 CREATED 状态 */ int net_socket(int domain, int type) { + /* 新分配的 Socket 描述符 */ int sockfd; + /* 分配到的控制块指针 */ net_sock_t *p_sock; - /* 参数检查*/ + /* 参数检查：地址族仅支持 NET_AF_INET */ if (domain != NET_AF_INET) { + /* 不支持的地址族 → INVAL */ s_net_errno = NET_ERR_INVAL; return -1; } - /* 分配空闲 Socket */ + /* 分配空闲控制块（in_use=0 的槽位） */ sockfd = alloc_socket(); if (sockfd < 0) { + /* 无空闲控制块 → NOMEM */ s_net_errno = NET_ERR_NOMEM; return -1; } + /* 初始化控制块：芯片侧 Socket 编号与描述符一一对应 */ p_sock = &s_net_socks[sockfd]; + /* 芯片侧 Socket 索引（CH395F 命令的 sock 参数） */ p_sock->ch395_sock = (uint8_t)sockfd; + /* 协议类型：SOCK_STREAM(TCP) / SOCK_DGRAM(UDP) */ p_sock->type = (uint8_t)type; + /* 初始状态 CREATED（TCP 待 bind+listen；UDP 在 bind 时直接开芯片侧） */ p_sock->state = NET_SOCK_STATE_CREATED; + /* 标记在用 */ p_sock->in_use = 1; + /* 发送缓冲初始为空闲（可发） */ p_sock->send_ready = 1; + /* 无可读数据 */ p_sock->readable = 0; - p_sock->released_abnormal = 0; /* 新 fd 不得继承上一条连接的释放原因（Trap 23 待办 #3） */ - net_relisten_clear(sockfd); /* 新 fd 不得继承上一次的待重试状态 */ - net_pending_clear(sockfd); /* 新 fd 不得继承上一次挂起的 recv 请求（L3） */ + /* 新 fd 不得继承上一条连接的释放原因（Trap 23 待办 #3） */ + p_sock->released_abnormal = 0; + /* 新 fd 不得继承上一次的待重试状态（D10） */ + net_relisten_clear(sockfd); + /* 新 fd 不得继承上一次挂起的 recv 请求（L3） */ + net_pending_clear(sockfd); + /* 返回描述符（控制块已就绪） */ return sockfd; } @@ -805,92 +825,122 @@ int net_socket(int domain, int type) { * 入口参数：sockfd - Socket 描述符 (0~7) int * addr - 本地地址结构体指针 const struct net_sockaddr * * addrlen - 地址结构体长度 int >= sizeof(struct net_sockaddr_in) + * 出口参数：无 * 返回值：0 - 绑定成功 int * -1 - 绑定失败（参数无效、Socket 未使用等） int * 限定条件：Socket 已通过 net_socket() 创建且未被其他操作占用；net_init() 已调用 * 函数说明：1. TCP Socket 仅记录本地端口，进入 BOUND 状态等待 listen - * 2. UDP Socket（SOCK_DGRAM）立即打开 CH395F Socket 并配置为 Server 模式 - * - Socket 4~7 需显式分配收发缓冲区 + * 2. UDP Socket（SOCK_DGRAM）立即打开 CH395F Socket 并配置为 Server 模式（Socket 4~7 需显式分配收发缓冲区） */ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) { + /* Socket 控制块指针 */ net_sock_t *p_sock; + /* 本地地址（IPv4）强转 */ const struct net_sockaddr_in *p_addr_in; - /* 参数检查 */ + /* 参数检查：描述符范围 */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { + /* 越界 → BADF */ s_net_errno = NET_ERR_BADF; return -1; } + /* 取控制块 */ p_sock = &s_net_socks[sockfd]; + /* 控制块未在用（未创建/已关闭）→ BADF */ if (!p_sock->in_use) { s_net_errno = NET_ERR_BADF; return -1; } + /* 地址指针/长度无效 → INVAL */ if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 地址强转为 IPv4 结构体 */ p_addr_in = (const struct net_sockaddr_in *)addr; - /* 设置本地端口（转换为主机序） */ + /* 设置本地端口（结构体中为网络序 → 转主机序） */ p_sock->local_port = net_ntohs(p_addr_in->sin_port); /* port=0 时自动分配动态端口（49152~65535） */ if (p_sock->local_port == 0) { + /* 取当前动态端口值 */ p_sock->local_port = s_dynamic_port; + /* 推进动态端口，供下次分配 */ s_dynamic_port++; + /* 回绕：越过 65535 后回到动态区起始 */ if (s_dynamic_port == 0) { s_dynamic_port = 49152; } } - /* UDP (SOCK_DGRAM): 直接在此打开 CH395F Socket */ + /* UDP (SOCK_DGRAM)：直接在此打开 CH395F Socket（无需等 listen） */ if (p_sock->type == NET_SOCK_DGRAM) { + /* open_socket 返回状态 */ uint8_t status; /* net_init 已为全部 8 个 Socket 分配缓冲；此处仅对 Socket 4~7 兜底重设， * 使用与 net_init 相同的布局（由 MSS 推导，见 net_init） */ if (sockfd >= 4) { + /* 每 Socket 块数 = 接收 + 发送 */ uint8_t blocks_per_socket = (uint8_t)(CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS); + /* 本 Socket 接收缓冲起始块 */ uint8_t recv_start = (uint8_t)(sockfd * blocks_per_socket); + /* 发送缓冲起始块（接收块之后） */ uint8_t send_start = (uint8_t)(recv_start + CH395F_RECV_BLOCKS); + /* （重）设置发送缓冲块 */ ch395f_set_send_buf((uint8_t)sockfd, send_start, (uint8_t)CH395F_SEND_BLOCKS); + /* （重）设置接收缓冲块 */ ch395f_set_recv_buf((uint8_t)sockfd, recv_start, (uint8_t)CH395F_RECV_BLOCKS); } + /* 设置协议类型为 UDP */ ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_UDP); + /* 设置本地（源）端口 */ ch395f_set_sour_port((uint8_t)sockfd, p_sock->local_port); - /* DesIP=0xFFFFFFFF UDP Server 模式（接受任意来源） */ + /* DesIP=0xFFFFFFFF：UDP Server 模式（接受任意来源） */ { + /* 任意源地址（全 0xFF） */ uint8_t broadcast[4] = {0xFF, 0xFF, 0xFF, 0xFF}; + /* 目的 IP 设为任意源 */ ch395f_set_des_ip((uint8_t)sockfd, broadcast); } + /* 目的端口 0（服务端不限定对端端口） */ ch395f_set_des_port((uint8_t)sockfd, 0); + /* 打开芯片侧 Socket */ status = ch395f_open_socket((uint8_t)sockfd); if (status != CH395F_ERR_SUCCESS) { + /* open 失败：留痕并返回 BUSY（芯片忙/复位冲突） */ DBG_ERROR("sock%d open_socket FAIL: status=0x%02X (expected 0x00)", sockfd, status); s_net_errno = NET_ERR_BUSY; return -1; } + /* UDP 打开即可用（无监听态） */ p_sock->state = NET_SOCK_STATE_UDP_OPEN; } else { + /* TCP 仅记录本地端口，待 listen 打开芯片侧 */ p_sock->state = NET_SOCK_STATE_BOUND; } + /* 绑定成功 */ return 0; } /* * 函数功能：启动 TCP Server 监听（内部版本，必须在 netTask 上下文调用） * 入口参数：sockfd - Socket 描述符 (0~7) int + * 出口参数：无 * 返回值：0 - 成功，-1 - 失败 int * 限定条件：sockfd 已绑定且为 TCP；netTask 上下文 + * 函数说明：1. 芯片侧 open + TCP_LISTEN（端口=控制块 local_port；open 失败重试 3 次，见 Trap 09） + * 2. 成功置 LISTENING 并启用 auto_relisten（BSD 风格监听常驻） + * 3. 启动监听前清各 Socket 中断状态寄存器（读即清），防残留中断误触发 */ int net_listen_locked(int sockfd) { /* 取监听 Socket 控制块（直接下标访问，sockfd 已在上层 net_listen 校验过范围） */ @@ -911,20 +961,24 @@ int net_listen_locked(int sockfd) { return -1; } - /* - * 本实现仅支持单连接：监听 Socket 自身即为数据通道，复用 CH395F 默认收发缓冲 - * （Socket 0~3 默认缓冲互不重叠），不再为数据 Socket 额外分配。 - */ + /* 单连接：监听 Socket 自身即数据通道，复用 CH395F 默认收发缓冲， + * 不额外分配（Socket 0~3 默认缓冲互不重叠） */ + /* 设置协议类型为 TCP */ ch395f_set_proto_type(sockfd, CH395F_PROTO_TYPE_TCP); + /* 本地端口 = 控制块 local_port */ ch395f_set_sour_port(sockfd, p_sock->local_port); /* CH395F 关闭 Socket 后需延时才能重新打开（Trap 09），故失败重试最多 3 次 */ for (int open_try = 0; open_try < 3; open_try++) { + /* 尝试打开芯片侧 Socket */ status = ch395f_open_socket(sockfd); if (status == CH395F_ERR_SUCCESS) { - break; /* 打开成功，退出重试 */ + /* 打开成功，退出重试 */ + break; } - ch395f_close_socket(sockfd); /* 打开失败先关闭，再延时后重试 */ + /* 打开失败先关闭，再延时后重试 */ + ch395f_close_socket(sockfd); + /* 等 500ms 芯片沉降后再试（Trap 09） */ osDelay(500); } /* 3 次仍失败，返回错误 */ @@ -934,6 +988,7 @@ int net_listen_locked(int sockfd) { } /* 下发 TCP LISTEN 命令，进入监听状态 */ status = ch395f_tcp_listen(sockfd); + /* LISTEN 失败 → BUSY */ if (status != CH395F_ERR_SUCCESS) { s_net_errno = NET_ERR_BUSY; return -1; @@ -943,51 +998,63 @@ int net_listen_locked(int sockfd) { p_sock->state = NET_SOCK_STATE_LISTENING; /* 单连接模式：连接断开后由 net 层自动回到 LISTEN（模拟 BSD 监听常驻） */ p_sock->auto_relisten = 1; - /* 单连接：CONNECT 中断直接作用于本 Socket 自身 */ - - /* - * 启动监听前清空各 Socket 及全局中断状态寄存器（读即清除）， - * 避免历史残留/伪中断在监听刚开始时误触发连接或断开事件。 - */ + /* 单连接：CONNECT 中断直接作用于本 Socket 自身；启动监听前清空各 + * Socket 及全局中断状态寄存器（读即清除），避免历史残留/伪中断在 + * 监听刚开始时误触发连接或断开事件 */ for (int j = 0; j < NET_MAX_SOCKETS; j++) { + /* 读即清：本 Socket 中断状态寄存器 */ (void)ch395f_get_sock_int_status((uint8_t)j); } + /* 读即清：全局中断状态寄存器 */ (void)ch395f_get_glob_int_status_all(); + /* 监听建立完成 */ return 0; } /* * 函数功能：启动 TCP Server 监听（线程安全版本，通过消息队列委托给 netTask） * 入口参数：sockfd - Socket 描述符 int + * 出口参数：无 * 返回值：0 - 成功，-1 - 失败 int * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在任务上下文中调用 * 函数说明：通过消息队列委托给 netTask，确保 SPI 串行化 */ int net_listen(int sockfd) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：启动 TCP 监听 */ msg.type = NET_MSG_LISTEN; + /* 目标 Socket */ msg.sockfd = sockfd; + /* 无超时（监听立即完成） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("lis", sockfd); if (msg.result < 0) { @@ -996,50 +1063,60 @@ int net_listen(int sockfd) { s_net_errno = msg.result; return -1; } + /* 返回结果（成功 = 描述符/字节数） */ return msg.result; } /* * 函数功能：TCP Server 接受新连接（内部版本，必须在 netTask 上下文调用） * 入口参数：sockfd - 监听 Socket 描述符 int - * addr - 输出：客户端地址结构体指针 struct net_sockaddr *（可为 NULL） + * 出口参数：addr - 输出：客户端地址结构体指针 struct net_sockaddr *（可为 NULL） * addrlen - 输入输出：地址结构体长度 int *（可为 NULL） * 返回值：新连接的 Socket 描述符，失败返回 -1 int * 限定条件：Socket 处于 LISTENING 状态 * 函数说明：单连接：监听 Socket 自身在 CONNECT 后已转为 ESTABLISHED */ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen) { + /* 监听 Socket 控制块 */ net_sock_t *p_listen_sock; + /* 取控制块（sockfd 已在上层校验范围） */ p_listen_sock = &s_net_socks[sockfd]; + /* 控制块未在用 → INVAL */ if (!p_listen_sock->in_use) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 先轮询一次：把状态机刷新到芯片侧最新状态 */ net_poll(); - /* 单连接：本 Socket 自身在 CONNECT 后已转为 ESTABLISHED， - * 只有处于 ESTABLISHED 才表示有可接受的连接；否则尚无连接。 - * 注：芯片丢中断导致的失同步不在此处自愈——单次状态读会误判"刚 listen 尚未生效"， - * 曾致监听反复重建直至放弃（2026-09-23 实测风暴）。统一由 net_reconcile_tick() - * 周期对账（带去抖）处理。 */ + /* 单连接：本 Socket 自身在 CONNECT 后处于 ESTABLISHED 才表示有可接受的连接 + * 芯片丢中断导致的失同步不在此处自愈：单次状态读会误判"刚 listen 尚未生效" + * （2026-09-23 实测风暴：监听被反复重建直至放弃），统一由 net_reconcile_tick() 周期对账（带去抖）处理 */ if (p_listen_sock->state != NET_SOCK_STATE_ESTABLISHED) { /* 连接已断开（CLOSED）且启用自动重监听：先把 Socket 重新置回 LISTEN， * 下一次 accept 即可等待新连接（BSD 风格监听常驻） */ if (p_listen_sock->state == NET_SOCK_STATE_CLOSED && p_listen_sock->auto_relisten) { - (void)net_relisten_try(p_listen_sock); /* 非阻塞：失败由重试轮询接管 */ + /* 非阻塞：失败由 D10 重试轮询接管 */ + (void)net_relisten_try(p_listen_sock); } + /* 当前无连接 → WOULDBLOCK */ s_net_errno = NET_ERR_WOULDBLOCK; return -1; } /* 填充对端地址（若调用方需要） */ if (addr != NULL && addrlen != NULL) { + /* 强转为 IPv4 地址结构体 */ struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr; + /* 地址族 = IPv4 */ p_addr_in->sin_family = NET_AF_INET; + /* 对端端口（主机序 → 网络序） */ p_addr_in->sin_port = net_htons(p_listen_sock->remote_port); + /* 对端 IP（控制块按网络序保存） */ p_addr_in->sin_addr.s_addr = p_listen_sock->remote_ip; + /* 回填结构体长度 */ *addrlen = sizeof(struct net_sockaddr_in); } @@ -1050,40 +1127,54 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen /* * 函数功能：TCP Server 接受新连接（线程安全版本，通过消息队列委托给 netTask） * 入口参数：sockfd - 监听 Socket 描述符 int - * addr - 输出：客户端地址结构体指针 struct net_sockaddr *（可为 NULL） + * 出口参数：addr - 输出：客户端地址结构体指针 struct net_sockaddr *（可为 NULL） * addrlen - 输入输出：地址结构体长度 int *（可为 NULL） * 返回值：新连接的 Socket 描述符，失败返回 -1 int * 限定条件：Socket 处于 LISTENING 状态；net_init() + MX_FREERTOS_Init() 已执行；非 netTask 上下文 * 函数说明：将接受请求放入消息队列，阻塞等待 netTask 处理完毕 */ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：接受新连接 */ msg.type = NET_MSG_ACCEPT; + /* 监听 Socket */ msg.sockfd = sockfd; + /* 对端地址指针经 buf 字段携带 */ msg.buf = (void *)addr; + /* addrlen 经 len 字段携带（不回填时记 0） */ msg.len = (addrlen != NULL) ? *addrlen : 0; + /* 无超时（accept 立即完成） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("acc", sockfd); + /* 成功时回填地址结构体长度供调用方读取 */ if (addrlen != NULL &&addr != NULL) { *addrlen = sizeof(struct net_sockaddr_in); } @@ -1094,6 +1185,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) { s_net_errno = msg.result; return -1; } + /* 返回结果（成功 = 新连接描述符） */ return msg.result; } @@ -1102,47 +1194,63 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) { * 入口参数：sockfd - Socket 描述符 (0~7)，必须为已创建的 TCP Socket int * addr - 服务器地址结构体指针 const struct net_sockaddr * * addrlen - 地址结构体长度 int >= sizeof(struct net_sockaddr_in) + * 出口参数：无 * 返回值：0 - 连接请求发送成功（异步，需等待 ESTABLISHED） int * -1 - 连接失败（参数无效、状态错误等） int * 限定条件：Socket 已通过 net_socket() 创建且 type == NET_SOCK_STREAM；尚未连接 - * 函数说明：将连接请求放入消息队列，阻塞等待 netTask 处理完毕。实际的 SPI 操作在 netTask - * 上下文中执行，避免与 net_poll() 的 SPI 访问产生竞争（否则会破坏 CH395F 寄存器）。 - * 连接建立需等待 net_poll() 检测到 CONNECT 事件并将状态更新为 ESTABLISHED + * 函数说明：1. 将连接请求放入消息队列，阻塞等待 netTask 处理完毕 + * 2. 实际的 SPI 操作在 netTask 上下文中执行，避免与 net_poll() 的 SPI 访问竞争（否则会破坏 CH395F 寄存器） + * 3. 连接建立需等待 net_poll() 检测到 CONNECT 事件并将状态更新为 ESTABLISHED */ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 服务器地址无效 → INVAL */ if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 消息类型：发起 TCP 连接 */ msg.type = NET_MSG_CONNECT; + /* 目标 Socket（须为已创建的 TCP Socket） */ msg.sockfd = sockfd; + /* buf/len/flags 在 connect 中不使用（显式置空） */ msg.buf = NULL; msg.len = 0; msg.flags = 0; + /* 服务器地址拷入消息（队列按值拷贝，指针传不过去） */ memcpy(&msg.addr, addr, sizeof(struct net_sockaddr_in)); + /* 地址长度 */ msg.addrlen = addrlen; + /* 无超时（connect 为异步命令，成败由中断裁定） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("con", sockfd); if (msg.result < 0) { @@ -1151,97 +1259,139 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) { s_net_errno = msg.result; return -1; } + /* 返回结果（0 = 连接命令已下发，ESTABLISHED 须以状态轮询等待） */ return msg.result; } /* * 函数功能：TCP Client 发起连接（netTask 内部锁定版本，由消息队列委托执行） + * 入口参数：sockfd - Socket 描述符 (0~7)，必须为已创建的 TCP Socket int + * addr - 服务器地址结构体指针 const struct net_sockaddr * + * addrlen - 地址结构体长度 int >= sizeof(struct net_sockaddr_in) + * 出口参数：无 + * 返回值：0 - 连接请求已发出（异步，成功以 CONNECT 事件为准）；-1 - 失败 int * 限定条件：net_init() 已调用；必须在 netTask 上下文中调用 + * 函数说明：1. 校验控制块（in_use、TCP 类型、地址参数）并保存对端地址 + * 2. 芯片侧 OPEN（失败重试 3 次、间隔 500ms，见 Trap 09）+ 配置源/目的端口与目的 IP + * 3. 清本 Socket 残留中断状态（丢弃上一条连接遗留的 DISCONNECT） + * 4. 发起 TCP_CONNECT 并置 CONNECTING；成败由 net_poll() 的 CONNECT/TIMEOUT 中断裁定 */ static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int addrlen) { + /* Socket 控制块指针 */ net_sock_t *p_sock; + /* 服务器地址（IPv4）强转 */ const struct net_sockaddr_in *p_addr_in; + /* 芯片命令返回状态 */ uint8_t status; - /* 参数检查 */ + /* 参数检查：描述符范围 */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { + /* 越界 → BADF */ s_net_errno = NET_ERR_BADF; return -1; } + /* 取控制块 */ p_sock = &s_net_socks[sockfd]; + /* 未在用或非 TCP 流类型 → INVAL */ if (!p_sock->in_use || p_sock->type != NET_SOCK_STREAM) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 服务器地址无效 → INVAL */ if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 地址强转为 IPv4 结构体 */ p_addr_in = (const struct net_sockaddr_in *)addr; - /* 保存远端地址 */ + /* 保存远端地址（IP 按网络序、端口转主机序） */ p_sock->remote_ip = p_addr_in->sin_addr.s_addr; p_sock->remote_port = net_ntohs(p_addr_in->sin_port); /* 转换 IP 为数组格式（大端/网络字节序，与 ch395f set_des_ip 期望一致， * 同 Phase2 phase2_tc201 的 test_parse_ip 结果 [192,168,1,2]） */ p_sock->remote_ip_arr[0] = (uint8_t)(p_sock->remote_ip >> 24); + /* 最高字节 → [0]（大端序） */ p_sock->remote_ip_arr[1] = (uint8_t)(p_sock->remote_ip >> 16); p_sock->remote_ip_arr[2] = (uint8_t)(p_sock->remote_ip >> 8); + /* 最低字节 → [3] */ p_sock->remote_ip_arr[3] = (uint8_t)(p_sock->remote_ip); /* 配置 CH395F Socket：先 OPEN 再写源/目的端口（避免 open 复位寄存器） */ + /* 设置协议类型为 TCP */ ch395f_set_proto_type(sockfd, CH395F_PROTO_TYPE_TCP); /* CH395F 关闭 Socket 后需延时才能重新打开（Trap 09），故失败重试最多 3 次 */ for (int open_try = 0; open_try < 3; open_try++) { + /* 尝试打开芯片侧 Socket */ status = ch395f_open_socket(sockfd); if (status == CH395F_ERR_SUCCESS) { - break; /* 打开成功，退出重试 */ + /* 打开成功，退出重试 */ + break; } - ch395f_close_socket(sockfd); /* 打开失败先关闭，再延时后重试 */ + /* 打开失败先关闭，再延时后重试 */ + ch395f_close_socket(sockfd); + /* 等 500ms 芯片沉降后再试（Trap 09） */ osDelay(500); } + /* 3 次仍失败 → BUSY */ if (status != CH395F_ERR_SUCCESS) { s_net_errno = NET_ERR_BUSY; return -1; } /* 清掉本 Socket 可能残留的中断状态，丢弃上一条连接遗留的 DISCONNECT */ + /* 读即清：本 Socket 中断状态寄存器 */ (void)ch395f_get_sock_int_status((uint8_t)sockfd); + /* 读即清：全局中断状态寄存器 */ (void)ch395f_get_glob_int_status_all(); + /* 设置本地（源）端口 */ ch395f_set_sour_port(sockfd, p_sock->local_port); + /* 设置目的 IP（大端数组） */ ch395f_set_des_ip(sockfd, p_sock->remote_ip_arr); + /* 设置目的端口 */ ch395f_set_des_port(sockfd, p_sock->remote_port); /* 诊断：回读目的 IP/端口与 Socket 状态（GET_REMOT_IPP 为小端，故需按小端解析） * 注意 ch395f_get_socket_status 输出**2 字节**：[0]=Socket 开关状态、[1]=TCP 状态， * 必须给 2 字节缓冲（曾只给 1 字节 → 栈越界 1 字节） */ { + /* 回读的目的 IP/端口（6 字节：4B IP + 2B 端口，小端） */ uint8_t rip[6]; + /* 两字节 Socket 状态（须给 2 字节缓冲） */ uint8_t st[2] = {0, 0}; + /* 目的 IP 解析成的 32 位值（小端 → 主机序） */ uint32_t dip; + /* 目的端口 */ uint16_t dp; + /* 回读目的 IP + 端口 */ ch395f_get_remot_ipp((uint8_t)sockfd, rip); + /* 回读 Socket 状态 */ ch395f_get_socket_status((uint8_t)sockfd, st); + /* 小端 IP 组装为主机序 */ dip = ((uint32_t)rip[3] << 24) | ((uint32_t)rip[2] << 16) | ((uint32_t)rip[1] << 8) | rip[0]; + /* 小端端口组装 */ dp = ((uint16_t)rip[5] << 8) | rip[4]; + /* 留痕：目的地址 + Socket 状态（现场排障） */ DBG_INFO("[CONN] sock%d openOK dest=%d.%d.%d.%d:%d status=0x%02X tcp=0x%02X", sockfd, (dip >> 24) & 0xFF, (dip >> 16) & 0xFF, (dip >> 8) & 0xFF, dip & 0xFF, dp, st[0], st[1]); } - /* 发起 TCP 连接 */ + /* 发起 TCP 连接（异步：芯片立即返回） */ ch395f_tcp_connect(sockfd); + /* 状态 → CONNECTING（等待 CONNECT/TIMEOUT 中断裁定） */ p_sock->state = NET_SOCK_STATE_CONNECTING; + /* 连接请求已发出（0） */ return 0; } @@ -1255,9 +1405,6 @@ static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int a #define NET_SEND_CHUNK_MAX ((int)CH395F_SEND_BUF_SIZE_BYTES < NET_DMA_MAX_PAYLOAD ? \ (int)CH395F_SEND_BUF_SIZE_BYTES : NET_DMA_MAX_PAYLOAD) -/* - * 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用） - */ /* * 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用） * 入口参数：p_sock - Socket 控制块指针 net_sock_t * @@ -1273,28 +1420,38 @@ static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int a * （errno=CONNRESET，不再空等超时） */ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) { + /* 累计实际发送字节数 */ int sent = 0; + /* 当前等待阶段起始时刻（tick） */ uint32_t tick_start; + /* 由控制块指针反推描述符（数组下标） */ int sockfd = (int)(p_sock - s_net_socks); + /* 参数检查：缓冲区无效 → INVAL */ if (buf == NULL || len <= 0) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 未建立连接 → NOTCONN */ if (p_sock->state != NET_SOCK_STATE_ESTABLISHED) { s_net_errno = NET_ERR_NOTCONN; return -1; } + /* 记录起始时刻（用于停滞超时判定） */ tick_start = HAL_GetTick(); + /* 分块发送循环：直到全部写入或失败退出 */ while (sent < len) { + /* 剩余待发字节 */ int chunk = len - sent; + /* 单块以硬件发送缓冲为上限（Trap 20：防写穿 1KB FIFO） */ if (chunk > NET_SEND_CHUNK_MAX) { chunk = NET_SEND_CHUNK_MAX; } + /* 发送缓冲未空：等待腾出后再写下一块 */ if (!p_sock->send_ready) { /* 发送中途断连（DISCONNECT/TIMEOUT 已由 net_poll 处理并置状态非 ESTABLISHED）： * 立即失败，不再空等满超时（旧行为：白等 1s 后报 TIMEDOUT） */ @@ -1302,19 +1459,25 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) { s_net_errno = NET_ERR_CONNRESET; break; } + /* 停滞超时：NET_SEND_TIMEOUT_MS 后 send_ready 仍未置位 */ if (NET_SEND_TIMEOUT_MS > 0 && (HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) { DBG_ERROR("sock%d send stall: send_ready not set (%d/%d)", sockfd, sent, len); s_net_errno = NET_ERR_TIMEDOUT; break; } + /* 轮询一次（更新 send_ready/状态），下一轮再试 */ net_poll(); continue; } + /* 本块写入芯片发送 FIFO */ ch395f_write_send_buf(sockfd, (uint8_t *)buf + sent, (uint16_t)chunk); + /* 标记发送缓冲占用中 */ p_sock->send_ready = 0; + /* 累计发送偏移 */ sent += chunk; + /* 累计发送字节统计 */ p_sock->send_bytes += (uint32_t)chunk; #if defined(TEST_LATENCY_PROBE) @@ -1323,31 +1486,38 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) { uint32_t c_l3 = lat_cycles_now(); #endif + /* 重置本等待阶段计时 */ tick_start = HAL_GetTick(); + /* 等待本块发完（SENBUF_FREE 中断重新置 send_ready） */ while (!p_sock->send_ready) { /* 发送中途断连：立即失败（同外层，避免白等超时） */ if (p_sock->state != NET_SOCK_STATE_ESTABLISHED) { s_net_errno = NET_ERR_CONNRESET; break; } + /* 轮询：处理 SEND_OK/SENBUF_FREE 中断 */ net_poll(); + /* 等待超时：本块放弃（外层统一处理） */ if (NET_SEND_TIMEOUT_MS > 0 && (HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) { break; } } #if defined(TEST_LATENCY_PROBE) + /* 探针已武装：累计本段等待样本 */ if (lat_probe_armed() != 0U) { lat_probe_add_seg("chunk_wait", lat_cycles_diff_us(c_l3)); } #endif } + /* 发送未完成 = 短写 */ if (sent < len) { /* 短写告警：调用方必须检查返回值。静默截断会让对端永久等待剩余字节 * （2026-09-21 实证：UI 推流应答被截断 → 客户端反复判定"全程无字节"失联）。 */ DBG_ERROR("sock%d short send %d/%d (errno=%d)", sockfd, sent, len, s_net_errno); } + /* 返回实际发送字节数（调用方必须检查，勿只看非负） */ return sent; } @@ -1365,16 +1535,17 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) { * 限定条件：p_sock 非空；netTask 上下文 * 函数说明：1. 数据已在（快速路径）→ 立即读出返回，行为与旧实现一致 * 2. 非阻塞模式无数据立即返回 -1（NET_ERR_WOULDBLOCK） - * 3. 无数据 + 阻塞等待 → 登记挂起请求（L3 pending 化，E-02 结构演进）： - * netTask 零占用立即返回；完成条件（数据/到点/断连）由 - * net_pending_tick 按主循环节拍检查并通知 caller； - * 关闭/网络重建/陈旧重同步由对应路径显式了结（取消必通知）。 - * CLOSED 状态语义（排空 + EOF + 自动重监听）逐项保留在 tick 内 + * 3. 无数据 + 阻塞等待 → 登记挂起请求（L3 pending 化，E-02 结构演进） + * 4. netTask 零占用立即返回；完成条件（数据/到点/断连）由 net_pending_tick 按主循环节拍检查 + * 5. 并通知 caller；关闭/网络重建/陈旧重同步由对应路径显式了结（取消必通知） + * 6. CLOSED 状态语义（排空 + EOF + 自动重监听）逐项保留在 tick 内 */ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags, uint32_t timeout_ms, TaskHandle_t caller) { + /* 由控制块指针反推描述符（数组下标） */ int sockfd = (int)(p_sock - s_net_socks); + /* 参数检查：缓冲区无效 → INVAL */ if (buf == NULL || len <= 0) { s_net_errno = NET_ERR_INVAL; return -1; @@ -1383,26 +1554,40 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags, /* 超时来源：调用方指定（单次预算）优先，否则用默认值（均作为挂起截止） */ uint32_t to_ms = (timeout_ms != 0U) ? timeout_ms : (uint32_t)NET_RECV_TIMEOUT_MS; + /* 先轮询一次：刷新状态机与可读标志 */ net_poll(); + /* 查询芯片侧接收缓冲可用字节数 */ int recv_len = ch395f_get_recv_len(sockfd); + /* 快速路径：数据已在 */ if (recv_len > 0) { + /* 本次读取量 = 缓冲容量与芯片可用量的较小值 */ int read_len = (recv_len > len) ? len : recv_len; + /* 读出到调用方缓冲区 */ ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)read_len); + /* 累计接收字节统计 */ p_sock->recv_bytes += (uint32_t)read_len; - p_sock->readable = 0; /* 已消费数据（注：部分读受 Trap 13 限制，下一次 RECV_OK 会重新置位） */ + /* 已消费数据（注：部分读受 Trap 13 限制，下一次 RECV_OK 会重新置位） */ + p_sock->readable = 0; + /* 返回本次读出字节数 */ return read_len; } + /* 非阻塞模式（DONTWAIT） */ if (flags & NET_MSG_DONTWAIT) { /* 非阻塞且当前无数据：若连接已断开则视为 EOF(0) 并自动重监听， * 否则返回 WOULDBLOCK(-1) 表示暂时无数据 */ + /* 连接已断开（CLOSED）：按 EOF 处理 */ if (p_sock->state == NET_SOCK_STATE_CLOSED) { + /* 启用自动重监听：先把监听器重新置回 LISTEN */ if (p_sock->auto_relisten) { - (void)net_relisten_try(p_sock); /* 非阻塞：失败由重试轮询接管 */ + /* 非阻塞：失败由 D10 重试轮询接管 */ + (void)net_relisten_try(p_sock); } + /* EOF：返回 0（非错误） */ return 0; } + /* 暂时无数据 → WOULDBLOCK */ s_net_errno = NET_ERR_WOULDBLOCK; return -1; } @@ -1410,12 +1595,10 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags, /* 无数据 + 阻塞等待：登记挂起请求，立即返回（netTask 任何时刻都不被占用）。 * 调用方在自己上下文睡任务通知（LwIP netconn 模型）；等待期间 netTask * 继续主循环（事件泵 + 队列），其他消费者零头阻塞。 */ + /* 登记挂起请求（L3）：返回值即登记结果 */ return net_pending_register(sockfd, buf, len, to_ms, caller); } -/* - * 函数功能：关闭 socket（内部锁定版本，必须在 netTask 上下文调用） - */ /* * 函数功能：关闭 Socket（内部锁定版本，必须在 netTask 上下文调用） * 入口参数：p_sock - Socket 控制块指针 net_sock_t * @@ -1427,24 +1610,28 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags, */ /* Trap 23（2026-09-23 生产路径实测）：异常释放（芯片 TIMEOUT，例如客户端中止上传） * 后的**隔离期**。实测时序：中止时对端仍有在途数据 → 芯片 TIMEOUT（此时 MCU 侧 recv=0） - * → 在途段随后落进芯片 RX 缓冲（约 2KB 残渣）→ 若立即 open+listen，残渣被下一条连接 - * 当作自己的数据读走：新上传只收 2KB 就被判定结束、回报成功（静默截断）。 - * 处置：异常释放的 socket 先隔离 NET_RELISTEN_QUARANTINE_MS：期间持续排空 RX、主动 - * close 并排空中断、等芯片回到 CLOSED/TCP_CLOSED；隔离期满才 open+listen。上限 - * NET_RELISTEN_SETTLE_MS 后强制放行，保证监听器不会永久失效。 - * 正常 FIN 释放（handle_disconnect_event）不走此路径——既有行为零改动。 - * 声明须早于 net_relisten_locked（其余重试状态见其后区块）。 */ + * 在途段随后落进芯片 RX 缓冲（约 2KB 残渣） + * 若立即 open+listen，残渣被下一条连接当作自己的数据读走 + * 新上传只收 2KB 就被判定结束、回报成功（静默截断） + * 处置：异常释放的 socket 先隔离 NET_RELISTEN_QUARANTINE_MS：期间持续排空 RX、主动 close 并排空中断 + * 等芯片回到 CLOSED/TCP_CLOSED；隔离期满才 open+listen + * 上限 NET_RELISTEN_SETTLE_MS 后强制放行，保证监听器不会永久失效 + * 正常 FIN 释放（handle_disconnect_event）不走此路径——既有行为零改动 + * 声明须早于 net_relisten_locked（其余重试状态见其后区块） + */ #define NET_RELISTEN_QUARANTINE_MS 400U /* 异常释放最短隔离（等在途数据落尽 + 排空残渣） */ #define NET_RELISTEN_GRACEFUL_MS 100U /* 正常释放最短沉降（等芯片完成上一条连接的收尾） */ #define NET_RELISTEN_SETTLE_MS 800U /* 隔离上限（须 < NET_RELISTEN_DEADLINE_MS， * 否则隔离耗尽重试预算 → 监听被放弃，2026-09-23 实测） */ -/* 重监听前"清芯片收尾状态"的两个等级（s_relisten_quarantine 取值）： - * QUARANTINE - 异常释放（芯片 TIMEOUT）：对端可能仍有在途数据，须清理 + 最短等 400ms； - * GRACEFUL - 正常释放（芯片 DISCONNECT）：无在途数据，清理 + 最短等 100ms。 - * 2026-09-24 台架实证：正常释放走的是既有"不复位芯片收尾状态"的路径，残留的 DISCONNECT - * 会在**复用同一 fd 的下一条连接**上被投递（accept 后约 10~20ms）→ 下一条上传被静默截断 - * 到 2048B（一个芯片 RX 缓冲）且回报 226。只清理不等待（0ms）实测**无效**（4/4 仍截断）， - * 说明芯片需要时间完成上一条连接的内部收尾；给足沉降即 4/4 通过。 */ +/* 重监听前"清芯片收尾状态"的两个等级（s_relisten_quarantine 取值） + * QUARANTINE - 异常释放（芯片 TIMEOUT）：对端可能仍有在途数据，须清理 + 最短等 400ms + * GRACEFUL - 正常释放（芯片 DISCONNECT）：无在途数据，清理 + 最短等 100ms + * 2026-09-24 台架实证：正常释放走的是既有"不复位芯片收尾状态"的路径 + * 残留的 DISCONNECT 会在复用同一 fd 的下一条连接上被投递（accept 后约 10~20ms） + * 下一条上传被静默截断到 2048B（一个芯片 RX 缓冲）且回报 226 + * 只清理不等待（0ms）实测无效（4/4 仍截断）：芯片需要时间完成上一条连接的内部收尾 + * 给足沉降即 4/4 通过 + */ #define NET_RELISTEN_SETTLE_QUARANTINE 1U #define NET_RELISTEN_SETTLE_GRACEFUL 2U static uint8_t s_relisten_quarantine[NET_MAX_SOCKETS]; /* 0=免清；1=异常释放；2=正常释放 */ @@ -1454,23 +1641,30 @@ static uint32_t s_relisten_settle_dead[NET_MAX_SOCKETS]; /* 隔离上限到期 /* * 函数功能：清空芯片该 socket 的 RX 残留（Trap 23） * 入口参数：sockfd - Socket 描述符 (0~7) int + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文；socket 即将 close/open（数据已无意义，丢弃） - * 函数说明：中止/异常断开时芯片 RX 缓冲可能残留上一条连接的数据（实测残留约一个 - * 缓冲 = 2048B）；残渣带入下一条连接会使其在约 2KB 处被芯片拆链（上传被 - * 静默截断）。关闭前主动读空即清除。分块读避免新增静态缓冲。 + * 函数说明：1. 中止/异常断开时芯片 RX 缓冲可能残留上一条连接的数据（实测残留约一个缓冲 = 2048B） + * 2. 残渣带入下一条连接会使其在约 2KB 处被芯片拆链（上传被静默截断） + * 3. 关闭前主动读空即清除；分块读避免新增静态缓冲 */ static void net_drain_chip_rx(int sockfd) { + /* 复用分块缓冲（256B/块，避免新增静态缓冲） */ uint8_t scratch[256]; - for (int guard = 0; guard < 16; guard++) { /* 上限 16×256 = 4KB（缓冲仅 2KB），防死循环 */ + /* 上限 16×256 = 4KB（缓冲仅 2KB），防死循环 */ + for (int guard = 0; guard < 16; guard++) { + /* 查询芯片 RX 可用字节数 */ int n = (int)ch395f_get_recv_len((uint8_t)sockfd); + /* 已排空 → 结束 */ if (n <= 0) { break; } + /* 单块以缓冲容量为上限 */ if (n > (int)sizeof(scratch)) { n = (int)sizeof(scratch); } + /* 丢弃该块（读即清） */ ch395f_read_recv_buf((uint8_t)sockfd, scratch, (uint16_t)n); } } @@ -1478,96 +1672,141 @@ static void net_drain_chip_rx(int sockfd) { /* * 函数功能：单连接模式断连后自动重新进入 LISTEN（不清空控制块，保留 fd） * 入口参数：p_sock - 已断开（CLOSED）的 TCP 监听型 Socket 控制块 net_sock_t * + * 出口参数：无 * 返回值：0 - 成功，-1 - 失败 * 限定条件：netTask 上下文；p_sock->in_use == 1；保留 local_port/auto_relisten * 函数说明：1. 复用原本地端口与协议，重新 OPEN + TCP_LISTEN * 2. 仅将 state 置回 LISTENING，不 memset（fd 与 auto_relisten 保持不变） * 3. 实现 BSD 风格"监听 Socket 常驻"，应用层无需手动重监听 - * 4. **单次尝试**：失败立即返回（Trap 09 沉降交给 net_relisten_try/ - * net_relisten_retry_tick 非阻塞重试，见下）。旧实现在此 osDelay(500) - * 忙等，netTask 冻结 500ms、实测恢复 588ms（M3 台架 D10） + * 4. **单次尝试**：失败立即返回（不 osDelay 忙等） + * 5. Trap 09 沉降交给 net_relisten_try / net_relisten_retry_tick 非阻塞重试（见下） + * 6. 旧实现在此 osDelay(500) 忙等，netTask 冻结 500ms、实测恢复 588ms（M3 台架 D10） */ static int net_relisten_locked(net_sock_t *p_sock) { + /* 芯片命令返回状态 */ uint8_t status; + /* 由控制块指针反推描述符 */ int sockfd = (int)(p_sock - s_net_socks); + /* 释放隔离期（Trap 23）：重监听前先清芯片收尾状态 */ if (s_relisten_quarantine[sockfd] != 0U) { + /* 芯片状态两字节：[0]=Socket，[1]=TCP */ uint8_t st[2] = {0, 0}; + /* 当前 tick */ uint32_t now = HAL_GetTick(); - /* 最短等待由释放来源决定（见 NET_RELISTEN_SETTLE_* 定义）：异常释放等 400ms - * 让在途数据落尽；正常释放等 100ms 让芯片完成上一条连接的内部收尾。 - * 日志按等级区分 quarantine（异常）/ settle（正常），便于台架分辨触发路径。 */ + /* 隔离等级（1=异常释放 2=正常释放） */ uint8_t lvl = s_relisten_quarantine[sockfd]; + /* 最短等待由释放来源决定（NET_RELISTEN_SETTLE_*）：异常释放 400ms（等在途数据落尽） + * 正常释放 100ms（等芯片内部收尾） */ uint32_t hold = (lvl == NET_RELISTEN_SETTLE_QUARANTINE) ? NET_RELISTEN_QUARANTINE_MS : NET_RELISTEN_GRACEFUL_MS; + /* 日志标签（台架分辨触发路径） */ const char *tag = (lvl == NET_RELISTEN_SETTLE_QUARANTINE) ? "quarantine" : "settle"; + /* 首次进入隔离期：记录起点与上限 */ if (s_relisten_settle_start[sockfd] == 0U) { + /* 隔离起点 = 本 tick */ s_relisten_settle_start[sockfd] = now; + /* 隔离上限 = 起点 + 800ms */ s_relisten_settle_dead[sockfd] = now + NET_RELISTEN_SETTLE_MS; } - net_drain_chip_rx(sockfd); /* 隔离期内持续排空 RX 残渣 */ - ch395f_close_socket((uint8_t)sockfd); /* 主动关：清旧连接收尾状态 */ + /* 隔离期内持续排空 RX 残渣 */ + net_drain_chip_rx(sockfd); + /* 主动关：清旧连接收尾状态 */ + ch395f_close_socket((uint8_t)sockfd); + /* 读即清：本 Socket 中断状态寄存器 */ (void)ch395f_get_sock_int_status((uint8_t)sockfd); + /* 读即清：全局中断状态寄存器 */ (void)ch395f_get_glob_int_status_all(); + /* 读芯片当前状态（两字节） */ ch395f_get_socket_status((uint8_t)sockfd, st); + /* 芯片尚未回到 CLOSED/TCP_CLOSED，或未满最短等待 */ if (((st[0] != CH395F_SOCKET_CLOSED) || (st[1] != CH395F_TCP_CLOSED) || ((uint32_t)(now - s_relisten_settle_start[sockfd]) < hold))) { + /* 未到上限：交重试轮询（30ms 后复检） */ if ((int32_t)(now - s_relisten_settle_dead[sockfd]) < 0) { DBG_INFO("sock%d relisten %s (sock=0x%02X tcp=0x%02X)", sockfd, tag, st[0], st[1]); + /* 置 BUSY（结果回传调用方） */ s_net_errno = NET_ERR_BUSY; - return -1; /* 交重试轮询（30ms 后复检） */ + /* 交重试轮询（30ms 后复检） */ + return -1; } + /* 隔离上限已至：强制放行（防监听器永久失效） */ DBG_INFO("sock%d relisten %s timeout, force open (sock=0x%02X tcp=0x%02X)", sockfd, tag, st[0], st[1]); } - s_relisten_quarantine[sockfd] = 0U; /* 隔离完成（或强制放行） */ + /* 隔离完成（或强制放行） */ + s_relisten_quarantine[sockfd] = 0U; + /* 清隔离起点（回到"未开始"） */ s_relisten_settle_start[sockfd] = 0U; + /* 清上限时刻 */ s_relisten_settle_dead[sockfd] = 0U; } + /* 重置协议类型为 TCP */ ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_TCP); + /* 本地端口（沿用原监听） */ ch395f_set_sour_port((uint8_t)sockfd, p_sock->local_port); + /* 打开芯片侧 Socket */ status = ch395f_open_socket((uint8_t)sockfd); + /* open 失败 → BUSY（Trap 09：芯片需沉降时间才能重开） */ if (status != CH395F_ERR_SUCCESS) { /* Trap 09：断开后芯片需沉降时间才能重新 open。此处只清理并返回 * （严禁 osDelay 忙等）→ 由重试轮询到点再来。 */ + /* 先关闭，交重试轮询（30ms 后复检） */ ch395f_close_socket((uint8_t)sockfd); + /* 置 BUSY（结果回传调用方） */ s_net_errno = NET_ERR_BUSY; + /* 交重试轮询（30ms 后复检） */ return -1; } + /* 下发 TCP LISTEN 命令 */ status = ch395f_tcp_listen((uint8_t)sockfd); + /* LISTEN 失败 → BUSY（同样交重试） */ if (status != CH395F_ERR_SUCCESS) { + /* 置 BUSY（结果回传调用方） */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 状态置回 LISTENING（fd 保留） */ p_sock->state = NET_SOCK_STATE_LISTENING; - p_sock->released_abnormal = 0U; /* 新监听不得继承上一条连接的释放原因（Trap 23 待办 #3） */ + /* 新监听不得继承上一条连接的释放原因（Trap 23 待办 #3） */ + p_sock->released_abnormal = 0U; + /* 清对端端口（新连接待用） */ p_sock->remote_port = 0; + /* 清对端 IP */ p_sock->remote_ip = 0; + /* 清对端 IP 数组 */ memset(p_sock->remote_ip_arr, 0, sizeof(p_sock->remote_ip_arr)); + /* 新开 Socket 发送缓冲按占用计（由 SEND_OK 清除） */ p_sock->send_ready = 0; + /* 清接收字节统计（新连接） */ p_sock->recv_bytes = 0; /* auto_relisten 保持为 1，下次断连仍自动重监听 */ + /* 读即清：各 Socket 中断状态寄存器（防残留中断误触发） */ for (int j = 0; j < NET_MAX_SOCKETS; j++) { (void)ch395f_get_sock_int_status((uint8_t)j); } + /* 读即清：全局中断状态寄存器 */ (void)ch395f_get_glob_int_status_all(); + /* 留痕：监听器重建完成 */ DBG_INFO("sock%d auto-relisten ok", sockfd); + /* 重监听成功 */ return 0; } /* ===== Trap 09 非阻塞重监听重试（D10 修复，2026-09-22 M3 实测） ===== - * 旧实现：open 失败 → close → osDelay(500) → 重试：netTask 忙等 500ms（全网冻结）， - * 且实测恢复 588ms、期间客户端重连被拒。 + * 旧实现：open 失败 → close → osDelay(500) → 重试，netTask 忙等 500ms（全网冻结） + * 且实测恢复 588ms、期间客户端重连被拒 * 新实现：首次失败即登记待重试，由 netTask 每轮 net_process_messages() 到点重试 - * → 恢复时间 ≈ NET_RELISTEN_RETRY_MS 量级，且**任何时刻都不阻塞任务**。 */ + * 恢复时间 ≈ NET_RELISTEN_RETRY_MS 量级，任何时刻都不阻塞任务 + */ #define NET_RELISTEN_RETRY_MS 30U /* 重试间隔（Trap 09 沉降窗口；实测 100ms 首次必成， * 收紧到 30ms 以缩短恢复时间——未成则下一轮到点再来） */ #define NET_RELISTEN_DEADLINE_MS 2000U /* 放弃时限（自首次尝试起） */ @@ -1582,32 +1821,45 @@ static lat_tmark_t s_relisten_mark[NET_MAX_SOCKETS]; /* 恢复计时起点（ /* * 函数功能：清除本 fd 的待重监听重试状态（关闭/新建 fd 时调用） * 入口参数：sockfd - Socket 描述符 (0~7) + * 出口参数：无 * 返回值：无 * 限定条件：无 + * 函数说明：1. 清"待重试"标志与重试时刻，fd 关闭/新建时调用（防残留重试） */ static void net_relisten_clear(int sockfd) { + /* 描述符越界：直接返回（本函数不设错误码） */ if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) { return; } + /* 清"待重试"标志 */ s_relisten_wait[sockfd] = 0U; + /* 清下次重试时刻 */ s_relisten_next[sockfd] = 0U; + /* 清放弃时刻 */ s_relisten_dead[sockfd] = 0U; - s_relisten_settle_dead[sockfd] = 0U; /* Trap 23：一并清沉降/隔离状态 */ + /* Trap 23：一并清沉降/隔离状态 */ + s_relisten_settle_dead[sockfd] = 0U; + /* 清沉降起点 */ s_relisten_settle_start[sockfd] = 0U; - s_relisten_quarantine[sockfd] = 0U; /* 一并清隔离标志：关闭/重建即确定性释放， - * 防同 fd 下一生成继承上轮的 400/800ms - * 隔离等待（2026-09-24 台架发现跨轮残留） */ + /* 一并清隔离标志：关闭/重建即确定性释放， + * 防同 fd 下一生成继承上轮的 400/800ms + * 隔离等待（2026-09-24 台架发现跨轮残留） */ + s_relisten_quarantine[sockfd] = 0U; } /* * 函数功能：标记重监听完成（清重试状态；探针构建下报告恢复计时样本） * 入口参数：sockfd - Socket 描述符 (0~7) + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文 + * 函数说明：1. 重监听成功收尾：清重试状态；探针构建（TEST_LATENCY_PROBE）下上报恢复计时样本 */ static void net_relisten_done(int sockfd) { + /* 清重试状态（复用清除函数） */ net_relisten_clear(sockfd); #if defined(TEST_LATENCY_PROBE) + /* 上报恢复计时样本（首次尝试 → 成功） */ lat_probe_add_seg("relisten", lat_mark_us(&s_relisten_mark[sockfd])); #endif } @@ -1615,104 +1867,140 @@ static void net_relisten_done(int sockfd) { /* * 函数功能：尝试重监听一次；失败则登记"待重试"（**不阻塞** netTask） * 入口参数：p_sock - CLOSED 的监听型 Socket 控制块 net_sock_t * + * 出口参数：无 * 返回值：0 - 成功（监听器已就绪）；-1 - 本次失败或已在重试队列中 * 限定条件：netTask 上下文 * 函数说明：已有待重试时直接返回 -1（不重复尝试、不重置重试时刻）——否则每 10ms * 一次的 accept 轮询会不断把重试时刻往后推，导致永不重试（饥饿）。 */ static int net_relisten_try(net_sock_t *p_sock) { + /* 由控制块指针反推描述符 */ int sockfd = (int)(p_sock - s_net_socks); + /* 当前 tick */ uint32_t now = HAL_GetTick(); + /* 描述符越界 → BADF */ if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) { s_net_errno = NET_ERR_BADF; return -1; } + /* 已在重试队列：不重复尝试、不重置时刻（防重试饥饿） */ if (s_relisten_wait[sockfd] != 0U) { s_net_errno = NET_ERR_BUSY; - return -1; /* 已在重试队列：由 tick 负责 */ + /* 已在重试队列：由 tick 负责 */ + return -1; } #if defined(TEST_LATENCY_PROBE) - lat_mark(&s_relisten_mark[sockfd]); /* 恢复计时自首次尝试起 */ + /* 恢复计时自首次尝试起 */ + lat_mark(&s_relisten_mark[sockfd]); #endif + /* 本次尝试成功 */ if (net_relisten_locked(p_sock) == 0) { + /* 标记完成（清状态 + 探针样本） */ net_relisten_done(sockfd); + /* 监听器已就绪 */ return 0; } + /* 登记"待重试" */ s_relisten_wait[sockfd] = 1U; + /* 下次重试时刻 = now + 30ms */ s_relisten_next[sockfd] = now + NET_RELISTEN_RETRY_MS; + /* 放弃时刻 = now + 2s */ s_relisten_dead[sockfd] = now + NET_RELISTEN_DEADLINE_MS; + /* 本次失败（重试交 tick） */ return -1; } /* * 函数功能：重试轮询（netTask 每轮调用一次，非阻塞） + * 入口参数：无 + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文（net_process_messages 开头调用） * 函数说明：到点重试待办的自动重监听；成功即报告探针样本；超时放弃并记错误日志 */ static void net_relisten_retry_tick(void) { + /* 当前 tick */ uint32_t now = HAL_GetTick(); + /* Socket 循环索引 */ int i; for (i = 0; i < NET_MAX_SOCKETS; i++) { + /* 本 fd 无待重试重监听：跳过 */ if (s_relisten_wait[i] == 0U) { continue; } + /* 本 fd 有在途挂起 recv：重开 Socket 会摧毁在途连接（L3 保险） */ if (s_net_pending[i].active != 0U) { - continue; /* 本 fd 有在途挂起 recv：重开 Socket 会摧毁在途连接（L3 保险） */ + continue; } + /* 未到点（tick 差值按有符号比较，抗回绕） */ if ((int32_t)(now - s_relisten_next[i]) < 0) { - continue; /* 未到点（tick 差值按有符号比较，抗回绕） */ + continue; } + /* 已到放弃时限 */ if ((int32_t)(now - s_relisten_dead[i]) >= 0) { + /* 清重试状态 */ net_relisten_clear(i); + /* 放弃并记错误日志 */ DBG_ERROR("sock%d relisten give up (Trap 09 not cleared)", i); continue; } + /* 重试成功 */ if (net_relisten_locked(&s_net_socks[i]) == 0) { + /* 标记完成（清状态 + 探针样本） */ net_relisten_done(i); + /* 留痕：重试成功 */ DBG_INFO("sock%d relisten retry ok", i); } else { + /* 仍未成：置下次重试时刻 */ s_relisten_next[i] = now + NET_RELISTEN_RETRY_MS; } } } /* ===== L3 挂起 recv 请求的实现（一期，2026-09-22） ===== - * 完成条件按 ①数据 ②到点 ③断连 顺序检查（逐项对齐旧自旋循环语义）： - * ① 数据通道（ESTABLISHED/UDP_OPEN）内 readable 门控 SPI 读——常见无数据路径 - * 零额外 SPI 事务（INT# 电平触发链保证缓冲有数据时每轮重读 SINT 重位置位） + * 完成条件按 ①数据 ②到点 ③断连 顺序检查（逐项对齐旧自旋循环语义） + * ① 数据通道（ESTABLISHED/UDP_OPEN）内 readable 门控 SPI 读——常见无数据路径零额外 SPI 事务 + * （INT# 电平触发链保证缓冲有数据时每轮重读 SINT 重位置位） * ② 到点（与状态无关，旧自旋亦在任何状态下检查超时）→ NET_ERR_TIMEDOUT - * ③ CLOSED：先排空（Trap 13：FIN 可能先于数据）→ 有数据按数据完成， - * 否则 EOF(0) + 自动重监听 - * 其他状态（CONNECTING/LISTENING/…）保持等待状态迁移（CONNECT→ESTABLISHED - * 是合法路径；陈旧 resync 由显式取消处理）——不做状态推断取消，避免误杀 - * 正在建链的等待。看门狗兜底：到点后仍未了结 = 完成逻辑缺位 → 强制了结留痕。 */ + * ③ CLOSED：先排空（Trap 13：FIN 可能先于数据）→ 有数据按数据完成，否则 EOF(0) + 自动重监听 + * 其他状态（CONNECTING/LISTENING/…）保持等待状态迁移（CONNECT→ESTABLISHED 是合法路径； + * 陈旧 resync 由显式取消处理）——不做状态推断取消，避免误杀正在建链的等待 + * 看门狗兜底：到点后仍未了结 = 完成逻辑缺位 → 强制了结留痕 + */ /* * 函数功能：通知调用方并清除本 fd 的挂起请求（所有完成/取消路径的公共出口） * 入口参数：sockfd - Socket 描述符 (0~7) int * result - 32 位结果原值（>0 字节数 / 0 EOF / 负错误码） int + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文；sockfd 合法且挂起在位（否则静默返回，防重复通知） * 函数说明：通知值 = 结果本身（与消息分派同一回传通道，调用方 net_recv/net_recv_to * 的映射逻辑不变）；失败结果同步 errno 保持 netTask 上下文一致性 */ static void net_pending_complete(int sockfd, int result) { + /* 本 fd 挂起请求指针 */ net_pending_t *p; + /* 描述符越界：静默返回（防重复通知） */ if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) { return; } + /* 取挂起请求 */ p = &s_net_pending[sockfd]; + /* 无在位挂起（已了结/已取消）：静默返回 */ if (p->active == 0U) { return; } + /* 失败结果：同步 errno（保持 netTask 上下文一致性） */ if (result < 0) { s_net_errno = result; } + /* 覆盖式写入通知值 = 结果本身（32 位原值） */ xTaskNotify(p->caller, (uint32_t)result, eSetValueWithOverwrite); + /* 清除挂起状态 */ p->active = 0U; } @@ -1723,6 +2011,7 @@ static void net_pending_complete(int sockfd, int result) { * len - 缓冲容量 int * to_ms - 本次等待预算（截止 = 登记时刻 + to_ms） uint32_t * caller - 调用方任务句柄（完成通知目标） TaskHandle_t + * 出口参数：无 * 返回值：NET_PENDING_REGISTERED - 登记成功（分派跳过即时通知） * -1 - 拒绝（同 fd 已有挂起 / 执行任务自身发起） * 限定条件：netTask 上下文 @@ -1732,51 +2021,75 @@ static void net_pending_complete(int sockfd, int result) { */ static int net_pending_register(int sockfd, void *buf, int len, uint32_t to_ms, TaskHandle_t caller) { + /* 挂起请求指针 */ net_pending_t *p; + /* 登记时刻（tick） */ uint32_t now; + /* 描述符越界 → BADF */ if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) { s_net_errno = NET_ERR_BADF; return -1; } + /* 取挂起请求 */ p = &s_net_pending[sockfd]; + /* 同 fd 已有挂起：拒绝（覆盖将丢失前通知 = 该任务永久挂死） */ if (p->active != 0U) { s_net_errno = NET_ERR_BUSY; return -1; } + /* netTask 自身发起：无他人可完成（tick 跑在 netTask 内）→ 拒绝（自等死锁） */ if ((caller == NULL) || (caller == s_net_task_handle)) { s_net_errno = NET_ERR_BUSY; return -1; } + /* 当前 tick（截止/看门狗基准） */ now = HAL_GetTick(); + /* 标记挂起在位 */ p->active = 1U; + /* 调用方接收缓冲（须保持有效至完成） */ p->buf = buf; + /* 缓冲容量 */ p->len = len; + /* 截止时刻 = 登记时刻 + 预算 */ p->deadline = now + to_ms; + /* 登记时刻（看门狗基准） */ p->registered = now; + /* 完成通知目标 */ p->caller = caller; + /* 登记成功：分派跳过即时通知 */ return NET_PENDING_REGISTERED; } /* * 函数功能：挂起 recv 完成检查（netTask 每轮 net_process_messages 调用一次，非阻塞） + * 入口参数：无 + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文 + * 函数说明：1. 逐 fd 检查完成条件：数据到达 / 到点（deadline）/ 断连 + * 2. 完成即经 net_pending_complete 通知并清除；看门狗（NET_PENDING_WATCHDOG_MS）超时强制了结 */ static void net_pending_tick(void) { + /* 当前 tick */ uint32_t now = HAL_GetTick(); + /* Socket 循环索引 */ int i; for (i = 0; i < NET_MAX_SOCKETS; i++) { + /* 本 fd 挂起请求 */ net_pending_t *p = &s_net_pending[i]; + /* 本 fd 控制块 */ net_sock_t *p_sock = &s_net_socks[i]; + /* 无挂起请求：跳过 */ if (p->active == 0U) { continue; } + /* fd 已关闭 */ if (p_sock->in_use == 0U) { /* fd 已关闭（正常路径在 close 内先了结；此处兜底，防任何路径漏结） */ net_pending_complete(i, NET_ERR_CONNRESET); @@ -1786,48 +2099,70 @@ static void net_pending_tick(void) { /* ① 数据到达（数据优先，与旧自旋一致） */ if ((p_sock->state == NET_SOCK_STATE_ESTABLISHED) || (p_sock->state == NET_SOCK_STATE_UDP_OPEN)) { + /* 可读标志置位 */ if (p_sock->readable != 0U) { + /* 查询芯片侧可用字节数 */ int avail = ch395f_get_recv_len((uint8_t)i); + /* 有数据 */ if (avail > 0) { + /* 本次读取量 = min(可用, 缓冲容量) */ int rd = (avail > p->len) ? p->len : avail; + /* 读入调用方缓冲区 */ ch395f_read_recv_buf((uint8_t)i, (uint8_t *)p->buf, (uint16_t)rd); + /* 累计接收字节统计 */ p_sock->recv_bytes += (uint32_t)rd; + /* 数据已消费，清可读标志 */ p_sock->readable = 0U; + /* 了结：以字节数通知 */ net_pending_complete(i, rd); continue; } - p_sock->readable = 0U; /* 虚假标志：缓冲无数据，继续等待 */ + /* 虚假标志：缓冲无数据，继续等待 */ + p_sock->readable = 0U; } } /* ② 到点（tick 差值按有符号比较，抗回绕） */ if ((int32_t)(now - p->deadline) >= 0) { + /* 置 TIMEDOUT（同步 errno） */ s_net_errno = NET_ERR_TIMEDOUT; + /* 了结：超时 */ net_pending_complete(i, NET_ERR_TIMEDOUT); continue; } /* ③ 断连：排空 → 数据或 EOF(0) + 自动重监听 */ if (p_sock->state == NET_SOCK_STATE_CLOSED) { + /* 查询残留字节数 */ int rem = ch395f_get_recv_len((uint8_t)i); + /* 有残留数据：按数据完成 */ if (rem > 0) { + /* 本次读取量 = min(残留, 缓冲容量) */ int rd = (rem > p->len) ? p->len : rem; + /* 读入调用方缓冲区 */ ch395f_read_recv_buf((uint8_t)i, (uint8_t *)p->buf, (uint16_t)rd); + /* 累计接收字节统计 */ p_sock->recv_bytes += (uint32_t)rd; + /* 数据已消费，清可读标志 */ p_sock->readable = 0U; + /* 了结：以字节数通知 */ net_pending_complete(i, rd); } else { + /* 启用自动重监听：先把监听器重新置回 LISTEN */ if (p_sock->auto_relisten != 0U) { - (void)net_relisten_try(p_sock); /* 非阻塞：失败由重试轮询接管 */ + /* 非阻塞：失败由 D10 重试轮询接管 */ + (void)net_relisten_try(p_sock); } - /* Trap 23 待办 #3：异常释放（TIMEOUT/RST）不是正常 EOF——对端未发 - * 正常 FIN → 以连接重置了结，应用（lftpd STOR）对异常结束回 5xx - * 而非误报 226；正常 FIN（DISCONNECT）仍回 0（FTP STOR 无长度声明， - * 在途 FIN 与正常完成不可区分——协议边界，见 Trap 23 记录） */ + /* Trap 23 待办 #3：异常释放（TIMEOUT/RST）不是正常 EOF（对端未发正常 FIN） + * → 以连接重置了结：应用（lftpd STOR）对异常结束回 5xx 而非误报 226； + * 正常 FIN（DISCONNECT）仍回 0（在途 FIN 与正常完成不可区分——协议边界，见 Trap 23 记录） */ + /* 异常释放：以连接重置了结（回 5xx，不误报 226） */ if (p_sock->released_abnormal != 0U) { + /* 置 CONNRESET（同步 errno） */ s_net_errno = NET_ERR_CONNRESET; net_pending_complete(i, NET_ERR_CONNRESET); } else { + /* 正常 EOF：以 0 了结 */ net_pending_complete(i, 0); } } @@ -1838,9 +2173,12 @@ static void net_pending_tick(void) { /* ④ 看门狗：到点 + 裕量仍未了结 = 完成逻辑缺位 → 强制了结并留痕 */ if ((int32_t)(now - p->deadline) >= (int32_t)NET_PENDING_WATCHDOG_MS) { + /* 强制了结留痕（超截止时刻的毫秒数） */ DBG_ERROR("sock%d pending recv stuck %ums past deadline (force settle)", i, (unsigned)((int32_t)now - (int32_t)p->deadline)); + /* 置 TIMEDOUT（同步 errno） */ s_net_errno = NET_ERR_TIMEDOUT; + /* 强制了结：超时 */ net_pending_complete(i, NET_ERR_TIMEDOUT); } } @@ -1849,13 +2187,18 @@ static void net_pending_tick(void) { /* * 函数功能：清除本 fd 的挂起请求（不通知；用于"新 fd 不得继承"与 close 后的幂等清理） * 入口参数：sockfd - Socket 描述符 (0~7) int + * 出口参数：无 * 返回值：无 * 限定条件：无 + * 函数说明：1. 静默清理不发通知：close 路径先经 settle 通知，本调用仅保证状态归零（幂等） + * 2. 新建 fd 时调用，防复用槽位继承上一条连接的挂起请求 */ static void net_pending_clear(int sockfd) { + /* 描述符越界：直接返回 */ if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) { return; } + /* 挂起状态清零（静默，不发通知） */ s_net_pending[sockfd].active = 0U; } @@ -1863,21 +2206,28 @@ static void net_pending_clear(int sockfd) { * 函数功能：取消本 fd 的挂起请求并通知调用方（显式路径：陈旧 resync 等） * 入口参数：sockfd - Socket 描述符 (0~7) int * err - 通知的错误码（如 NET_ERR_CONNRESET） int + * 出口参数：无 * 返回值：无（无在位挂起时静默返回） * 限定条件：netTask 上下文 + * 函数说明：经 net_pending_complete 以指定错误码通知调用方（取消必通知，防挂死） */ static void net_pending_cancel(int sockfd, int err) { - net_pending_complete(sockfd, err); /* complete 内部校验范围与在位 */ + /* complete 内部校验范围与在位（未在位则静默返回） */ + net_pending_complete(sockfd, err); } /* * 函数功能：取消全部挂起请求并逐一通知（网络重建路径） * 入口参数：err - 通知的错误码 int + * 出口参数：无 * 返回值：无 * 限定条件：netTask 上下文；须在控制块清零与芯片复位之前调用 + * 函数说明：网络重建（net_stack_bring_up）前调用，保证所有在位调用方均被唤醒 */ static void net_pending_cancel_all(int err) { + /* 逐 fd 遍历 */ for (int i = 0; i < NET_MAX_SOCKETS; i++) { + /* 取消并通知（未在位则静默跳过） */ net_pending_complete(i, err); } } @@ -1885,28 +2235,42 @@ static void net_pending_cancel_all(int err) { /* * 函数功能：关闭前了结本 fd 的挂起 recv（per-fd 串行：先完成、再关闭） * 入口参数：p_sock - 将被关闭的 Socket 控制块指针 net_sock_t * + * 出口参数：无 * 返回值：无（无在位挂起时静默返回） * 限定条件：netTask 上下文；须在 ch395f_close_socket 之前调用 * 函数说明：先排空尝试——关闭不丢已到达数据（芯片缓冲在 close 前可读）； * 有数据按字节数通知，否则取消（NET_ERR_CONNRESET） */ static void net_pending_settle_close(net_sock_t *p_sock) { + /* 由控制块指针反推描述符 */ int sockfd = (int)(p_sock - s_net_socks); + /* 通知用结果值（默认为取消） */ int val; + /* 芯片 RX 可用字节数 */ int avail; + /* 无在位挂起：静默返回 */ if (s_net_pending[sockfd].active == 0U) { return; } + /* 默认结果 = 取消（CONNRESET） */ val = NET_ERR_CONNRESET; + /* 查询芯片 RX 可用字节（缓冲内数据在 close 前可读） */ avail = ch395f_get_recv_len((uint8_t)sockfd); + /* 数据已到达：排空，关闭不丢数据 */ if (avail > 0) { + /* 本次读取量 = min(可用, 缓冲容量) */ int rd = (avail > s_net_pending[sockfd].len) ? s_net_pending[sockfd].len : avail; + /* 读入调用方缓冲区 */ ch395f_read_recv_buf((uint8_t)sockfd, (uint8_t *)s_net_pending[sockfd].buf, (uint16_t)rd); + /* 累计接收字节统计 */ p_sock->recv_bytes += (uint32_t)rd; + /* 数据已消费，清可读标志 */ p_sock->readable = 0U; + /* 有数据：以字节数通知 */ val = rd; } + /* 了结（必通知） */ net_pending_complete(sockfd, val); } @@ -1921,38 +2285,50 @@ static void net_pending_settle_close(net_sock_t *p_sock) { * 2. 等待芯片回到 CLOSED 状态（超时 500ms），再清零控制块 */ static int net_close_locked(net_sock_t *p_sock) { + /* 由控制块指针反推描述符 */ int sockfd = (int)(p_sock - s_net_socks); + /* 起始时刻（等芯片 CLOSED 的 500ms 上限基准） */ uint32_t tick = HAL_GetTick(); /* L3：先了结本 fd 的挂起 recv（排空/取消 + 必通知），再关芯片 Socket * ——关闭不得让等待中的调用方永久悬挂 */ net_pending_settle_close(p_sock); + /* 关闭芯片侧 Socket */ ch395f_close_socket(sockfd); - /* 排空上一条连接残留的 DISCONNECT 中断（单连接模式仅有 Socket 0， - * 复用同一 Socket 时，旧连接的 DISCONNECT 在 FIN/ACK 完成后才上报， - * 若不清除会被下一连接误判为"刚建立就断开"）。等待芯片回到 CLOSED - * 并清掉 Socket/全局中断状态，避免事件串扰。 - */ + /* 排空上一条连接残留的 DISCONNECT 中断（单连接模式仅 Socket 0；复用同一 Socket 时 + * 旧 DISCONNECT 在 FIN/ACK 完成后才上报，不清除会被下一连接误判为"刚建立就断开"） + * 等待芯片回到 CLOSED 并清掉 Socket/全局中断状态，避免事件串扰 */ do { - uint8_t st[2] = {0, 0}; /* [0]=Socket 状态 [1]=TCP 状态（该 API 输出 2 字节） */ + /* [0]=Socket 状态 [1]=TCP 状态（该 API 输出 2 字节） */ + uint8_t st[2] = {0, 0}; + /* 读芯片状态（两字节） */ ch395f_get_socket_status((uint8_t)sockfd, st); + /* 读即清：本 Socket 中断状态 */ (void)ch395f_get_sock_int_status((uint8_t)sockfd); + /* 读即清：全局中断状态 */ (void)ch395f_get_glob_int_status_all(); + /* 芯片已回 CLOSED：结束 */ if (st[0] == CH395F_SOCKET_CLOSED) { break; } + /* 等待超时（500ms）：停止等待继续 */ if (HAL_GetTick() - tick > 500) { break; } + /* 等 5ms 再查（循环受 500ms 上限约束） */ osDelay(5); } while (1); + /* 清零控制块（memset 0 = 释放本 fd 全部状态） */ memset(p_sock, 0, sizeof(net_sock_t)); - net_relisten_clear(sockfd); /* 关闭即取消该 fd 的待重试（D10 重试队列） */ - net_pending_clear(sockfd); /* 关闭即清除该 fd 的挂起状态（L3；幂等） */ + /* 关闭即取消该 fd 的待重试（D10 重试队列） */ + net_relisten_clear(sockfd); + /* 关闭即清除该 fd 的挂起状态（L3；幂等） */ + net_pending_clear(sockfd); + /* 关闭成功 */ return 0; } @@ -1962,53 +2338,68 @@ static int net_close_locked(net_sock_t *p_sock) { * buf - 待发送数据缓冲区指针（调用返回前须保持有效，本函数不拷贝数据） const void * * len - 数据长度（字节），> 0 int * flags - 标志位，当前实现忽略（保留 BSD send 接口兼容） int + * 出口参数：无 * 返回值：实际发送字节数 int >= 0 || -1 * -1 - 发送失败（参数非法 / 消息队列入队失败 / netTask 侧发送错误） int - * 限定条件：1. 必须在【非 netTask】上下文中调用（应用/测试任务）；若在 netTask 内调用会自己等自己 - * （netTask 阻塞在 xTaskNotifyWait 而无人处理消息）→ 死锁。netTask 内请直接用 net_send_locked()。 - * 2. Socket 须处于 ESTABLISHED 状态；net_init() + MX_FREERTOS_Init() 已执行； - * netMsgQueueHandle 已由 net_init 创建。 - * 函数说明：所有 CH395F SPI 访问只允许在 netTask 内串行执行（见 Trap 16）。本函数作为应用侧 API， - * 自身不直接触碰 SPI，而是把发送请求打包成 net_msg_t 投递到 netMsgQueueHandle，由 netTask - * 的 net_process_messages() 取出并在 netTask 上下文调用 net_send_locked() 真正写 CH395F。 - * 调用方通过 FreeRTOS TaskNotify 阻塞等待处理结果，从而对外呈现"同步发送"语义： - * 函数返回即代表本次发送已被 netTask 处理完毕（成功或失败）。 + * 限定条件：1. 必须在【非 netTask】上下文中调用（应用/测试任务）；若在 netTask 内调用会自己等自己 → 死锁 + * （netTask 阻塞在 xTaskNotifyWait 而无人处理消息）；netTask 内请直接用 net_send_locked() + * 2. Socket 须处于 ESTABLISHED 状态 + * 3. net_init() + MX_FREERTOS_Init() 已执行，netMsgQueueHandle 已由 net_init 创建 + * 函数说明：1. 所有 CH395F SPI 访问只允许在 netTask 内串行执行（见 Trap 16） + * 2. 本函数不直接触碰 SPI，而是把发送请求打包成 net_msg_t 投递到 netMsgQueueHandle + * 3. netTask 的 net_process_messages() 取出并在 netTask 上下文调用 net_send_locked() 真正写 CH395F + * 4. 调用方经 FreeRTOS TaskNotify 阻塞等待处理结果，对外呈现"同步发送"语义 + * 5. 函数返回 = 本次发送已被 netTask 处理完毕（成功或失败） */ int net_send(int sockfd, const void *buf, int len, int flags) { - (void)flags; /* flags 当前未使用，显式 void 以消除未用参数告警 */ - net_msg_t msg; /* 一次性消息结构体；入队后由 netTask 取出处理（注意只传指针不拷贝数据） */ + /* flags 当前未使用，显式 void 以消除未用参数告警 */ + (void)flags; + /* 一次性消息结构体；入队后由 netTask 取出处理（注意只传指针不拷贝数据） */ + net_msg_t msg; /* ---- 1. 参数合法性检查 ---- */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { - s_net_errno = NET_ERR_BADF; /* 描述符越界 */ + /* 描述符越界 */ + s_net_errno = NET_ERR_BADF; return -1; } /* ---- 2. 运行环境检查：消息队列须已创建（网络层已初始化） ---- */ if (netMsgQueueHandle == NULL) { - s_net_errno = NET_ERR; /* 网络层未初始化 */ + /* 网络层未初始化 */ + s_net_errno = NET_ERR; return -1; } /* ---- 3. 组装消息：把本次 send 的全部上下文填入 msg ---- */ - msg.type = NET_MSG_SEND; /* 消息类型，netTask 据此分派到 net_send_locked */ - msg.sockfd = sockfd; /* 目标 Socket */ - msg.buf = (void *)buf; /* 数据缓冲（队列仅拷贝指针，buf 须有效至函数返回） */ - msg.len = len; /* 待发送字节数 */ - msg.flags = 0; /* 实际标志位（忽略入参 flags） */ - msg.timeout_ms = 0U; /* 发送不使用超时字段 */ - msg.caller = xTaskGetCurrentTaskHandle(); /* 记录调用任务句柄，供 netTask 回执时精准通知 */ - msg.result = -1; /* 预置失败；netTask 处理成功后会改写为实际发送字节数 */ + /* 消息类型，netTask 据此分派到 net_send_locked */ + msg.type = NET_MSG_SEND; + /* 目标 Socket */ + msg.sockfd = sockfd; + /* 数据缓冲（队列仅拷贝指针，buf 须有效至函数返回） */ + msg.buf = (void *)buf; + /* 待发送字节数 */ + msg.len = len; + /* 实际标志位（忽略入参 flags） */ + msg.flags = 0; + /* 发送不使用超时字段 */ + msg.timeout_ms = 0U; + /* 记录调用任务句柄，供 netTask 回执时精准通知 */ + msg.caller = xTaskGetCurrentTaskHandle(); + /* 预置失败；netTask 处理成功后会改写为实际发送字节数 */ + msg.result = -1; /* ---- 4. 入队：将消息投递给 netTask，osWaitForever 表示队列满时阻塞调用方 ---- */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { - s_net_errno = NET_ERR_BUSY; /* 入队失败（队列异常等极端情况） */ + /* 入队失败（队列异常等极端情况） */ + s_net_errno = NET_ERR_BUSY; return -1; } /* ---- 5. 阻塞等待 netTask 处理完毕：netTask 调 net_send_locked 后通过 * xTaskNotify() 唤醒本任务，并把结果（实际发送字节数或 -1）作为通知值传回 ---- */ - msg.result = net_wait_result("snd", sockfd); /* 两段式等待（防丢失通知，见 net_wait_result） */ + /* 两段式等待（防丢失通知，见 net_wait_result） */ + msg.result = net_wait_result("snd", sockfd); /* ---- 6. 结果回传：负数视为错误并设置线程级错误码；否则返回实际发送字节数 ---- */ if (msg.result < 0) { @@ -2017,6 +2408,7 @@ int net_send(int sockfd, const void *buf, int len, int flags) { s_net_errno = msg.result; return -1; } + /* 返回实际发送字节数 */ return msg.result; } @@ -2026,6 +2418,7 @@ int net_send(int sockfd, const void *buf, int len, int flags) { * buf - 接收缓冲区指针 void * * len - 缓冲区大小 int > 0 * flags - 标志位，0=阻塞，NET_MSG_DONTWAIT=非阻塞 int + * 出口参数：无 * 返回值：实际接收字节数 int >= 0 || 0 || -1 * 0 - 对端关闭连接 int * -1 - 接收失败（参数无效、队列满等） int @@ -2033,32 +2426,46 @@ int net_send(int sockfd, const void *buf, int len, int flags) { * 函数说明：将接收请求放入消息队列，阻塞等待 netTask 处理完毕并返回结果。netTask 内请使用 net_recv_sock() */ int net_recv(int sockfd, void *buf, int len, int flags) { + /* 一次性消息结构体（队列按值存结构副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：接收数据 */ msg.type = NET_MSG_RECV; + /* 目标 Socket */ msg.sockfd = sockfd; + /* 接收缓冲（队列仅拷贝指针，缓冲须有效至调用返回） */ msg.buf = buf; + /* 缓冲容量 */ msg.len = len; + /* 标志：0=阻塞，NET_MSG_DONTWAIT=非阻塞 */ msg.flags = flags; + /* 0 = 默认超时预算（netTask 侧用 NET_RECV_TIMEOUT_MS） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("rcv", sockfd); if (msg.result < 0) { @@ -2067,6 +2474,7 @@ int net_recv(int sockfd, void *buf, int len, int flags) { s_net_errno = msg.result; return -1; } + /* 返回结果（接收字节数；0 = EOF） */ return msg.result; } @@ -2075,68 +2483,79 @@ int net_recv(int sockfd, void *buf, int len, int flags) { * 入口参数：sockfd - Socket 描述符 int >= 0 && < NET_MAX_SOCKETS * buf / len - 接收缓冲与容量 void * / int > 0 * timeout_ms - 单次占用 netTask 的最长等待（毫秒，>0） uint32_t + * 出口参数：无 * 返回值：>0 字节数；0 = 对端关闭(EOF)；-1 = 真错误（errno 可查）；**-2 = 超时无数据** * 限定条件：非 netTask 上下文；net 层已初始化 - * 函数说明：E-02 修复配套接口。lftpd 等"等对端下一行/下一块数据"的调用方若用 - * 默认 30s 阻塞 recv，会把 netTask（全部 socket 操作的唯一执行者）长期 - * 占住，导致其余任务的网络操作整体冻结（M3 实测一次空闲 FTP 登录冻结 - * 远端显示 17.7s）。用本接口把等待切成 ≤timeout_ms 的片，调用方自行 - * 累计总预算，从而"总超时语义不变、单次占用有界"。 - * 超时用独立返回码 -2（而非靠 errno 区分）→ 无跨任务 errno 竞态。 + * 函数说明：1. E-02 修复配套接口：lftpd 等"等对端下一行/下一块数据"的调用方 + * 若用默认 30s 阻塞 recv，会把 netTask（全部 socket 操作的唯一执行者）长期占住 + * 2. 导致其余任务的网络操作整体冻结（M3 实测一次空闲 FTP 登录冻结远端显示 17.7s） + * 3. 用本接口把等待切成 ≤timeout_ms 的片，调用方自行累计总预算：总超时语义不变、单次占用有界 + * 4. 超时用独立返回码 -2（而非靠 errno 区分）→ 无跨任务 errno 竞态 */ int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms) { - net_msg_t msg; /* 一次性消息结构体：队列按值存结构副本（仅指针、不拷数据），入队后由 netTask 取出处理 */ + /* 一次性消息结构体：队列按值存结构副本（仅指针、不拷数据），入队后由 netTask 取出处理 */ + net_msg_t msg; /* ---- 1. 参数合法性检查 ---- */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { - s_net_errno = NET_ERR_BADF; /* 描述符越界 */ + /* 描述符越界 */ + s_net_errno = NET_ERR_BADF; return -1; } /* ---- 2. 运行环境检查：消息队列须已创建（网络层已初始化） ---- */ if (netMsgQueueHandle == NULL) { - s_net_errno = NET_ERR; /* 网络层未初始化 */ + /* 网络层未初始化 */ + s_net_errno = NET_ERR; return -1; } /* ---- 3. 分片长度检查：timeout_ms = 0 在 netTask 侧意味着"改用默认 * NET_RECV_TIMEOUT_MS（30 秒）"，恰是本接口要规避的长阻塞，直接拒绝 ---- */ if (timeout_ms == 0U) { - s_net_errno = NET_ERR_INVAL; /* 分片长度必须 > 0 */ + /* 分片长度必须 > 0 */ + s_net_errno = NET_ERR_INVAL; return -1; } /* ---- 4. 组装消息：把本次分片读的全部上下文填入 msg ---- */ - msg.type = NET_MSG_RECV; /* 消息类型，netTask 据此分派到 net_recv_locked */ - msg.sockfd = sockfd; /* 目标 Socket */ - msg.buf = buf; /* 接收缓冲（队列仅拷贝指针，buf 须有效至本函数返回） */ - msg.len = len; /* 缓冲容量：单次读取字节数上限（允许部分读） */ - msg.flags = 0; /* 阻塞式：netTask 侧轮询至"有数据"或"本片超时"（勿置 NET_MSG_DONTWAIT） */ - msg.timeout_ms = timeout_ms; /* 本片预算：netTask 最多等待 timeout_ms，保证对 netTask 的占用有界（E-02） */ - msg.caller = xTaskGetCurrentTaskHandle(); /* 记录调用任务句柄，netTask 处理后经 xTaskNotify() 精准回执 */ - msg.result = -1; /* 预置失败（仅防御值；真实结果经任务通知值回传，见步骤 6） */ + /* 消息类型，netTask 据此分派到 net_recv_locked */ + msg.type = NET_MSG_RECV; + /* 目标 Socket */ + msg.sockfd = sockfd; + /* 接收缓冲（队列仅拷贝指针，buf 须有效至本函数返回） */ + msg.buf = buf; + /* 缓冲容量：单次读取字节数上限（允许部分读） */ + msg.len = len; + /* 阻塞式：netTask 侧轮询至"有数据"或"本片超时"（勿置 NET_MSG_DONTWAIT） */ + msg.flags = 0; + /* 本片预算：netTask 最多等待 timeout_ms，保证对 netTask 的占用有界（E-02） */ + msg.timeout_ms = timeout_ms; + /* 记录调用任务句柄，netTask 处理后经 xTaskNotify() 精准回执 */ + msg.caller = xTaskGetCurrentTaskHandle(); + /* 预置失败（仅防御值；真实结果经任务通知值回传，见步骤 6） */ + msg.result = -1; /* ---- 5. 入队：将消息投递给 netTask，osWaitForever 表示队列满时阻塞调用方 ---- */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { - s_net_errno = NET_ERR_BUSY; /* 入队失败（队列异常等极端情况） */ + /* 入队失败（队列异常等极端情况） */ + s_net_errno = NET_ERR_BUSY; return -1; } - /* ---- 6. 阻塞等待 netTask 处理完毕：netTask 执行 net_recv_locked 后经 - * xTaskNotify() 把结果（字节数 / 0 / 负错误码）以 32 位通知值回传本任务； - * 注意 net_msg_t 按值拷入队列，队列里的 result 字段不会回来—— - * 通知值是唯一的真实回传通道（勿给 net_msg_t 加"回传用"字段） ---- */ - msg.result = net_wait_result("rcv", sockfd); /* 两段式等待：零等待拾取 + 阻塞，防丢失通知（见 net_wait_result） */ + /* ---- 6. 阻塞等待 netTask 处理完毕：netTask 执行 net_recv_locked 后经 xTaskNotify() + * 把结果（字节数 / 0 / 负错误码）以 32 位通知值回传本任务 + * net_msg_t 按值拷入队列，result 字段不会回来——通知值是唯一的真实回传通道（勿加"回传用"字段） ---- */ + /* 两段式等待：零等待拾取 + 阻塞，防丢失通知（见 net_wait_result） */ + msg.result = net_wait_result("rcv", sockfd); /* ---- 7. 回传结果（三分支：分片超时 / 真错误 / 数据或 EOF） ---- */ if (msg.result == NET_ERR_TIMEDOUT) { - /* 本片超时：timeout_ms 内未等到数据，非致命。 - * 超时只凭返回码 -2 判定、不得依赖 errno：s_net_errno 是跨任务共享的 - * 全局量，netTask 处理本片时写入的 NET_ERR_TIMEDOUT 随时可能被其他任务 - * 的 net 调用覆盖；而返回码是 netTask 经任务通知值专为本任务回传的， - * 天然无竞态（本分支也不再改写 s_net_errno）。 - * 调用方见到 -2 后累计自身总超时预算，决定是否发起下一片。 - * （本判断必须先于下方通用 <0 分支：NET_ERR_TIMEDOUT = -9 同样满足 <0） */ + /* 本片超时：timeout_ms 内未等到数据，非致命 → 返回 -2 */ + /* 超时只凭返回码 -2 判定、不得依赖 errno：s_net_errno 是跨任务共享全局量，netTask 写入的值随时可能被其他任务的 net 调用覆盖 */ + /* 返回码是 netTask 经任务通知值专为本任务回传的，天然无竞态（本分支也不再改写 s_net_errno） */ + /* 调用方见到 -2 后累计自身总超时预算，决定是否发起下一片 */ + /* 本判断必须先于下方通用 <0 分支：NET_ERR_TIMEDOUT = -9 同样满足 <0 */ return -2; } if (msg.result < 0) { @@ -2149,12 +2568,14 @@ int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms) { /* >= 0：0 = 对端关闭（EOF，net 层尽力自动重监听，失败由重试轮询接管）； * > 0 = 实际接收字节数（可能小于 len，属正常部分读） */ + /* 返回结果（0=EOF / >0=字节数） */ return msg.result; } /* * 函数功能：关闭 Socket（线程安全版本，通过消息队列委托给 netTask） * 入口参数：sockfd - Socket 描述符 int >= 0 && < NET_MAX_SOCKETS + * 出口参数：无 * 返回值：0 - 关闭成功 int * -1 - 关闭失败 int * 限定条件：Socket 已创建且处于非 CLOSED 状态；net_init() + MX_FREERTOS_Init() 已执行；非 netTask 上下文 @@ -2162,29 +2583,40 @@ int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms) { * netTask 内请使用 net_close_sock() */ int net_close(int sockfd) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：关闭 Socket */ msg.type = NET_MSG_CLOSE; + /* 目标 Socket */ msg.sockfd = sockfd; + /* 无超时（关闭立即完成） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("clo", sockfd); if (msg.result < 0) { @@ -2193,6 +2625,7 @@ int net_close(int sockfd) { s_net_errno = msg.result; return -1; } + /* 关闭成功（0） */ return msg.result; } @@ -2204,29 +2637,40 @@ int net_close(int sockfd) { * flags - 标志位，通常为 0 int * dest_addr - 目标地址结构体指针 const struct net_sockaddr * * addrlen - 目标地址结构体长度 int >= sizeof(struct net_sockaddr_in) + * 出口参数：无 * 返回值：实际发送字节数 int > 0 || -1 * -1 - 发送失败 int * 限定条件：Socket 已创建且为 UDP 类型（SOCK_DGRAM）；net_init() 已调用 + * 函数说明：1. UDP 数据报无需连接：目标地址随消息一并投递 + * 2. 与 net_send 同一消息通道，SPI 访问串行在 netTask */ int net_sendto(int sockfd, const void *buf, int len, int flags, const struct net_sockaddr *dest_addr, int addrlen) { + /* Socket 控制块指针 */ net_sock_t *p_sock; + /* 目标地址（IPv4）强转 */ const struct net_sockaddr_in *p_addr_in; + /* 累计实际发送字节数 */ int sent = 0; + /* 当前等待阶段起始时刻（tick） */ uint32_t tick_start; /* 参数检查 */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { + /* 描述符越界 → BADF */ s_net_errno = NET_ERR_BADF; return -1; } + /* 取控制块 */ p_sock = &s_net_socks[sockfd]; + /* 控制块未在用 → BADF */ if (!p_sock->in_use) { s_net_errno = NET_ERR_BADF; return -1; } + /* 缓冲区无效 → INVAL */ if (buf == NULL || len <= 0) { s_net_errno = NET_ERR_INVAL; return -1; @@ -2234,50 +2678,70 @@ int net_sendto(int sockfd, const void *buf, int len, int flags, /* UDP 模式：设置目标地址 */ if (dest_addr != NULL && addrlen >= (int)sizeof(struct net_sockaddr_in)) { + /* 强转为 IPv4 地址结构体 */ p_addr_in = (const struct net_sockaddr_in *)dest_addr; /* 转换 IP 为大端数组（同 TCP 客户端，set_des_ip 期望大端） */ + /* 大端 IP 数组 */ uint8_t ip_arr[4]; + /* 目的 IP（网络序 32 位） */ uint32_t ip = p_addr_in->sin_addr.s_addr; + /* 最高字节 → [0]（大端序） */ ip_arr[0] = (uint8_t)(ip >> 24); ip_arr[1] = (uint8_t)(ip >> 16); ip_arr[2] = (uint8_t)(ip >> 8); + /* 最低字节 → [3] */ ip_arr[3] = (uint8_t)(ip); + /* 设置目的 IP */ ch395f_set_des_ip(sockfd, ip_arr); + /* 设置目的端口（网络序 → 主机序） */ ch395f_set_des_port(sockfd, net_ntohs(p_addr_in->sin_port)); } + /* 记录起始时刻（用于停滞超时判定） */ tick_start = HAL_GetTick(); - /* 发送数据 */ + /* 分块发送循环 */ while (sent < len) { + /* 剩余待发字节 */ int chunk = len - sent; + /* 单块以硬件发送缓冲为上限（Trap 20） */ if (chunk > NET_SEND_CHUNK_MAX) { chunk = NET_SEND_CHUNK_MAX; } - /* 检查发送缓冲区 */ + /* 发送缓冲未空：等待腾出 */ if (!p_sock->send_ready) { + /* 停滞超时 */ if (NET_SEND_TIMEOUT_MS > 0 && (HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) { DBG_ERROR("sock%d send stall: send_ready not set (%d/%d)", sockfd, sent, len); s_net_errno = NET_ERR_TIMEDOUT; break; } + /* 轮询一次，下一轮再试 */ net_poll(); continue; } + /* 本块写入芯片发送 FIFO */ ch395f_write_send_buf(sockfd, (uint8_t *)buf + sent, (uint16_t)chunk); + /* 标记发送缓冲占用中 */ p_sock->send_ready = 0; + /* 累计发送偏移 */ sent += chunk; + /* 累计发送字节统计 */ p_sock->send_bytes += (uint32_t)chunk; /* 等待发送完成 */ + /* 重置本等待阶段计时 */ tick_start = HAL_GetTick(); + /* 等待本块发完（SENBUF_FREE 中断重新置 send_ready） */ while (!p_sock->send_ready) { + /* 轮询：处理 SEND_OK/SENBUF_FREE 中断 */ net_poll(); + /* 等待超时：本块放弃（外层统一处理） */ if (NET_SEND_TIMEOUT_MS > 0 && (HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) { break; @@ -2285,11 +2749,13 @@ int net_sendto(int sockfd, const void *buf, int len, int flags, } } + /* 发送未完成 = 短写 */ if (sent < len) { /* 短写告警：调用方必须检查返回值。静默截断会让对端永久等待剩余字节 * （2026-09-21 实证：UI 推流应答被截断 → 客户端反复判定"全程无字节"失联）。 */ DBG_ERROR("sock%d short send %d/%d (errno=%d)", sockfd, sent, len, s_net_errno); } + /* 返回实际发送字节数（调用方必须检查） */ return sent; } /* @@ -2298,73 +2764,101 @@ int net_sendto(int sockfd, const void *buf, int len, int flags, * buf - 接收缓冲区指针 void * * len - 缓冲区大小 int > 0 * flags - 标志位，通常为 0 int - * src_addr - 输出：发送方地址结构体指针 struct net_sockaddr *（可为 NULL） + * 出口参数：src_addr - 输出：发送方地址结构体指针 struct net_sockaddr *（可为 NULL） * addrlen - 输入输出：源地址长度 int *（可为 NULL） * 返回值：实际接收字节数 int >= 0 || -1 * -1 - 接收失败 int * 限定条件：Socket 已创建且为 UDP 类型（SOCK_DGRAM）；net_init() 已调用；有数据可用 + * 函数说明：1. 轮询检查芯片接收缓冲（net_poll + get_recv_len），有数据即返回 + * 2. UDP 数据报前 8 字节为报文头（源端口+源 IP），据此填充 src_addr + * 3. 无数据时：DONTWAIT 立即返回 -1（WOULDBLOCK）；默认等待 NET_RECV_TIMEOUT_MS 后返回 TIMEDOUT */ int net_recvfrom(int sockfd, void *buf, int len, int flags, struct net_sockaddr *src_addr, int *addrlen) { + /* Socket 控制块指针 */ net_sock_t *p_sock; + /* 起始时刻（超时判定基准，tick） */ uint32_t tick_start; /* 参数检查 */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { + /* 描述符越界 → BADF */ s_net_errno = NET_ERR_BADF; return -1; } + /* 取控制块 */ p_sock = &s_net_socks[sockfd]; + /* 控制块未在用 → BADF */ if (!p_sock->in_use) { s_net_errno = NET_ERR_BADF; return -1; } + /* 缓冲区无效 → INVAL */ if (buf == NULL || len <= 0) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 记录起始时刻（超时基准） */ tick_start = HAL_GetTick(); + /* 轮询直到：有数据 / 非阻塞 / 超时 */ while (1) { + /* 轮询一次：更新状态机与可读标志 */ net_poll(); + /* 查询芯片侧可用字节数 */ int recv_len = ch395f_get_recv_len(sockfd); + /* 有数据 */ if (recv_len > 0) { /* UDP Server 模式：前 8 字节为固定格式（IP + 端口 + 长度）*/ + /* UDP 数据报：解析 8 字节报文头 */ if (p_sock->type == NET_SOCK_DGRAM && recv_len >= 8) { + /* 8 字节报文头 */ uint8_t header[8]; + /* 读出报文头（剥头 = 消费芯片缓冲） */ ch395f_read_recv_buf(sockfd, header, 8); + /* 数据长度 = 总长 - 头长 */ recv_len -= 8; /* 填充来源地址 */ if (src_addr != NULL &&addrlen != NULL && *addrlen >= (int)sizeof(struct net_sockaddr_in)) { + /* 强转为 IPv4 地址结构体 */ struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)src_addr; + /* 地址族 = IPv4 */ p_addr_in->sin_family = NET_AF_INET; /* CH395F UDP 头 [0-1] reserved [2-3] src_port(LE) [4-7] src_ip */ + /* 源端口（小端 2 字节 → 主机序 → 网络序） */ p_addr_in->sin_port = net_htons((uint16_t)(header[2] | (header[3] << 8))); + /* 源 IP（小端 4 字节组装为网络序） */ p_addr_in->sin_addr.s_addr = ((uint32_t)header[4]) | ((uint32_t)header[5] << 8) | ((uint32_t)header[6] << 16) | ((uint32_t)header[7] << 24); + /* 回填结构体长度 */ *addrlen = sizeof(struct net_sockaddr_in); } } /* 读取数据 */ if (recv_len > 0) { + /* 本次读取量 = min(可用, 缓冲容量) */ int read_len = (recv_len > len) ? len : recv_len; + /* 读入调用方缓冲区 */ ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)read_len); + /* 累计接收字节统计 */ p_sock->recv_bytes += (uint32_t)read_len; + /* 返回本次读出字节数 */ return read_len; } } - /* 非阻塞模式检查 */ + /* 非阻塞模式：无数据立即返回 */ if (flags & NET_MSG_DONTWAIT) { + /* 置 WOULDBLOCK */ s_net_errno = NET_ERR_WOULDBLOCK; return -1; } @@ -2372,15 +2866,13 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags, /* 超时检查 */ if (NET_RECV_TIMEOUT_MS > 0 && (HAL_GetTick() - tick_start) >= NET_RECV_TIMEOUT_MS) { + /* 置 TIMEDOUT */ s_net_errno = NET_ERR_TIMEDOUT; return -1; } } } -/* - * 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用） - */ /* * 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用） * 入口参数：p_sock - Socket 控制块指针 net_sock_t * @@ -2392,10 +2884,12 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags, * 函数说明：直接调用 net_send_locked 完成发送 */ int net_send_sock(net_sock_t *p_sock, const void *buf, int len) { + /* 控制块指针为空 → BADF */ if (p_sock == NULL) { s_net_errno = NET_ERR_BADF; return -1; } + /* 直接委托锁定实现（netTask 上下文，无队列往返） */ return net_send_locked(p_sock, buf, len); } /* @@ -2404,35 +2898,42 @@ int net_send_sock(net_sock_t *p_sock, const void *buf, int len) { * buf - 接收缓冲区指针 void * * len - 缓冲区大小 int > 0 * flags - 标志位，NET_MSG_DONTWAIT=非阻塞 int + * 出口参数：buf - 填充接收到的数据 * 返回值：实际接收字节数 int >= 0 || 0 || -1 * 0 - 对端关闭连接 int * -1 - 接收失败 int * 限定条件：必须在 netTask 上下文中调用；p_sock->in_use == 1 - * 函数说明：直接操作 Socket 控制块，不经过消息队列。避免 netTask 向自身发送消息造成死锁 - * （L3 后：netTask 上下文的阻塞等待会被挂起登记拒绝——自通知死锁， - * 本函数阻塞用法仅对 DONTWAIT 有效） + * 函数说明：1. 直接操作 Socket 控制块，不经过消息队列。避免 netTask 向自身发送消息造成死锁 + * 2. L3 后：netTask 上下文的阻塞等待会被挂起登记拒绝（自通知死锁） + * 3. 本函数阻塞用法仅对 DONTWAIT 有效 */ int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags) { + /* 控制块指针为空 → BADF */ if (p_sock == NULL) { s_net_errno = NET_ERR_BADF; return -1; } - return net_recv_locked(p_sock, buf, len, flags, 0U, /* 0 = 默认 NET_RECV_TIMEOUT_MS */ + /* 直接委托锁定实现（netTask 上下文，无队列往返）； + * 0 = 默认 NET_RECV_TIMEOUT_MS；caller = netTask 自身（自调用） */ + return net_recv_locked(p_sock, buf, len, flags, 0U, xTaskGetCurrentTaskHandle()); } /* * 函数功能：关闭 Socket（内部版本，绕过消息队列，供 netTask 直接使用） * 入口参数：p_sock - Socket 控制块指针 net_sock_t * + * 出口参数：无 * 返回值：0 - 关闭成功 int * -1 - 关闭失败 int * 限定条件：必须在 netTask 上下文中调用；p_sock->in_use == 1 * 函数说明：直接操作 Socket 控制块，不经过消息队列。TCP Socket 先断开连接再释放控制块 */ int net_close_sock(net_sock_t *p_sock) { + /* 控制块指针为空 → BADF */ if (p_sock == NULL) { s_net_errno = NET_ERR_BADF; return -1; } + /* 直接委托锁定实现（netTask 上下文，无队列往返） */ return net_close_locked(p_sock); } /* @@ -2440,142 +2941,189 @@ int net_close_sock(net_sock_t *p_sock) { * 入口参数：sockfd - Socket 描述符 int >= 0 && < NET_MAX_SOCKETS * cb - 回调函数指针 net_event_cb_t（可为 NULL 取消注册） * arg - 用户自定义参数指针 void * + * 出口参数：无 * 返回值：0 - 注册成功 int * -1 - 注册失败 int * 限定条件：Socket 已创建且 in_use == 1；net_init() 已调用 + * 函数说明：1. 回调在 netTask 上下文触发（事件分派路径内），实现须短小且不得阻塞 + * 2. cb 传 NULL 可取消注册 */ int net_set_event_cb(int sockfd, net_event_cb_t cb, void *arg) { + /* Socket 控制块指针 */ net_sock_t *p_sock; /* 参数检查 */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { + /* 描述符越界 → BADF */ s_net_errno = NET_ERR_BADF; return -1; } + /* 取控制块 */ p_sock = &s_net_socks[sockfd]; + /* 控制块未在用 → BADF */ if (!p_sock->in_use) { s_net_errno = NET_ERR_BADF; return -1; } + /* 注册回调函数（NULL = 取消注册） */ p_sock->event_cb = cb; + /* 注册用户自定义参数 */ p_sock->event_arg = arg; + /* 注册成功 */ return 0; } /* * 函数功能：获取 Socket 最后一次操作返回的错误码 + * 入口参数：无 + * 出口参数：无 * 返回值：当前错误码值（NET_OK=0, NET_ERR_xxx=-N） int * 限定条件：无 * 函数说明：每次 net_*() API 调用失败后，错误码被设置。调用成功时不自动清零 */ int net_get_errno(void) { + /* 返回当前错误码（只读快照，成功时不自动清零） */ return s_net_errno; } /* * 函数功能：查询 Socket 当前状态（只读，无锁） * 入口参数：sockfd - Socket 描述符 int + * 出口参数：无 * 返回值：状态值（net_sock_state_t）；描述符无效/未占用 → -1 * 限定条件：无（单字节读，无撕裂；值可能滞后于 netTask 的最新状态） - * 函数说明：跨任务只读快照。典型用途——检测"芯片静默回收"失步 - * （2026-09-22 台架实证：peer 发 FIN 后芯片自行把 Socket 回收 - * 回 LISTEN 且不发 DISCONNECT 中断 → MCU 侧状态滞留 ESTABLISHED - * → 新连接字节被旧会话吞掉）；上层可据此执行 close+listen 重同步 + * 函数说明：1. 跨任务只读快照；典型用途：检测"芯片静默回收"失步（2026-09-22 台架实证） + * 2. peer 发 FIN 后芯片自行把 Socket 回收回 LISTEN 且不发 DISCONNECT 中断 + * 3. MCU 侧状态滞留 ESTABLISHED → 新连接字节被旧会话吞掉 + * 4. 上层可据此执行 close+listen 重同步 */ int net_sock_state(int sockfd) { + /* 描述符越界：返回 -1（不设错误码，只读查询） */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { return -1; } + /* 控制块未在用：返回 -1 */ if (!s_net_socks[sockfd].in_use) { return -1; } + /* 返回状态快照（单字节读，无撕裂；值可能滞后于 netTask 最新状态） */ return (int)s_net_socks[sockfd].state; } /* * 函数功能：断连重同步（仅 MCU 侧状态，见头文件注释的适用场景） * 入口参数：sockfd - Socket 描述符 int + * 出口参数：无 * 返回值：0 - 已同步/原本即一致；-1 - 失败 * 限定条件：连接已死且芯片已静默回收后调用（应用层判定） + * 函数说明：1. 适用：芯片已静默回收连接（无 DISCONNECT 中断）而本层状态滞留 ESTABLISHED + * 2. 状态收回 LISTENING 并重建监听，后续 accept 恢复正常 */ int net_resync_listen(int sockfd) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：断连重同步（MCU 侧收回 LISTENING 并重建监听） */ msg.type = NET_MSG_RESYNC_LISTEN; + /* 目标 Socket */ msg.sockfd = sockfd; + /* 无超时（重同步立即完成） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("rsl", sockfd); + /* 失败：恢复 errno（对外统一 -1） */ if (msg.result < 0) { s_net_errno = msg.result; return -1; } + /* 重同步成功（0） */ return 0; } /* * 函数功能：无条件重新监听（芯片侧 open+listen，含 Trap 09 失败重试） * 入口参数：sockfd - Socket 描述符 int + * 出口参数：无 * 返回值：0 - 成功；-1 - 失败 * 限定条件：TCP 监听型 Socket；net_init() 已完成 - * 函数说明：用于"断连后监听器可能已失位"的自愈场景（2026-09-22 run9 实证： - * 一次性 net_listen 落在 Trap 09 窗口失败且被静默忽略 → 监听器 - * 永久丢失 → 后续连接全部拒绝）。与 auto_relisten 内部路径同一 - * 实现（net_relisten_locked：3 次 open 尝试，失败则 close+500ms 重试）。 - * 芯片侧已在监听时：首次 open 失败 → close 重建 → 监听短暂中断 ~1s。 + * 函数说明：1. 用于"断连后监听器可能已失位"的自愈场景（2026-09-22 run9 实证） + * 2. 一次性 net_listen 落在 Trap 09 窗口失败且被静默忽略 → 监听器永久丢失 + * 3. 后续连接全部拒绝 + * 4. 与 auto_relisten 内部路径同一实现（net_relisten_locked：单次尝试 + 非阻塞重试，见 net_relisten_retry_tick） + * 5. 芯片侧已在监听时：首次 open 失败 → close 重建 → 监听短暂中断 ~1s */ int net_relisten(int sockfd) { + /* 消息体（按值拷入队列，netTask 改的是其副本） */ net_msg_t msg; + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 消息队列未创建（网络层未初始化）→ 通用错误 */ if (netMsgQueueHandle == NULL) { s_net_errno = NET_ERR; return -1; } + /* 消息类型：无条件重新监听（含 Trap 09 非阻塞重试） */ msg.type = NET_MSG_RELISTEN; + /* 目标 Socket */ msg.sockfd = sockfd; + /* 无超时（重监听立即尝试） */ msg.timeout_ms = 0U; + /* 调用方任务句柄（netTask 凭它回传回执） */ msg.caller = xTaskGetCurrentTaskHandle(); + /* 结果占位（netTask 侧覆写实际结果） */ msg.result = -1; + /* 入队：队列满时阻塞调用方直至有空位 */ if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) { + /* 入队失败 → BUSY */ s_net_errno = NET_ERR_BUSY; return -1; } + /* 阻塞等待 netTask 回执（两段式拾取，防丢失通知） */ msg.result = net_wait_result("rel", sockfd); + /* 失败：恢复 errno（对外统一 -1） */ if (msg.result < 0) { s_net_errno = msg.result; return -1; } + /* 重监听成功（0） */ return 0; } @@ -2590,25 +3138,34 @@ int net_relisten(int sockfd) { * 2. 转换结果经 NET_HTONL 转为网络字节序 */ uint32_t net_inet_addr(const char *cp) { + /* 组装出的 32 位地址（主机序，末转网络序） */ uint32_t addr = 0; + /* 段循环索引 */ int i; + /* 参数为空：返回 0（无效） */ if (cp == NULL) { return 0; } + /* 逐段解析（4 段） */ for (i = 0; i < 4; i++) { + /* 本段数值 */ uint32_t val = 0; + /* 逐字符解析十进制数字 */ while (*cp >= '0' && *cp <= '9') { val = val * 10 + (*cp - '0'); cp++; } + /* 本段放入对应字节位（段 0 = 最低字节，小端组装） */ addr |= (val << (i * 8)); + /* 跳过分隔符点（末段可无点） */ if (*cp == '.') { cp++; } } + /* 转网络字节序后返回 */ return NET_HTONL(addr); } @@ -2622,18 +3179,22 @@ uint32_t net_inet_addr(const char *cp) { * 函数说明：1. 先经 NET_NTOHL 转为主机字节序再格式化输出 */ char *net_inet_ntoa(uint32_t addr, char *buf) { + /* 网络序 → 主机序 */ uint32_t naddr = NET_NTOHL(addr); + /* 输出缓冲为 NULL：返回 NULL */ if (buf == NULL) { return NULL; } + /* 四段格式化为点分十进制（最低段在前，16B 缓冲） */ snprintf(buf, 16, "%lu.%lu.%lu.%lu", (unsigned long)(naddr & 0xFF), (unsigned long)((naddr >> 8) & 0xFF), (unsigned long)((naddr >> 16) & 0xFF), (unsigned long)((naddr >> 24) & 0xFF)); + /* 返回输出缓冲 */ return buf; } @@ -2647,6 +3208,7 @@ char *net_inet_ntoa(uint32_t addr, char *buf) { * 函数说明：直接调用 NET_HTONS 完成转换 */ uint16_t net_htons(uint16_t hostshort) { + /* 主机序 → 网络序（16 位端口） */ return NET_HTONS(hostshort); } @@ -2660,6 +3222,7 @@ uint16_t net_htons(uint16_t hostshort) { * 函数说明：直接调用 NET_NTOHS 完成转换 */ uint16_t net_ntohs(uint16_t netshort) { + /* 网络序 → 主机序（16 位端口） */ return NET_NTOHS(netshort); } @@ -2672,6 +3235,7 @@ uint16_t net_ntohs(uint16_t netshort) { * 函数说明：直接调用 NET_HTONL 完成转换 */ uint32_t net_htonl(uint32_t hostlong) { + /* 主机序 → 网络序（32 位 IP） */ return NET_HTONL(hostlong); } @@ -2684,6 +3248,7 @@ uint32_t net_htonl(uint32_t hostlong) { * 函数说明：直接调用 NET_NTOHL 完成转换 */ uint32_t net_ntohl(uint32_t netlong) { + /* 网络序 → 主机序（32 位 IP） */ return NET_NTOHL(netlong); } @@ -2697,14 +3262,19 @@ uint32_t net_ntohl(uint32_t netlong) { * 2. 调用方负责初始化该控制块 */ static int alloc_socket(void) { + /* 循环索引 */ int i; + /* 线性扫描首个空闲控制块 */ for (i = 0; i < NET_MAX_SOCKETS; i++) { + /* in_use == 0：空闲槽位 */ if (!s_net_socks[i].in_use) { + /* 返回空闲索引（初始化由调用方负责） */ return i; } } + /* 无空闲控制块：返回 -1 */ return -1; } @@ -2720,40 +3290,59 @@ static int alloc_socket(void) { */ static void handle_connect_event(net_sock_t *p_sock) { #if defined(NET_BENCH_CMD_LOG) + /* Bench：记 'a'（accept）命令 */ net_bench_cmd_log('a', (int)p_sock->ch395_sock, 0); #endif + /* 监听态：有连接到达 */ if (p_sock->state == NET_SOCK_STATE_LISTENING) { /* 单连接：收到 CONNECT 中断 = 自身有连接到达，转为 ESTABLISHED */ DBG_INFO("sock%d standalone accept", p_sock->ch395_sock); + /* 对端 IP/端口（6 字节：4B IP + 2B 端口，小端） */ uint8_t remote[6]; + /* 回读对端 IP + 端口 */ ch395f_get_remot_ipp(p_sock->ch395_sock, remote); + /* 对端 IP 数组（前 4 字节，大端） */ memcpy(p_sock->remote_ip_arr, remote, 4); + /* 小端 IP 组装为 32 位值 */ p_sock->remote_ip = ((uint32_t)remote[0]) | ((uint32_t)remote[1] << 8) | ((uint32_t)remote[2] << 16) | ((uint32_t)remote[3] << 24); + /* 对端端口（小端 2 字节） */ p_sock->remote_port = (uint16_t)(remote[4] | (remote[5] << 8)); + /* 状态 → ESTABLISHED（监听自身转数据通道） */ p_sock->state = NET_SOCK_STATE_ESTABLISHED; + /* 新开 Socket 发送缓冲按空闲计 */ p_sock->send_ready = 1; /* 清除残留的 TIMEOUT 中断标志 */ + /* 读即清：本 Socket 中断状态寄存器 */ (void)ch395f_get_sock_int_status(p_sock->ch395_sock); + /* 触发连接建立事件回调 */ fire_event(p_sock, NET_EVENT_CONNECTED); } else if (p_sock->state == NET_SOCK_STATE_CONNECTING) { /* TCP Client 连接成功 */ + /* 对端 IP/端口（6 字节：4B IP + 2B 端口，小端） */ uint8_t remote[6]; + /* 回读对端 IP + 端口 */ ch395f_get_remot_ipp(p_sock->ch395_sock, remote); + /* 对端 IP 数组（前 4 字节） */ memcpy(p_sock->remote_ip_arr, remote, 4); + /* 小端 IP 组装为 32 位值 */ p_sock->remote_ip = ((uint32_t)remote[0]) | ((uint32_t)remote[1] << 8) | ((uint32_t)remote[2] << 16) | ((uint32_t)remote[3] << 24); + /* 对端端口（小端 2 字节） */ p_sock->remote_port = (uint16_t)(remote[4] | (remote[5] << 8)); + /* 状态 → ESTABLISHED */ p_sock->state = NET_SOCK_STATE_ESTABLISHED; + /* 使能 KeepAlive（客户端连接保活） */ ch395f_set_keepalive_enable(p_sock->ch395_sock, 1); + /* 触发连接建立事件回调 */ fire_event(p_sock, NET_EVENT_CONNECTED); } } @@ -2770,74 +3359,83 @@ static void handle_connect_event(net_sock_t *p_sock) { */ static void handle_disconnect_event(net_sock_t *p_sock) { #if defined(NET_BENCH_CMD_LOG) + /* Bench：记 'd'（disconnect）命令 */ net_bench_cmd_log('d', (int)p_sock->ch395_sock, 0); #endif + /* 由控制块指针反推描述符 */ int sockfd = (int)(p_sock - s_net_socks); + /* 监听态：DISCONNECT 落在监听器上 */ if (p_sock->state == NET_SOCK_STATE_LISTENING) { - /* Trap 22 / N-6：监听态收到 DISCONNECT —— 芯片在断开后会自动关闭该 Socket - * （FUN_PARA 默认行为），本层若不重开则**监听永久死亡**（此后所有 SYN 被拒、不自恢复）。 - * 触发场景（2026-09-23 生产固件复现：FTP :21 断连后 100ms 快速复连，第 29 轮起全拒）： - * 断连后 <~1s 的快速复连，芯片完成握手但 CONNECT 中断未上报（无 standalone accept， - * 控制块滞留 LISTENING），随后该连接断开 → DISCONNECT 落到本分支。 - * 处置：回读芯片 socket 状态——已不在监听（芯片已关闭）即重建监听 - * （net_relisten_try 走 D10 非阻塞重试，失败由重试轮询接管）；仍在监听则判陈旧事件丢弃。 */ + /* Trap 22 / N-6：监听态收到 DISCONNECT——芯片断开后自动关闭该 Socket（FUN_PARA 默认），不重开则监听永久死亡（此后所有 SYN 被拒）； + * 触发 = 断连后 <~1s 快速复连时 CONNECT 中断未上报（控制块滞留 LISTENING）后该连接断开（2026-09-23 生产固件复现）； + * → 回读芯片状态：监听已失位即重建（D10 非阻塞重试），仍在监听判陈旧丢弃 */ + /* 回读缓冲（芯片状态 2 字节） */ uint8_t st[2] = {0, 0}; + /* 回读芯片状态 */ ch395f_get_socket_status((uint8_t)sockfd, st); + /* 监听已失位（芯片已关闭）：留痕并重建监听 */ if ((st[0] == CH395F_SOCKET_CLOSED) || (st[1] != CH395F_TCP_LISTEN)) { DBG_INFO("sock%d listen lost (chip sock=0x%02X tcp=0x%02X), relisten now", sockfd, st[0], st[1]); + /* 非阻塞：失败由 D10 重试轮询接管 */ (void)net_relisten_try(p_sock); } else { + /* 仍在监听：判陈旧事件丢弃 */ DBG_INFO("sock%d stale listen DISCONNECT ignored (chip tcp=0x%02X)", sockfd, st[1]); } } else if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) { - /* 陈旧 DISCONNECT 甄别（D20 修复，2026-09-22 台架实证）： - * 单连接模型下同一个 fd 会被"关闭 → 重新监听 → 再连接"循环复用，而上一条 - * 连接的 FIN/ACK 可能在本 fd 已复用为新连接**之后**才上报（本层是主动 close， - * net_close_locked 当时排空的中断里还没有它）→ 新连接被误判为断开。 - * 实测表现：FTP 同一会话第二个数据连接必失败 425；日志 = connect 后约 20ms - * 立即 "DISCONNECTED, releasing"。 - * 处置：向芯片回读状态，TCP 仍为 ESTABLISHED 即判为陈旧事件丢弃（中断已被 - * net_poll 读取清除，不会重复上报）。真断开时芯片处于 CLOSE_WAIT(0x07)/ - * CLOSED(0x00) 等状态，照常处理；超时事件走 handle_timeout_event，不受影响。 */ + /* 陈旧 DISCONNECT 甄别（D20 修复，2026-09-22 台架实证）：同一 fd 被"关闭 → 重新监听 → 再连接"循环复用，上一条连接的 FIN/ACK + * 可能在 fd 已复用为新连接**之后**才上报（net_close_locked 排空的中断里还没有它）→ 新连接被误判为断开（实测：FTP 同一会话第二个数据连接必失败 425）； + * 处置：回读芯片状态，TCP 仍 ESTABLISHED 判陈旧丢弃（已读清不重复上报）；真断开时芯片处于 CLOSE_WAIT(0x07)/CLOSED(0x00) 等状态照常处理；超时事件走 handle_timeout_event，不受影响 */ + /* 芯片状态回读缓冲（2 字节） */ uint8_t st[2]; + /* 回读芯片状态（Socket + TCP） */ ch395f_get_socket_status((uint8_t)sockfd, st); + /* 芯片仍 ESTABLISHED：陈旧事件 */ if (st[1] == CH395F_TCP_ESTABLISHED) { + /* 留痕：陈旧事件丢弃 */ DBG_ERROR("sock%d stale DISCONNECT ignored (chip TCP still ESTABLISHED)", sockfd); + /* 直接返回（中断已读清，不会重复上报） */ return; } /* 单连接：先不关 CH395F Socket， * 留给 net_recv_locked 把剩余数据读出来再关，置 CLOSED 等待应用重新监听 */ DBG_INFO("sock%d DISCONNECTED, releasing (chip tcp=0x%02X)", p_sock->ch395_sock, st[1]); /* Trap 23 推广（2026-09-24 台架实证）：正常 DISCONNECT 释放留下的芯片收尾状态 - * 会在复用同一 fd 的下一条连接上以"伪 DISCONNECT"形式投递（实测 accept 后约 - * 10~20ms）→ 该连接被提前释放，应用把已到的 2048B 当整份文件并回报 226。 - * 仅在**本连接收过数据**时登记沉降：实测触发源是"收过数据的数据通道被关闭"， - * 而纯连接即关（tcp_reconnect_probe 的 0ms 复连用例）与只发不收的下载连接不残留 - * —— 对它们免沉降即可保住 Trap 22 的快速复连时序（:21 @0ms ×50 全通过）。 */ + * 会在复用同一 fd 的下一条连接上以"伪 DISCONNECT"形式投递（实测 accept 后约 10~20ms）→ 该连接被提前释放，应用把已到的 2048B 当整份文件并回报 226； + * 仅**本连接收过数据**时登记沉降（实测触发源 = 收过数据的数据通道被关闭），纯连接即关/只发不收的连接免沉降，保住 Trap 22 的快速复连时序（:21 @0ms ×50 全通过） */ + /* 本连接收过数据：登记沉降（同 fd 下次重监听前多等 400/800ms 沉降窗口） */ if (p_sock->recv_bytes != 0U) { + /* 反推描述符（沉降按 fd 登记） */ int qfd = (int)(p_sock - s_net_socks); + /* 描述符范围保护 */ if ((qfd >= 0) && (qfd < NET_MAX_SOCKETS)) { + /* 登记优雅沉降（NET_RELISTEN_SETTLE_GRACEFUL） */ s_relisten_quarantine[qfd] = NET_RELISTEN_SETTLE_GRACEFUL; } } - p_sock->released_abnormal = 0U; /* 正常释放（对端 FIN）：断连了结回 EOF(0) */ + /* 正常释放（对端 FIN）：断连了结回 EOF(0) */ + p_sock->released_abnormal = 0U; + /* 状态 → CLOSED */ p_sock->state = NET_SOCK_STATE_CLOSED; + /* 触发断连事件回调 */ + /* 触发断连事件回调 */ fire_event(p_sock, NET_EVENT_DISCONNECTED); + /* 其他状态：未预期的断开 */ } else if (p_sock->state != NET_SOCK_STATE_CLOSED && p_sock->state != NET_SOCK_STATE_BOUND && p_sock->state != NET_SOCK_STATE_CREATED) { - /* 未预期的断开 */ + /* 未预期的断开：记错误日志 */ DBG_ERROR("sock%d disconnect in state %d", p_sock->ch395_sock, p_sock->state); + /* 触发断连事件回调（统一） */ fire_event(p_sock, NET_EVENT_DISCONNECTED); } } /* - * 函数功能：处理数据接收事件 * 函数功能：处理 Socket 数据接收（RECV_OK）事件 * 入口参数：p_sock - 发生接收事件的 Socket 控制块指针 net_sock_t * * 出口参数：无 @@ -2849,7 +3447,9 @@ static void handle_disconnect_event(net_sock_t *p_sock) { static void handle_recv_event(net_sock_t *p_sock) { /* RECV_OK 中断已触发，直接通知上层。不在此读 recv_len， * 避免和 net_recv_locked 里面的 ch395f_get_recv_len 冲突（Trap 13） */ - p_sock->readable = 1; /* 置可读标志，供 net_select 在无 SPI 访问下判读 */ + /* 置可读标志，供 net_select 在无 SPI 访问下判读 */ + p_sock->readable = 1; + /* 触发数据到达事件回调 */ fire_event(p_sock, NET_EVENT_DATA_RECEIVED); } @@ -2862,6 +3462,7 @@ static void handle_recv_event(net_sock_t *p_sock) { * 函数说明：触发 NET_EVENT_SEND_COMPLETE 回调通知上层 */ static void handle_send_event(net_sock_t *p_sock) { + /* 触发发送完成事件回调 */ fire_event(p_sock, NET_EVENT_SEND_COMPLETE); } @@ -2878,19 +3479,26 @@ static void handle_send_event(net_sock_t *p_sock) { */ static void handle_timeout_event(net_sock_t *p_sock) { #if defined(NET_BENCH_CMD_LOG) + /* Bench：记 'x'（timeout）命令 */ net_bench_cmd_log('x', (int)p_sock->ch395_sock, 0); #endif + /* 连接中状态：连接超时 */ if (p_sock->state == NET_SOCK_STATE_CONNECTING) { /* TCP Client 连接超时 */ DBG_ERROR("sock%d CONNECT TIMEOUT", p_sock->ch395_sock); + /* 状态 → CREATED（客户端槽位回可复用） */ p_sock->state = NET_SOCK_STATE_CREATED; } else if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) { + /* 已建立连接超时 */ DBG_ERROR("sock%d TIMEOUT", p_sock->ch395_sock); /* Trap 23：异常释放（TIMEOUT，例如客户端中止上传）→ 复监听前隔离， * 等对端在途数据落尽并排空 RX 残渣（详见 net_relisten_locked 区块注释） */ { + /* 反推描述符 */ int qfd = (int)(p_sock - s_net_socks); + /* 描述符范围保护 */ if ((qfd >= 0) && (qfd < NET_MAX_SOCKETS)) { + /* 登记异常释放隔离（重监听前等待在途数据落尽 + RX 排空） */ s_relisten_quarantine[qfd] = 1U; } } @@ -2898,12 +3506,14 @@ static void handle_timeout_event(net_sock_t *p_sock) { * NET_ERR_CONNRESET 了结（而非 EOF），应用（lftpd STOR）回报 5xx * 而非误报 226（见 net_pending_tick 断连分支） */ p_sock->released_abnormal = 1U; + /* 状态 → CLOSED */ p_sock->state = NET_SOCK_STATE_CLOSED; } else if (p_sock->state == NET_SOCK_STATE_LISTENING) { /* 监听超时（异常情况） */ DBG_ERROR("sock%d LISTEN TIMEOUT", p_sock->ch395_sock); } + /* 触发超时事件回调（统一） */ fire_event(p_sock, NET_EVENT_TIMEOUT); } @@ -2918,7 +3528,9 @@ static void handle_timeout_event(net_sock_t *p_sock) { * 2. 回调参数为 ch395_sock、event、event_arg */ static void fire_event(net_sock_t *p_sock, net_event_t event) { + /* 已注册回调 */ if (p_sock->event_cb != NULL) { + /* 调用回调（ch395_sock、event、用户参数） */ p_sock->event_cb(p_sock->ch395_sock, event, p_sock->event_arg); } } @@ -2934,19 +3546,26 @@ static void fire_event(net_sock_t *p_sock, net_event_t event) { * 2. 参数非法（NULL）时直接返回，不做解析 */ static void parse_ip_string(const char *str, uint8_t *ip_arr) { + /* 段循环索引 */ int i; + /* 参数非法（NULL）：直接返回，不做解析 */ if (str == NULL ||ip_arr == NULL) { return; } + /* 逐段解析（4 段） */ for (i = 0; i < 4; i++) { + /* 本段数值 */ uint32_t val = 0; + /* 逐字符解析十进制数字 */ while (*str >= '0' && *str <= '9') { val = val * 10 + (*str - '0'); str++; } + /* 本段写入 ip_arr（段 0 = 最低字节，小端） */ ip_arr[i] = (uint8_t)val; + /* 跳过分隔符点（末段可无点） */ if (*str == '.') { str++; } @@ -2963,52 +3582,66 @@ static void parse_ip_string(const char *str, uint8_t *ip_arr) { * 2. 未使用（in_use == 0）的 Socket 返回 NULL */ net_sock_t *net_get_sock(int sockfd) { + /* 描述符越界：返回 NULL */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { return NULL; } + /* Socket 未在用：返回 NULL */ if (!s_net_socks[sockfd].in_use) { return NULL; } + /* 返回控制块指针 */ return &s_net_socks[sockfd]; } /* * 函数功能：获取 Socket 本地地址（IP + Port） * 入口参数：sockfd - socket 描述符 int - * addr - 输出：本地地址 struct net_sockaddr * + * 出口参数：addr - 输出：本地地址 struct net_sockaddr * * addrlen - 输入输出：地址结构体长度 int * * 返回值：0 - 成功，-1 - 失败 int * 限定条件：socket 已创建或已绑定 * 函数说明：返回 sin_family + sin_port（网络序）+ sin_addr（网络序，从 net_init 缓存的 s_local_ip） */ int net_getsockname(int sockfd, struct net_sockaddr *addr, int *addrlen) { + /* 描述符越界 → BADF */ if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) { s_net_errno = NET_ERR_BADF; return -1; } + /* 控制块（const：本函数只读 Socket 信息） */ const net_sock_t *p_sock = &s_net_socks[sockfd]; + /* 未在用且状态 CLOSED → BADF */ if (!p_sock->in_use && p_sock->state == NET_SOCK_STATE_CLOSED) { s_net_errno = NET_ERR_BADF; return -1; } + /* 输出参数无效（NULL 或长度不足）→ INVAL */ if (addr == NULL ||addrlen == NULL || *addrlen < (int)sizeof(struct net_sockaddr_in)) { s_net_errno = NET_ERR_INVAL; return -1; } + /* 强转为 IPv4 地址结构体 */ struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr; + /* 清零地址结构体（防御：全部字段归零） */ memset(p_addr_in, 0, sizeof(struct net_sockaddr_in)); + /* 地址族 = IPv4 */ p_addr_in->sin_family = NET_AF_INET; + /* 本地端口（主机序 → 网络序） */ p_addr_in->sin_port = net_htons(p_sock->local_port); + /* 本地 IP：由 s_local_ip 数组小端组装为 32 位网络序值 */ p_addr_in->sin_addr.s_addr = ((uint32_t)s_local_ip[0]) | ((uint32_t)s_local_ip[1] << 8) | ((uint32_t)s_local_ip[2] << 16) | ((uint32_t)s_local_ip[3] << 24); + /* 回填结构体长度 */ *addrlen = sizeof(struct net_sockaddr_in); + /* 成功（0） */ return 0; }