Android WiFi 源码分析(四):Supplicant 启动 -- eloop 与 AIDL 的细节

// external_wpa_supplicant_8/wpa_supplicant/wpa_supplicant_i.h:283-324// （行号基于 Android 16 / API 36 版本，其他版本可能偏移）struct wpa_global {    struct wpa_supplicant *ifaces;        // 接口链表头（单链表）    struct wpa_params params;             // 命令行参数（debug level 等）    struct ctrl_iface_global_priv *ctrl_iface;  // 全局 ctrl socket    struct wpas_dbus_priv *dbus;          // D-Bus 连接    struct wpas_aidl_priv *aidl;          // AIDL binder 连接    void **drv_priv;                      // 各驱动的私有数据    size_t drv_count;                     // 已加载的驱动 wrapper 数量    struct os_time suspend_time;          // 挂起时间    struct p2p_data *p2p;                 // P2P 全局状态    struct wpa_supplicant *p2p_init_wpa_s;      // P2P 发起者    struct wpa_supplicant *p2p_group_formation; // P2P 建组中    struct wpa_supplicant *p2p_invite_group;    // P2P 邀请中    u8 p2p_dev_addr[ETH_ALEN];            // P2P 设备地址    struct dl_list p2p_srv_bonjour;       // Bonjour 服务列表    struct dl_list p2p_srv_upnp;          // UPnP 服务列表    int p2p_disabled;                     // P2P 是否禁用    int cross_connection;                 // 跨连接标志    struct wpa_freq_range_list p2p_disallow_freq; // P2P 禁用频率    struct wpa_freq_range_list p2p_go_avoid_freq; // GO 避开频率    enum wpa_conc_pref conc_pref;         // 并发优先级（STA vs P2P）    // ...省略 WiFi Display 和 PSK 列表字段...};

// external_wpa_supplicant_8/wpa_supplicant/wpa_supplicant_i.h:697-1150+// 精简：只展示核心字段，按功能分组，省略 P2P/MESH 等高级特性struct wpa_supplicant {    // ===== 身份与层级 =====    struct wpa_global *global;            // 所属全局对象    struct wpa_radio *radio;              // 共享的射频上下文    struct dl_list radio_list;            // radio::ifaces 的链表节点    struct wpa_supplicant *parent;        // 父接口（P2P group → P2P dev）    struct wpa_supplicant *p2pdev;        // 对应的 P2P device 接口    struct wpa_supplicant *next;          // global->ifaces 链表的下一个    unsigned char own_addr[ETH_ALEN];     // 自己的 MAC 地址    unsigned char perm_addr[ETH_ALEN];    // 永久 MAC 地址    char ifname[100];                     // 接口名（"wlan0"）    // ===== 当前连接信息 =====    u8 bssid[ETH_ALEN];                   // 当前连接的 AP 的 BSSID    u8 pending_bssid[ETH_ALEN];           // 正在关联的目标 BSSID    struct wpa_ssid *current_ssid;        // 当前网络配置    struct wpa_ssid *last_ssid;           // 上次连接的网络    struct wpa_bss *current_bss;          // 当前 AP 的扫描信息    unsigned int assoc_freq;              // 当前关联频率（MHz）    int disconnected;                     // 是否主动断开连接    int reassociate;                      // 是否正在重关联    bool roam_in_progress;                // 是否正在漫游    // ===== MLO（WiFi 7 多链路）=====    u8 ap_mld_addr[ETH_ALEN];             // AP MLD 地址    u8 mlo_assoc_link_id;                 // 关联的 link ID    u16 valid_links;                      // 有效的 link bitmap    struct {                              // 每个 link 的状态        u8 addr[ETH_ALEN];        u8 bssid[ETH_ALEN];        unsigned int freq;        struct wpa_bss *bss;        bool disabled;    } links[MAX_NUM_MLD_LINKS];    // ===== 安全参数（根据 Beacon/ProbeResp 的 WPA IE 选定）=====    int pairwise_cipher;                  // 成对密钥密码套件    int group_cipher;                     // 组密钥密码套件    int key_mgmt;                         // 密钥管理方式    int wpa_proto;                        // WPA 协议版本    int mgmt_group_cipher;                // 管理帧保护组密钥密码套件    // ===== 配置与网络列表 =====    struct wpa_config *conf;              // 配置对象（包含 network blocks 链表）    struct wpa_ssid *next_ssid;           // 下一个优先连接的网络    // ===== 驱动接口 =====    const struct wpa_driver_ops *driver;  // 驱动虚函数表    void *drv_priv;                       // 驱动的私有数据    u64 drv_flags;                        // 驱动能力标志位    u64 drv_flags2;                       // 驱动能力标志位（扩展）    int max_scan_ssids;                   // 驱动支持的扫描 SSID 数    unsigned int max_remain_on_chan;       // 驱动支持的 offchannel 时长    // ===== 密钥与 EAPOL 状态机 =====    struct wpa_sm *wpa;                   // WPA 状态机（四次握手/组密钥握手）    struct eapol_sm *eapol;               // EAPOL 状态机    unsigned int keys_cleared;            // 已清除的 key index bitmap    struct ptksa_cache *ptksa;            // PTKSA 缓存    // ===== 扫描相关 =====    enum wpa_states scan_prev_wpa_state;  // 扫描前的状态（扫描完成后恢复）    struct wpa_radio_work *scan_work;     // 当前扫描的 radio work    int scanning;                         // 是否正在扫描    int sched_scanning;                   // 是否正在 scheduled scan    struct os_reltime scan_trigger_time;  // 扫描触发时间    struct os_reltime scan_start_time;    // 扫描开始时间    struct os_reltime scan_min_time;      // 扫描结果最小新鲜度    struct os_reltime last_scan;          // 上次扫描完成时间    struct dl_list bss;                   // BSS 缓存链表    size_t num_bss;                       // BSS 缓存数量    int scan_interval;                    // 扫描间隔（秒）    int normal_scans;                     // 调度扫描前执行的常规扫描次数    struct wpa_bss **last_scan_res;       // 上次扫描结果数组    size_t last_scan_res_used;            // 已使用的扫描结果数    // ===== 状态与连接追踪 =====    enum wpa_states wpa_state;            // 当前 WPA 状态    int new_connection;                   // 是否是新连接    unsigned int consecutive_conn_failures; // 连续连接失败次数    struct os_reltime roam_start;         // 漫游开始时间    struct os_reltime roam_time;          // 漫游耗时    struct os_reltime session_start;      // 会话开始时间    struct os_reltime session_length;     // 会话时长    // ===== L2 与 EAPOL =====    struct l2_packet_data *l2;            // L2 层 packet socket（EAPOL 收发）    unsigned char last_eapol_src[ETH_ALEN]; // 上次收到 EAPOL 的源 MAC    int eapol_received;                   // 关联后收到的 EAPOL 包数    // ===== ctrl interface =====    struct ctrl_iface_priv *ctrl_iface;   // per-interface ctrl socket    // ... 省略 P2P（约 100 字段）、SME（约 40 字段）、    //        WPS、DPP、HS20、Mesh、TDLS 等功能模块字段 ...};

