自学教程：C++ wpa_supplicant_event函数代码示例

static void handle_dhcp(int sock, void *eloop_ctx, void *sock_ctx){	int len;	unsigned char buf[3000];	struct dhcp_message *msg;	u8 *mac_address;	union wpa_event_data event;	len = recv(sock, buf, sizeof(buf), 0);	if (len < 0) {		wpa_printf(MSG_ERROR, "recv: %s", strerror(errno));		return;	}	/* must contain at least dhcp_message->chaddr */	if (len < 44) {		wpa_printf(MSG_MSGDUMP, "handle_dhcp: too short (%d)", len);		return;	}	msg = (struct dhcp_message *) buf;	mac_address = (u8 *) &(msg->chaddr);	wpa_printf(MSG_MSGDUMP, "Got DHCP broadcast packet from " MACSTR,		   MAC2STR(mac_address));	os_memset(&event, 0, sizeof(event));	event.new_sta.addr = mac_address;	wpa_supplicant_event(eloop_ctx, EVENT_NEW_STA, &event);}

int wpa_driver_tista_parse_custom(void *ctx, const void *custom){    IPC_EV_DATA * pData = NULL;    pData = (IPC_EV_DATA *)custom;    wpa_printf(MSG_DEBUG, "uEventType %d", pData->EvParams.uEventType);    switch (pData->EvParams.uEventType) {    case	IPC_EVENT_LINK_SPEED:        wpa_printf(MSG_DEBUG, "IPC_EVENT_LINK_SPEED");        if(pData->uBufferSize == sizeof(u32))        {            wpa_printf(MSG_DEBUG, "update link_speed");            /* Dm: pStaDrv->link_speed = *((u32 *)pData->uBuffer) / 2; */        }        /* Dm: wpa_printf(MSG_INFO,"wpa_supplicant - Link Speed = %u", pStaDrv->link_speed ); */        break;    case	IPC_EVENT_SCAN_FAILED:        wpa_printf(MSG_INFO, "IPC_EVENT_SCAN_FAILED");        wpa_supplicant_event(ctx, EVENT_SCAN_RESULTS, NULL);        break;    default:        wpa_printf(MSG_DEBUG, "Unknown event");        break;    }    return 0;}

void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event,				 union wpa_event_data *data){	struct wpa_priv_global *global = ctx;	struct wpa_priv_interface *iface;	if (event != EVENT_INTERFACE_STATUS)		return;	for (iface = global->interfaces; iface; iface = iface->next) {		if (os_strcmp(iface->ifname, data->interface_status.ifname) ==		    0)			break;	}	if (iface && iface->driver->get_ifindex) {		unsigned int ifindex;		ifindex = iface->driver->get_ifindex(iface->drv_priv);		if (ifindex != data->interface_status.ifindex) {			wpa_printf(MSG_DEBUG,				   "%s: interface status ifindex %d mismatch (%d)",				   iface->ifname, ifindex,				   data->interface_status.ifindex);			return;		}	}	if (iface)		wpa_supplicant_event(iface, event, data);}

static void handle_frame(struct wpa_driver_nl80211_data *drv,			 u8 *buf, size_t len, int datarate, int ssi_signal){	struct ieee80211_hdr *hdr;	u16 fc;	union wpa_event_data event;	hdr = (struct ieee80211_hdr *) buf;	fc = le_to_host16(hdr->frame_control);	switch (WLAN_FC_GET_TYPE(fc)) {	case WLAN_FC_TYPE_MGMT:		os_memset(&event, 0, sizeof(event));		event.rx_mgmt.frame = buf;		event.rx_mgmt.frame_len = len;		event.rx_mgmt.datarate = datarate;		event.rx_mgmt.ssi_signal = ssi_signal;		wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);		break;	case WLAN_FC_TYPE_CTRL:		/* can only get here with PS-Poll frames */		wpa_printf(MSG_DEBUG, "CTRL");		from_unknown_sta(drv, buf, len);		break;	case WLAN_FC_TYPE_DATA:		from_unknown_sta(drv, buf, len);		break;	}}

