mbtk/libgsw_lib/gsw_wifi_interface_sdk.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>

#include "gsw_wifi_interface_sdk.h"
#include <dlfcn.h>
#define MAX_COMMAND_LEN 512
#define MAX_SSID_LEN 32
#define MIN_SSID_LEN 6
#define MIN_PASSWORD_LEN 8
#define MAX_PASSWORD_LEN 64
#define MAX_IP_LEN 32
#define MAX_MAC_LEN 32

#define WLAN_STA_DEV "wlan0-vxd"
#define WLAN_AP_DEV "wlan0"

#define HOSTAPD_CONF_PATH "/etc/wifi/hostapd.conf"
#define HOSTAPD_LOG_PATH "/etc/wifi/hostapd.log"
#define WPA_SUPPLICANT_CONF_PATH "/etc/wifi/wpa_supplicant.conf"
#define AIC8800_BSP_DRIVER_PATH "aic8800_bsp"
#define AIC8800_FDRV_DRIVER_PATH "aic8800_fdrv"
#define CTRL_INTERFACE "/var/run/hostapd"

#define WPA_SUPPLICANT_CTRL_PATH "/var/run/wpa_supplicant"

#define VALID_2G_CHANNELS {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
#define VALID_5G_CHANNELS {36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165}

#include "gsw_log_interface.h"
#define GSW_WIFI "[HAL][GSW_WIFI]"

static inline int handle()
{
    return GSW_HAL_SUCCESS;
}

// 辅助函数：执行系统命令
int execute_command(const char *cmd)
{
    int status = system(cmd);
    if (status == -1)
    {
        LOGE(GSW_WIFI,"Failed to execute command");
        return GSW_HAL_NORMAL_FAIL;
    }
    if (WIFEXITED(status))
    {
        return WEXITSTATUS(status);
    }
    else
    {
        // 子进程异常退出，比如被信号终止
        return GSW_HAL_NORMAL_FAIL;
    }
}

// 辅助函数：读取文件内容到缓冲区
int read_file(const char *path, char *buffer, size_t buffer_len)
{
    FILE *file = fopen(path, "r");
    if (!file)
        return GSW_HAL_NORMAL_FAIL;
    size_t length = fread(buffer, 1, buffer_len - 1, file);
    if (length == 0)
    {
        fclose(file);
        return GSW_HAL_NORMAL_FAIL;
    }
    buffer[length] = '\0';
    fclose(file);
    return (int)length;
}

// 新增：静态互斥锁用于保护文件写入操作
static pthread_mutex_t write_file_mutex = PTHREAD_MUTEX_INITIALIZER;

int write_file(const char *path, const char *buffer)
{
    // 加锁：确保同一时间只有一个线程执行文件写入
    pthread_mutex_lock(&write_file_mutex);

    FILE *file = fopen(path, "w");
    if (!file)
    {
        // 解锁后返回错误
        pthread_mutex_unlock(&write_file_mutex);
        return GSW_HAL_NORMAL_FAIL;
    }

    fputs(buffer, file);
    fclose(file);

    // 解锁：释放锁资源
    pthread_mutex_unlock(&write_file_mutex);
    return GSW_HAL_SUCCESS;
}

// 辅助函数：检查 hostapd 是否正在运行
int is_hostapd_running()
{
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "ps | grep 'hostapd' | grep -v -E 'grep|global'");
    FILE *output = popen(cmd, "r");
    if (!output)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[1]; // 只需检查是否有输出，读取一个字符即可
    int result = fread(buffer, 1, 1, output);
    pclose(output);
    if (result > 0)
    {
        return GSW_HAL_SUCCESS; // 找到指定配置的hostapd进程
    }
    return GSW_HAL_NORMAL_FAIL; // 未找到
}

int gsw_wifi_ap_start()
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"gsw_wifi_ap_start\n");
    // 强制终止所有hostapd进程（关键新增：避免残留进程占用资源）
    execute_command("killall -9 hostapd >/dev/null 2>&1"); // 9信号强制终止
    sleep(1);                                              // 等待进程完全退出

    // 清理网络桥接接口（关键新增：避免br-lan绑定冲突）
    char brctl_cmd[MAX_COMMAND_LEN];
    snprintf(brctl_cmd, sizeof(brctl_cmd), "brctl delif br-lan %s >/dev/null 2>&1", WLAN_AP_DEV);
    execute_command(brctl_cmd);

    // 检查并删除残留的控制接口文件（原有逻辑保留）
    char ctrl_path[MAX_COMMAND_LEN];
    snprintf(ctrl_path, sizeof(ctrl_path), "%s/%s", CTRL_INTERFACE, WLAN_AP_DEV);
    if (access(ctrl_path, F_OK) == 0)
    {
        if (remove(ctrl_path) != 0)
        {
            LOGE(GSW_WIFI,"Failed to remove old hostapd control interface file");
            return GSW_HAL_NORMAL_FAIL;
        }
    }

    // 启动hostapd（原有逻辑保留）
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "echo ap starting > %s ;hostapd -q %s >> %s &", HOSTAPD_LOG_PATH, HOSTAPD_CONF_PATH, HOSTAPD_LOG_PATH);
    int status = execute_command(cmd);
    sleep(8);

    char log_buffer[1024] = {0};
    if (read_file(HOSTAPD_LOG_PATH, log_buffer, sizeof(log_buffer)) != -1)
    {
        // 检查日志中是否包含关键错误信息（示例："Failed"、"error"）
        if (strstr(log_buffer, "failed") || strstr(log_buffer, "error") || strstr(log_buffer, "wasn't started"))
        {
            LOGE(GSW_WIFI,"Hostapd start failed, check log: %s", log_buffer);
            return GSW_HAL_NORMAL_FAIL;
        }
        if(is_hostapd_running() == GSW_HAL_SUCCESS)
        {
            LOGI(GSW_WIFI,"Hostapd start success");
        }
        else
        {
            LOGE(GSW_WIFI,"Hostapd start failed, check log: %s", log_buffer);
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        if (is_hostapd_running() != GSW_HAL_SUCCESS)
        {
            LOGE(GSW_WIFI,"Failed to read hostapd log file: %s", HOSTAPD_LOG_PATH);
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    LOGI(GSW_WIFI,"gsw_wifi_ap_start ret = %d\n", status);
    return status;
}

// 辅助函数：判断 wpa_supplicant 服务是否起来
int is_wpa_supplicant_running()
{
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "ps | grep wpa_supplicant | grep -v grep");
    FILE *output = popen(cmd, "r");
    if (!output)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[1]; // 只需检查是否有输出，读取一个字符即可
    int result = fread(buffer, 1, 1, output);
    pclose(output);
    if (result > 0)
    {
        return GSW_HAL_SUCCESS; // wpa_supplicant 服务存在
    }
    return GSW_HAL_NORMAL_FAIL; // wpa_supplicant 服务不存在
}

typedef struct
{
    void *arg;
    GSW_AP_CALLBACK_FUNC_PTR gsw_cb;
    pthread_t thread_id;
    int running;
} AP_Event_Context;

static AP_Event_Context ap_event_context;
int gsw_wifi_ap_stop()
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_hostapd_running() != 0)
    {
        LOGI(GSW_WIFI,"Hostapd is not running, no need to stop.\n");
        return GSW_HAL_SUCCESS;
    }

    LOGI(GSW_WIFI,"Hostapd is running, stop it.\n");
    // 先停止事件监听线程
    /*if (ap_event_context.running)
    {
        ap_event_context.running = 0;
        if (ap_event_context.thread_id != 0)
        {
            pthread_join(ap_event_context.thread_id, NULL);
            ap_event_context.thread_id = 0;
        }
    }*/

    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "killall hostapd");
    int status = execute_command(cmd);

    // 关闭对应的 hostapd 后，删除对应的文件
    char path[MAX_COMMAND_LEN];
    snprintf(path, sizeof(path), "%s/%s", CTRL_INTERFACE, WLAN_AP_DEV);
    if (access(path, F_OK) == 0)
    {
        if (remove(path) != 0)
        {
            LOGE(GSW_WIFI,"Failed to remove hostapd control interface file");
        }
    }
    LOGI(GSW_WIFI,"gsw_wifi_ap_stop ret = %d\n", status);
    return status;
}