// external_wpa_supplicant_8/wpa_supplicant/wpa_supplicant_i.h:334-370struct wpa_radio {    char name[16];                        // radio 名称（驱动提供）    struct wpa_supplicant *external_scan_req_interface; // 外部扫描请求者    unsigned int num_active_works;        // 当前活跃的 work 数量    struct dl_list ifaces;                // 共享此 radio 的接口链表    struct dl_list work;                  // work 队列（按时间排序）};struct wpa_radio_work {    struct dl_list list;                  // radio->work 链表的节点    unsigned int freq;                    // 目标频率（0 = 所有频率）    const char *type;                     // work 类型（"scan"/"connect"/"p2p-scan"...）    struct wpa_supplicant *wpa_s;         // 所属接口    void (*cb)(struct wpa_radio_work *work, int deinit); // 回调函数    void *ctx;                            // 回调上下文    unsigned int started:1;               // 是否已开始执行    struct os_reltime time;               // 创建时间    unsigned int bands;                   // 涉及的频段 bitmap};

// external_wpa_supplicant_8/wpa_supplicant/config_ssid.h（精简）struct wpa_ssid {    struct wpa_ssid *next;            // 链表下一个节点    int id;                           // 网络 ID（Supplicant 内部分配）    int priority;                     // 连接优先级（数值越大越优先）    u8 ssid[SSID_MAX_LEN];           // SSID（最长 32 字节）    size_t ssid_len;                  // SSID 长度    u8 bssid[ETH_ALEN];              // 限定 BSSID（非空时只连指定 AP）    int key_mgmt;                     // 密钥管理方式（WPA-PSK / WPA-EAP / SAE / ...）    int proto;                        // 协议版本（WPA / RSN）    int pairwise_cipher;              // 成对密钥密码套件    int group_cipher;                 // 组密钥密码套件    u8 psk[PMK_LEN];                 // 原始 PSK（32 字节，已派生）    char *passphrase;                 // PSK 密码短语（8-63 字符，未派生）    char *sae_password;               // SAE 密码（WPA3）    // ... EAP 配置（eap_method / identity / password / ca_cert 等约 20 个字段）...    int disabled;                     // 是否禁用（用户在 Settings 中关闭了此网络）    int auto_disabled;                // 因连续失败被临时禁用    // ... 扫描过滤、漫游策略、BSS transition 等高级字段 ...};

// external_wpa_supplicant_8/wpa_supplicant/main.cintmain(int argc, char *argv[]){    struct wpa_interface *ifaces;    struct wpa_params params;    struct wpa_global *global;    int i, exitcode;    // ===== 第一步：OS 级初始化 =====    // 在 Android 上：降权到 wifi 用户（setuid/setgid/setgroups）、    // 保留 CAP_NET_ADMIN/CAP_NET_RAW 能力（capset）、初始化随机数种子    if (os_program_init())        return -1;    // 解析命令行参数    // Android 启动命令示例：    //   wpa_supplicant -O /data/vendor/wifi/wpa/sockets    //                  -g @android:wpa_wlan0    //                  -i wlan0 -D nl80211    os_memset(¶ms, 0, sizeof(params));    params.wpa_debug_level = MSG_INFO;    // ...解析 argc/argv...    // ===== 第二步：全局初始化 =====    // 创建 struct wpa_global，初始化 eloop，注册 EAP 方法    global = wpa_supplicant_init(¶ms);    if (global == NULL)        return -1;

    // ===== 第三步：为每个接口调用 add_iface =====    // 在 Android 上通常只有一个接口：wlan0    for (i = 0; i < params.iface_count; i++) {        wpa_s = wpa_supplicant_add_iface(global, &ifaces[i], NULL);        if (wpa_s == NULL)            return -1;    }    // ===== 第四步：进入事件循环 =====    // 从此刻起，进程进入事件驱动的无限循环    // 所有后续操作（扫描、关联、EAPOL 握手）都是 eloop 中的事件回调    exitcode = wpa_supplicant_run(global);    // 清理（只在进程终止时才执行到这里）    wpa_supplicant_deinit(global);    os_program_deinit();    return exitcode;}

// wpa_supplicant/wpa_supplicant.cstruct wpa_global * wpa_supplicant_init(struct wpa_params *params){    struct wpa_global *global;    // 1. 注册 wpa_msg 的 ifname 回调    wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);    // 2. 配置 debug 输出（文件 / syslog / stdout / Android logcat / tracing）    wpa_debug_open_file(params->wpa_debug_file_path);    wpa_debug_setup_stdout();    // 3. 【重要】注册所有 EAP 方法    //    包括：EAP-PEAP、EAP-TLS、EAP-TTLS、EAP-SIM、EAP-AKA、    //          EAP-AKA'、EAP-PWD、EAP-FAST、EAP-GTC 等数十种    //    每种 EAP 方法注册自己的 init/deinit/process/getKey 等回调    eap_register_methods();    // 4. 分配 global 结构体，逐字段拷贝参数    //    字符串字段（pid_file / ctrl_interface 等）通过 os_strdup 深拷贝    global = os_zalloc(sizeof(*global));    global->params.daemonize = params->daemonize;    global->params.wait_for_monitor = params->wait_for_monitor;    global->params.pid_file = os_strdup(params->pid_file);    global->params.ctrl_interface = os_strdup(params->ctrl_interface);    // ... 其他字段逐个拷贝 ...    // 5. 【核心】初始化 eloop 事件循环    //    在 Linux/Android 上使用 epoll_create1(0)    if (eloop_init()) {        wpa_supplicant_deinit(global);        return NULL;    }

    // 6. 初始化随机数生成器    //    从 /dev/urandom 读取种子 + 可选 entropy file    random_init(params->entropy_file);    // 7. 创建全局 ctrl interface（Unix domain socket）    //    路径如：@android:wpa_wlan0（Android abstract socket namespace）    wpa_supplicant_global_ctrl_iface_init(global);    // 8. 通知 D-Bus 等外部系统    wpas_notify_supplicant_initialized(global);    // 9. 统计可用的驱动数量    //    遍历 wpa_drivers[] 数组（包含 nl80211、wext 等驱动 wrapper）    //    为每个驱动分配 priv 指针数组    // 10. WiFi Display 初始化（如果编译了 CONFIG_WIFI_DISPLAY）    wifi_display_init(global);    // 11. 注册周期性清理 timer    //    每 WPA_SUPPLICANT_CLEANUP_INTERVAL 秒清理过期的 BSS 条目、    //    重新加载配置文件    eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,                           wpas_periodic, global, NULL);    return global;}