static void wpa_driver_privsep_event_assoc(void *ctx,					   enum wpa_event_type event,					   u8 *buf, size_t len){	union wpa_event_data data;	int inc_data = 0;	u8 *pos, *end;	int ie_len;	os_memset(&data, 0, sizeof(data));	pos = buf;	end = buf + len;	if (end - pos < (int) sizeof(int))		return;	os_memcpy(&ie_len, pos, sizeof(int));	pos += sizeof(int);	if (ie_len < 0 || ie_len > end - pos)		return;	if (ie_len) {		data.assoc_info.req_ies = pos;		data.assoc_info.req_ies_len = ie_len;		pos += ie_len;		inc_data = 1;	}	wpa_supplicant_event(ctx, event, inc_data ? &data : NULL);}

static int wpa_driver_wext_event_wireless_pmkidcand(	struct wpa_driver_wext_data *drv, void *ctx, const char *ev, int len){	const struct iw_pmkid_cand *cand;	union wpa_event_data data;	const u8 *addr;	if (len < sizeof(*cand))		return -1;	cand = (const struct iw_pmkid_cand *) ev;	addr = (const u8 *) cand->bssid.sa_data;	wpa_printf(MSG_DEBUG, "PMKID candidate wireless event: "		   "flags=0x%x index=%d bssid=" MACSTR, cand->flags,		   cand->index, MAC2STR(addr));	memset(&data, 0, sizeof(data));	memcpy(data.pmkid_candidate.bssid, addr, ETH_ALEN);	data.pmkid_candidate.index = cand->index;	data.pmkid_candidate.preauth = cand->flags & IW_PMKID_CAND_PREAUTH;	wpa_supplicant_event(drv->ctx, EVENT_PMKID_CANDIDATE, &data);	return 0;}

static voidhostapd_wireless_event_wireless_custom(struct hostap_driver_data *drv,				       char *custom){	wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom);	if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) {		char *pos;		u8 addr[ETH_ALEN];		pos = strstr(custom, "addr=");		if (pos == NULL) {			wpa_printf(MSG_DEBUG,				   "MLME-MICHAELMICFAILURE.indication "				   "without sender address ignored");			return;		}		pos += 5;		if (hwaddr_aton(pos, addr) == 0) {			union wpa_event_data data;			os_memset(&data, 0, sizeof(data));			data.michael_mic_failure.unicast = 1;			data.michael_mic_failure.src = addr;			wpa_supplicant_event(drv->hapd,					     EVENT_MICHAEL_MIC_FAILURE, &data);		} else {			wpa_printf(MSG_DEBUG,				   "MLME-MICHAELMICFAILURE.indication "				   "with invalid MAC address");		}	}}

int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,				  size_t buf_len ){	struct i802_bss *bss = priv;	struct wpa_driver_nl80211_data *drv = bss->drv;	struct ifreq ifr;	android_wifi_priv_cmd priv_cmd;	int ret = 0;	if (os_strcasecmp(cmd, "STOP") == 0) {		linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0);		wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");	} else if (os_strcasecmp(cmd, "START") == 0) {		linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);		wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");	} else if (os_strcasecmp(cmd, "MACADDR") == 0) {		u8 macaddr[ETH_ALEN] = {};		ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr);		if (!ret)			ret = os_snprintf(buf, buf_len,					  "Macaddr = " MACSTR "/n", MAC2STR(macaddr));	} else { /* Use private command */		memset(&ifr, 0, sizeof(ifr));		memset(&priv_cmd, 0, sizeof(priv_cmd));		os_memcpy(buf, cmd, strlen(cmd) + 1);		os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);		priv_cmd.buf = buf;		priv_cmd.used_len = buf_len;		priv_cmd.total_len = buf_len;		ifr.ifr_data = &priv_cmd;		if ((ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {			wpa_printf(MSG_ERROR, "%s: failed to issue private commands/n", __func__);		} else {			drv_errors = 0;			ret = 0;			if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||			    (os_strcasecmp(cmd, "RSSI") == 0) ||			    (os_strcasecmp(cmd, "GETBAND") == 0) )				ret = strlen(buf);			else if (os_strcasecmp(cmd, "COUNTRY") == 0)				wpa_supplicant_event(drv->ctx,					EVENT_CHANNEL_LIST_CHANGED, NULL);			else if (os_strncasecmp(cmd, "SETBAND", 7) == 0)				wpa_printf(MSG_DEBUG, "%s: %s ", __func__, cmd);			else if (os_strcasecmp(cmd, "P2P_DEV_ADDR") == 0)				wpa_printf(MSG_DEBUG, "%s: P2P: Device address ("MACSTR")",					__func__, MAC2STR(buf));			else if (os_strcasecmp(cmd, "P2P_SET_PS") == 0)				wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);			else if (os_strcasecmp(cmd, "P2P_SET_NOA") == 0)				wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);			else				wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));		}	}	return ret;}