int gsw_wifi_ap_restart(void)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    int ret = 0;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "killall hostapd");
    int status = execute_command(cmd);
    LOGI(GSW_WIFI,"killall hostapd status = %d\n", status);
    // 关闭对应的 hostapd 后，删除对应的文件
    char path[MAX_COMMAND_LEN];
    snprintf(path, sizeof(path), "%s/%s", CTRL_INTERFACE, WLAN_AP_DEV);
    if (access(path, F_OK) == 0)
    {
        if (remove(path) != 0)
        {
            LOGE(GSW_WIFI,"Failed to remove hostapd control interface file");
        }
    }
    ret = gsw_wifi_ap_start();
    LOGI(GSW_WIFI,"gsw_wifi_ap_restart ret = %d\n", ret);
    return ret;
}

int gsw_wifi_ap_ssid_set(char *ssid)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    if (ssid == NULL) {
        LOGE(GSW_WIFI,"Password cannot be NULL");
        return GSW_HAL_NORMAL_FAIL;
    }
    size_t ssid_len = strlen(ssid);
    if (ssid_len > MAX_SSID_LEN || ssid_len < MIN_SSID_LEN) {
        LOGE(GSW_WIFI,"SSID length must be 6-32 characters, current length: %zu", ssid_len);
        return GSW_HAL_NORMAL_FAIL;
    }
    LOGI(GSW_WIFI,"AP set ssid: %s\n", ssid);
    // 读取现有配置
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        // 如果文件不存在，创建新配置（修改默认配置内容）
        FILE *conf = fopen(HOSTAPD_CONF_PATH, "w");
        if (!conf)
            return GSW_HAL_NORMAL_FAIL;

        // 写入用户指定的完整默认配置
        fprintf(conf, "ctrl_interface=%s\n", CTRL_INTERFACE);
        fprintf(conf, "ctrl_interface_group=0\n");
        fprintf(conf, "interface=%s\n", WLAN_AP_DEV);
        fprintf(conf, "driver=nl80211\n");
        fprintf(conf, "bridge=br-lan\n");
        fprintf(conf, "ssid=%s\n", ssid); // 使用传入的ssid
        fprintf(conf, "hw_mode=g\n");
        fprintf(conf, "ieee80211d=1\n");
        fprintf(conf, "channel=0\n");
        fprintf(conf, "auth_algs=1\n");
        fprintf(conf, "wme_enabled=1\n");
        fprintf(conf, "noscan=0\n");
        fprintf(conf, "beacon_int=100\n");
        fprintf(conf, "wpa=3\n");
        fprintf(conf, "wpa_passphrase=12345678\n");
        fprintf(conf, "ieee80211n=1\n");
        fprintf(conf, "ieee80211ac=1\n");
        fprintf(conf, "ieee80211ax=1\n");
        fprintf(conf, "vht_oper_chwidth=0\n");
        fprintf(conf, "vht_oper_centr_freq_seg0_idx=0\n");
        fprintf(conf, "he_oper_chwidth=0\n");
        fprintf(conf, "he_oper_centr_freq_seg0_idx=0\n");
        fprintf(conf, "he_basic_mcs_nss_set=65534\n");
        fprintf(conf, "he_su_beamformee=0\n");
        fprintf(conf, "he_twt_required=0\n");
        fprintf(conf, "vht_capab=[SHORT-GI-80][VHT40+][VHT40-][MAX-A-MPDU-LEN-EXP7][RX-STBC-1][RX-LDPC]\n");
        fprintf(conf, "ht_capab=[SHORT-GI-20][SHORT-GI-40][HT40+][HT40-][LDPC][RX-STBC1]\n");
        fprintf(conf, "wpa_key_mgmt=WPA-PSK\n");
        fprintf(conf, "wpa_pairwise=TKIP CCMP\n");
        fprintf(conf, "rsn_pairwise=CCMP\n");
        fprintf(conf, "ignore_broadcast_ssid=0\n");
        fprintf(conf, "country_code=CN\n");
        fprintf(conf, "max_num_sta=32\n");
        fprintf(conf, "macaddr_acl=0\n");
        fprintf(conf, "deny_mac_file=/etc/wifi/hostapd.deny\n");
        fprintf(conf, "accept_mac_file=/etc/wifi/hostapd.accept\n");
        fprintf(conf, "sae_pwe=2\n");

        fclose(conf);
        return GSW_HAL_SUCCESS;
    }

    // 处理每一行（新增ctrl_interface和ctrl_interface_group的检查）
    char *line = strtok(buffer, "\n");
    int ssid_processed = 0; // 标记是否已处理过ssid行
    while (line)
    {
        if (!ssid_processed && strncmp(line, "ssid=", 5) == 0)
        {
            char ssid_line[64];
            snprintf(ssid_line, sizeof(ssid_line), "ssid=%s", ssid);
            strcat(new_config, ssid_line);
            strcat(new_config, "\n");
            ssid_processed = 1;
            line = strtok(NULL, "\n");
            continue;
        }
        else if (strncmp(line, "ssid=", 5) == 0)
        {
            line = strtok(NULL, "\n");
            continue;
        }
        else if (strncmp(line, "ctrl_interface=", 15) == 0)
        {
            char ctrl_line[128];
            snprintf(ctrl_line, sizeof(ctrl_line), "ctrl_interface=%s", CTRL_INTERFACE);
            strcat(new_config, ctrl_line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "ctrl_interface_group=", 21) == 0)
        {
            char ctrl_group_line[64];
            snprintf(ctrl_group_line, sizeof(ctrl_group_line), "ctrl_interface_group=0");
            strcat(new_config, ctrl_group_line);
            strcat(new_config, "\n");
        }
        else
        {
            strcat(new_config, line);
            strcat(new_config, "\n");
        }
        line = strtok(NULL, "\n");
    }

    if (!ssid_processed)
    {
        char ssid_line[64];
        snprintf(ssid_line, sizeof(ssid_line), "ssid=%s\n", ssid);
        strcat(new_config, ssid_line);
    }

    return write_file(HOSTAPD_CONF_PATH, new_config);
}

int gsw_wifi_ap_ssid_get(char *ssid)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (ssid == NULL) {
        LOGE(GSW_WIFI,"ssid cannot be NULL");
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[1024] = {0};
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char *ssid_line = strstr(buffer, "ssid=");
    if (ssid_line)
    {
        ssid_line += 5; // 跳过 "ssid="
        char *end = strchr(ssid_line, '\n');
        if (end)
            *end = '\0';
        strncpy(ssid, ssid_line, MAX_SSID_LEN);
    }
    LOGI(GSW_WIFI,"AP get ssid: %s\n", ssid);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_ap_frequency_set(int gsw_wifi_frequency)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    LOGI(GSW_WIFI,"AP set frequency: %d\n", gsw_wifi_frequency);
    gsw_wifi_bandwidth_type_e gsw_wifi_bandwidth;
    gsw_wifi_ap_bandwidth_get(&gsw_wifi_bandwidth);
    if (gsw_wifi_bandwidth == GSW_WIFI_BANDWIDTH_HT80 && gsw_wifi_frequency == 1)
    {
        LOGE(GSW_WIFI,"HT80 cannot be set to 2.4G");
        return GSW_HAL_NORMAL_FAIL;
    }
    // 读取现有配置
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    // 处理每一行
    char *line = strtok(buffer, "\n");
    while (line)
    {
        // 如果是hw_mode行，替换为新值
        if (strstr(line, "hw_mode=") != NULL)
        {
            char mode_line[32];
            snprintf(mode_line, sizeof(mode_line), "hw_mode=%c", gsw_wifi_frequency == 1 ? 'g' : 'a');
            strcat(new_config, mode_line);
        }
        else
        {
            strcat(new_config, line);
        }
        strcat(new_config, "\n");
        line = strtok(NULL, "\n");
    }

    // 如果没有找到hw_mode行，添加新的设置
    if (strstr(new_config, "hw_mode=") == NULL)
    {
        char mode_line[32];
        snprintf(mode_line, sizeof(mode_line), "hw_mode=%c\n", gsw_wifi_frequency == 1 ? 'g' : 'a');
        strcat(new_config, mode_line);
    }

    // 写回文件
    return write_file(HOSTAPD_CONF_PATH, new_config);
}