// wpa_supplicant/wpa_supplicant.cstaticintwpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,                                     const struct wpa_interface *iface){    // ===== 第一阶段：基础准备（步骤 1-4） =====    // 1. 读取配置（从 wpa_supplicant.conf）    //    在 Android 上，这个文件由 WiFiService 通过 AIDL 动态写入    //    （因为包含加密后的密码，不能明文存储）    wpa_s->conf = wpa_config_read(wpa_s->confname, NULL, false);    if (wpa_s->conf == NULL)        return -1;    // 2. 复制接口名（通常是 "wlan0"）    os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));    // 3. 设置 EAPOL 端口状态为 disabled    //    在 802.1X 中，端口开始是 disabled 的，    //    只有 EAPOL 认证成功后才会变为 authorized    eapol_sm_notify_portEnabled(wpa_s->eapol, false);    eapol_sm_notify_portValid(wpa_s->eapol, false);    // 4. 【核心】选择和初始化驱动    if (wpas_init_driver(wpa_s, iface))        return -1;    //   内部调用链：    //     wpa_supplicant_set_driver(wpa_s, "nl80211")    //     └── wpa_drv_init(wpa_s, "wlan0")    //         └── wpa_driver_nl80211_init() → 打开 netlink socket    //         └── nl80211_get_capabilities() → 获取驱动能力    //         └── radio_add_interface() → 加入 radio 管理

    // ===== 第二阶段：能力探测与 WPA 初始化（步骤 5-8） =====    // 5. 初始化 WPA 状态机（WPA/WPA2/WPA3 协商的核心）    wpa_supplicant_init_wpa(wpa_s);    // 6. 获取硬件特性数据（如 ACS channel list）    wpa_drv_get_hw_feature_data(wpa_s, ...);    // 7. 获取驱动能力（max_scan_ssids、max_remain_on_chan 等）    wpa_drv_get_capa(wpa_s);    // 8. 驱动最终配置    if (wpa_supplicant_driver_init(wpa_s))        return -1;    //   内部步骤：    //     a. wpa_supplicant_update_mac_addr() → 获取 MAC 地址    //        （内部调用 l2_packet_init() 初始化 EAPOL L2 packet socket）    //     c. wpa_clear_keys() → 清除所有 key material    //     d. wpa_drv_flush_pmkid() → 清空 PMKID 缓存    //     e. wpa_supplicant_enabled_networks() → 启用已配置的网络

    // ===== 第三阶段：高级功能与对外接口（步骤 9-12） =====    // 9. 初始化各种高级功能    wpas_wps_init(wpa_s);           // WPS (WiFi Protected Setup)    wpas_dpp_init(wpa_s);           // DPP (Device Provisioning Protocol / WiFi Easy Connect)    wpas_nan_usd_init(wpa_s);       // NAN USD (Neighbor Awareness Networking)    wpa_supplicant_init_eapol(wpa_s); // EAPOL 状态机    // 10. 创建 per-interface ctrl socket    //     路径如：/data/vendor/wifi/wpa/sockets/wlan0    if (wpa_supplicant_ctrl_iface_init(wpa_s))        return -1;    // 11. 初始化 GAS query（用于 ANQP/Hotspot 2.0）    wpa_s->gas = gas_query_init(wpa_s);    // 12. 初始化 P2P（如果支持）    wpas_p2p_init(wpa_s->global, wpa_s);    return 0;}

// src/utils/eloop.c:163-192// 精简说明：实际源码通过 CONFIG_ELOOP_EPOLL/POLL/SELECT/KQUEUE// 条件编译支持 4 种后端，以下展示 Android 平台的 epoll 路径。// 源码有精简（去除了 select/poll/kqueue 分支、trace 代码）。inteloop_init(void){    os_memset(&eloop, 0, sizeof(eloop));    dl_list_init(&eloop.timeout);    // Android/Linux 走 epoll 路径    eloop.epollfd = epoll_create1(0);    if (eloop.epollfd < 0) {        wpa_printf(MSG_ERROR, "%s: epoll_create1 failed. %s",                   __func__, strerror(errno));        return -1;    }    // 三个 socket table 的 type 标签——在 eloop_sock_table_dispatch() 中    // 用于将 epoll 返回的 EPOLLIN/EPOLLOUT/EPOLLERR 映射到对应的 handler 数组    // EVENT_TYPE_* 是 eloop 内部定义的私有枚举，与 epoll 事件位掩码一一对应    eloop.readers.type = EVENT_TYPE_READ;    eloop.writers.type = EVENT_TYPE_WRITE;    eloop.exceptions.type = EVENT_TYPE_EXCEPTION;    return 0;}

// src/utils/eloop.c:1071-1253（行号对应原始含条件编译的源码，精简为 epoll 路径后仅作参考）voideloop_run(void){    int timeout_ms = -1;    int res;    struct os_reltime tv, now;    while (!eloop.terminate &&           (!dl_list_empty(&eloop.timeout) ||            eloop.readers.count > 0 ||            eloop.writers.count > 0 ||            eloop.exceptions.count > 0)) {        struct eloop_timeout *timeout;        // 1. 处理待决的终止信号        if (eloop.pending_terminate) {            eloop_process_pending_signals();            if (eloop.terminate)                break;        }        // 2. 计算下一个 timeout 的到期时间        //    取 timer 链表头（按到期时间排序），        //    计算距离 now 的时间差（秒+微秒 → 毫秒）        timeout = dl_list_first(&eloop.timeout, struct eloop_timeout, list);        if (timeout) {            os_get_reltime(&now);            if (os_reltime_before(&now, &timeout->time))                os_reltime_sub(&timeout->time, &now, &tv);            else                tv.sec = tv.usec = 0;            timeout_ms = tv.sec * 1000 + tv.usec / 1000;        }        // 3. 调用 epoll_wait 阻塞等待        //    可能被三类事件唤醒：        //    a. 已注册的 fd 变为可读/可写/异常        //    b. timeout 到期（返回 0）        //    c. 信号到达（返回 -1，errno == EINTR）        if (eloop.count == 0) {            res = 0;        } else {            res = epoll_wait(eloop.epollfd, eloop.epoll_events,                             eloop.count, timeout_ms);        }        // 4. 错误处理        if (res < 0 && errno != EINTR && errno != 0) {            wpa_printf(MSG_ERROR, "eloop: epoll: %s", strerror(errno));            goto out;        }

        // 5. 清除 changed 标志 + 处理待决信号        eloop.readers.changed = 0;        eloop.writers.changed = 0;        eloop.exceptions.changed = 0;        eloop_process_pending_signals();        // 6. 处理到期的 timer        //    每次循环只处理链表头的第一个 timer（timer 按到期时间排序）。        //    处理完一个 timer 后，while 循环重新进入，epoll_wait 重新计算        //    最近一个 timer 的超时——如果还有到期的 timer，下一轮会继续处理，        //    直到所有到期 timer 都被消费。        timeout = dl_list_first(&eloop.timeout, struct eloop_timeout, list);        if (timeout) {            os_get_reltime(&now);            if (!os_reltime_before(&now, &timeout->time)) {                void *eloop_data = timeout->eloop_data;                void *user_data = timeout->user_data;                eloop_timeout_handler handler = timeout->handler;                eloop_remove_timeout(timeout);                handler(eloop_data, user_data);            }        }        // 7. res == 0 表示纯 timeout 唤醒，无 I/O 事件，跳过 dispatch        if (res <= 0)            continue;        // 8. 如果 socket 表在 signal/timeout handler 中被修改，重试        if (eloop.readers.changed ||            eloop.writers.changed ||            eloop.exceptions.changed) {            continue;        }        // 9. 分发 I/O 事件到注册的 callback        //    epoll 路径通过 event.data.fd 查找对应 socket 的 callback        eloop_sock_table_dispatch(eloop.epoll_events, res);    }    eloop.terminate = 0;out:    return;}

