service p2p_supplicant /system/bin/wpa_supplicant \
    -ip2p0 -Dnl80211 -c/data/misc/wifi/p2p_supplicant.conf \
    -I/system/etc/wifi/p2p_supplicant_overlay.conf -N \
    -iwlan0 -Dnl80211 -c/data/misc/wifi/wpa_supplicant.conf \
    -I/system/etc/wifi/wpa_supplicant_overlay.conf \
    -O/data/misc/wifi/sockets -puse_p2p_group_interface=1 -dd \
    -e/data/misc/wifi/entropy.bin -g@android:wpa_wlan0
    class main
    socket wpa_wlan0 dgram 660 wifi wifi
    disabled
    oneshot

service wpa_supplicant /system/bin/wpa_supplicant \
    -iwlan0 -Dnl80211 -c/data/misc/wifi/wpa_supplicant.conf \
    -I/system/etc/wifi/wpa_supplicant_overlay.conf \
    -O/data/misc/wifi/sockets -dd \
    -e/data/misc/wifi/entropy.bin -g@android:wpa_wlan0
    class main
    socket wpa_wlan0 dgram 660 wifi wifi
    disabled
    oneshot

int main(int argc, char *argv[])
{
	int c, i;
	struct wpa_interface *ifaces, *iface;
	int iface_count, exitcode = -1;
	struct wpa_params params;
	struct wpa_global *global;

	os_memset(&params, 0, sizeof(params));
	params.wpa_debug_level = MSG_INFO;

	iface = ifaces = os_zalloc(sizeof(struct wpa_interface));
	iface_count = 1;

         // 输入输出重定向到/dev/null设备
	wpa_supplicant_fd_workaround(1);

         // 参数解析
	for (;;) {
		c = getopt(argc, argv,
			   "b:Bc:C:D:de:f:g:G:hi:I:KLm:No:O:p:P:qsTtuvW");
		if (c < 0)
			break;
		switch (c) {
		......
		case 'c':
			iface->confname = optarg;
			break;
		......
		case 'd':
			// wpa_debug_level 越小开放的 log 越多
			params.wpa_debug_level--;
			break;
		case 'e':
			params.entropy_file = optarg;
			break;
                  ......
		case 'i':
			iface->ifname = optarg;
			break;
		......
		}
	}

	exitcode = 0;

         // 关键函数，根据传入的参数， 创建并初始化一个wpa_global对象
	global = wpa_supplicant_init(&params);
	
         ......

         // WPAS支持操作多个无线网络设备， 此处通过 wpa_supplicant_add_iface 将它们一一添加到WPAS中
	for (i = 0; exitcode == 0 && i < iface_count; i++) {
		struct wpa_supplicant *wpa_s;

		......
		wpa_s = wpa_supplicant_add_iface(global, &ifaces[i], NULL);
		}
	}

         // 运行 event loop
	if (exitcode == 0)
		exitcode = wpa_supplicant_run(global);

	wpa_supplicant_deinit(global);

	fst_global_deinit();

out:
	......
}

struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
{
	struct wpa_global *global;
	int ret, i;
	......

         // 注册各种EAP方法 ，后面在单独分析
	ret = eap_register_methods();	

         // 创建一个wpa_global对象
	global = os_zalloc(sizeof(*global));

	...... // 初始化global中的其他参数， 其中会将传进来的 params 信息保存到 global 中

         // 初始化了WPAS中事件驱动的核心数据结构体 eloop_data
	if (eloop_init()) {
		......
	}

	random_init(params->entropy_file);

         // 初始化全局控制接口对象
	global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);

	for (i = 0; wpa_drivers[i]; i++)
		global->drv_count++;
	if (global->drv_count == 0) {
		wpa_printf(MSG_ERROR, "No drivers enabled");
		wpa_supplicant_deinit(global);
		return NULL;
	}

         // 分配全局driver wrapper上下文信息数组
	global->drv_priv = os_calloc(global->drv_count, sizeof(void *));

	return global;
}

struct eloop_data {
    int max_sock;    //供select使用
  
    int count;     //所有事件表中事件总数
    ......
    struct eloop_sock_table readers;    //read事件表
    struct eloop_sock_table writers;    //write事件表
    struct eloop_sock_table exceptions;    //exception事件表
  
    struct dl_list timeout;    //timeout事件表
  
    int signal_count;    //signal事件个数
    struct eloop_signal *signals;    //signal事件表
    ......
};

struct eloop_sock_table {
	int count;
	struct eloop_sock *table;
	
	eloop_event_type type;
		typedef enum {
			EVENT_TYPE_READ = 0,
			EVENT_TYPE_WRITE,
			EVENT_TYPE_EXCEPTION
		} eloop_event_type;
	int changed;
};

@ eloop.h

// 注册socket读事件处理函数,参数sock代表一个socket句柄。一旦该句柄上有读事件发生,则handler函数将被事件处理循环调用
int eloop_register_read_sock(int sock, eloop_sock_handler handler, void *eloop_data, void *user_data);
   
// 注册socket事件处理函数,具体是哪种事件(只能是读、写或异常)由type参数决定
int eloop_register_sock(int sock, eloop_event_type type, eloop_sock_handler handler,void *eloop_data, void *user_data);
   
// 注册超时事件处理函数
int eloop_register_timeout(unsigned int secs, unsigned int usecs, eloop_timeout_handler handler, void *eloop_data, void *user_data);
   
// 注册信号事件处理函数,具体要处理的信号由sig参数指定
int eloop_register_signal(int sig, eloop_signal_handler handler, void *user_data);