int gsw_wifi_ap_frequency_get(int *gsw_wifi_frequency)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (gsw_wifi_frequency == NULL) {
        LOGE(GSW_WIFI,"gsw_wifi_frequency cannot be NULL");
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[1024] = {0};
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char *mode_line = strstr(buffer, "hw_mode=");
    if (mode_line)
    {
        mode_line += 8; // 跳过 "hw_mode="
        *gsw_wifi_frequency = (mode_line[0] == 'g') ? 1 : 2;
    }
    LOGI(GSW_WIFI,"AP get frequency: %d\n", *gsw_wifi_frequency);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_ap_bandwidth_set(gsw_wifi_bandwidth_type_e bandwidth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    LOGI(GSW_WIFI,"AP set bandwidth: %d\n", bandwidth);
    int current_freq;
    if (gsw_wifi_ap_frequency_get(&current_freq) != 0)
    {
        LOGI(GSW_WIFI,"Failed to get current frequency\n");
        return GSW_HAL_NORMAL_FAIL;
    }
    if (current_freq == 1 && bandwidth == GSW_WIFI_BANDWIDTH_HT80) // 1表示2.4GHz
    {
        LOGI(GSW_WIFI,"2.4GHz band does not support 80MHz bandwidth");
        return GSW_HAL_NORMAL_FAIL;
    }
    // 读取现有配置
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
        return GSW_HAL_NORMAL_FAIL;

    // 定义各带宽类型对应的替换规则（新增三个参数）
    const char *ht_capab = NULL;
    const char *vht_capab = NULL;
    const char *vht_oper_chwidth = NULL;
    const char *he_oper_chwidth = NULL;
    int vht_oper_centr_freq_seg0_idx_val = 0;
    int he_oper_centr_freq_seg0_idx_val = 0;
    int he_su_beamformee_val = 0;

    // 根据带宽类型初始化替换值（补充新增参数逻辑）
    switch (bandwidth)
    {
    case GSW_WIFI_BANDWIDTH_HT20:
        ht_capab = "ht_capab=[HT20][SHORT-GI-20][LDPC][RX-STBC1]";
        vht_capab = "vht_capab=[VHT20][SHORT-GI-20][MAX-A-MPDU-LEN-EXP7]";
        vht_oper_chwidth = "vht_oper_chwidth=0";
        he_oper_chwidth = "he_oper_chwidth=0";
        vht_oper_centr_freq_seg0_idx_val = 0;
        he_oper_centr_freq_seg0_idx_val = 0;
        he_su_beamformee_val = 0;
        break;
    case GSW_WIFI_BANDWIDTH_HT40:
        ht_capab = "ht_capab=[SHORT-GI-20][SHORT-GI-40][HT40+][HT40-][LDPC][RX-STBC1]";
        vht_capab = "vht_capab=[SHORT-GI-80][VHT40+][VHT40-][MAX-A-MPDU-LEN-EXP7][RX-STBC-1][RX-LDPC]";
        vht_oper_chwidth = "vht_oper_chwidth=0";
        he_oper_chwidth = "he_oper_chwidth=0";
        vht_oper_centr_freq_seg0_idx_val = 0;
        he_oper_centr_freq_seg0_idx_val = 0;
        he_su_beamformee_val = 0;
        break;
    case GSW_WIFI_BANDWIDTH_HT80:
        ht_capab = "ht_capab=[HT20][HT40+][HT40-][SHORT-GI-40][LDPC][RX-STBC1]";
        vht_capab = "vht_capab=[VHT40][VHT80][SHORT-GI-80][MAX-A-MPDU-LEN-EXP7]";
        vht_oper_chwidth = "vht_oper_chwidth=1";
        he_oper_chwidth = "he_oper_chwidth=1";
        vht_oper_centr_freq_seg0_idx_val = 42;
        he_oper_centr_freq_seg0_idx_val = 42;
        he_su_beamformee_val = 1;
        break;
    default:
        return GSW_HAL_NORMAL_FAIL;
    }

    // 新增标记：确保只处理第一个ht_capab行
    int ht_capab_processed = 0;

    // 逐行处理配置文件（增加新增参数的匹配）
    char *line = strtok(buffer, "\n");
    while (line)
    {
        // 处理ht_capab行（仅替换第一个以"ht_capab="开头的行）
        if (!ht_capab_processed && strncmp(line, "ht_capab=", 9) == 0)
        {
            if (ht_capab)
            {
                strcat(new_config, ht_capab);
                ht_capab_processed = 1; // 标记已处理
            }
            else
            {
                strcat(new_config, line);
            }
            strcat(new_config, "\n");
            line = strtok(NULL, "\n");
            continue;
        }
        else if (strncmp(line, "ht_capab=", 9) == 0)
        {
            line = strtok(NULL, "\n");
            continue;
        }
        else if (strncmp(line, "vht_oper_centr_freq_seg0_idx=", 25) == 0)
        {
            char vht_centr_line[64];
            snprintf(vht_centr_line, sizeof(vht_centr_line), "vht_oper_centr_freq_seg0_idx=%d", vht_oper_centr_freq_seg0_idx_val);
            strcat(new_config, vht_centr_line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "he_oper_centr_freq_seg0_idx=", 25) == 0)
        {
            char he_centr_line[64];
            snprintf(he_centr_line, sizeof(he_centr_line), "he_oper_centr_freq_seg0_idx=%d", he_oper_centr_freq_seg0_idx_val);
            strcat(new_config, he_centr_line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "he_su_beamformee=", 17) == 0)
        {
            char he_beam_line[32];
            snprintf(he_beam_line, sizeof(he_beam_line), "he_su_beamformee=%d", he_su_beamformee_val);
            strcat(new_config, he_beam_line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "vht_capab=", 10) == 0)
        {
            if (vht_capab)
                strcat(new_config, vht_capab);
            else
                strcat(new_config, line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "vht_oper_chwidth=", 17) == 0)
        {
            if (vht_oper_chwidth)
                strcat(new_config, vht_oper_chwidth);
            else
                strcat(new_config, line);
            strcat(new_config, "\n");
        }
        else if (strncmp(line, "he_oper_chwidth=", 16) == 0)
        {
            if (he_oper_chwidth)
                strcat(new_config, he_oper_chwidth);
            else
                strcat(new_config, line);
            strcat(new_config, "\n");
        }
        else
        {
            strcat(new_config, line);
            strcat(new_config, "\n");
        }
        line = strtok(NULL, "\n");
    }

    // 如果原文件无ht_capab行，补充新行（保持原有逻辑）
    if (!ht_capab_processed && ht_capab)
    {
        strcat(new_config, ht_capab);
        strcat(new_config, "\n");
    }

    // 检查vht_oper_centr_freq_seg0_idx是否已处理
    if (!strstr(new_config, "vht_oper_centr_freq_seg0_idx="))
    {
        char vht_centr_line[64];
        snprintf(vht_centr_line, sizeof(vht_centr_line), "vht_oper_centr_freq_seg0_idx=%d\n", vht_oper_centr_freq_seg0_idx_val);
        strcat(new_config, vht_centr_line);
    }
    // 检查he_oper_centr_freq_seg0_idx是否已处理
    if (!strstr(new_config, "he_oper_centr_freq_seg0_idx="))
    {
        char he_centr_line[64];
        snprintf(he_centr_line, sizeof(he_centr_line), "he_oper_centr_freq_seg0_idx=%d\n", he_oper_centr_freq_seg0_idx_val);
        strcat(new_config, he_centr_line);
    }
    // 检查he_su_beamformee是否已处理
    if (!strstr(new_config, "he_su_beamformee="))
    {
        char he_beam_line[32];
        snprintf(he_beam_line, sizeof(he_beam_line), "he_su_beamformee=%d\n", he_su_beamformee_val);
        strcat(new_config, he_beam_line);
    }

    return write_file(HOSTAPD_CONF_PATH, new_config);
}


int gsw_wifi_ap_bandwidth_get(gsw_wifi_bandwidth_type_e *bandwidth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[1024] = {0};
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    // 精确解析ht_capab参数
    char *ht_line = strstr(buffer, "ht_capab=");
    char *vht_line = strstr(buffer, "vht_capab=");
    char *vht_width = strstr(buffer, "vht_oper_chwidth=1");

    // 优先检查80MHz配置
    if (vht_width && vht_line && strstr(vht_line, "VHT80"))
    {
        *bandwidth = GSW_WIFI_BANDWIDTH_HT80;
    }
    else if (ht_line && strstr(ht_line, "HT40+"))
    {
        *bandwidth = GSW_WIFI_BANDWIDTH_HT40;
    }
    else
    {
        *bandwidth = GSW_WIFI_BANDWIDTH_HT20;
    }
    LOGI(GSW_WIFI,"AP get bandwidth: %d\n", *bandwidth);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_ap_channel_set(int channel)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    // 新增频率和信道校验
    LOGI(GSW_WIFI,"AP set channel: %d\n", channel);
    int current_freq;
    if (gsw_wifi_ap_frequency_get(&current_freq) != 0)
    {
        LOGE(GSW_WIFI,"Failed to get current frequency\n");
        return GSW_HAL_NORMAL_FAIL;
    }
    // 定义各频段支持的信道范围
    const int valid_2g_channels[] = VALID_2G_CHANNELS;
    const int valid_5g_channels[] = VALID_5G_CHANNELS;

    int valid = 0;
    if (current_freq == 1)
    { // 2.4GHz
        for (int i = 0; i < sizeof(valid_2g_channels) / sizeof(int); i++)
        {
            if (channel == valid_2g_channels[i])
            {
                valid = 1;
                break;
            }
        }
    }
    else
    { // 5GHz
        for (int i = 0; i < sizeof(valid_5g_channels) / sizeof(int); i++)
        {
            if (channel == valid_5g_channels[i])
            {
                valid = 1;
                break;
            }
        }
    }

    if (!valid && channel != 0)
    { // 允许0表示自动选择
        LOGI(GSW_WIFI,"Invalid channel %d for %s band\n",
             channel, (current_freq == 1) ? "2.4GHz" : "5GHz");
        return GSW_HAL_NORMAL_FAIL;
    }

    // 修改为读取整个文件并替换channel行
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    int noscan_set = 0; // 新增：标记是否已处理noscan行

    // 读取现有配置
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    // 处理每一行
    char *line = strtok(buffer, "\n");
    while (line)
    {
        // 新增：处理noscan行
        if (strstr(line, "noscan=") != NULL)
        {
            char noscan_line[32];
            snprintf(noscan_line, sizeof(noscan_line), "noscan=%d", (channel == 0) ? 0 : 1);
            strcat(new_config, noscan_line);
            strcat(new_config, "\n");
            noscan_set = 1;
        }
        // 如果是channel行，替换为新值
        else if (strstr(line, "channel=") != NULL)
        {
            char channel_line[32];
            snprintf(channel_line, sizeof(channel_line), "channel=%d", channel);
            strcat(new_config, channel_line);
            strcat(new_config, "\n");
        }
        // 其他行保持不变
        else
        {
            strcat(new_config, line);
            strcat(new_config, "\n");
        }
        line = strtok(NULL, "\n");
    }

    // 如果没有找到channel行，添加新的channel设置
    if (strstr(new_config, "channel=") == NULL)
    {
        char channel_line[32];
        snprintf(channel_line, sizeof(channel_line), "channel=%d\n", channel);
        strcat(new_config, channel_line);
    }

    // 新增：如果没有找到noscan行，根据channel值补充
    if (!noscan_set)
    {
        char noscan_line[32];
        snprintf(noscan_line, sizeof(noscan_line), "noscan=%d\n", (channel == 0) ? 0 : 1);
        strcat(new_config, noscan_line);
    }

    // 写回文件
    return write_file(HOSTAPD_CONF_PATH, new_config);
}


int gsw_wifi_ap_channel_get(int *channel)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (channel == NULL)
    {
        LOGI(GSW_WIFI,"channel is NULL\n");
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[1024] = {0};
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char *channel_line = strstr(buffer, "channel=");
    if (channel_line)
    {
        channel_line += 8; // 跳过 "channel="
        *channel = atoi(channel_line);
    }
    LOGI(GSW_WIFI,"AP get channel: %d\n", *channel);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_ap_auth_set(gsw_wifi_auth_e auth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    int wpa_set = 0, key_mgmt_set = 0, wpa_pairwise_set = 0, rsn_pairwise_set = 0, ieee80211w_set = 0, auth_algs_set = 0;

    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    LOGI(GSW_WIFI,"AP set auth: %d\n", auth);
    char *line = strtok(buffer, "\n");
    while (line)
    {
        // 匹配行首为"wpa="的行（长度4）
        if (strncmp(line, "wpa=", 4) == 0)
        {
            char wpa_line[32];
            if (auth == GSW_WIFI_AUTH_OPEN || auth == GSW_WIFI_AUTH_WEP)
                snprintf(wpa_line, sizeof(wpa_line), "wpa=%d", 0);
            else if (auth == GSW_WIFI_AUTH_WPA_PSK)
                snprintf(wpa_line, sizeof(wpa_line), "wpa=%d", 1);
            else if (auth == GSW_WIFI_AUTH_WPA2_PSK)
            {
                snprintf(wpa_line, sizeof(wpa_line), "wpa=%d", 3);
            }
            else if (auth == GSW_WIFI_AUTH_WPA3_PSK)
                snprintf(wpa_line, sizeof(wpa_line), "wpa=%d", 2);
            else
                snprintf(wpa_line, sizeof(wpa_line), "wpa=%d", 2);
            strcat(new_config, wpa_line);
            strcat(new_config, "\n");
            wpa_set = 1;
        }
        else if (strncmp(line, "wpa_key_mgmt=", 13) == 0)
        {
            const char *key_mgmt = (auth == GSW_WIFI_AUTH_WPA3_PSK) ? "SAE WPA-PSK" : "WPA-PSK";
            char key_mgmt_line[64];
            snprintf(key_mgmt_line, sizeof(key_mgmt_line), "wpa_key_mgmt=%s", key_mgmt);
            strcat(new_config, key_mgmt_line);
            strcat(new_config, "\n");
            key_mgmt_set = 1;
        }
        else if (strncmp(line, "auth_algs=", 9) == 0)
        {
            char auth_algs_line[32];
            snprintf(auth_algs_line, sizeof(auth_algs_line), "auth_algs=%d", (auth == GSW_WIFI_AUTH_WEP) ? 3 : 1);
            strcat(new_config, auth_algs_line);
            strcat(new_config, "\n");
            auth_algs_set = 1;
        }
        else if (strncmp(line, "wpa_pairwise=", 13) == 0)
        {
            const char *pairwise = NULL;
            if (auth == GSW_WIFI_AUTH_WPA_PSK)
                pairwise = "TKIP";
            else if (auth == GSW_WIFI_AUTH_WPA2_PSK)
                pairwise = "TKIP CCMP";
            else if (auth == GSW_WIFI_AUTH_WPA3_PSK)
                pairwise = "CCMP";
            else
                pairwise = "TKIP CCMP";
            char pairwise_line[64];
            snprintf(pairwise_line, sizeof(pairwise_line), "wpa_pairwise=%s", pairwise);
            strcat(new_config, pairwise_line);
            strcat(new_config, "\n");
            wpa_pairwise_set = 1;
        }
        else if (strncmp(line, "rsn_pairwise=", 13) == 0)
        {
            if (auth == GSW_WIFI_AUTH_WPA2_PSK || auth == GSW_WIFI_AUTH_WPA3_PSK)
            {
                strcat(new_config, "rsn_pairwise=CCMP\n");
            }
            rsn_pairwise_set = 1;
        }
        else if (strncmp(line, "ieee80211w=", 11) == 0)
        {
            if (auth == GSW_WIFI_AUTH_WPA3_PSK)
            {
                strcat(new_config, "ieee80211w=2\n"); // WPA3 强制 MFP
                ieee80211w_set = 1;
            }
            else if (auth == GSW_WIFI_AUTH_WPA2_PSK)
            {
                strcat(new_config, "ieee80211w=1\n"); // WPA2 可选 MFP
                ieee80211w_set = 1;
            }
            // 其他模式不添加该行（直接跳过）
        }
        else
        {
            strcat(new_config, line);
            strcat(new_config, "\n");
        }
        line = strtok(NULL, "\n");
    }

    // 补全未匹配的配置项
    if (!wpa_set)
    {
        if (auth == GSW_WIFI_AUTH_OPEN || auth == GSW_WIFI_AUTH_WEP)
            strcat(new_config, "wpa=0");
        else if (auth == GSW_WIFI_AUTH_WPA_PSK)
            strcat(new_config, "wpa=1");
        else if (auth == GSW_WIFI_AUTH_WPA2_PSK)
        {
            strcat(new_config, "wpa=3");
        }
        else if (auth == GSW_WIFI_AUTH_WPA3_PSK)
            strcat(new_config, "wpa=2");
        else
            strcat(new_config, "wpa=2");
        strcat(new_config, "\n");
    }
    if (!key_mgmt_set)
    {
        const char *key_mgmt = (auth == GSW_WIFI_AUTH_WPA3_PSK) ? "WPA-PSK SAE" : "WPA-PSK";
        strcat(new_config, "wpa_key_mgmt=");
        strcat(new_config, key_mgmt);
        strcat(new_config, "\n");
    }
    if (!auth_algs_set)
    {
        char auth_algs_line[32];
        snprintf(auth_algs_line, sizeof(auth_algs_line), "auth_algs=%d\n", (auth == GSW_WIFI_AUTH_WEP) ? 3 : 1);
        strcat(new_config, auth_algs_line);
    }
    if (!wpa_pairwise_set)
    {
        const char *pairwise = NULL;
        if (auth == GSW_WIFI_AUTH_WPA_PSK)
            pairwise = "TKIP";
        else if (auth == GSW_WIFI_AUTH_WPA2_PSK)
            pairwise = "TKIP CCMP";
        else if (auth == GSW_WIFI_AUTH_WPA3_PSK)
            pairwise = "CCMP";
        else
            pairwise = "TKIP CCMP";
        strcat(new_config, "wpa_pairwise=");
        strcat(new_config, pairwise);
        strcat(new_config, "\n");
    }
    if (!rsn_pairwise_set)
    {
        if (auth == GSW_WIFI_AUTH_WPA2_PSK || auth == GSW_WIFI_AUTH_WPA3_PSK)
        {
            strcat(new_config, "rsn_pairwise=CCMP\n");
        }
    }
    if (!ieee80211w_set && (auth == GSW_WIFI_AUTH_WPA3_PSK || auth == GSW_WIFI_AUTH_WPA2_PSK))
    {
        // 仅当需要时补全 ieee80211w 行（其他模式不添加）
        strcat(new_config, (auth == GSW_WIFI_AUTH_WPA3_PSK) ? "ieee80211w=2\n" : "ieee80211w=1\n");
    }

    return write_file(HOSTAPD_CONF_PATH, new_config);
}

int gsw_wifi_ap_auth_get(gsw_wifi_auth_e *auth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[1024] = {0};
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    char *auth_algs_line = strstr(buffer, "auth_algs=");
    if (auth_algs_line)
    {
        auth_algs_line += 10; // 跳过 "auth_algs="
        int auth_algs_val = atoi(auth_algs_line);
        if (auth_algs_val == 3)
        {
            *auth = GSW_WIFI_AUTH_WEP;
            return GSW_HAL_SUCCESS;
        }
    }
    // 优先通过 wpa_key_mgmt 判断 WPA3（包含 SAE 关键字）
    char *key_mgmt_line = strstr(buffer, "wpa_key_mgmt=");
    if (key_mgmt_line)
    {
        key_mgmt_line += 12; // 跳过 "wpa_key_mgmt="
        if (strstr(key_mgmt_line, "SAE"))
        {
            *auth = GSW_WIFI_AUTH_WPA3_PSK;
            return GSW_HAL_SUCCESS;
        }
    }

    // 若未找到 SAE，再通过 wpa= 判断 WPA2 或开放模式
    char *wpa_line = strstr(buffer, "wpa=");
    if (wpa_line)
    {
        wpa_line += 4;
        int wpa_val = atoi(wpa_line);
        if(wpa_val > 1)
        {
            *auth = GSW_WIFI_AUTH_WPA2_PSK;
        }
        else if (wpa_val == 1)
        {
            *auth = GSW_WIFI_AUTH_WPA_PSK;
        }
        else
        {
            *auth = GSW_WIFI_AUTH_OPEN;
        }
    }
    else
    {
        *auth = GSW_WIFI_AUTH_OPEN; // 默认开放模式
    }
    LOGI(GSW_WIFI,"AP get auth: %d\n", *auth);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_ap_password_set(char *password)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0};
    char new_config[4096] = {0};
    int has_passphrase = 0; // 标记是否已处理过密码行
    if (password == NULL) {
        LOGE(GSW_WIFI,"Password cannot be NULL");
        return GSW_HAL_NORMAL_FAIL;
    }
    LOGI(GSW_WIFI,"AP set password\n");
    size_t pass_len = strlen(password);
    if (pass_len < MIN_PASSWORD_LEN || pass_len > MAX_PASSWORD_LEN) {
        LOGE(GSW_WIFI,"Password length must be 8-63 characters, current length: %zu", pass_len);
        return GSW_HAL_NORMAL_FAIL;
    }
    // 读取现有配置文件内容
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    // 逐行处理配置文件（修改：增加密码行存在标记）
    char *line = strtok(buffer, "\n");
    while (line)
    {
        // 匹配到原密码行时替换为新密码，并标记已处理
        if (strstr(line, "wpa_passphrase=") != NULL)
        {
            char new_pass_line[128];
            snprintf(new_pass_line, sizeof(new_pass_line), "wpa_passphrase=%s", password);
            strcat(new_config, new_pass_line);
            has_passphrase = 1; // 标记存在密码行
        }
        else
        {
            strcat(new_config, line);
        }
        strcat(new_config, "\n"); // 保留换行符
        line = strtok(NULL, "\n");
    }

    // 若原文件无密码行，添加新密码行到末尾
    if (!has_passphrase)
    {
        char new_pass_line[128];
        snprintf(new_pass_line, sizeof(new_pass_line), "wpa_passphrase=%s\n", password);
        strcat(new_config, new_pass_line);
    }

    // 写回配置文件
    return write_file(HOSTAPD_CONF_PATH, new_config);
}

int gsw_wifi_ap_password_get(char *password)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096] = {0}; // 使用更大的缓冲区
    if (read_file(HOSTAPD_CONF_PATH, buffer, sizeof(buffer)) == -1)
    {
        LOGI(GSW_WIFI,"Failed to read hostapd config file\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    // 查找密码行
    char *passphrase_line = strstr(buffer, "wpa_passphrase=");
    if (!passphrase_line)
    {
        LOGI(GSW_WIFI,"No password line found in config\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    passphrase_line += 15; // 跳过 "wpa_passphrase="

    // 查找行结束位置
    char *end = strchr(passphrase_line, '\n');
    if (end)
    {
        *end = '\0'; // 确保字符串正确终止
    }

    // 检查密码长度是否合法
    size_t pass_len = strlen(passphrase_line);
    if (pass_len == 0 || pass_len >= MAX_PASSWORD_LEN)
    {
        LOGI(GSW_WIFI,"Invalid password length: %zu\n", pass_len);
        return GSW_HAL_NORMAL_FAIL;
    }

    // 复制密码
    strncpy(password, passphrase_line, MAX_PASSWORD_LEN);
    password[MAX_PASSWORD_LEN] = '\0'; // 确保终止
    LOGI(GSW_WIFI,"AP get password\n");
    return GSW_HAL_SUCCESS;
}

/**
 * @brief 获取 AP 模式的运行状态
 * @param [out] ap_status 用于存储 AP 模式运行状态的指针
 * @retval 0 表示函数执行成功
 */
int gsw_wifi_get_ap_status(gsw_wifi_ap_run_status_e *ap_status)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    int result = is_hostapd_running();
    if (result == 0)
    {
        *ap_status = GSW_WIFI_AP_STATUS_ENABLE;
    }
    else
    {
        *ap_status = GSW_WIFI_AP_STATUS_DISABLE;
    }
    return GSW_HAL_SUCCESS;
}

/* STA 模式相关函数实现 */

// 辅助函数：更新 wpa_supplicant 配置文件
int update_wpa_supplicant_conf()
{
    char new_config[4096] = {0};

    // 直接写入必需配置项（覆盖原有文件），新增WPA3支持的关键配置
    const char *required_configs[] = {
        "ctrl_interface=/var/run/wpa_supplicant", // 接口路径
        "ctrl_interface_group=root",              // 组设置
        "update_config=1",                        // 允许自动更新配置
        "ap_scan=1",                              // 主动扫描AP
        // 网络块配置调整：使用数值19表示SAE组（替代SUITE_B_192文本标识）
        "network={\n  key_mgmt=SAE\n  pairwise=CCMP\n  ieee80211w=2\n }"
    };
    int config_count = sizeof(required_configs) / sizeof(required_configs[0]);

    // 添加所有必需的配置项（确保顺序）
    for (int i = 0; i < config_count; i++)
    {
        strcat(new_config, required_configs[i]);
        strcat(new_config, "\n");
    }

    // 写回文件（完全覆盖）
    return write_file(WPA_SUPPLICANT_CONF_PATH, new_config);
}

int gsw_wifi_sta_start()
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"Starting wpa_supplicant...\n");
    // 更新 wpa_supplicant 配置文件
    if (update_wpa_supplicant_conf() != 0)
    {
        LOGI(GSW_WIFI,"Failed to update wpa_supplicant configuration file.\n");
        return GSW_HAL_NORMAL_FAIL;
    }

    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_supplicant -Dnl80211 -i%s -c%s -B", WLAN_STA_DEV, WPA_SUPPLICANT_CONF_PATH);
    int status = execute_command(cmd);
    sleep(5);
    memset(cmd, 0, sizeof(cmd));
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan > /dev/null", WLAN_STA_DEV);
    execute_command(cmd);
    memset(cmd, 0, sizeof(cmd));
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan_results > /dev/null", WLAN_STA_DEV);
    execute_command(cmd);
    LOGI(GSW_WIFI,"wpa_supplicant starting success\n");
    return status;
}

