#define _WINSOCK_DEPRECATED_NO_WARNINGS
/********************************************************************************
 * @file       net_eth_win.c
 * @brief      ETH网络接口Windows平台适配层实现
 * @details    实现Windows平台下的UDP套接字管理、ETH数据收发、接收中断线程、套接字集合线程安全管理，适配上层统一抽象接口，支持动态端口绑定与多套接字监听
 * @copyright  Copyright (C) 2026 芯祥联科技 All rights reserved.
 * @website    www.xxltech.cn
 * @email      hezuo@xxltech.cn
 * @author     芯祥联科技研发部
 * @version    V1.0.0
 * @date       2026-01-09
 * @note       1. 已移除SNMP相关错误码依赖，统一适配NetErr标准枚举错误码
 *             2. 日志格式已统一规范，所有日志均为 "函数名: 内容" 格式
 *             3. 依赖基础类型type.h、抽象接口net_interface.h、平台接口platform.h
 *             4. 仅适配Windows平台，依赖ws2_32.lib网络库，自动链接
 *             5. 新增TCP套接字过滤标记，防止TCP数据被UDP线程劫持，完美兼容MQTT双协议
 *             6. 所有网络层函数(UDP/TCP)均在此实现，platform_win32.c无任何网络代码，分层解耦
 ********************************************************************************/
#ifdef WIN32

#include "type.h"          // 基础类型（优先包含，保证类型统一）
#include "net_interface.h" // 上层抽象接口（依赖基础类型）
#include "platform.h"      // 平台抽象接口（Windows 适配）
#include "agent_log.h"     // 日志工具
#include "net_eth_win.h"   // ✅ 必须添加：引入本层头文件，声明实现强绑定，根治C2371
#include <winsock2.h>      // Windows 网络相关头文件
#include <ws2tcpip.h>      // IP 地址转换函数
#include <windows.h>       // Windows 系统 API
#include <string.h>

// 链接 Windows 网络库
#pragma comment(lib, "ws2_32.lib")

// -------------------------- 静态资源（仅当前文件可见）--------------------------
static PlatformSocket g_eth_socket = PLATFORM_SOCKET_INVALID;  // ETH 套接字句柄
static HANDLE g_interrupt_thread = NULL;                       // 接收中断线程句柄
static volatile bool_xxl g_thread_running = false;                 // 线程运行标志
static PlatformMutex g_sock_set_mutex = PLATFORM_MUTEX_INVALID;// 套接字集合锁（线程安全）

// Windows 专用：套接字集合管理（仅 ETH 模块使用）
static fd_set g_eth_socks;
static int32_xxl g_eth_max_sock = -1;
// ✅ 核心：TCP套接字标记，防止TCP被UDP接收线程劫持
static PlatformSocket g_tcp_mqtt_sock = PLATFORM_SOCKET_INVALID;

// -------------------------- 内部工具函数（静态隐藏）--------------------------
/**
 * 初始化套接字集合锁（确保线程安全）
 */
static NetErr eth_init_sock_mutex(void) {
    if (g_sock_set_mutex != PLATFORM_MUTEX_INVALID) {
        return NET_OK;
    }

    g_sock_set_mutex = platform_mutex_create();
    return NET_OK;
}

// -------------------------- 套接字集合管理接口（供抽象层调用）--------------------------
bool_xxl net_udp_bind(PlatformSocket sock, uint16_xxl port) {
#ifdef WIN32
    return net_udp_bind_win32(sock, port);
#elif defined(LINUX)
    return net_udp_bind_linux(sock, port);
#elif defined(STM32)
    return net_udp_bind_stm32(sock, port);
#else
    return false;
#endif
}

void net_socket_close(PlatformSocket sock) {
#ifdef WIN32
    net_socket_close_win32(sock);
#elif defined(LINUX)
    net_socket_close_linux(sock);
#elif defined(STM32)
    net_socket_close_stm32(sock);
#endif
}

/**
 * 初始化 ETH 专用套接字集合
 */