// wpa_supplicant/aidl/vendor/aidl.cppstruct wpas_aidl_priv *wpas_aidl_init(struct wpa_global *global){    struct wpas_aidl_priv *priv;    priv = os_zalloc(sizeof(*priv));    if (!priv)        return NULL;    priv->global = global;    // 1. 设置 binder 轮询    //    返回一个 fd，当有 binder 请求到达时该 fd 变为可读    ABinderProcess_setupPolling(&priv->aidl_fd);    // 2. 把 binder fd 注册到 eloop    //    从此刻起，Java 端的 binder 请求会触发 eloop 中的    //    wpas_aidl_sock_handler() 回调    if (eloop_register_read_sock(priv->aidl_fd,                                 wpas_aidl_sock_handler,                                 global, priv) < 0) {        wpas_aidl_deinit(priv);        return NULL;    }    // 3. 创建 Supplicant 对象（继承自 BnSupplicant）    //    这个对象持有 struct wpa_global* 指针，    //    当 Java 调用 addStaInterface 时，内部调用 wpa_supplicant_add_iface()    aidl_manager = AidlManager::getInstance();    // 4. 向 ServiceManager 注册 AIDL 服务    //    服务名：android.hardware.wifi.supplicant.ISupplicant/default    if (aidl_manager->registerAidlService(global) != 0) {        wpas_aidl_deinit(priv);        return NULL;    }    return priv;}

// packages_modules_Wifi/service/java/com/android/server/wifi/SupplicantStaIfaceHalAidlImpl.javapublic class SupplicantStaIfaceHalAidlImpl {    private ISupplicant mISupplicant;    private Map<String, ISupplicantStaIface> mISupplicantStaIfaces;    // 1. 等待服务注册（阻塞直到超时或服务出现）    boolean initialize() {        if (!ServiceManager.isDeclared(                "android.hardware.wifi.supplicant.ISupplicant/default")) {            return false;        }        return true;    }    // 2. 连接到 AIDL 服务    boolean startDaemon() {        mISupplicant = ISupplicant.Stub.asInterface(            ServiceManager.waitForDeclaredService(                "android.hardware.wifi.supplicant.ISupplicant/default"));        // 3. 注册 DeathRecipient（当 Supplicant 进程崩溃时收到通知）        mISupplicant.asBinder().linkToDeath(mDeathRecipient, 0);        return true;    }    // 4. 设置 STA 接口    ISupplicantStaIface setupIface(String ifaceName) {        // 调用 AIDL 方法 addStaInterface        // 在 native 侧：Supplicant::addStaInterface()        //     └── wpa_supplicant_add_iface(wpa_global_, "wlan0", ...)        ISupplicantStaIface iface = mISupplicant.addStaInterface(ifaceName);        mISupplicantStaIfaces.put(ifaceName, iface);        return iface;    }    // 5. 注册回调（接收 Supplicant 事件通知）    void registerCallback(String ifaceName, ISupplicantStaIfaceCallback callback) {        mISupplicantStaIfaces.get(ifaceName).registerCallback(callback);    }}

// external_wpa_supplicant_8/src/common/defs.h:248-353enum wpa_states {    /**     * WPA_DISCONNECTED - 断开连接状态     *     * 客户端未关联，但可能随时开始搜索 AP。     * 连接丢失时进入此状态。     */    WPA_DISCONNECTED,           // 0    /**     * WPA_INTERFACE_DISABLED - 接口已禁用     *     * 网络接口被禁用时进入（如 rfkill 关闭 WiFi）。     * Supplicant 拒绝任何使用射频的新操作，直到接口重新启用。     */    WPA_INTERFACE_DISABLED,     // 1    /**     * WPA_INACTIVE - 非活跃状态     *     * 配置中没有启用的网络时进入。Supplicant 不会主动关联，     * 需要外部交互（ctrl_iface 调用添加或启用网络）来启动关联。     */    WPA_INACTIVE,               // 2    /**     * WPA_SCANNING - 正在扫描网络     *     * Supplicant 开始扫描时进入。     */    WPA_SCANNING,               // 3    /**     * WPA_AUTHENTICATING - 正在与 BSS 认证     *     * 找到合适的 BSS 后，驱动配置为尝试与该 BSS 认证。     * 仅在使用 wpa_supplicant 作为 SME 的驱动中使用。     */    WPA_AUTHENTICATING,         // 4    /**     * WPA_ASSOCIATING - 正在与 BSS 关联     *     * ap_scan=1 模式下驱动配置为尝试关联。     * ap_scan=2 模式下驱动配置为使用已配置的 SSID 和安全策略关联。     */    WPA_ASSOCIATING,            // 5    /**     * WPA_ASSOCIATED - 关联已完成     *     * 驱动报告关联成功。如果使用 IEEE 802.1X，     * Supplicant 保持在此状态直到 EAPOL 认证完成。     */    WPA_ASSOCIATED,             // 6    /**     * WPA_4WAY_HANDSHAKE - WPA 四次握手进行中     *     * WPA-PSK: 关联后收到第一个 EAPOL-Key 帧时进入。     * WPA-EAP: IEEE 802.1X/EAPOL 认证完成后进入。     */    WPA_4WAY_HANDSHAKE,         // 7    /**     * WPA_GROUP_HANDSHAKE - WPA 组密钥握手进行中     *     * 四次握手完成后（Supplicant 发出 msg 4/4），     * 或 AP 发起组密钥更新时（收到 msg 1/2）。     */    WPA_GROUP_HANDSHAKE,        // 8    /**     * WPA_COMPLETED - 所有认证已完成     *     * WPA2: 四次握手成功完成。     * WPA: 组密钥握手完成后。     * IEEE 802.1X: 收到动态密钥后（或 EAP 认证完成后）。     * 静态 WEP/明文: 关联完成后。     *     * 此状态表示数据连接已完全配置好。     */    WPA_COMPLETED               // 9};