int gsw_wifi_sta_stop()
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"Stopping wpa_supplicant...\n");
    if (is_wpa_supplicant_running() != 0)
    {
        LOGI(GSW_WIFI,"wpa_supplicant is not running, no need to stop.\n");
        return GSW_HAL_SUCCESS;
    }

    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "killall wpa_supplicant");
    LOGI(GSW_WIFI,"Stoping success\n");
    return execute_command(cmd);
}

int gsw_wifi_get_sta_status(gsw_wifi_sta_run_status_e *sta_status)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() == 0)
    {
        *sta_status = GSW_WIFI_STA_STATUS_ENABLE;
    }
    else
    {
        *sta_status = GSW_WIFI_STA_STATUS_DISABLE;
    }
    return GSW_HAL_SUCCESS;
}

// 修改涉及 wpa_cli 命令的函数
int gsw_wifi_get_sta_ssid(char *sta_ssid)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'ssid=' | cut -d '=' -f 2", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[MAX_SSID_LEN + 1];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    strncpy(sta_ssid, buffer, MAX_SSID_LEN);
    LOGI(GSW_WIFI,"SSID: %s\n", sta_ssid);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_sta_auth(gsw_wifi_auth_e *auth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        LOGI(GSW_WIFI,"wpa_supplicant is not running.\n");
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    // 修改命令，获取 key_mgmt 字段
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'key_mgmt=' | cut -d '=' -f 2", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command: %s\n", cmd);
    FILE *output = popen(cmd, "r");
    if (!output)
    {
        LOGI(GSW_WIFI,"Failed to execute command: %s\n", cmd);
        return GSW_HAL_NORMAL_FAIL;
    }
    char buffer[32];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        LOGI(GSW_WIFI,"No output from command: %s\n", cmd);
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    LOGI(GSW_WIFI,"Command output: %s\n", buffer);

    if (strstr(buffer, "WPA2-PSK"))
    {
        *auth = GSW_WIFI_AUTH_WPA2_PSK;
    }
    else if (strstr(buffer, "WPA-PSK"))
    {
        *auth = GSW_WIFI_AUTH_WPA_PSK;
    }
    else if (strstr(buffer, "SAE"))
    {
        *auth = GSW_WIFI_AUTH_WPA3_PSK;
    }
    else if (strstr(buffer, "NONE"))
    {
        *auth = GSW_WIFI_AUTH_OPEN;
    }
    else
    {
        LOGI(GSW_WIFI,"Unknown authentication type: %s. Assuming WPA2-PSK.\n", buffer);
        *auth = GSW_WIFI_AUTH_WPA2_PSK;
    }
    LOGI(GSW_WIFI,"Authentication type: %s\n", buffer);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_sta_connect(char *ssid, gsw_wifi_auth_e auth, char *password)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }

    char quoted_ssid[MAX_SSID_LEN + 3]; // 为引号和字符串结尾留空间
    char quoted_password[MAX_PASSWORD_LEN + 3];

    // 添加引号
    snprintf(quoted_ssid, sizeof(quoted_ssid), "\\\"%s\\\"", ssid);
    if (auth != GSW_WIFI_AUTH_OPEN)
    {
        snprintf(quoted_password, sizeof(quoted_password), "\\\"%s\\\"", password);
    }

    LOGI(GSW_WIFI,"SSID = %s\n", quoted_ssid);

    char cmd[MAX_COMMAND_LEN];
    int status;

    // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s remove_network 0", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command type: Remove network\n");
    status = execute_command(cmd);
    if (status != 0)
    {
        return status;
    }

    // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s ap_scan 1", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command type: Set AP scan\n");
    status = execute_command(cmd);
    if (status != 0)
    {
        return status;
    }

    // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s add_network", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command type: Add network\n");
    status = execute_command(cmd);
    if (status != 0)
    {
        return status;
    }

    // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 ssid %s", WLAN_STA_DEV, quoted_ssid);
    LOGI(GSW_WIFI,"Executing command type: Set SSID\n");
    status = execute_command(cmd);
    if (status != 0)
    {
        return status;
    }

    if (auth != GSW_WIFI_AUTH_OPEN)
    {
        const char *key_mgmt;
        switch (auth)
        {
        case GSW_WIFI_AUTH_WEP:
            key_mgmt = "NONE";
            // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
            snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 wep_key0 %s", WLAN_STA_DEV, quoted_password);
            LOGI(GSW_WIFI,"Executing command type: Set WEP key\n");
            status = execute_command(cmd);
            if (status != 0)
                return status;

            // 修改：-p 改为 -i 并使用 WLAN_STA_DEV（注意原代码中可能存在拼写错误 "weep_tx_keyidx" 应为 "wep_tx_keyidx"）
            snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 wep_tx_keyidx 0", WLAN_STA_DEV);
            LOGI(GSW_WIFI,"Executing command type: Set WEP TX key index\n");
            status = execute_command(cmd);
            if (status != 0)
                return status;
            break;

        case GSW_WIFI_AUTH_WPA_PSK:
            key_mgmt = "WPA-PSK";
            break;
        case GSW_WIFI_AUTH_WPA2_PSK:
            key_mgmt = "WPA-PSK";
            break;
        case GSW_WIFI_AUTH_WPA3_PSK:
            key_mgmt = "SAE";
            break;
        default:
            key_mgmt = "WPA-PSK";
            break;
        }

        if (auth != GSW_WIFI_AUTH_WEP)
        {
            // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
            snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 key_mgmt %s", WLAN_STA_DEV, key_mgmt);
            LOGI(GSW_WIFI,"Executing command type: Set key management\n");
            status = execute_command(cmd);
            if (status != 0)
                return status;

            if (auth == GSW_WIFI_AUTH_WPA3_PSK)
            {
                // WPA3 特有配置：确保在设置key_mgmt后配置SAE参数
                // 设置椭圆曲线组（使用NIST P-256，组号19）
                snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 sae_groups 19", WLAN_STA_DEV);
                status = execute_command(cmd);
                if (status != 0)
                    return status;

                // 强制MFP保护（WPA3要求必须启用）
                snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 sae_require_mfp 1", WLAN_STA_DEV);
                status = execute_command(cmd);
                if (status != 0)
                    return status;

                // 使用SAE+CCMP加密组合（确保与AP端匹配）
                snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 pairwise CCMP", WLAN_STA_DEV);
                status = execute_command(cmd);
                if (status != 0)
                    return status;
            }

            // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
            snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 psk %s", WLAN_STA_DEV, quoted_password);
            LOGI(GSW_WIFI,"Executing command type: Set PSK\n");
            status = execute_command(cmd);
            if (status != 0)
                return status;
        }
    }
    else
    {
        // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
        snprintf(cmd, sizeof(cmd), "wpa_cli -i %s set_network 0 key_mgmt NONE", WLAN_STA_DEV);
        LOGI(GSW_WIFI,"Executing command type: Set key management for open network\n");
        status = execute_command(cmd);
        if (status != 0)
            return status;
    }

    // 修改：-p 改为 -i 并使用 WLAN_STA_DEV
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s select_network 0", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command type: Select network\n");
    status = execute_command(cmd);
    if (status != 0)
    {
        return status;
    }

    // udhcpc 命令无需修改（已使用 WLAN_STA_DEV）
    snprintf(cmd, sizeof(cmd), "udhcpc -i %s -n", WLAN_STA_DEV);
    LOGI(GSW_WIFI,"Executing command type: Request DHCP IP\n");
    status = execute_command(cmd);
    return status;
}