void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event,				 union wpa_event_data *data){	struct hapd_interfaces *interfaces = ctx;	struct hostapd_data *hapd;	if (event != EVENT_INTERFACE_STATUS)		return;	hapd = hostapd_get_iface(interfaces, data->interface_status.ifname);	if (hapd && hapd->driver && hapd->driver->get_ifindex &&	    hapd->drv_priv) {		unsigned int ifindex;		ifindex = hapd->driver->get_ifindex(hapd->drv_priv);		if (ifindex != data->interface_status.ifindex) {			wpa_dbg(hapd->msg_ctx, MSG_DEBUG,				"interface status ifindex %d mismatch (%d)",				ifindex, data->interface_status.ifindex);			return;		}	}	if (hapd)		wpa_supplicant_event(hapd, event, data);}

static void atheros_raw_receive(void *ctx, const u8 *src_addr, const u8 *buf,				size_t len){	struct atheros_driver_data *drv = ctx;	const struct ieee80211_mgmt *mgmt;	u16 fc;	union wpa_event_data event;	/* Send Probe Request information to WPS processing */	if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req))		return;	mgmt = (const struct ieee80211_mgmt *) buf;	fc = le_to_host16(mgmt->frame_control);	if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT ||	    WLAN_FC_GET_STYPE(fc) != WLAN_FC_STYPE_PROBE_REQ)		return;	os_memset(&event, 0, sizeof(event));	event.rx_probe_req.sa = mgmt->sa;	event.rx_probe_req.da = mgmt->da;	event.rx_probe_req.bssid = mgmt->bssid;	event.rx_probe_req.ie = mgmt->u.probe_req.variable;	event.rx_probe_req.ie_len =		len - (IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req));	wpa_supplicant_event(drv->hapd, EVENT_RX_PROBE_REQ, &event);}

static void handle_data(struct hostap_driver_data *drv, u8 *buf, size_t len,			u16 stype){	struct ieee80211_hdr *hdr;	u16 fc, ethertype;	u8 *pos, *sa;	size_t left;	union wpa_event_data event;	if (len < sizeof(struct ieee80211_hdr))		return;	hdr = (struct ieee80211_hdr *) buf;	fc = le_to_host16(hdr->frame_control);	if ((fc & (WLAN_FC_FROMDS | WLAN_FC_TODS)) != WLAN_FC_TODS) {		printf("Not ToDS data frame (fc=0x%04x)/n", fc);		return;	}	sa = hdr->addr2;	os_memset(&event, 0, sizeof(event));	event.rx_from_unknown.bssid = get_hdr_bssid(hdr, len);	event.rx_from_unknown.addr = sa;	wpa_supplicant_event(drv->hapd, EVENT_RX_FROM_UNKNOWN, &event);	pos = (u8 *) (hdr + 1);	left = len - sizeof(*hdr);	if (left < sizeof(rfc1042_header)) {		printf("Too short data frame/n");		return;	}	if (memcmp(pos, rfc1042_header, sizeof(rfc1042_header)) != 0) {		printf("Data frame with no RFC1042 header/n");		return;	}	pos += sizeof(rfc1042_header);	left -= sizeof(rfc1042_header);	if (left < 2) {		printf("No ethertype in data frame/n");		return;	}	ethertype = WPA_GET_BE16(pos);	pos += 2;	left -= 2;	switch (ethertype) {	case ETH_P_PAE:		drv_event_eapol_rx(drv->hapd, sa, pos, left);		break;	default:		printf("Unknown ethertype 0x%04x in data frame/n", ethertype);		break;	}}