// external_wpa_supplicant_8/wpa_supplicant/wpa_supplicant.c:1032-1209// 精简：去掉 CONFIG_P2P/CONFIG_SME/CONFIG_FILS 等条件编译分支voidwpa_supplicant_set_state(struct wpa_supplicant *wpa_s,                              enum wpa_states state){    enum wpa_states old_state = wpa_s->wpa_state;    wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",            wpa_supplicant_state_txt(wpa_s->wpa_state),            wpa_supplicant_state_txt(state));    // ===== 阶段 1：准备阶段（新状态的副作用） =====    // 到达 COMPLETED → 记录漫游时间    if (state == WPA_COMPLETED &&        os_reltime_initialized(&wpa_s->roam_start)) {        os_reltime_age(&wpa_s->roam_start, &wpa_s->roam_time);        wpa_s->roam_start.sec = 0;        wpa_s->roam_start.usec = 0;        wpas_notify_auth_changed(wpa_s);        wpas_notify_roam_time(wpa_s);        wpas_notify_roam_complete(wpa_s);    }    // 离开漫游状态（回到 DISCONNECTED）→ 清除漫游时间    else if (state == WPA_DISCONNECTED &&             os_reltime_initialized(&wpa_s->roam_start)) {        wpa_s->roam_start.sec = 0;        wpa_s->roam_start.usec = 0;        wpa_s->roam_time.sec = 0;        wpa_s->roam_time.usec = 0;        wpas_notify_roam_complete(wpa_s);    }    // 接口被禁用 → 重置 normal_scans    if (state == WPA_INTERFACE_DISABLED)        wpa_s->normal_scans = 0;    // 到达 COMPLETED → 清理 connect work、重置 normal_scans    if (state == WPA_COMPLETED) {        wpas_connect_work_done(wpa_s);        wpa_s->normal_scans = 0;    }    // ===== 阶段 2：新连接副作用 =====    // 离开 SCANNING → 通知扫描停止    if (state != WPA_SCANNING)        wpa_supplicant_notify_scanning(wpa_s, 0);    // 到达 COMPLETED 且是新连接 → 发送 WPA_EVENT_CONNECTED 事件    if (state == WPA_COMPLETED && wpa_s->new_connection) {        struct wpa_ssid *ssid = wpa_s->current_ssid;        char mld_addr[50];        mld_addr[0] = '\0';        if (wpa_s->valid_links)            os_snprintf(mld_addr, sizeof(mld_addr),                        " ap_mld_addr=" MACSTR,                        MAC2STR(wpa_s->ap_mld_addr));        wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "                MACSTR " completed [id=%d id_str=%s%s]%s",                MAC2STR(wpa_s->bssid),                ssid ? ssid->id : -1,                ssid && ssid->id_str ? ssid->id_str : "",                fils_hlp_sent ? " FILS_HLP_SENT" : "", mld_addr);        // 连接成功 → 清除临时禁用、重置连续失败计数        wpas_clear_temp_disabled(wpa_s, ssid, 1);        wpa_s->consecutive_conn_failures = 0;        wpa_s->new_connection = 0;        wpa_drv_set_operstate(wpa_s, 1);     // 通知内核接口 UP        wpa_s->after_wps = 0;        wpa_s->known_wps_freq = 0;        sme_sched_obss_scan(wpa_s, 1);       // 调度 OBSS 扫描    }    // 回到 DISCONNECTED / ASSOCIATING / ASSOCIATED → 标记新连接    else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||             state == WPA_ASSOCIATED) {        wpa_s->new_connection = 1;        wpa_drv_set_operstate(wpa_s, 0);     // 通知内核接口 DOWN        sme_sched_obss_scan(wpa_s, 0);    }

    // ===== 阶段 3：赋值 =====    wpa_s->wpa_state = state;    // ===== 阶段 4：赋值后副作用（依赖新状态值） =====    // 到达 COMPLETED 但切换了 SSID → 重置后台扫描    if (state == WPA_COMPLETED && wpa_s->current_ssid != wpa_s->bgscan_ssid)        wpa_supplicant_reset_bgscan(wpa_s);    else if (state < WPA_ASSOCIATED)        wpa_supplicant_stop_bgscan(wpa_s);    // 超过 SCANNING → 停止自动扫描    if (state > WPA_SCANNING)        wpa_supplicant_stop_autoscan(wpa_s);    // DISCONNECTED 或 INACTIVE → 启动自动扫描    if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)        wpa_supplicant_start_autoscan(wpa_s);    // 完成态 / 禁用态 / 非活跃态 → 重置 BTM    if (state == WPA_COMPLETED || state == WPA_INTERFACE_DISABLED ||        state == WPA_INACTIVE)        wnm_btm_reset(wpa_s);    // 从已关联掉到未关联 → 通知 WMM AC 断开    if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)        wmm_ac_notify_disassoc(wpa_s);    // ===== 阶段 5：状态变更通知（仅当状态确实变化时） =====    if (wpa_s->wpa_state != old_state) {        wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);        // 通知 P2P Device 接口        wpas_p2p_indicate_state_change(wpa_s);        // COMPLETED 进出 → 通知认证变更        if (wpa_s->wpa_state == WPA_COMPLETED ||            old_state == WPA_COMPLETED)            wpas_notify_auth_changed(wpa_s);        // 到达 COMPLETED 且 bigtk 已设置但未验证 → 验证 SSID beacon protection        if (wpa_s->wpa_state == WPA_COMPLETED &&            wpa_s->bigtk_set && !wpa_s->ssid_verified)            wpas_verify_ssid_beacon_prot(wpa_s);    }}