int gsw_wifi_sta_forget_ap(char *ssid, gsw_wifi_auth_e auth)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s remove_network $(wpa_cli -i %s list_networks | grep '%s' | awk '{print $1}')", WLAN_STA_DEV, WLAN_STA_DEV, ssid);
    return execute_command(cmd);
}

int gsw_wifi_sta_start_scan(void)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan", WLAN_STA_DEV);
    return execute_command(cmd);
}

int gsw_wifi_get_interface_ip(gsw_wifi_index_e idx, char *ip)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "ip addr show dev %s | grep 'inet ' | awk '{print $2}' | cut -d '/' -f 1", idx == GSW_WIFI_INTERFACE_0 ? WLAN_STA_DEV : WLAN_AP_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[MAX_IP_LEN + 1];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    strncpy(ip, buffer, MAX_IP_LEN);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_interface_mac(gsw_wifi_index_e idx, char *mac)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "ip link show dev %s | grep 'link/ether' | awk '{print $2}'", idx == GSW_WIFI_INTERFACE_0 ? WLAN_STA_DEV : WLAN_AP_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[MAX_MAC_LEN + 1];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';  // 移除换行符
    
    // 关键修改：确保MAC地址仅保留17位有效字符（标准MAC格式为xx:xx:xx:xx:xx:xx，共17字符）
    strncpy(mac, buffer, 17);  // 限制复制17个字符
    mac[17] = '\0';  // 显式添加字符串结束符
    
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_connect_ap_mac(char *mac)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'bssid=' | cut -d '=' -f 2", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[MAX_MAC_LEN + 1];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    strncpy(mac, buffer, MAX_MAC_LEN);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_connect_ap_rssi(int *rssi)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'signal=' | cut -d '=' -f 2", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[16];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    *rssi = atoi(buffer);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_connect_ap_band(gsw_wifi_band_e *band)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'frequency=' | cut -d '=' -f 2", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[32];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    int freq = atoi(buffer);
    if (freq < 2500)
    {
        *band = GSW_WIFI_2G_band;
    }
    else
    {
        *band = GSW_WIFI_5G_band;
    }
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_connect_ap_ip(char *ip)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s status | grep 'ip_address=' | cut -d '=' -f 2", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[MAX_IP_LEN + 1];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    strncpy(ip, buffer, MAX_IP_LEN);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_sta_available_ap(gsw_ap_detail_info_s *info)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan > /dev/null", WLAN_STA_DEV);
    execute_command(cmd);
    sleep(1);
    memset(cmd, 0, sizeof(cmd));
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan_results | awk '{print $1,$2,$3,$4,$5}' | sort -k3 -nr | head -n 1", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[256];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    pclose(output);
    buffer[strcspn(buffer, "\n")] = '\0';
    sscanf(buffer, "%x %d %31s %31s %31s", (int*)&info->base_info.auth, &info->rssi, info->base_info.ap_ssid, info->base_info.ap_ip, info->base_info.ap_mac);
    info->status = GSW_WIFI_AP_STATUS_ENABLE;
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_ap_device_list(gsw_ap_info_s *ap_info, gsw_device_info_s *device_list, int len, int *dev_len)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "hostapd_cli -i %s all_sta", WLAN_AP_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096];
    size_t length = fread(buffer, 1, sizeof(buffer) - 1, output);
    if (length == 0)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    buffer[length] = '\0';
    pclose(output);
    // 解析 hostapd_cli 输出，填充 device_list
    *dev_len = 0;
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_sta_saved_ap(gsw_saved_ap_info_s *list, int len, int *list_len)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s list_networks", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096];
    size_t length = fread(buffer, 1, sizeof(buffer) - 1, output);
    if (length == 0)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    buffer[length] = '\0';
    pclose(output);
    // 解析 wpa_cli 输出，填充 list
    *list_len = 0;
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_get_scan_list(gsw_scan_info_s *list, int len, int *list_len)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    if (is_wpa_supplicant_running() != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan > /dev/null", WLAN_STA_DEV);
    execute_command(cmd);
    sleep(1);
    memset(cmd, 0, sizeof(cmd));
    snprintf(cmd, sizeof(cmd), "wpa_cli -i %s scan_results", WLAN_STA_DEV);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[4096];
    size_t length = fread(buffer, 1, sizeof(buffer) - 1, output);
    if (length == 0)
    {
        pclose(output);
        return GSW_HAL_NORMAL_FAIL;
    }
    buffer[length] = '\0';
    pclose(output);

    // 解析 wpa_cli 输出，填充 list
    *list_len = 0;
    char *line = strtok(buffer, "\n");
    // 跳过标题行
    if (line)
        line = strtok(NULL, "\n");

    while (line && *list_len < len)
    {
        gsw_scan_info_s *info = &list[*list_len];
        int freq;        // 临时变量用于存储频率，以判断频段
        char flags[256]; // 临时变量用于存储认证标志

        // 假设输出格式为：bssid freq signal flags ssid
        // 解析每一行数据
        sscanf(line, "%31s %d %d %255s %32[^\n]", info->mac, &freq, &info->rssi, flags, info->ssid);

        // 根据频率判断频段
        if (freq < 2500)
        {
            info->band = GSW_WIFI_2G_band;
        }
        else
        {
            info->band = GSW_WIFI_5G_band;
        }

        // 根据 flags 判断认证方式
        if (strstr(flags, "SAE") != NULL || strstr(flags, "WPA3") != NULL)
        {
            info->auth = GSW_WIFI_AUTH_WPA3_PSK;
        }
        else if (strstr(flags, "WPA2") != NULL)
        {
            info->auth = GSW_WIFI_AUTH_WPA2_PSK;
        }
        else if (strstr(flags, "WPA") != NULL)
        {
            info->auth = GSW_WIFI_AUTH_WPA_PSK;
        }
        else
        {
            info->auth = GSW_WIFI_AUTH_OPEN;
        }

        (*list_len)++;
        line = strtok(NULL, "\n");
    }
    return GSW_HAL_SUCCESS;
}