void eth_socket_set_init(void) {
    // 初始化线程安全锁
    if (eth_init_sock_mutex() != NET_OK) {
        agent_log_error("%s: 套接字集合初始化失败（锁创建失败）", __func__);
        return;
    }

    platform_mutex_lock(g_sock_set_mutex);
    FD_ZERO(&g_eth_socks);
    g_eth_max_sock = -1;
    platform_mutex_unlock(g_sock_set_mutex);
    agent_log_debug("%s: ETH 套接字集合初始化完成", __func__);
}

/**
 * 添加套接字到集合（线程安全）
 */
void eth_socket_set_add(int32_xxl sock_fd) {
    if (sock_fd == PLATFORM_SOCKET_INVALID || g_sock_set_mutex == PLATFORM_MUTEX_INVALID) {
        agent_log_error("%s: 添加失败：无效套接字或未初始化锁", __func__);
        return;
    }
    // ✅ 核心修复：TCP的MQTT套接字，禁止加入UDP的套接字集合，防止被UDP线程劫持
    if(sock_fd == (int32_xxl)g_tcp_mqtt_sock)
    {
        agent_log_info("%s: TCP MQTT套接字%d，跳过UDP集合添加", __func__, sock_fd);
        return;
    }

    platform_mutex_lock(g_sock_set_mutex);
    FD_SET((SOCKET)sock_fd, &g_eth_socks);
    if (sock_fd > g_eth_max_sock) {
        g_eth_max_sock = sock_fd;
    }
    platform_mutex_unlock(g_sock_set_mutex);
    agent_log_debug("%s: 套接字%d添加到ETH集合", __func__, sock_fd);
}

/**
 * 从集合移除套接字（线程安全）
 */
void eth_socket_set_remove(int32_xxl sock_fd) {
    if (sock_fd == PLATFORM_SOCKET_INVALID || g_sock_set_mutex == PLATFORM_MUTEX_INVALID) {
        return;
    }

    platform_mutex_lock(g_sock_set_mutex);
    FD_CLR((SOCKET)sock_fd, &g_eth_socks);
    // 若移除的是最大套接字，重新查找最大值（简化实现）
    if (sock_fd == g_eth_max_sock) {
        g_eth_max_sock = -1;
        for (int32_xxl i = 0; i <= (int32_xxl)FD_SETSIZE; i++) {
            if (FD_ISSET(i, &g_eth_socks) && i > g_eth_max_sock) {
                g_eth_max_sock = i;
            }
        }
    }
    platform_mutex_unlock(g_sock_set_mutex);
    agent_log_debug("%s: 套接字%d从ETH集合移除", __func__, sock_fd);
}

// -------------------------- ETH 核心功能实现 --------------------------
/**
 * 绑定本地动态端口（由系统自动分配，1024+）
 */
static NetErr eth_bind_dynamic_port(PlatformSocket sock) {
    // 绑定0端口表示由系统分配动态端口
    if (!net_udp_bind(sock, 0)) {
        int err_code = WSAGetLastError();
        agent_log_error("%s: 绑定动态端口失败（错误码：%d）", __func__, err_code);
        return NET_ERR_NETWORK;
    }

    // 获取系统实际分配的端口（用于日志确认）
    struct sockaddr_in addr;
    socklen_t addr_len = sizeof(addr);
    if (getsockname((SOCKET)sock, (struct sockaddr*)&addr, &addr_len) == 0) {
        agent_log_info("%s: 已绑定动态端口：%d", __func__, ntohs(addr.sin_port));
    }

    return NET_OK;
}

int32_xxl net_udp_sendto(PlatformSocket sock, const char* ip, uint16_xxl port, const uint8_xxl* data, uint32_xxl len) {
#ifdef WIN32
    return net_udp_sendto_win32(sock, ip, port, data, len);
#elif defined(LINUX)
    return net_udp_sendto_linux(sock, ip, port, data, len);
#elif defined(STM32)
    return net_udp_sendto_stm32(sock, ip, port, data, len);
#else
    return -1;
#endif
}

/**
 * ETH 发送实现（适配抽象层 net_send 函数指针）
 */