内核 nl80211 事件    │    ▼wpa_driver_nl80211_event_receive()   ← eloop callback（fd 可读）    │  解析 netlink message，提取事件类型和 data    ▼wpa_supplicant_event()               ← 事件分发总入口（本章主题）    │  switch (event) → 按类型分发    ├── EVENT_AUTH     → sme_event_auth()    ├── EVENT_ASSOC    → wpa_supplicant_event_assoc()    ├── EVENT_DISASSOC → wpas_event_disassoc()    ├── EVENT_DEAUTH   → wpas_event_deauth()    ├── EVENT_SCAN_RESULTS → wpa_supplicant_event_scan_results()    ├── EVENT_EAPOL_RX → wpa_supplicant_rx_eapol()    └── ... (30+ 种事件)

// external_wpa_supplicant_8/wpa_supplicant/events.c:6274-6445// 精简：去掉 CONFIG_FST/CONFIG_TDLS/CONFIG_WNM 等条件编译分支，//       保留核心 STA 事件路径voidwpa_supplicant_event(void *ctx, enum wpa_event_type event,                          union wpa_event_data *data){    struct wpa_supplicant *wpa_s = ctx;    // ===== 入口守卫：接口禁用时忽略大多数事件 =====    if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED &&        event != EVENT_INTERFACE_ENABLED &&        event != EVENT_INTERFACE_STATUS &&        event != EVENT_SCAN_RESULTS &&        event != EVENT_SCHED_SCAN_STOPPED) {        wpa_dbg(wpa_s, MSG_DEBUG,                "Ignore event %s (%d) while interface is disabled",                event_to_string(event), event);        return;    }    // ===== 事件分发（switch 30+ 种事件类型） =====    switch (event) {    case EVENT_AUTH:        // 认证结果（仅 SME 模式使用）        sme_event_auth(wpa_s, data);        wpa_s->auth_status_code = data->auth.status_code;        wpas_notify_auth_status_code(wpa_s);        break;    case EVENT_ASSOC:        // 关联成功 —— 核心路径        if (wpa_s->disconnected) {            wpa_printf(MSG_INFO,                       "Ignore unexpected EVENT_ASSOC in disconnected state");            break;        }        wpa_supplicant_event_assoc(wpa_s, data);        wpa_s->assoc_status_code = WLAN_STATUS_SUCCESS;        // 如果驱动报告 authorized 或 FILS 已完成 → 立即推进到授权        if (data &&            (data->assoc_info.authorized ||             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&              wpa_fils_is_completed(wpa_s->wpa))))            wpa_supplicant_event_assoc_auth(wpa_s, data);        break;    case EVENT_DISASSOC:        // 收到 Disassociation 帧        // 省略 CONFIG_TESTING_OPTIONS 守卫分支        wpas_event_disassoc(wpa_s,                            data ? &data->disassoc_info : NULL);        break;    case EVENT_DEAUTH:        // 收到 Deauthentication 帧        // 省略 CONFIG_TESTING_OPTIONS 守卫分支（ignore_auth_resp 等）        wpas_event_deauth(wpa_s,                          data ? &data->deauth_info : NULL);        break;

    case EVENT_SCAN_STARTED:        // 扫描已开始（硬件确认）        if (wpa_s->own_scan_requested ||            (data && !data->scan_info.external_scan)) {            os_get_reltime(&wpa_s->scan_start_time);            wpa_s->own_scan_requested = 0;            wpa_s->own_scan_running = 1;            wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED);        } else {            wpa_dbg(wpa_s, MSG_DEBUG, "External program started a scan");            wpa_s->radio->external_scan_req_interface = wpa_s;        }        break;    case EVENT_SCAN_RESULTS:        // 扫描结果到达 —— 核心路径        if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {            wpa_s->scan_res_handler = NULL;            wpa_s->own_scan_running = 0;            break;        }        // 记录扫描耗时        if (!(data && data->scan_info.external_scan) &&            os_reltime_initialized(&wpa_s->scan_start_time)) {            struct os_reltime now, diff;            os_get_reltime(&now);            os_reltime_sub(&now, &wpa_s->scan_start_time, &diff);            wpa_s->wps_scan_done = true;        }        // 处理扫描结果（解析、缓存、通知上层）        if (wpa_supplicant_event_scan_results(wpa_s, data))            break; /* interface may have been removed */        wpa_s->own_scan_running = 0;        // 检查是否有下一个 radio work 需要执行        radio_work_check_next(wpa_s);        break;    case EVENT_ASSOC_REJECT:        // 关联被 AP 拒绝        wpas_event_assoc_reject(wpa_s, data);        break;    case EVENT_AUTH_TIMED_OUT:        // 认证超时（SME 模式）        if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)            sme_event_auth_timed_out(wpa_s, data);        break;    case EVENT_ASSOC_TIMED_OUT:        // 关联超时（SME 模式）        if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)            sme_event_assoc_timed_out(wpa_s, data);        break;

    case EVENT_EAPOL_RX:        // 收到 EAPOL 帧 → 推入 EAPOL 状态机        wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src,                                data->eapol_rx.data,                                data->eapol_rx.data_len,                                data->eapol_rx.encrypted);        break;    case EVENT_SIGNAL_CHANGE:        // 信号强度变化 → 通知上层        wpa_bss_update_level(wpa_s->current_bss,                             data->signal_change.data.signal);        bgscan_notify_signal_change(wpa_s, ...);        wpas_notify_signal_change(wpa_s);        break;    case EVENT_INTERFACE_ENABLED:        // 接口重新启用 → 从 WPA_INTERFACE_DISABLED 恢复        if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {            wpa_supplicant_update_mac_addr(wpa_s);            wpa_supplicant_set_default_scan_ies(wpa_s);            wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);            wpa_s->scan_req = NORMAL_SCAN_REQ;            wpa_supplicant_req_scan(wpa_s, 0, 0);        }        break;    case EVENT_RX_MGMT:        // 收到管理帧 → 按子类型分发给 P2P/IBSS/Mesh/PASN/SAE 等模块        // （此处省略约 100 行的子类型分发逻辑）        break;    case EVENT_MICHAEL_MIC_FAILURE:        // Michael MIC 失败 → 可能是 TKIP 攻击        wpa_supplicant_event_michael_mic_failure(wpa_s, data);        break;    // ... 更多事件类型：EVENT_REMAIN_ON_CHANNEL、EVENT_CH_SWITCH、    //     EVENT_DFS_*、EVENT_TX_STATUS、EVENT_INTERFACE_MAC_CHANGED ...    }}