void *ap_event_listener(void *arg)
{
    char list_cmd[MAX_COMMAND_LEN];
    snprintf(list_cmd, sizeof(list_cmd), "hostapd_cli -i %s all_sta | grep -E '^[0-9a-f:]{17}$|connected_time=' | \
     awk '/^[0-9a-f:]{17}$/ { mac=$0; getline; if ($0 ~ /connected_time=/) print mac }'",
             WLAN_AP_DEV);

    // 保存上一次的设备MAC地址列表
    char prev_macs[GSW_WIFI_AP_DEVICE_NUM][32] = {0};
    int prev_count = 0;
    while (ap_event_context.running && ap_event_context.gsw_cb)
    {
        if (is_hostapd_running() != 0)
        {
            sleep(5);
            continue;
        }

        // 使用list_cmd获取当前设备MAC列表
        char curr_macs[GSW_WIFI_AP_DEVICE_NUM][32] = {0};
        int curr_count = 0;
        FILE *list_output = popen(list_cmd, "r");
        if (list_output)
        {
            char buffer[1024];
            if (fread(buffer, 1, sizeof(buffer) - 1, list_output) > 0)
            {
                buffer[sizeof(buffer) - 1] = '\0';
                char *line = strtok(buffer, "\n");
                while (line && curr_count < GSW_WIFI_AP_DEVICE_NUM)
                {
                    if (strchr(line, ':'))
                    {
                        strncpy(curr_macs[curr_count], line, 17); // 复制MAC地址
                        curr_count++;
                    }
                    line = strtok(NULL, "\n");
                }
            }
            pclose(list_output);
        }

        // 数量变化时直接触发事件（保持原有逻辑）
        if (curr_count > prev_count && ap_event_context.gsw_cb)
        {
            ap_event_context.gsw_cb(ap_event_context.arg, GSW_WIFI_STATUS_CONNECT);
        }
        else if (curr_count < prev_count && ap_event_context.gsw_cb)
        {
            ap_event_context.gsw_cb(ap_event_context.arg, GSW_WIFI_STATUS_DISCONNECT);
        }
        else if (curr_count == prev_count && ap_event_context.gsw_cb)
        {
            int mac_updated = 0;
            // 遍历检查是否有MAC地址变化
            for (int i = 0; i < curr_count; i++)
            {
                int found = 0;
                for (int j = 0; j < prev_count; j++)
                {
                    if (strcasecmp(curr_macs[i], prev_macs[j]) == 0)
                    {
                        found = 1;
                        break;
                    }
                }
                // 发现新MAC地址（当前存在但之前不存在）
                if (!found)
                {
                    LOGI(GSW_WIFI,"New device connected: %s\n", curr_macs[i]);
                    mac_updated++;
                    break;
                }
            }
            // 若有更新则触发连接事件（可根据需求扩展为断开事件）
            if (mac_updated)
            {
                ap_event_context.gsw_cb(ap_event_context.arg, GSW_WIFI_STATUS_DISCONNECT);
                ap_event_context.gsw_cb(ap_event_context.arg, GSW_WIFI_STATUS_CONNECT);
            }
        }

        memcpy(prev_macs, curr_macs, sizeof(prev_macs));
        prev_count = curr_count;

        sleep(2); // 定期轮询
    }
    return NULL;
}