static void handle_frame(struct hostap_driver_data *drv, u8 *buf, size_t len){	struct ieee80211_hdr *hdr;	u16 fc, type, stype;	size_t data_len = len;	int ver;	union wpa_event_data event;	/* PSPOLL is only 16 bytes, but driver does not (at least yet) pass	 * these to user space */	if (len < 24) {		wpa_printf(MSG_MSGDUMP, "handle_frame: too short (%lu)",			   (unsigned long) len);		return;	}	hdr = (struct ieee80211_hdr *) buf;	fc = le_to_host16(hdr->frame_control);	type = WLAN_FC_GET_TYPE(fc);	stype = WLAN_FC_GET_STYPE(fc);	if (type != WLAN_FC_TYPE_MGMT || stype != WLAN_FC_STYPE_BEACON) {		wpa_hexdump(MSG_MSGDUMP, "Received management frame",			    buf, len);	}	ver = fc & WLAN_FC_PVER;	/* protocol version 2 is reserved for indicating ACKed frame (TX	 * callbacks), and version 1 for indicating failed frame (no ACK, TX	 * callbacks) */	if (ver == 1 || ver == 2) {		handle_tx_callback(drv, buf, data_len, ver == 2 ? 1 : 0);		return;	} else if (ver != 0) {		printf("unknown protocol version %d/n", ver);		return;	}	switch (type) {	case WLAN_FC_TYPE_MGMT:		os_memset(&event, 0, sizeof(event));		event.rx_mgmt.frame = buf;		event.rx_mgmt.frame_len = data_len;		wpa_supplicant_event(drv->hapd, EVENT_RX_MGMT, &event);		break;	case WLAN_FC_TYPE_CTRL:		wpa_printf(MSG_DEBUG, "CTRL");		break;	case WLAN_FC_TYPE_DATA:		wpa_printf(MSG_DEBUG, "DATA");		handle_data(drv, buf, data_len, stype);		break;	default:		wpa_printf(MSG_DEBUG, "unknown frame type %d", type);		break;	}}