// hardware_interfaces/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicant.aidl@VintfStabilityinterface ISupplicant {    // ===== 接口管理（核心方法） =====    @PropagateAllowBlocking ISupplicantStaIface addStaInterface(in String ifName);     // 添加 STA 接口    @PropagateAllowBlocking ISupplicantP2pIface addP2pInterface(in String ifName);     // 添加 P2P 接口    void removeInterface(in IfaceInfo ifaceInfo);              // 移除接口    @PropagateAllowBlocking ISupplicantStaIface getStaInterface(in String ifName);     // 获取已有 STA 接口    @PropagateAllowBlocking ISupplicantP2pIface getP2pInterface(in String ifName);     // 获取已有 P2P 接口    IfaceInfo[] listInterfaces();                           // 列出所有接口    // ===== 回调注册 =====    void registerCallback(in ISupplicantCallback callback);    // 注册全局回调    void registerNonStandardCertCallback(in INonStandardCertCallback callback);    // ===== 全局控制 =====    void setDebugParams(in DebugLevel level, in boolean showTimestamp, in boolean showKeys);    DebugLevel getDebugLevel();    void setConcurrencyPriority(in IfaceType type);            // 设置 STA/P2P 并发优先级    oneway void terminate();                                       // 终止服务}

// hardware_interfaces/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantStaIface.aidl@VintfStabilityinterface ISupplicantStaIface {    // ===== 网络管理 =====    @PropagateAllowBlocking ISupplicantStaNetwork addNetwork();         // 添加网络配置 → 返回 network 对象    voidremoveNetwork(inint id);                  // 删除网络    int[] listNetworks();                        // 列出所有网络 ID    @PropagateAllowBlocking ISupplicantStaNetwork getNetwork(inint id);    // 获取指定网络    // ===== 连接控制 =====    voiddisconnect();                           // 断开当前连接    voidreassociate();                          // 强制重新关联    voidreconnect();                            // 重新连接（仅当已断开时）    voidenableAutoReconnect(in boolean enable);    // 启用/禁用自动重连    // ===== 回调注册 =====    voidregisterCallback(in ISupplicantStaIfaceCallback callback);    // ===== 射频控制 =====    intaddExtRadioWork(in String name, inint freqInMhz, inint timeoutInSec); // 外部射频任务    voidremoveExtRadioWork(inint id);             // 取消外部射频任务    // ===== 高级功能入口 =====    voidsetPowerSave(in boolean enable);           // 省电模式    voidsetCountryCode(inbyte[] code);            // 国家码    voidsetBtCoexistenceMode(in BtCoexistenceMode mode);  // BT 共存    voidsetBtCoexistenceScanModeEnabled(in boolean enable);    // ... DPP, WPS, ANQP, TDLS, QoS, USD 等 30+ 个方法 ...}

// hardware_interfaces/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantStaNetwork.aidl@VintfStabilityinterface ISupplicantStaNetwork {    // ===== 核心配置 =====    voidsetSsid(inbyte[] ssid);                   // 设置 SSID（最长 32 字节）    voidsetBssid(inbyte[] bssid);                 // 设置目标 BSSID（限定 AP）    voidsetKeyMgmt(in KeyMgmtMask keyMgmtMask);    // 设置密钥管理方式    voidsetPskPassphrase(in String psk);           // 设置 PSK 密码短语（8-63 字符）    voidsetPsk(inbyte[] psk);                     // 设置原始 PSK（32 字节）    voidsetSaePassword(in String saePassword);     // 设置 SAE 密码（WPA3）    voidsetSaePasswordId(in String saePasswordId); // 设置 SAE 密码 ID    // ===== 安全套件 =====    voidsetProto(in ProtoMask protoMask);          // WPA/RSN 协议版本    voidsetPairwiseCipher(in PairwiseCipherMask mask);   // 成对密钥密码    voidsetGroupCipher(in GroupCipherMask mask);         // 组密钥密码    voidsetGroupMgmtCipher(in GroupMgmtCipherMask mask); // 管理帧保护密码    voidsetRequirePmf(in boolean enable);          // 要求 PMF    // ===== EAP 配置 =====    voidsetEapMethod(in EapMethod method);         // EAP 方法    voidsetEapPhase2Method(in EapPhase2Method method); // Phase 2 方法    voidsetEapIdentity(inbyte[] identity);    voidsetEapPassword(inbyte[] password);    voidsetEapCACert(in String path);              // CA 证书路径    voidsetEapClientCert(in String path);          // 客户端证书路径    voidsetEapPrivateKeyId(in String id);          // 私钥 ID（智能卡）    // ===== 连接控制 =====    @PropagateAllowBlocking voidselect();          // 发起连接    voidenable(in boolean noConnect);              // 启用网络    voiddisable();                                 // 禁用网络    // ===== 查询 =====    intgetId();                                 // 获取网络 ID    byte[] getSsid();                            // 获取 SSID    String getPskPassphrase();                   // 获取密码短语    IfaceType getType();                         // 获取接口类型    // ... 更多 getter/setter ...}

// hardware_interfaces/wifi/supplicant/aidl/android/hardware/wifi/supplicant/// ISupplicantStaIfaceCallback.aidl@VintfStabilityoneway interface ISupplicantStaIfaceCallback {    // 状态变化通知（核心）    void onStateChanged(StaIfaceCallbackState newState, byte[] bssid,                        int id, byte[] ssid, boolean filsHlpSent);    void onSupplicantStateChanged(SupplicantStateChangeData stateChangeData); // v2    // 连接事件    void onDisconnected(byte[] bssid, boolean locallyGenerated,                        StaIfaceReasonCode reasonCode);    void onAssociationRejected(AssociationRejectionData assocRejectData);    void onAuthenticationTimeout(byte[] bssid);    // 网络事件    void onNetworkAdded(int id);    void onNetworkRemoved(int id);    void onNetworkNotFound(byte[] ssid);    // 安全事件    void onEapFailure(byte[] bssid, int errorCode);    void onPmkCacheAdded(long expirationTimeInSec, byte[] serializedEntry); // deprecated    void onPmkSaCacheAdded(PmkSaCacheData pmkSaData); // v2 replacement    // BSS 事件    void onBssidChanged(BssidChangeReason reason, byte[] bssid);    void onBssFrequencyChanged(int frequencyMhz);    void onBssTmHandlingDone(BssTmData tmData);    // ... WPS/DPP/QoS/MLO/USD 等 30+ 个回调方法 ...}

wpa_s->wpa_state 变化    │    ▼wpa_supplicant_set_state()  (阶段 5: wpas_notify_state_changed)    │    ├──→ wpa_msg_ctrl() → "WPA_EVENT_STATE_CHANGED" → ctrl socket    │       （wpa_cli 可见，用于调试）    │    └──→ wpas_aidl_notify_state_changed()            │  aidl/vendor/aidl.cpp            ▼          SupplicantStaIfaceCallback::onStateChanged()  [Binder 跨进程]            │            ▼          SupplicantStaIfaceCallbackAidlImpl::onStateChanged()            │  packages_modules_Wifi/.../SupplicantStaIfaceHalAidlImpl.java            ▼          WifiMonitor.broadcastSupplicantStateChangeEvent()            │            ▼          ClientModeImpl (StateMachine) → 更新连接状态