/**
 * @brief   register ap event notification function
 * @param  [in] arg  as gsw_cb function parameter, can be NULL
 * @param  [in] gsw_cb callback
 * @retval 0: success
 * @retval other: fail
 */
int gsw_wifi_reg_ap_event_callback(void *arg, GSW_AP_CALLBACK_FUNC_PTR gsw_cb)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"%s - start.\n",__func__);
    if (ap_event_context.running)
    {
        return GSW_HAL_NORMAL_FAIL; // 已经注册了回调
    }
    if (arg == NULL)
    {
        LOGE(GSW_WIFI,"%s - arg is NULL.\n",__func__);
    }
    if (gsw_cb == NULL)
    {
        LOGE(GSW_WIFI,"%s - gsw_cb is NULL.\n",__func__);
        return GSW_HAL_NORMAL_FAIL; // 回调函数不能为空
    }
    ap_event_context.arg = arg;
    ap_event_context.gsw_cb = gsw_cb;
    ap_event_context.running = 1;
    if (pthread_create(&ap_event_context.thread_id, NULL, ap_event_listener, NULL) != 0)
    {
        ap_event_context.running = 0;
        return GSW_HAL_NORMAL_FAIL;
    }
    LOGI(GSW_WIFI,"%s - end.\n",__func__);
    return GSW_HAL_SUCCESS;
}