static int wpa_driver_test_associate(	void *priv, struct wpa_driver_associate_params *params){	struct wpa_driver_test_data *drv = priv;	wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d "		   "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",		   __func__, priv, params->freq, params->pairwise_suite,		   params->group_suite, params->key_mgmt_suite,		   params->auth_alg, params->mode);	if (params->bssid) {		wpa_printf(MSG_DEBUG, "   bssid=" MACSTR,			   MAC2STR(params->bssid));	}	if (params->ssid) {		wpa_hexdump_ascii(MSG_DEBUG, "   ssid",				  params->ssid, params->ssid_len);	}	if (params->wpa_ie) {		wpa_hexdump(MSG_DEBUG, "   wpa_ie",			    params->wpa_ie, params->wpa_ie_len);		drv->assoc_wpa_ie_len = params->wpa_ie_len;		if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie))			drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie);		memcpy(drv->assoc_wpa_ie, params->wpa_ie,		       drv->assoc_wpa_ie_len);	} else		drv->assoc_wpa_ie_len = 0;	if (drv->test_socket >= 0) {		char cmd[200], *pos, *end;		int i;		end = cmd + sizeof(cmd);		pos = cmd;		pos += snprintf(pos, end - pos, "ASSOC " MACSTR " ",				MAC2STR(drv->own_addr));		for (i = 0; i < params->ssid_len; i++) {			pos += snprintf(pos, end - pos, "%02x",					params->ssid[i]);		}		pos += snprintf(pos, end - pos, " ");		for (i = 0; i < params->wpa_ie_len; i++) {			pos += snprintf(pos, end - pos, "%02x",					params->wpa_ie[i]);		}		if (sendto(drv->test_socket, cmd, strlen(cmd), 0,			   (struct sockaddr *) &drv->hostapd_addr,			   sizeof(drv->hostapd_addr)) < 0) {			perror("sendto(test_socket)");			return -1;		}		memcpy(drv->ssid, params->ssid, params->ssid_len);		drv->ssid_len = params->ssid_len;	} else		wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);	return 0;}

static int wpa_driver_test_disassociate(void *priv, const u8 *addr,					int reason_code){	struct wpa_driver_test_data *drv = priv;	wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",		   __func__, MAC2STR(addr), reason_code);	memset(drv->bssid, 0, ETH_ALEN);	wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);	return wpa_driver_test_send_disassoc(drv);}

static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv,				      struct sockaddr_un *from,				      socklen_t fromlen,				      const char *data){	/* ASSOCRESP BSSID <res> */	if (hwaddr_aton(data, drv->bssid)) {		wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in "			   "assocresp");	}	if (drv->use_associnfo) {		union wpa_event_data event;		memset(&event, 0, sizeof(event));		event.assoc_info.req_ies = drv->assoc_wpa_ie;		event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len;		wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event);	}	wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);}

static void wpa_driver_privsep_event_stkstart(void *ctx, u8 *buf, size_t len){	union wpa_event_data data;	if (len != ETH_ALEN)		return;	os_memset(&data, 0, sizeof(data));	os_memcpy(data.stkstart.peer, buf, ETH_ALEN);	wpa_supplicant_event(ctx, EVENT_STKSTART, &data);}

static voidmadwifi_wireless_event_wireless_custom(struct madwifi_driver_data *drv,				       char *custom){	wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom);	if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) {		char *pos;		u8 addr[ETH_ALEN];		pos = strstr(custom, "addr=");		if (pos == NULL) {			wpa_printf(MSG_DEBUG,				   "MLME-MICHAELMICFAILURE.indication "				   "without sender address ignored");			return;		}		pos += 5;		if (hwaddr_aton(pos, addr) == 0) {			union wpa_event_data data;			os_memset(&data, 0, sizeof(data));			data.michael_mic_failure.unicast = 1;			data.michael_mic_failure.src = addr;			wpa_supplicant_event(drv->hapd,					     EVENT_MICHAEL_MIC_FAILURE, &data);		} else {			wpa_printf(MSG_DEBUG,				   "MLME-MICHAELMICFAILURE.indication "				   "with invalid MAC address");		}	} else if (strncmp(custom, "STA-TRAFFIC-STAT", 16) == 0) {		char *key, *value;		u32 val;		key = custom;		while ((key = strchr(key, '/n')) != NULL) {			key++;			value = strchr(key, '=');			if (value == NULL)				continue;			*value++ = '/0';			val = strtoul(value, NULL, 10);			if (strcmp(key, "mac") == 0)				hwaddr_aton(value, drv->acct_mac);			else if (strcmp(key, "rx_packets") == 0)				drv->acct_data.rx_packets = val;			else if (strcmp(key, "tx_packets") == 0)				drv->acct_data.tx_packets = val;			else if (strcmp(key, "rx_bytes") == 0)				drv->acct_data.rx_bytes = val;			else if (strcmp(key, "tx_bytes") == 0)				drv->acct_data.tx_bytes = val;			key = value;		}	}}

static void wpa_driver_privsep_event_pmkid_candidate(void *ctx, u8 *buf,						     size_t len){	union wpa_event_data data;	if (len != sizeof(struct pmkid_candidate))		return;	os_memset(&data, 0, sizeof(data));	os_memcpy(&data.pmkid_candidate, buf, len);	wpa_supplicant_event(ctx, EVENT_PMKID_CANDIDATE, &data);}

static void wpa_driver_privsep_event_michael_mic_failure(	void *ctx, u8 *buf, size_t len){	union wpa_event_data data;	if (len != sizeof(int))		return;	os_memset(&data, 0, sizeof(data));	os_memcpy(&data.michael_mic_failure.unicast, buf, sizeof(int));	wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, &data);}