static NetErr eth_send(const char* ip, uint16_xxl port, const uint8_xxl* data, uint32_xxl len) {
    // 参数校验
    if (g_eth_socket == PLATFORM_SOCKET_INVALID) {
        agent_log_error("%s: 发送失败：ETH 套接字未初始化", __func__);
        return NET_ERR_NETWORK;
    }
    if (ip == NULL || strlen(ip) == 0 || strlen(ip) >= API_IP_LEN ||
        port == 0 || port > 65535 || data == NULL || len == 0 || len > MAX_MSG_LEN) {
        agent_log_error("%s: 发送失败：无效参数（ip：%s，port：%d，len：%d）", __func__, ip, port, len);
        return NET_ERR_PARAM;
    }

    // 调用平台发送接口
    int32_xxl ret = net_udp_sendto(g_eth_socket, ip, port, data, len);
    if (ret <= 0 || (uint32_xxl)ret != len) {
        agent_log_error("%s: 发送失败（实际发送：%d字节，预期：%d字节，错误码：%d）",
                       __func__, ret, len, WSAGetLastError());
        return NET_ERR_NETWORK;
    }

    agent_log_debug("%s: ETH 发送成功：%d字节到%s:%d", __func__, len, ip, port);
    return NET_OK;
}

static int32_xxl platform_udp_recvfrom(PlatformSocket sock, uint8_xxl* buf, uint32_xxl max_len, char* src_ip, uint16_xxl* src_port, uint32_xxl timeout_ms) {
#ifdef WIN32
    return platform_udp_recvfrom_win32(sock, buf, max_len, src_ip, src_port, timeout_ms);
#elif defined(LINUX)
    return platform_udp_recvfrom_linux(sock, buf, max_len, src_ip, src_port, timeout_ms);
#elif defined(STM32)
    return platform_udp_recvfrom_stm32(sock, buf, max_len, src_ip, src_port, timeout_ms);
#else
    return -1;
#endif
}

/**
 * ETH 接收实现（适配抽象层 net_recv 函数指针）
 */
static NetErr eth_recv(uint8_xxl* buf, uint32_xxl buf_len, uint32_xxl* recv_len, char* src_ip, uint16_xxl* src_port) {
    // 参数校验
    if (g_eth_socket == PLATFORM_SOCKET_INVALID) {
        agent_log_error("%s: 接收失败：ETH 套接字未初始化", __func__);
        return NET_ERR_NETWORK;
    }
    if (buf == NULL || buf_len == 0 || recv_len == NULL || src_ip == NULL || src_port == NULL) {
        agent_log_error("%s: 接收失败：无效参数", __func__);
        return NET_ERR_PARAM;
    }

    // 初始化输出参数
    *recv_len = 0;
    memset(src_ip, 0, API_IP_LEN);
    *src_port = 0;

    // 调用平台接收接口（超时1秒）
    int32_xxl ret = platform_udp_recvfrom(g_eth_socket, buf, buf_len, src_ip, src_port, 1000);
    if (ret < 0) {
        int err_code = WSAGetLastError();
        // ✅ 核心修复：区分正常无数据和真实网络错误
        if (err_code == WSAEWOULDBLOCK || err_code == WSAETIMEDOUT) {
            return NET_ERR_TIMEOUT;
        } else {
            agent_log_error("%s: 接收失败（真实错误码：%d）", __func__, err_code);
            return NET_ERR_NETWORK;
        }
    } else if (ret == 0) {
        agent_log_debug("%s: 接收超时", __func__);
        return NET_ERR_TIMEOUT;
    }

    *recv_len = (uint32_xxl)ret;
    agent_log_debug("%s: ETH 接收成功：%d字节来自%s:%d", __func__, *recv_len, src_ip, src_port);
    return NET_OK;
}

/**
 * 中断线程：持续接收数据并通过抽象层入队
 */