@eloop.c

void eloop_run(void)
{
    // fd_set是select中用到的一种参数类型
    fd_set *rfds, *wfds, *efds; 
    struct timeval _tv;
    int res;
    struct os_time 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;
        // 判断是否有超时事件需要等待
        timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,list);
        if (timeout) {
            os_get_time(&now);
            if (os_time_before(&now, &timeout->time))
                os_time_sub(&timeout->time, &now, &tv);
            else
                tv.sec = tv.usec = 0;
            _tv.tv_sec = tv.sec;
            _tv.tv_usec = tv.usec;
        }
        // 将外界设置的读事件添加到对应的fd_set中
        eloop_sock_table_set_fds(&eloop.readers, rfds);   
        ......// 设置写、异常事件到fd_set中
        // 调用select函数
        res = select(eloop.max_sock + 1, rfds, wfds, efds,timeout ? &_tv : NULL);
        if(res < 0) {......// 错误处理}
        // 先处理信号事件
        eloop_process_pending_signals();
        // 判断是否有超时事件发生
        timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,list);
        if (timeout) {
            os_get_time(&now);
            if (!os_time_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);
                // 处理超时事件
            }
        }
        ......// 处理读/写/异常事件。方法和下面这个函数类似
        eloop_sock_table_dispatch(&eloop.readers, rfds);
        ......// 处理wfds和efds
    }
    out:
        return;
}

struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
						 struct wpa_interface *iface,
						 struct wpa_supplicant *parent)
{
	struct wpa_supplicant *wpa_s;
	struct wpa_interface t_iface;
	struct wpa_ssid *ssid;		//用于存储某个无线网络的配置信息,wpa_supplicant.conf中的每个network项都对应一个wpa_ssid对象

	wpa_s = wpa_supplicant_alloc(parent);

	wpa_s->global = global;
	t_iface = *iface;		
	
         ......

	if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
		wpa_printf(MSG_DEBUG, "Failed to add interface %s",
			   iface->ifname);
		wpa_supplicant_deinit_iface(wpa_s, 0, 0);
		return NULL;
	}

	wpa_s->next = global->ifaces;
	global->ifaces = wpa_s;

	wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);

	return wpa_s;
}

static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
				     struct wpa_interface *iface)
{
	struct wpa_driver_capa capa;
	int capa_res;

	if (iface->confname) {
                  ......
		//解析配置文件，例如 wpa_s->confname 为"/datnl80211_global_inita/misc/wifi/wpa_supplicant.conf"
		wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
		......
		wpa_s->confanother = os_rel2abs_path(iface->confanother);
		wpa_config_read(wpa_s->confanother, wpa_s->conf);

		//保存driver相关参数
		if (iface->ctrl_interface) {
			os_free(wpa_s->conf->ctrl_interface);
			wpa_s->conf->ctrl_interface =
				os_strdup(iface->ctrl_interface);
		}

		if (iface->driver_param) {
			os_free(wpa_s->conf->driver_param);
			wpa_s->conf->driver_param =
				os_strdup(iface->driver_param);
		}

		if (iface->p2p_mgmt && !iface->ctrl_interface) {
			os_free(wpa_s->conf->ctrl_interface);
			wpa_s->conf->ctrl_interface = NULL;
		}
	} else
		wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
						     iface->driver_param);

	......

	os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
	......
	/* RSNA Supplicant Key Management - INITIALIZE */
	eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
	eapol_sm_notify_portValid(wpa_s->eapol, FALSE);

	//初始化相应的driver
	if (wpas_init_driver(wpa_s, iface) < 0)
		return -1;

	//初始化wpa_sm相关的资源
	if (wpa_supplicant_init_wpa(wpa_s) < 0)
		return -1;

	wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
			  wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
			  NULL);
	wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);

	.......

	wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
						      &wpa_s->hw.num_modes,
						      &wpa_s->hw.flags);
	......

	capa_res = wpa_drv_get_capa(wpa_s, &capa);
	if (capa_res == 0) {
		...... //相关capability信息
	}
	if (wpa_s->max_remain_on_chan == 0)
		wpa_s->max_remain_on_chan = 1000;

	if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
		wpa_s->p2p_mgmt = iface->p2p_mgmt;
	else
		iface->p2p_mgmt = 1;

	if (wpa_s->num_multichan_concurrent == 0)
		wpa_s->num_multichan_concurrent = 1;

	if (wpa_supplicant_driver_init(wpa_s) < 0)
		return -1;


	if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
	    wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
		wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
		return -1;
	}

	if (wpas_wps_init(wpa_s))
		return -1;

	if (wpa_supplicant_init_eapol(wpa_s) < 0)
		return -1;
	wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);

	wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);

	wpa_s->gas = gas_query_init(wpa_s);
	if (wpa_s->gas == NULL) {
		wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
		return -1;
	}

	......

	return 0;
}

static int wpas_init_driver(struct wpa_supplicant *wpa_s,
			    struct wpa_interface *iface)
{
	const char *ifname, *driver, *rn;

	driver = iface->driver;
next_driver:
	//根据nl80211找到wpa_driver数组中nl80211指定的driver对象 wpa_driver_nl80211_ops ,并调用其 global_init
	//global_init 会创建netlink_socket 来接收kernel 中的消息
	if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
		return -1;

	//调用 wpa_driver_nl80211_ops 的 init2
	wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
	......
	if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
		wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
			"driver_param '%s'", wpa_s->conf->driver_param);
		return -1;
	}

	......

	return 0;
}