void sme_event_auth(struct wpa_supplicant *wpa_s, union wpa_event_data *data){	struct wpa_ssid *ssid = wpa_s->current_ssid;	if (ssid == NULL) {		wpa_printf(MSG_DEBUG, "SME: Ignore authentication event when "			   "network is not selected");		return;	}	if (wpa_s->wpa_state != WPA_AUTHENTICATING) {		wpa_printf(MSG_DEBUG, "SME: Ignore authentication event when "			   "not in authenticating state");		return;	}	if (os_memcmp(wpa_s->pending_bssid, data->auth.peer, ETH_ALEN) != 0) {		wpa_printf(MSG_DEBUG, "SME: Ignore authentication with "			   "unexpected peer " MACSTR,			   MAC2STR(data->auth.peer));		return;	}	wpa_printf(MSG_DEBUG, "SME: Authentication response: peer=" MACSTR		   " auth_type=%d status_code=%d",		   MAC2STR(data->auth.peer), data->auth.auth_type,		   data->auth.status_code);	wpa_hexdump(MSG_MSGDUMP, "SME: Authentication response IEs",		    data->auth.ies, data->auth.ies_len);	if (data->auth.status_code != WLAN_STATUS_SUCCESS) {		wpa_printf(MSG_DEBUG, "SME: Authentication failed (status "			   "code %d)", data->auth.status_code);                ros_assoc_failed(wpa_s, data->auth.peer, "Authentication failed");		return;	}#ifdef CONFIG_IEEE80211R	if (data->auth.auth_type == WLAN_AUTH_FT) {		union wpa_event_data edata;		os_memset(&edata, 0, sizeof(edata));		edata.ft_ies.ies = data->auth.ies;		edata.ft_ies.ies_len = data->auth.ies_len;		os_memcpy(edata.ft_ies.target_ap, data->auth.peer, ETH_ALEN);		wpa_supplicant_event(wpa_s, EVENT_FT_RESPONSE, &edata);	}#endif /* CONFIG_IEEE80211R */	sme_associate(wpa_s, ssid->mode, data->auth.peer,		      data->auth.auth_type);}

static void wpa_driver_privsep_event_ft_response(void *ctx, u8 *buf,						 size_t len){	union wpa_event_data data;	if (len < sizeof(int) + ETH_ALEN)		return;	os_memset(&data, 0, sizeof(data));	os_memcpy(&data.ft_ies.ft_action, buf, sizeof(int));	os_memcpy(data.ft_ies.target_ap, buf + sizeof(int), ETH_ALEN);	data.ft_ies.ies = buf + sizeof(int) + ETH_ALEN;	data.ft_ies.ies_len = len - sizeof(int) - ETH_ALEN;	wpa_supplicant_event(ctx, EVENT_FT_RESPONSE, &data);}

static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s){	struct wpa_ssid *ssid;	union wpa_event_data data;	ssid = wpa_supplicant_get_ssid(wpa_s);	if (ssid == NULL)		return;	if (wpa_s->current_ssid == NULL)		wpa_s->current_ssid = ssid;	wpa_supplicant_initiate_eapol(wpa_s);	wpa_printf(MSG_DEBUG, "Already associated with a configured network - "		   "generating associated event");	os_memset(&data, 0, sizeof(data));	wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data);}

/** update channel list in wpa_supplicant* if coutry code chanaged*/static void wpa_driver_notify_country_change(void *ctx, char *cmd){    if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {        union wpa_event_data event;        os_memset(&event, 0, sizeof(event));        event.channel_list_changed.initiator = REGDOM_SET_BY_USER;        if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {            event.channel_list_changed.type = REGDOM_TYPE_COUNTRY;            if (os_strlen(cmd) > 9) {                event.channel_list_changed.alpha2[0] = cmd[8];                event.channel_list_changed.alpha2[1] = cmd[9];            }        } else            event.channel_list_changed.type = REGDOM_TYPE_UNKNOWN;        wpa_supplicant_event(ctx, EVENT_CHANNEL_LIST_CHANGED, &event);    }}

static void handle_tx_callback(void *ctx, u8 *buf, size_t len, int ok){	struct ieee80211_hdr *hdr;	u16 fc;	union wpa_event_data event;	hdr = (struct ieee80211_hdr *) buf;	fc = le_to_host16(hdr->frame_control);	os_memset(&event, 0, sizeof(event));	event.tx_status.type = WLAN_FC_GET_TYPE(fc);	event.tx_status.stype = WLAN_FC_GET_STYPE(fc);	event.tx_status.dst = hdr->addr1;	event.tx_status.data = buf;	event.tx_status.data_len = len;	event.tx_status.ack = ok;	wpa_supplicant_event(ctx, EVENT_TX_STATUS, &event);}

static void wpa_driver_privsep_event_interface_status(void *ctx, u8 *buf,						      size_t len){	union wpa_event_data data;	int ievent;	if (len < sizeof(int) ||	    len - sizeof(int) > sizeof(data.interface_status.ifname))		return;	os_memcpy(&ievent, buf, sizeof(int));	os_memset(&data, 0, sizeof(data));	data.interface_status.ievent = ievent;	os_memcpy(data.interface_status.ifname, buf + sizeof(int),		  len - sizeof(int));	wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &data);}