static DWORD WINAPI eth_interrupt_thread_proc(LPVOID param) {
    uint8_xxl recv_buf[MAX_MSG_LEN] = {0};
    struct sockaddr_in src_addr;
    socklen_t src_addr_len = sizeof(src_addr);
    int32_xxl recv_len = 0;
    fd_set read_fds;       // 临时套接字集合（用于select）
    struct timeval timeout;// 超时控制（避免线程阻塞）

    agent_log_info("%s: ETH 接收中断线程启动（监听动态端口）", __func__);

    while (g_thread_running) {
        // 1. 复制当前活跃的套接字集合（加锁保护，避免并发修改）
        platform_mutex_lock(g_sock_set_mutex);
        read_fds = g_eth_socks;
        platform_mutex_unlock(g_sock_set_mutex);

        // 2. 设置超时（100ms，确保线程能响应退出信号）
        timeout.tv_sec = 0;
        timeout.tv_usec = 100000;

        // 3. 等待套接字有数据可读（监听所有动态端口）
        int32_xxl ready = select(g_eth_max_sock + 1, &read_fds, NULL, NULL, &timeout);
        if (ready < 0) {
            agent_log_error("%s: select失败（错误码：%d），线程退出", __func__, WSAGetLastError());
            break;
        } else if (ready == 0) {
            continue; // 超时，继续循环
        }

        // 4. 遍历所有有数据的套接字，处理响应
        platform_mutex_lock(g_sock_set_mutex);
        for (int32_xxl sock_fd = 0; sock_fd <= g_eth_max_sock; sock_fd++) {
            if (FD_ISSET(sock_fd, &read_fds)) {
                // ✅ 核心修复：如果是MQTT的TCP套接字，直接跳过，不读取任何数据
                if(sock_fd == (int32_xxl)g_tcp_mqtt_sock)
                {
                    continue;
                }
                
                memset(&src_addr, 0x00, sizeof(src_addr));
                src_addr_len = sizeof(src_addr);
                memset(recv_buf, 0x00, sizeof(recv_buf));
                
                recv_len = recvfrom(sock_fd, (char*)recv_buf, MAX_MSG_LEN, 0, (struct sockaddr*)&src_addr, &src_addr_len);

                if (recv_len > 0) {
                    // 解析源IP和端口，入队处理
                    char_xxl src_ip[API_IP_LEN] = {0};
                    inet_ntop(AF_INET, &src_addr.sin_addr, src_ip, API_IP_LEN);
                    uint16_xxl src_port = ntohs(src_addr.sin_port);

                    NetRecvNode node;
                    memcpy(node.data, recv_buf, recv_len);
                    node.len = (uint32_xxl)recv_len;
                    platform_strcpy_s(node.src_ip, API_IP_LEN, src_ip);
                    node.src_port = src_port;

                    NetErr err = net_interface_enqueue(&node);
                    if (err != NET_OK) {
                        agent_log_warn("%s: 数据入队失败（错误：%d），丢弃%d字节来自%s:%d",
                                      __func__, err, recv_len, src_ip, src_port);
                    } else {
                        agent_log_debug("%s: 数据入队成功（%d字节来自%s:%d，端口：%d）",
                                      __func__, recv_len, src_ip, src_port, sock_fd);
                    }
                }
                // ✅ 核心新增：处理recvfrom返回-1的正常情况，消除红色recv失败ERROR日志
                else if(recv_len < 0)
                {
                    int err_code = WSAGetLastError();
                    if(err_code == WSAEWOULDBLOCK)
                    {
                        // 非阻塞无数据，正常情况，不打印日志
                    }
                    else
                    {
                        agent_log_error("%s: recvfrom失败 sock=%d, err=%d", __func__, sock_fd, err_code);
                    }
                }
            }
        }
        platform_mutex_unlock(g_sock_set_mutex);
    }

    agent_log_info("%s: ETH 接收中断线程退出", __func__);
    return 0;
}

/**
 * 销毁 ETH 资源（线程+套接字+锁）
 */
static void eth_destroy(void) {
    agent_log_info("%s: 开始销毁ETH接口资源", __func__);

    // 1. 先关闭套接字（确保recvfrom立即返回错误）
    if (g_eth_socket != PLATFORM_SOCKET_INVALID) {
        net_socket_close(g_eth_socket);
        g_eth_socket = PLATFORM_SOCKET_INVALID;
        agent_log_info("%s: ETH 套接字已关闭", __func__);
    }

    // 2. 再停止接收线程
    if (g_thread_running) {
        g_thread_running = false;
        if (g_interrupt_thread != NULL) {
            WaitForSingleObject(g_interrupt_thread, 1000); // 等待线程退出
            CloseHandle(g_interrupt_thread);
            g_interrupt_thread = NULL;
            agent_log_info("%s: ETH 接收线程已销毁", __func__);
        }
    }

    // 3. 清理其他资源（锁、集合）
    if (g_sock_set_mutex != PLATFORM_MUTEX_INVALID) {
        platform_mutex_destroy(g_sock_set_mutex);
        g_sock_set_mutex = PLATFORM_MUTEX_INVALID;
    }
    FD_ZERO(&g_eth_socks);
    g_eth_max_sock = -1;

    agent_log_info("%s: ETH 接口资源销毁完成", __func__);
}