// external_wpa_supplicant_8/src/drivers/driver.h:3097-5353// 精简：只展示代表性函数指针（完整结构体约 2256 行，包含 60+ 函数指针）struct wpa_driver_ops {    const char *name;                            // 驱动名称（"nl80211"）    const char *desc;                            // 描述    // 虚函数表 —— 每个驱动实现自己的版本    void * (*init)(void *ctx, const char *ifname);    // 初始化    void (*deinit)(void *priv);                       // 反初始化    int (*get_bssid)(void *priv, u8 *bssid);          // 获取 BSSID    int (*get_ssid)(void *priv, u8 *ssid);            // 获取 SSID    int (*set_key)(void *priv, struct wpa_driver_set_key_params *params); // 设置密钥    int (*associate)(void *priv, struct wpa_driver_associate_params *params); // 关联    int (*deauthenticate)(void *priv, const u8 *addr, u16 reason_code);  // 去认证    int (*get_capa)(void *priv, struct wpa_driver_capa *capa);           // 获取能力    int (*send_mlme)(void *priv, const u8 *data, size_t data_len, ...);  // 发送管理帧    void (*poll)(void *priv);                        // 轮询关联信息    int (*set_operstate)(void *priv, int state);     // 设置 operstate    struct hostapd_hw_modes * (*get_hw_feature_data)(void *priv, ...); // 硬件特性    // ... 共约 60 个函数指针 ...};

// Supplicant 核心代码通过 wpa_drv_* 宏调用，而不是直接调用 driver->*// wpa_supplicant/driver_i.hstatic inline intwpa_drv_associate(struct wpa_supplicant *wpa_s,                                     struct wpa_driver_associate_params *params){    if (wpa_s->driver->associate)        return wpa_s->driver->associate(wpa_s->drv_priv, params);    return -1;}// nl80211 驱动实现（wpa_driver_nl80211_ops）// src/drivers/driver_nl80211.cconst struct wpa_driver_ops wpa_driver_nl80211_ops = {    .name = "nl80211",    .desc = "Linux nl80211/cfg80211",    .init = wpa_driver_nl80211_init,    .deinit = wpa_driver_nl80211_deinit,    .get_bssid = wpa_driver_nl80211_get_bssid,    .get_ssid = wpa_driver_nl80211_get_ssid,    .set_key = wpa_driver_nl80211_set_key,    .associate = wpa_driver_nl80211_associate,    // ... 填充所有函数指针 ...};

wpa_supplicant_set_state()    │    ├──→ wpas_notify_state_changed(wpa_s, new_state, old_state)    │       │    │       ├──→ 全局 ctrl socket: wpa_msg_ctrl(global, "WPA_EVENT_STATE_CHANGED ...")    │       ├──→ per-iface ctrl socket: wpa_msg_ctrl(wpa_s, "WPA_EVENT_STATE_CHANGED ...")    │       └──→ AIDL callback: wpas_aidl_notify_state_changed()    │                │    │                └──→ SupplicantStaIfaceCallback::onStateChanged() [binder 跨进程]    │                         │    │                         └──→ SupplicantStaIfaceCallbackAidlImpl::onStateChanged()    │                                  │    │                                  └──→ WifiMonitor.broadcastSupplicantStateChange()    │                                           │    │                                           └──→ ClientModeImpl (StateMachine)    │    └──→ wpas_notify_auth_changed(wpa_s)  [COMPLETED 进出时额外触发]    │       │    │       └──→ AIDL callback (onAuthenticationTimeout / onEapFailure etc.)    │    └──→ wpas_p2p_indicate_state_change(wpa_s)  [通知 P2P Device 接口]

// external_wpa_supplicant_8/wpa_supplicant/wpa_supplicant.c:7131-7178// 精简：去掉调试日志intradio_add_work(struct wpa_supplicant *wpa_s, unsignedint freq,                   const char *type, int next,                   void (*cb)(struct wpa_radio_work *work, int deinit),                   void *ctx){    struct wpa_radio *radio = wpa_s->radio;    struct wpa_radio_work *work;    int was_empty;    // 1. 分配 work item，填充参数    work = os_zalloc(sizeof(*work));    work->freq = freq;    work->type = type;       // "scan" / "connect" / "p2p-scan" / ...    work->wpa_s = wpa_s;    work->cb = cb;           // 当 work 开始执行时调用    work->ctx = ctx;    // 2. 计算涉及的频段    if (freq)        work->bands = wpas_freq_to_band(freq);    else if (os_strcmp(type, "scan") == 0 ||             os_strcmp(type, "p2p-scan") == 0)        work->bands = wpas_get_bands(wpa_s,                         ((struct wpa_driver_scan_params *)ctx)->freqs);    else        work->bands = wpas_get_bands(wpa_s, NULL);    // 3. 插入队列（next=1 插头部，next=0 插尾部）    was_empty = dl_list_empty(&wpa_s->radio->work);    if (next)        dl_list_add(&wpa_s->radio->work, &work->list);      // 高优先级    else        dl_list_add_tail(&wpa_s->radio->work, &work->list); // 普通优先级    // 4. 如果队列之前是空的，立即开始    if (was_empty) {        radio_work_check_next(wpa_s);    }    // 5. 驱动支持并发 offchannel 且未满 → 尝试并行    else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)             && radio->num_active_works < MAX_ACTIVE_WORKS) {        radio_work_check_next(wpa_s);    }    return 0;}

// wpa_supplicant.c:7191-7202voidradio_work_done(struct wpa_radio_work *work){    struct wpa_supplicant *wpa_s = work->wpa_s;    unsigned int started = work->started;    // 记录耗时    radio_work_free(work);    // 如果确实开始执行过，检查下一个    if (started)        radio_work_check_next(wpa_s);}

// wpa_supplicant/scan.c:1157-1160// 开始扫描时（无条件保存当前状态）：wpa_s->scan_prev_wpa_state = wpa_s->wpa_state;  // 始终保存if (wpa_s->wpa_state == WPA_DISCONNECTED ||    wpa_s->wpa_state == WPA_INACTIVE)    wpa_supplicant_set_state(wpa_s, WPA_SCANNING);  // 仅这两种状态才转换// wpa_supplicant/scan.c:3282-3283（scan_only_handler 中）// 扫描完成时（有守卫条件）：if (wpa_s->wpa_state == WPA_SCANNING)    wpa_supplicant_set_state(wpa_s, wpa_s->scan_prev_wpa_state);