/**
 * @brief  unregister ap callback function
 * @param  [in] arg  reserved parameter, can be NULL
 * @retval 0: success
 * @retval other: fail
 */
int gsw_wifi_unreg_ap_event_callback(void *arg)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"%s - start.\n",__func__);
    ap_event_context.running = 0;

    // 检查线程是否存在
    if (ap_event_context.thread_id != 0)
    {
        if (pthread_join(ap_event_context.thread_id, NULL) != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
        ap_event_context.thread_id = 0; // 重置线程ID
    }

    ap_event_context.arg = NULL;
    ap_event_context.gsw_cb = NULL;
    LOGI(GSW_WIFI,"%s - end.\n",__func__);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_reg_sta_event_callback(void *arg, GSW_STA_CALLBACK_FUNC_PTR gsw_cb)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_unreg_sta_event_callback(void *arg)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_sdk_interface_init()
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    return GSW_HAL_SUCCESS;
}

int is_module_loaded(const char *module_name)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    char cmd[MAX_COMMAND_LEN];
    snprintf(cmd, sizeof(cmd), "lsmod | grep %s", module_name);
    FILE *output = popen(cmd, "r");
    if (!output)
        return GSW_HAL_NORMAL_FAIL;
    char buffer[256];
    if (fgets(buffer, sizeof(buffer), output) == NULL)
    {
        pclose(output);
        return GSW_HAL_SUCCESS;
    }
    pclose(output);
    return 1;
}
/**
 * @brief load wifi driver
 * @retval 0: success
 * @retval other: fail
 */
int gsw_wifi_enable(void)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"%s - start.\n",__func__);
    if (execute_command("echo 1 > /sys/devices/platform/mbtk-sdh/pwr_ctrl") != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    sleep(1);
    if (!is_module_loaded("cfg80211"))
    {
        if (execute_command("modprobe cfg80211") != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"cfg80211 has insmod.\n");
    }

    if (!is_module_loaded("aic8800_bsp"))
    {
        char cmd[MAX_COMMAND_LEN];
        snprintf(cmd, sizeof(cmd), "modprobe %s", AIC8800_BSP_DRIVER_PATH);
        if (execute_command(cmd) != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"aic8800_bsp has insmod.\n");
    }

    if (!is_module_loaded("aic8800_fdrv"))
    {
        char cmd[MAX_COMMAND_LEN];
        snprintf(cmd, sizeof(cmd), "modprobe %s", AIC8800_FDRV_DRIVER_PATH);
        if (execute_command(cmd) != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"aic8800_fdrv has insmod.\n");
    }
    LOGI(GSW_WIFI,"%s - end.\n",__func__);
    return GSW_HAL_SUCCESS;
}

/**
 * @brief uninstall wifi driver
 * @retval 0: success
 * @retval other: fail
 */
int gsw_wifi_disable(void)
{
    if (handle())
        return GSW_HAL_NORMAL_FAIL;
    LOGI(GSW_WIFI,"%s - start.\n",__func__);
    if (is_module_loaded("aic8800_fdrv"))
    {
        if (execute_command("rmmod aic8800_fdrv") != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"aic8800_fdrv not insmod.\n");
    }

    if (is_module_loaded("aic8800_bsp"))
    {
        if (execute_command("rmmod aic8800_bsp") != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"aic8800_bsp not insmod.\n");
    }

    if (is_module_loaded("cfg80211"))
    {
        if (execute_command("rmmod cfg80211") != 0)
        {
            return GSW_HAL_NORMAL_FAIL;
        }
    }
    else
    {
        LOGI(GSW_WIFI,"cfg80211 not insmod.\n");
    }
    if (execute_command("echo 0 > /sys/devices/platform/mbtk-sdh/pwr_ctrl") != 0)
    {
        return GSW_HAL_NORMAL_FAIL;
    }
    sleep(1);
    LOGI(GSW_WIFI,"%s - end.\n",__func__);
    return GSW_HAL_SUCCESS;
}

int gsw_wifi_sta_disconnect(char *ssid)
{
    return GSW_HAL_SUCCESS;
}