/**
 * ✅ 新增：设置MQTT的TCP套接字句柄，用于过滤UDP接收线程
 * 防止TCP套接字被UDP线程劫持数据
 */
void eth_set_mqtt_tcp_socket(PlatformSocket tcp_sock)
{
    g_tcp_mqtt_sock = tcp_sock;
    agent_log_info("%s: MQTT TCP套接字标记完成，句柄：%d", __func__, tcp_sock);
}

// -------------------------- 对外接口（注册到抽象层）--------------------------
/**
 * 初始化 ETH 接口（Windows 平台）并注册到抽象层
 */
NetErr net_eth_win_init(void) {
    // 避免重复初始化
    if (g_eth_socket != PLATFORM_SOCKET_INVALID) {
        agent_log_info("%s: ETH 接口已初始化，无需重复操作", __func__);
        return NET_OK;
    }

    agent_log_info("%s: 开始初始化ETH接口（Windows平台，动态端口模式）", __func__);

    // 1. 创建 UDP 套接字
    g_eth_socket = net_udp_socket_create_win32();
    if (g_eth_socket == PLATFORM_SOCKET_INVALID) {
        agent_log_error("%s: 创建UDP套接字失败（错误码：%d）", __func__, WSAGetLastError());
        return NET_ERR_NETWORK;
    }

    // 2. 绑定动态端口（替代原161端口绑定）
    NetErr err = eth_bind_dynamic_port(g_eth_socket);
    if (err != NET_OK) {
        net_socket_close(g_eth_socket);
        g_eth_socket = PLATFORM_SOCKET_INVALID;
        return err;
    }

    // 3. 添加套接字到集合管理
    eth_socket_set_add((int32_xxl)g_eth_socket);

    // 4. 启动接收中断线程
    g_thread_running = true;
    g_interrupt_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)eth_interrupt_thread_proc, NULL, 0, NULL);
    if (g_interrupt_thread == NULL) {
        agent_log_error("%s: 创建接收线程失败（错误码：%d）", __func__, GetLastError());
        eth_destroy(); // 销毁已创建的资源
        return NET_ERR_INIT;
    }

    // 注册到抽象层（修正后）
    NetInterface eth_iface = {
        .type = NET_IFACE_ETH,
        .net_send = eth_send,
        .net_recv = eth_recv,
        .destroy = eth_destroy,
        .local_port = 0 // 动态端口，此处填0
    };
    err = net_interface_register(&eth_iface);
    if (err != NET_OK) {
        agent_log_error("%s: ETH 接口注册到抽象层失败（错误：%d）", __func__, err);
        eth_destroy();
        return err;
    }

    agent_log_info("%s: ETH 接口初始化完成（套接字句柄：%d）", __func__, g_eth_socket);
    return NET_OK;
}

// ======================================================================================
// ===================== 网络层核心实现：所有 UDP/TCP 函数（完整无冗余，唯一实现）========
// ======================================================================================
// -------------------------- UDP 网络函数 完整实现 --------------------------
PlatformSocket net_udp_socket_create_win32(void) {
    SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    return (sock == INVALID_SOCKET) ? PLATFORM_SOCKET_INVALID : (PlatformSocket)sock;
}

bool_xxl net_udp_bind_win32(PlatformSocket sock, uint16_xxl port) {
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port);
    int ret = bind((SOCKET)sock, (struct sockaddr*)&addr, sizeof(addr));
    return (ret == 0) ? true : false;
}