static void from_unknown_sta(struct wpa_driver_nl80211_data *drv,			     u8 *buf, size_t len){	struct ieee80211_hdr *hdr = (void *)buf;	u16 fc;	union wpa_event_data event;	if (len < sizeof(*hdr))		return;	fc = le_to_host16(hdr->frame_control);	os_memset(&event, 0, sizeof(event));	event.rx_from_unknown.bssid = get_hdr_bssid(hdr, len);	event.rx_from_unknown.addr = hdr->addr2;	event.rx_from_unknown.wds = (fc & (WLAN_FC_FROMDS | WLAN_FC_TODS)) ==		(WLAN_FC_FROMDS | WLAN_FC_TODS);	wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);}

static void wpa_driver_wext_event_link(struct wpa_driver_wext_data *drv,				       void *ctx, char *buf, size_t len,				       int del){	union wpa_event_data event;	memset(&event, 0, sizeof(event));	if (len > sizeof(event.interface_status.ifname))		len = sizeof(event.interface_status.ifname) - 1;	memcpy(event.interface_status.ifname, buf, len);	event.interface_status.ievent = del ? EVENT_INTERFACE_REMOVED :		EVENT_INTERFACE_ADDED;	wpa_printf(MSG_DEBUG, "RTM_%sLINK, IFLA_IFNAME: Interface '%s' %s",		   del ? "DEL" : "NEW",		   event.interface_status.ifname,		   del ? "removed" : "added");	wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event);}

static int wpa_driver_wext_event_wireless_michaelmicfailure(	struct wpa_driver_wext_data *drv, void *ctx, const char *ev, int len){	const struct iw_michaelmicfailure *mic;	union wpa_event_data data;	if (len < sizeof(*mic))		return -1;	mic = (const struct iw_michaelmicfailure *) ev;	wpa_printf(MSG_DEBUG, "Michael MIC failure wireless event: "		   "flags=0x%x src_addr=" MACSTR, mic->flags,		   MAC2STR(mic->src_addr.sa_data));	memset(&data, 0, sizeof(data));	data.michael_mic_failure.unicast = !(mic->flags & IW_MICFAILURE_GROUP);	wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, &data);	return 0;}

static void handle_data(void *ctx, unsigned char *buf, size_t len){#ifdef HOSTAPD	struct ieee8023_hdr *hdr;	u8 *pos, *sa;	size_t left;	union wpa_event_data event;	/* must contain at least ieee8023_hdr 6 byte source, 6 byte dest,	 * 2 byte ethertype */	if (len < 14) {		wpa_printf(MSG_MSGDUMP, "handle_data: too short (%lu)",			   (unsigned long) len);		return;	}	hdr = (struct ieee8023_hdr *) buf;	switch (ntohs(hdr->ethertype)) {		case ETH_P_PAE:			wpa_printf(MSG_MSGDUMP, "Received EAPOL packet");			sa = hdr->src;			os_memset(&event, 0, sizeof(event));			event.new_sta.addr = sa;			wpa_supplicant_event(ctx, EVENT_NEW_STA, &event);			pos = (u8 *) (hdr + 1);			left = len - sizeof(*hdr);			drv_event_eapol_rx(ctx, sa, pos, left);		break;	default:		wpa_printf(MSG_DEBUG, "Unknown ethertype 0x%04x in data frame",			   ntohs(hdr->ethertype));		break;	}#endif /* HOSTAPD */}

static void wpa_driver_privsep_event_auth(void *ctx, u8 *buf, size_t len){	union wpa_event_data data;	struct privsep_event_auth *auth;	os_memset(&data, 0, sizeof(data));	if (len < sizeof(*auth))		return;	auth = (struct privsep_event_auth *) buf;	if (len < sizeof(*auth) + auth->ies_len)		return;	os_memcpy(data.auth.peer, auth->peer, ETH_ALEN);	os_memcpy(data.auth.bssid, auth->bssid, ETH_ALEN);	data.auth.auth_type = auth->auth_type;	data.auth.auth_transaction = auth->auth_transaction;	data.auth.status_code = auth->status_code;	if (auth->ies_len) {		data.auth.ies = (u8 *) (auth + 1);		data.auth.ies_len = auth->ies_len;	}	wpa_supplicant_event(ctx, EVENT_AUTH, &data);}