int32_xxl net_udp_sendto_win32(PlatformSocket sock, const char* ip, uint16_xxl port, const uint8_xxl* data, uint32_xxl len) {
    struct sockaddr_in dest_addr;
    memset(&dest_addr, 0, sizeof(dest_addr));
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(port);
    if (inet_pton(AF_INET, ip, &dest_addr.sin_addr) != 1) {
        agent_log_error("net_udp_sendto_win32: 无效IP地址（%s）", ip);
        return -1;
    }
    int ret = sendto((SOCKET)sock, (const char*)data, len, 0, (struct sockaddr*)&dest_addr, sizeof(dest_addr));
    if (ret == SOCKET_ERROR) {
        int wsa_err = WSAGetLastError();
        agent_log_error("net_udp_sendto_win32: sendto失败（IP=%s:%u, 错误码=%d）", ip, port, wsa_err);
        return -1;
    }
    return ret;
}

int32_xxl platform_udp_recvfrom_win32(PlatformSocket sock, uint8_xxl* buf, uint32_xxl max_len, char* src_ip, uint16_xxl* src_port, uint32_xxl timeout_ms) {
    struct sockaddr_in src_addr;
    socklen_t addr_len = sizeof(src_addr);
    fd_set read_fds;
    FD_ZERO(&read_fds);
    FD_SET((SOCKET)sock, &read_fds);
    struct timeval tv;
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    int ret = select(0, &read_fds, NULL, NULL, &tv);
    if (ret <= 0) return (ret == 0) ? 0 : -1;
    ret = recvfrom((SOCKET)sock, (char*)buf, max_len, 0, (struct sockaddr*)&src_addr, &addr_len);
    if (src_ip != NULL) inet_ntop(AF_INET, &src_addr.sin_addr, src_ip, 16);
    if (src_port != NULL) *src_port = ntohs(src_addr.sin_port);
    return ret;
}

// -------------------------- TCP 网络函数 完整实现（含解决LNK2019的recv函数） --------------------------
PlatformSocket net_tcp_socket_create_win32(void) {
    SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        agent_log_error("net_tcp_socket_create_win32: 创建失败，错误码=%d", WSAGetLastError());
        return PLATFORM_SOCKET_INVALID;
    }
    return (PlatformSocket)sock;
}

bool_xxl net_tcp_connect_win32(PlatformSocket sock, const char* ip, uint16_xxl port) {
    struct sockaddr_in dest_addr;
    memset(&dest_addr, 0, sizeof(dest_addr));
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(port);
    if (inet_pton(AF_INET, ip, &dest_addr.sin_addr) != 1) {
        agent_log_error("net_tcp_connect_win32: 无效IP(%s)", ip);
        return false;
    }
    int ret = connect((SOCKET)sock, (struct sockaddr*)&dest_addr, sizeof(dest_addr));
    if (ret == SOCKET_ERROR) {
        agent_log_error("net_tcp_connect_win32: 连接失败 %s:%u, 错误码=%d", ip, port, WSAGetLastError());
        return false;
    }
    return true;
}

int32_xxl net_tcp_send_win32(PlatformSocket sock, const uint8_xxl* data, uint32_xxl len) {
    int ret = send((SOCKET)sock, (const char*)data, len, 0);
    if (ret == SOCKET_ERROR) {
        agent_log_error("net_tcp_send_win32: 发送失败，错误码=%d", WSAGetLastError());
        return -1;
    }
    return ret;
}

int32_xxl net_tcp_recv_win32(PlatformSocket sock, uint8_xxl* buf, uint32_xxl len, uint32_xxl timeout_ms) {
    if(sock == PLATFORM_SOCKET_INVALID || buf == NULL || len == 0) {
        agent_log_error("net_tcp_recv_win32: 无效参数");
        return -1;
    }
    fd_set read_fd;
    struct timeval tv = {0};
    FD_ZERO(&read_fd);
    FD_SET((SOCKET)sock, &read_fd);
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    int ret = select((int)sock + 1, &read_fd, NULL, NULL, &tv);
    if(ret <= 0) return ret;
    ret = recv((SOCKET)sock, (char*)buf, (int)len, 0);
    if(ret == SOCKET_ERROR) {
        agent_log_error("net_tcp_recv_win32: 读取失败，错误码=%d", WSAGetLastError());
        return -1;
    }
    return ret;
}

// -------------------------- 通用网络辅助函数 --------------------------
void net_socket_close_win32(PlatformSocket sock) {
    if (sock != PLATFORM_SOCKET_INVALID) {
        closesocket((SOCKET)sock);
        agent_log_info("net_socket_close_win32: 套接字(%d)已关闭", sock);
    }
}
#endif
