1 /*
2 * Driver interaction with Linux nl80211/cfg80211 - Event processing
3 * Copyright (c) 2002-2017, Jouni Malinen <j@w1.fi>
4 * Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
5 * Copyright (c) 2009-2010, Atheros Communications
6 *
7 * This software may be distributed under the terms of the BSD license.
8 * See README for more details.
9 */
10
11 #include "includes.h"
12 #include <netlink/genl/genl.h>
13
14 #include "utils/common.h"
15 #include "utils/eloop.h"
16 #include "common/qca-vendor.h"
17 #include "common/qca-vendor-attr.h"
18 #include "common/brcm_vendor.h"
19 #include "common/ieee802_11_defs.h"
20 #include "common/ieee802_11_common.h"
21 #include "driver_nl80211.h"
22 #ifdef CONFIG_VENDOR_EXT
23 #include "vendor_ext.h"
24 #endif
25
26 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
27 #include "hm_miracast_sink.h"
28 #endif
29
30 static void
31 nl80211_control_port_frame_tx_status(struct wpa_driver_nl80211_data *drv,
32 const u8 *frame, size_t len,
33 struct nlattr *ack, struct nlattr *cookie);
34
35
nl80211_command_to_string(enum nl80211_commands cmd)36 const char * nl80211_command_to_string(enum nl80211_commands cmd)
37 {
38 #define C2S(x) case x: return #x;
39 switch (cmd) {
40 C2S(NL80211_CMD_UNSPEC)
41 C2S(NL80211_CMD_GET_WIPHY)
42 C2S(NL80211_CMD_SET_WIPHY)
43 C2S(NL80211_CMD_NEW_WIPHY)
44 C2S(NL80211_CMD_DEL_WIPHY)
45 C2S(NL80211_CMD_GET_INTERFACE)
46 C2S(NL80211_CMD_SET_INTERFACE)
47 C2S(NL80211_CMD_NEW_INTERFACE)
48 C2S(NL80211_CMD_DEL_INTERFACE)
49 C2S(NL80211_CMD_GET_KEY)
50 C2S(NL80211_CMD_SET_KEY)
51 C2S(NL80211_CMD_NEW_KEY)
52 C2S(NL80211_CMD_DEL_KEY)
53 C2S(NL80211_CMD_GET_BEACON)
54 C2S(NL80211_CMD_SET_BEACON)
55 C2S(NL80211_CMD_START_AP)
56 C2S(NL80211_CMD_STOP_AP)
57 C2S(NL80211_CMD_GET_STATION)
58 C2S(NL80211_CMD_SET_STATION)
59 C2S(NL80211_CMD_NEW_STATION)
60 C2S(NL80211_CMD_DEL_STATION)
61 C2S(NL80211_CMD_GET_MPATH)
62 C2S(NL80211_CMD_SET_MPATH)
63 C2S(NL80211_CMD_NEW_MPATH)
64 C2S(NL80211_CMD_DEL_MPATH)
65 C2S(NL80211_CMD_SET_BSS)
66 C2S(NL80211_CMD_SET_REG)
67 C2S(NL80211_CMD_REQ_SET_REG)
68 C2S(NL80211_CMD_GET_MESH_CONFIG)
69 C2S(NL80211_CMD_SET_MESH_CONFIG)
70 C2S(NL80211_CMD_SET_MGMT_EXTRA_IE)
71 C2S(NL80211_CMD_GET_REG)
72 C2S(NL80211_CMD_GET_SCAN)
73 C2S(NL80211_CMD_TRIGGER_SCAN)
74 C2S(NL80211_CMD_NEW_SCAN_RESULTS)
75 C2S(NL80211_CMD_SCAN_ABORTED)
76 C2S(NL80211_CMD_REG_CHANGE)
77 C2S(NL80211_CMD_AUTHENTICATE)
78 C2S(NL80211_CMD_ASSOCIATE)
79 C2S(NL80211_CMD_DEAUTHENTICATE)
80 C2S(NL80211_CMD_DISASSOCIATE)
81 C2S(NL80211_CMD_MICHAEL_MIC_FAILURE)
82 C2S(NL80211_CMD_REG_BEACON_HINT)
83 C2S(NL80211_CMD_JOIN_IBSS)
84 C2S(NL80211_CMD_LEAVE_IBSS)
85 C2S(NL80211_CMD_TESTMODE)
86 C2S(NL80211_CMD_CONNECT)
87 C2S(NL80211_CMD_ROAM)
88 C2S(NL80211_CMD_DISCONNECT)
89 C2S(NL80211_CMD_SET_WIPHY_NETNS)
90 C2S(NL80211_CMD_GET_SURVEY)
91 C2S(NL80211_CMD_NEW_SURVEY_RESULTS)
92 C2S(NL80211_CMD_SET_PMKSA)
93 C2S(NL80211_CMD_DEL_PMKSA)
94 C2S(NL80211_CMD_FLUSH_PMKSA)
95 C2S(NL80211_CMD_REMAIN_ON_CHANNEL)
96 C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL)
97 C2S(NL80211_CMD_SET_TX_BITRATE_MASK)
98 C2S(NL80211_CMD_REGISTER_FRAME)
99 C2S(NL80211_CMD_FRAME)
100 C2S(NL80211_CMD_FRAME_TX_STATUS)
101 C2S(NL80211_CMD_SET_POWER_SAVE)
102 C2S(NL80211_CMD_GET_POWER_SAVE)
103 C2S(NL80211_CMD_SET_CQM)
104 C2S(NL80211_CMD_NOTIFY_CQM)
105 C2S(NL80211_CMD_SET_CHANNEL)
106 C2S(NL80211_CMD_SET_WDS_PEER)
107 C2S(NL80211_CMD_FRAME_WAIT_CANCEL)
108 C2S(NL80211_CMD_JOIN_MESH)
109 C2S(NL80211_CMD_LEAVE_MESH)
110 C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE)
111 C2S(NL80211_CMD_UNPROT_DISASSOCIATE)
112 C2S(NL80211_CMD_NEW_PEER_CANDIDATE)
113 C2S(NL80211_CMD_GET_WOWLAN)
114 C2S(NL80211_CMD_SET_WOWLAN)
115 C2S(NL80211_CMD_START_SCHED_SCAN)
116 C2S(NL80211_CMD_STOP_SCHED_SCAN)
117 C2S(NL80211_CMD_SCHED_SCAN_RESULTS)
118 C2S(NL80211_CMD_SCHED_SCAN_STOPPED)
119 C2S(NL80211_CMD_SET_REKEY_OFFLOAD)
120 C2S(NL80211_CMD_PMKSA_CANDIDATE)
121 C2S(NL80211_CMD_TDLS_OPER)
122 C2S(NL80211_CMD_TDLS_MGMT)
123 C2S(NL80211_CMD_UNEXPECTED_FRAME)
124 C2S(NL80211_CMD_PROBE_CLIENT)
125 C2S(NL80211_CMD_REGISTER_BEACONS)
126 C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME)
127 C2S(NL80211_CMD_SET_NOACK_MAP)
128 C2S(NL80211_CMD_CH_SWITCH_NOTIFY)
129 C2S(NL80211_CMD_START_P2P_DEVICE)
130 C2S(NL80211_CMD_STOP_P2P_DEVICE)
131 C2S(NL80211_CMD_CONN_FAILED)
132 C2S(NL80211_CMD_SET_MCAST_RATE)
133 C2S(NL80211_CMD_SET_MAC_ACL)
134 C2S(NL80211_CMD_RADAR_DETECT)
135 C2S(NL80211_CMD_GET_PROTOCOL_FEATURES)
136 C2S(NL80211_CMD_UPDATE_FT_IES)
137 C2S(NL80211_CMD_FT_EVENT)
138 C2S(NL80211_CMD_CRIT_PROTOCOL_START)
139 C2S(NL80211_CMD_CRIT_PROTOCOL_STOP)
140 C2S(NL80211_CMD_GET_COALESCE)
141 C2S(NL80211_CMD_SET_COALESCE)
142 C2S(NL80211_CMD_CHANNEL_SWITCH)
143 C2S(NL80211_CMD_VENDOR)
144 C2S(NL80211_CMD_SET_QOS_MAP)
145 C2S(NL80211_CMD_ADD_TX_TS)
146 C2S(NL80211_CMD_DEL_TX_TS)
147 C2S(NL80211_CMD_GET_MPP)
148 C2S(NL80211_CMD_JOIN_OCB)
149 C2S(NL80211_CMD_LEAVE_OCB)
150 C2S(NL80211_CMD_CH_SWITCH_STARTED_NOTIFY)
151 C2S(NL80211_CMD_TDLS_CHANNEL_SWITCH)
152 C2S(NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH)
153 C2S(NL80211_CMD_WIPHY_REG_CHANGE)
154 C2S(NL80211_CMD_ABORT_SCAN)
155 C2S(NL80211_CMD_START_NAN)
156 C2S(NL80211_CMD_STOP_NAN)
157 C2S(NL80211_CMD_ADD_NAN_FUNCTION)
158 C2S(NL80211_CMD_DEL_NAN_FUNCTION)
159 C2S(NL80211_CMD_CHANGE_NAN_CONFIG)
160 C2S(NL80211_CMD_NAN_MATCH)
161 C2S(NL80211_CMD_SET_MULTICAST_TO_UNICAST)
162 C2S(NL80211_CMD_UPDATE_CONNECT_PARAMS)
163 C2S(NL80211_CMD_SET_PMK)
164 C2S(NL80211_CMD_DEL_PMK)
165 C2S(NL80211_CMD_PORT_AUTHORIZED)
166 C2S(NL80211_CMD_RELOAD_REGDB)
167 C2S(NL80211_CMD_EXTERNAL_AUTH)
168 C2S(NL80211_CMD_STA_OPMODE_CHANGED)
169 C2S(NL80211_CMD_CONTROL_PORT_FRAME)
170 C2S(NL80211_CMD_GET_FTM_RESPONDER_STATS)
171 C2S(NL80211_CMD_PEER_MEASUREMENT_START)
172 C2S(NL80211_CMD_PEER_MEASUREMENT_RESULT)
173 C2S(NL80211_CMD_PEER_MEASUREMENT_COMPLETE)
174 C2S(NL80211_CMD_NOTIFY_RADAR)
175 C2S(NL80211_CMD_UPDATE_OWE_INFO)
176 C2S(NL80211_CMD_PROBE_MESH_LINK)
177 C2S(NL80211_CMD_SET_TID_CONFIG)
178 C2S(NL80211_CMD_UNPROT_BEACON)
179 C2S(NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS)
180 C2S(NL80211_CMD_SET_SAR_SPECS)
181 C2S(__NL80211_CMD_AFTER_LAST)
182 #ifdef CONFIG_MLD_PATCH
183 C2S(NL80211_CMD_OBSS_COLOR_COLLISION)
184 C2S(NL80211_CMD_COLOR_CHANGE_REQUEST)
185 C2S(NL80211_CMD_COLOR_CHANGE_STARTED)
186 C2S(NL80211_CMD_COLOR_CHANGE_ABORTED)
187 C2S(NL80211_CMD_COLOR_CHANGE_COMPLETED)
188 C2S(NL80211_CMD_SET_FILS_AAD)
189 C2S(NL80211_CMD_ASSOC_COMEBACK)
190 C2S(NL80211_CMD_ADD_LINK)
191 C2S(NL80211_CMD_REMOVE_LINK)
192 C2S(NL80211_CMD_ADD_LINK_STA)
193 C2S(NL80211_CMD_MODIFY_LINK_STA)
194 C2S(NL80211_CMD_REMOVE_LINK_STA)
195 C2S(NL80211_CMD_SET_HW_TIMESTAMP)
196 C2S(NL80211_CMD_LINK_SWITCH_EVENT)
197 #endif
198 }
199 #undef C2S
200
201 return "NL80211_CMD_UNKNOWN";
202 }
203
204
mlme_event_auth(struct wpa_driver_nl80211_data * drv,const u8 * frame,size_t len)205 static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
206 const u8 *frame, size_t len)
207 {
208 const struct ieee80211_mgmt *mgmt;
209 union wpa_event_data event;
210
211 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
212 drv->force_connect_cmd) {
213 /*
214 * Avoid reporting two association events that would confuse
215 * the core code.
216 */
217 wpa_printf(MSG_DEBUG,
218 "nl80211: Ignore auth event when using driver SME");
219 return;
220 }
221
222 wpa_printf(MSG_DEBUG, "nl80211: Authenticate event");
223 mgmt = (const struct ieee80211_mgmt *) frame;
224 if (len < 24 + sizeof(mgmt->u.auth)) {
225 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
226 "frame");
227 return;
228 }
229
230 os_memcpy(drv->auth_bssid, mgmt->sa, ETH_ALEN);
231 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
232 os_memset(&event, 0, sizeof(event));
233 os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
234 event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
235 event.auth.auth_transaction =
236 le_to_host16(mgmt->u.auth.auth_transaction);
237 event.auth.status_code = le_to_host16(mgmt->u.auth.status_code);
238 if (len > 24 + sizeof(mgmt->u.auth)) {
239 event.auth.ies = mgmt->u.auth.variable;
240 event.auth.ies_len = len - 24 - sizeof(mgmt->u.auth);
241 }
242
243 wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
244 }
245
246
nl80211_parse_wmm_params(struct nlattr * wmm_attr,struct wmm_params * wmm_params)247 static void nl80211_parse_wmm_params(struct nlattr *wmm_attr,
248 struct wmm_params *wmm_params)
249 {
250 struct nlattr *wmm_info[NL80211_STA_WME_MAX + 1];
251 static struct nla_policy wme_policy[NL80211_STA_WME_MAX + 1] = {
252 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
253 };
254
255 if (!wmm_attr ||
256 nla_parse_nested(wmm_info, NL80211_STA_WME_MAX, wmm_attr,
257 wme_policy) ||
258 !wmm_info[NL80211_STA_WME_UAPSD_QUEUES])
259 return;
260
261 wmm_params->uapsd_queues =
262 nla_get_u8(wmm_info[NL80211_STA_WME_UAPSD_QUEUES]);
263 wmm_params->info_bitmap |= WMM_PARAMS_UAPSD_QUEUES_INFO;
264 }
265
266
mlme_event_assoc(struct wpa_driver_nl80211_data * drv,const u8 * frame,size_t len,struct nlattr * wmm,struct nlattr * req_ie)267 static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
268 const u8 *frame, size_t len, struct nlattr *wmm,
269 struct nlattr *req_ie)
270 {
271 const struct ieee80211_mgmt *mgmt;
272 union wpa_event_data event;
273 u16 status;
274 int ssid_len;
275
276 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
277 drv->force_connect_cmd) {
278 /*
279 * Avoid reporting two association events that would confuse
280 * the core code.
281 */
282 wpa_printf(MSG_DEBUG,
283 "nl80211: Ignore assoc event when using driver SME");
284 return;
285 }
286
287 wpa_printf(MSG_DEBUG, "nl80211: Associate event");
288 mgmt = (const struct ieee80211_mgmt *) frame;
289 if (len < 24 + sizeof(mgmt->u.assoc_resp)) {
290 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
291 "frame");
292 return;
293 }
294
295 status = le_to_host16(mgmt->u.assoc_resp.status_code);
296 if (status != WLAN_STATUS_SUCCESS) {
297 os_memset(&event, 0, sizeof(event));
298 event.assoc_reject.bssid = mgmt->bssid;
299 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
300 event.assoc_reject.resp_ies =
301 (u8 *) mgmt->u.assoc_resp.variable;
302 event.assoc_reject.resp_ies_len =
303 len - 24 - sizeof(mgmt->u.assoc_resp);
304 }
305 event.assoc_reject.status_code = status;
306
307 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
308 return;
309 }
310
311 drv->associated = 1;
312 os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
313 os_memcpy(drv->prev_bssid, mgmt->sa, ETH_ALEN);
314
315 os_memset(&event, 0, sizeof(event));
316 event.assoc_info.resp_frame = frame;
317 event.assoc_info.resp_frame_len = len;
318 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
319 event.assoc_info.resp_ies = (u8 *) mgmt->u.assoc_resp.variable;
320 event.assoc_info.resp_ies_len =
321 len - 24 - sizeof(mgmt->u.assoc_resp);
322 }
323
324 if (req_ie) {
325 event.assoc_info.req_ies = nla_data(req_ie);
326 event.assoc_info.req_ies_len = nla_len(req_ie);
327 }
328
329 /* When this association was initiated outside of wpa_supplicant,
330 * drv->ssid needs to be set here to satisfy later checking. */
331 ssid_len = nl80211_get_assoc_ssid(drv, drv->ssid);
332 if (ssid_len > 0) {
333 drv->ssid_len = ssid_len;
334 wpa_printf(MSG_DEBUG,
335 "nl80211: Set drv->ssid based on scan res info to '%s'",
336 anonymize_ssid(wpa_ssid_txt(drv->ssid, drv->ssid_len)));
337 }
338
339 event.assoc_info.freq = drv->assoc_freq;
340 drv->first_bss->freq = drv->assoc_freq;
341
342 nl80211_parse_wmm_params(wmm, &event.assoc_info.wmm_params);
343
344 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
345 }
346
347
348 #ifdef CONFIG_DRIVER_NL80211_QCA
349
qca_drv_connect_fail_reason_code_handler(struct nl_msg * msg,void * arg)350 static int qca_drv_connect_fail_reason_code_handler(struct nl_msg *msg,
351 void *arg)
352 {
353 struct nlattr *tb[NL80211_ATTR_MAX + 1];
354 struct nlattr *tb_sta_info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_MAX + 1];
355 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
356 u32 *reason_code = arg;
357
358 *reason_code = 0;
359 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
360 genlmsg_attrlen(gnlh, 0), NULL);
361
362 if (!tb[NL80211_ATTR_VENDOR_DATA]) {
363 wpa_printf(MSG_ERROR, "%s: Vendor data not found", __func__);
364 return NL_SKIP;
365 }
366
367 nla_parse(tb_sta_info, QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_MAX,
368 nla_data(tb[NL80211_ATTR_VENDOR_DATA]),
369 nla_len(tb[NL80211_ATTR_VENDOR_DATA]), NULL);
370
371 if (!tb_sta_info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_CONNECT_FAIL_REASON_CODE]) {
372 wpa_printf(MSG_INFO, "%s: Vendor attr not found", __func__);
373 return NL_SKIP;
374 }
375
376 *reason_code = nla_get_u32(tb_sta_info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_CONNECT_FAIL_REASON_CODE]);
377
378 return NL_SKIP;
379 }
380
381
382 static enum qca_sta_connect_fail_reason_codes
drv_get_connect_fail_reason_code(struct wpa_driver_nl80211_data * drv)383 drv_get_connect_fail_reason_code(struct wpa_driver_nl80211_data *drv)
384 {
385 enum qca_sta_connect_fail_reason_codes reason_code;
386 struct nl_msg *msg;
387 int ret;
388
389 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR);
390 if (!msg || nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
391 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
392 QCA_NL80211_VENDOR_SUBCMD_GET_STA_INFO)) {
393 nlmsg_free(msg);
394 return 0;
395 }
396
397 ret = send_and_recv_msgs(drv, msg,
398 qca_drv_connect_fail_reason_code_handler,
399 &reason_code, NULL, NULL);
400 if (ret)
401 wpa_printf(MSG_DEBUG,
402 "nl80211: Get connect fail reason_code failed: ret=%d (%s)",
403 ret, strerror(-ret));
404
405 return reason_code;
406 }
407
408
409 static enum sta_connect_fail_reason_codes
convert_connect_fail_reason_codes(enum qca_sta_connect_fail_reason_codes reason_code)410 convert_connect_fail_reason_codes(enum qca_sta_connect_fail_reason_codes
411 reason_code)
412 {
413 switch (reason_code) {
414 case QCA_STA_CONNECT_FAIL_REASON_NO_BSS_FOUND:
415 return STA_CONNECT_FAIL_REASON_NO_BSS_FOUND;
416 case QCA_STA_CONNECT_FAIL_REASON_AUTH_TX_FAIL:
417 return STA_CONNECT_FAIL_REASON_AUTH_TX_FAIL;
418 case QCA_STA_CONNECT_FAIL_REASON_AUTH_NO_ACK_RECEIVED:
419 return STA_CONNECT_FAIL_REASON_AUTH_NO_ACK_RECEIVED;
420 case QCA_STA_CONNECT_FAIL_REASON_AUTH_NO_RESP_RECEIVED:
421 return STA_CONNECT_FAIL_REASON_AUTH_NO_RESP_RECEIVED;
422 case QCA_STA_CONNECT_FAIL_REASON_ASSOC_REQ_TX_FAIL:
423 return STA_CONNECT_FAIL_REASON_ASSOC_REQ_TX_FAIL;
424 case QCA_STA_CONNECT_FAIL_REASON_ASSOC_NO_ACK_RECEIVED:
425 return STA_CONNECT_FAIL_REASON_ASSOC_NO_ACK_RECEIVED;
426 case QCA_STA_CONNECT_FAIL_REASON_ASSOC_NO_RESP_RECEIVED:
427 return STA_CONNECT_FAIL_REASON_ASSOC_NO_RESP_RECEIVED;
428 default:
429 return STA_CONNECT_FAIL_REASON_UNSPECIFIED;
430 }
431 }
432
433 #endif /* CONFIG_DRIVER_NL80211_QCA */
434
435 #ifdef CONFIG_MLD_PATCH
nl80211_parse_mlo_link_info(struct driver_sta_mlo_info * mlo,struct nlattr * mlo_links)436 static void nl80211_parse_mlo_link_info(struct driver_sta_mlo_info *mlo,
437 struct nlattr *mlo_links)
438 {
439 struct nlattr *link;
440 int rem_links;
441
442 nla_for_each_nested(link, mlo_links, rem_links) {
443 struct nlattr *tb[NL80211_ATTR_MAX + 1];
444 int link_id;
445
446 nla_parse(tb, NL80211_ATTR_MAX, nla_data(link), nla_len(link),
447 NULL);
448
449 if (!tb[NL80211_ATTR_MLO_LINK_ID] || !tb[NL80211_ATTR_MAC] ||
450 !tb[NL80211_ATTR_BSSID])
451 continue;
452
453 link_id = nla_get_u8(tb[NL80211_ATTR_MLO_LINK_ID]);
454 if (link_id >= MAX_NUM_MLD_LINKS)
455 continue;
456
457 if (tb[NL80211_ATTR_STATUS_CODE]) {
458 /* Set requested links only when status indicated */
459 mlo->req_links |= BIT(link_id);
460 if (nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]) ==
461 WLAN_STATUS_SUCCESS)
462 mlo->valid_links |= BIT(link_id);
463 } else {
464 mlo->valid_links |= BIT(link_id);
465 }
466
467 os_memcpy(mlo->links[link_id].addr,
468 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
469 os_memcpy(mlo->links[link_id].bssid,
470 nla_data(tb[NL80211_ATTR_BSSID]), ETH_ALEN);
471 wpa_printf(MSG_DEBUG, "nl80211: MLO link[%u] addr " MACSTR_SEC
472 " bssid " MACSTR_SEC,
473 link_id, MAC2STR_SEC(mlo->links[link_id].addr),
474 MAC2STR_SEC(mlo->links[link_id].bssid));
475 }
476 }
477
478
479 struct links_info {
480 /* bitmap of link IDs in Per-STA profile subelements */
481 u16 non_assoc_links;
482 u8 addr[MAX_NUM_MLD_LINKS][ETH_ALEN];
483 };
484
485
nl80211_get_basic_mle_links_info(const u8 * mle,size_t mle_len,struct links_info * info)486 static void nl80211_get_basic_mle_links_info(const u8 *mle, size_t mle_len,
487 struct links_info *info)
488 {
489 size_t rem_len;
490 const u8 *pos;
491
492 if (mle_len < MULTI_LINK_CONTROL_LEN + 1 ||
493 mle_len - MULTI_LINK_CONTROL_LEN < mle[MULTI_LINK_CONTROL_LEN])
494 return;
495
496 /* Skip Common Info */
497 pos = mle + MULTI_LINK_CONTROL_LEN + mle[MULTI_LINK_CONTROL_LEN];
498 rem_len = mle_len -
499 (MULTI_LINK_CONTROL_LEN + mle[MULTI_LINK_CONTROL_LEN]);
500
501 /* Parse Subelements */
502 while (rem_len > 2) {
503 size_t ie_len = 2 + pos[1];
504
505 if (rem_len < ie_len)
506 break;
507
508 if (pos[0] == MULTI_LINK_SUB_ELEM_ID_PER_STA_PROFILE) {
509 u8 link_id;
510 const u8 *sta_profile;
511 u16 sta_ctrl;
512
513 if (pos[1] < BASIC_MLE_STA_PROF_STA_MAC_IDX + ETH_ALEN)
514 goto next_subelem;
515
516 sta_profile = &pos[2];
517 sta_ctrl = WPA_GET_LE16(sta_profile);
518 link_id = sta_ctrl & BASIC_MLE_STA_CTRL_LINK_ID_MASK;
519 if (link_id >= MAX_NUM_MLD_LINKS)
520 goto next_subelem;
521
522 if (!(sta_ctrl & BASIC_MLE_STA_CTRL_PRES_STA_MAC))
523 goto next_subelem;
524
525 info->non_assoc_links |= BIT(link_id);
526 os_memcpy(info->addr[link_id],
527 &sta_profile[BASIC_MLE_STA_PROF_STA_MAC_IDX],
528 ETH_ALEN);
529 }
530 next_subelem:
531 pos += ie_len;
532 rem_len -= ie_len;
533 }
534 }
535
536
nl80211_update_rejected_links_info(struct driver_sta_mlo_info * mlo,struct nlattr * req_ie,struct nlattr * resp_ie)537 static int nl80211_update_rejected_links_info(struct driver_sta_mlo_info *mlo,
538 struct nlattr *req_ie,
539 struct nlattr *resp_ie)
540 {
541 int i;
542 struct wpabuf *mle;
543 struct ieee802_11_elems req_elems, resp_elems;
544 struct links_info req_info, resp_info;
545
546 if (!req_ie || !resp_ie) {
547 wpa_printf(MSG_INFO,
548 "nl80211: MLO: (Re)Association Request/Response frame elements not available");
549 return -1;
550 }
551
552 if (ieee802_11_parse_elems(nla_data(req_ie), nla_len(req_ie),
553 &req_elems, 0) == ParseFailed ||
554 ieee802_11_parse_elems(nla_data(resp_ie), nla_len(resp_ie),
555 &resp_elems, 0) == ParseFailed) {
556 wpa_printf(MSG_INFO,
557 "nl80211: MLO: Failed to parse (Re)Association Request/Response elements");
558 return -1;
559 }
560
561 mle = ieee802_11_defrag_mle(&req_elems, MULTI_LINK_CONTROL_TYPE_BASIC);
562 if (!mle) {
563 wpa_printf(MSG_INFO,
564 "nl80211: MLO: Basic Multi-Link element not found in Association Request");
565 return -1;
566 }
567 os_memset(&req_info, 0, sizeof(req_info));
568 nl80211_get_basic_mle_links_info(wpabuf_head(mle), wpabuf_len(mle),
569 &req_info);
570 wpabuf_free(mle);
571
572 mle = ieee802_11_defrag_mle(&resp_elems, MULTI_LINK_CONTROL_TYPE_BASIC);
573 if (!mle) {
574 wpa_printf(MSG_ERROR,
575 "nl80211: MLO: Basic Multi-Link element not found in Association Response");
576 return -1;
577 }
578 os_memset(&resp_info, 0, sizeof(resp_info));
579 nl80211_get_basic_mle_links_info(wpabuf_head(mle), wpabuf_len(mle),
580 &resp_info);
581 wpabuf_free(mle);
582
583 if (req_info.non_assoc_links != resp_info.non_assoc_links) {
584 wpa_printf(MSG_ERROR,
585 "nl80211: MLO: Association Request and Response links bitmaps not equal (0x%x != 0x%x)",
586 req_info.non_assoc_links,
587 resp_info.non_assoc_links);
588 return -1;
589 }
590
591 mlo->req_links = BIT(mlo->assoc_link_id) | req_info.non_assoc_links;
592 if ((mlo->req_links & mlo->valid_links) != mlo->valid_links) {
593 wpa_printf(MSG_ERROR,
594 "nl80211: MLO: Accepted links are not a subset of requested links (req_links=0x%x valid_links=0x%x non_assoc_links=0x%x assoc_link_id=0x%x)",
595 mlo->req_links, mlo->valid_links,
596 req_info.non_assoc_links, BIT(mlo->assoc_link_id));
597 return -1;
598 }
599
600 /* Get MLO links info for rejected links */
601 for (i = 0; i < MAX_NUM_MLD_LINKS; i++) {
602 if (!((mlo->req_links & ~mlo->valid_links) & BIT(i)))
603 continue;
604
605 os_memcpy(mlo->links[i].bssid, resp_info.addr[i], ETH_ALEN);
606 os_memcpy(mlo->links[i].addr, req_info.addr[i], ETH_ALEN);
607 }
608
609 return 0;
610 }
611
nl80211_get_assoc_link_id(const u8 * data,u8 len)612 static int nl80211_get_assoc_link_id(const u8 *data, u8 len)
613 {
614 u16 control;
615
616 if (len < 2)
617 return -1;
618
619 control = WPA_GET_LE16(data);
620 if (!(control & BASIC_MULTI_LINK_CTRL_PRES_LINK_ID))
621 return -1;
622
623 #define BASIC_ML_IE_COMMON_INFO_LINK_ID_IDX \
624 (2 + /* Multi-Link Control field */ \
625 1 + /* Common Info Length field (Basic) */ \
626 ETH_ALEN) /* MLD MAC Address field (Basic) */
627 if (len <= BASIC_ML_IE_COMMON_INFO_LINK_ID_IDX)
628 return -1;
629
630 return data[BASIC_ML_IE_COMMON_INFO_LINK_ID_IDX] & 0x0F;
631 }
632
nl80211_parse_mlo_info(struct wpa_driver_nl80211_data * drv,struct nlattr * addr,struct nlattr * mlo_links,struct nlattr * req_ie,struct nlattr * resp_ie)633 static void nl80211_parse_mlo_info(struct wpa_driver_nl80211_data *drv,
634 struct nlattr *addr,
635 struct nlattr *mlo_links,
636 struct nlattr *req_ie,
637 struct nlattr *resp_ie)
638 {
639 const u8 *ml_ie;
640 struct driver_sta_mlo_info *mlo = &drv->sta_mlo_info;
641 int res;
642
643 if (!addr || !mlo_links || !resp_ie)
644 return;
645
646 ml_ie = get_ml_ie(nla_data(resp_ie), nla_len(resp_ie),
647 MULTI_LINK_CONTROL_TYPE_BASIC);
648 if (!ml_ie)
649 return;
650
651 res = nl80211_get_assoc_link_id(&ml_ie[3], ml_ie[1] - 1);
652 if (res < 0 || res >= MAX_NUM_MLD_LINKS) {
653 wpa_printf(MSG_DEBUG,
654 "nl80211: Could not find a valid association Link ID (res=%d)",
655 res);
656 return;
657 }
658 drv->sta_mlo_info.assoc_link_id = res;
659
660 os_memcpy(mlo->ap_mld_addr, nla_data(addr), ETH_ALEN);
661 wpa_printf(MSG_DEBUG, "nl80211: AP MLD MAC Address " MACSTR_SEC,
662 MAC2STR_SEC(mlo->ap_mld_addr));
663
664 nl80211_parse_mlo_link_info(mlo, mlo_links);
665 if (!(mlo->valid_links & BIT(mlo->assoc_link_id)) ||
666 (!mlo->req_links &&
667 nl80211_update_rejected_links_info(mlo, req_ie, resp_ie))) {
668 wpa_printf(MSG_INFO, "nl80211: Invalid MLO connection info");
669 mlo->valid_links = 0;
670 return;
671 }
672
673 os_memcpy(drv->bssid, mlo->links[drv->sta_mlo_info.assoc_link_id].bssid,
674 ETH_ALEN);
675 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
676 }
677 #endif
mlme_event_connect(struct wpa_driver_nl80211_data * drv,enum nl80211_commands cmd,struct nlattr * status,struct nlattr * addr,struct nlattr * req_ie,struct nlattr * resp_ie,struct nlattr * timed_out,struct nlattr * timeout_reason,struct nlattr * authorized,struct nlattr * key_replay_ctr,struct nlattr * ptk_kck,struct nlattr * ptk_kek,struct nlattr * subnet_status,struct nlattr * fils_erp_next_seq_num,struct nlattr * fils_pmk,struct nlattr * fils_pmkid,struct nlattr * mlo_links)678 static void mlme_event_connect(struct wpa_driver_nl80211_data *drv,
679 enum nl80211_commands cmd, struct nlattr *status,
680 struct nlattr *addr, struct nlattr *req_ie,
681 struct nlattr *resp_ie,
682 struct nlattr *timed_out,
683 struct nlattr *timeout_reason,
684 struct nlattr *authorized,
685 struct nlattr *key_replay_ctr,
686 struct nlattr *ptk_kck,
687 struct nlattr *ptk_kek,
688 struct nlattr *subnet_status,
689 struct nlattr *fils_erp_next_seq_num,
690 struct nlattr *fils_pmk,
691 #ifdef CONFIG_MLD_PATCH
692 struct nlattr *fils_pmkid,
693 struct nlattr *mlo_links)
694 #else
695 struct nlattr *fils_pmkid)
696 #endif
697 {
698 union wpa_event_data event;
699 const u8 *ssid = NULL;
700 u16 status_code;
701 int ssid_len;
702
703 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
704 /*
705 * Avoid reporting two association events that would confuse
706 * the core code.
707 */
708 wpa_printf(MSG_DEBUG, "nl80211: Ignore connect event (cmd=%d) "
709 "when using userspace SME", cmd);
710 return;
711 }
712
713 drv->connect_reassoc = 0;
714
715 status_code = status ? nla_get_u16(status) : WLAN_STATUS_SUCCESS;
716
717 if (cmd == NL80211_CMD_CONNECT) {
718 wpa_printf(MSG_EXCESSIVE,
719 "nl80211: Connect event (status=%u ignore_next_local_disconnect=%d)",
720 status_code, drv->ignore_next_local_disconnect);
721 } else if (cmd == NL80211_CMD_ROAM) {
722 wpa_printf(MSG_DEBUG, "nl80211: Roam event");
723 }
724
725 os_memset(&event, 0, sizeof(event));
726 if (cmd == NL80211_CMD_CONNECT && status_code != WLAN_STATUS_SUCCESS) {
727 if (addr)
728 event.assoc_reject.bssid = nla_data(addr);
729 if (drv->ignore_next_local_disconnect) {
730 drv->ignore_next_local_disconnect = 0;
731 if (!event.assoc_reject.bssid ||
732 (os_memcmp(event.assoc_reject.bssid,
733 drv->auth_attempt_bssid,
734 ETH_ALEN) != 0)) {
735 /*
736 * Ignore the event that came without a BSSID or
737 * for the old connection since this is likely
738 * not relevant to the new Connect command.
739 */
740 wpa_printf(MSG_DEBUG,
741 "nl80211: Ignore connection failure event triggered during reassociation");
742 return;
743 }
744 }
745 if (resp_ie) {
746 event.assoc_reject.resp_ies = nla_data(resp_ie);
747 event.assoc_reject.resp_ies_len = nla_len(resp_ie);
748 }
749 event.assoc_reject.status_code = status_code;
750 event.assoc_reject.timed_out = timed_out != NULL;
751 if (timed_out && timeout_reason) {
752 enum nl80211_timeout_reason reason;
753
754 reason = nla_get_u32(timeout_reason);
755 switch (reason) {
756 case NL80211_TIMEOUT_SCAN:
757 event.assoc_reject.timeout_reason = "scan";
758 break;
759 case NL80211_TIMEOUT_AUTH:
760 event.assoc_reject.timeout_reason = "auth";
761 break;
762 case NL80211_TIMEOUT_ASSOC:
763 event.assoc_reject.timeout_reason = "assoc";
764 break;
765 default:
766 break;
767 }
768 }
769 if (fils_erp_next_seq_num)
770 event.assoc_reject.fils_erp_next_seq_num =
771 nla_get_u16(fils_erp_next_seq_num);
772
773 #ifdef CONFIG_DRIVER_NL80211_QCA
774 if (drv->get_sta_info_vendor_cmd_avail) {
775 enum qca_sta_connect_fail_reason_codes reason_code;
776
777 reason_code = drv_get_connect_fail_reason_code(drv);
778 event.assoc_reject.reason_code =
779 convert_connect_fail_reason_codes(reason_code);
780 }
781 #endif /* CONFIG_DRIVER_NL80211_QCA */
782
783 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
784 return;
785 }
786
787 drv->associated = 1;
788 #ifdef CONFIG_MLD_PATCH
789 os_memset(&drv->sta_mlo_info, 0, sizeof(drv->sta_mlo_info));
790 nl80211_parse_mlo_info(drv, addr, mlo_links, req_ie,
791 resp_ie);
792 if (!drv->sta_mlo_info.valid_links && addr) {
793 #else
794 if (addr) {
795 #endif
796 os_memcpy(drv->bssid, nla_data(addr), ETH_ALEN);
797 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
798 }
799
800 if (req_ie) {
801 event.assoc_info.req_ies = nla_data(req_ie);
802 event.assoc_info.req_ies_len = nla_len(req_ie);
803
804 if (cmd == NL80211_CMD_ROAM) {
805 ssid = get_ie(event.assoc_info.req_ies,
806 event.assoc_info.req_ies_len,
807 WLAN_EID_SSID);
808 if (ssid && ssid[1] > 0 && ssid[1] <= 32) {
809 drv->ssid_len = ssid[1];
810 os_memcpy(drv->ssid, ssid + 2, ssid[1]);
811 wpa_printf(MSG_DEBUG,
812 "nl80211: Set drv->ssid based on req_ie to '%s'",
813 anonymize_ssid(wpa_ssid_txt(drv->ssid,
814 drv->ssid_len)));
815 }
816 }
817 }
818 if (resp_ie) {
819 event.assoc_info.resp_ies = nla_data(resp_ie);
820 event.assoc_info.resp_ies_len = nla_len(resp_ie);
821 }
822
823 event.assoc_info.freq = nl80211_get_assoc_freq(drv);
824 drv->first_bss->freq = drv->assoc_freq;
825
826 if ((!ssid || ssid[1] == 0 || ssid[1] > 32) &&
827 (ssid_len = nl80211_get_assoc_ssid(drv, drv->ssid)) > 0) {
828 /* When this connection was initiated outside of wpa_supplicant,
829 * drv->ssid needs to be set here to satisfy later checking. */
830 drv->ssid_len = ssid_len;
831 wpa_printf(MSG_DEBUG,
832 "nl80211: Set drv->ssid based on scan res info to '%s'",
833 anonymize_ssid(wpa_ssid_txt(drv->ssid, drv->ssid_len)));
834 }
835
836 if (authorized && nla_get_u8(authorized)) {
837 event.assoc_info.authorized = 1;
838 wpa_printf(MSG_DEBUG, "nl80211: connection authorized");
839 }
840 if (key_replay_ctr) {
841 event.assoc_info.key_replay_ctr = nla_data(key_replay_ctr);
842 event.assoc_info.key_replay_ctr_len = nla_len(key_replay_ctr);
843 }
844 if (ptk_kck) {
845 event.assoc_info.ptk_kck = nla_data(ptk_kck);
846 event.assoc_info.ptk_kck_len = nla_len(ptk_kck);
847 }
848 if (ptk_kek) {
849 event.assoc_info.ptk_kek = nla_data(ptk_kek);
850 event.assoc_info.ptk_kek_len = nla_len(ptk_kek);
851 }
852
853 if (subnet_status) {
854 /*
855 * At least for now, this is only available from
856 * QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_SUBNET_STATUS and that
857 * attribute has the same values 0, 1, 2 as are used in the
858 * variable here, so no mapping between different values are
859 * needed.
860 */
861 event.assoc_info.subnet_status = nla_get_u8(subnet_status);
862 }
863
864 if (fils_erp_next_seq_num)
865 event.assoc_info.fils_erp_next_seq_num =
866 nla_get_u16(fils_erp_next_seq_num);
867
868 if (fils_pmk) {
869 event.assoc_info.fils_pmk = nla_data(fils_pmk);
870 event.assoc_info.fils_pmk_len = nla_len(fils_pmk);
871 }
872
873 if (fils_pmkid)
874 event.assoc_info.fils_pmkid = nla_data(fils_pmkid);
875
876 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
877
878 /* Avoid a race condition by stopping to ignore any following
879 * disconnection events now that the driver has indicated it is
880 * connected since that connection could have been triggered by a roam
881 * operation that happened in parallel with the disconnection request.
882 */
883 drv->ignore_next_local_disconnect = 0;
884 }
885
886
887 void mlme_event_disconnect(struct wpa_driver_nl80211_data *drv,
888 struct nlattr *reason, struct nlattr *addr,
889 struct nlattr *by_ap)
890 {
891 union wpa_event_data data;
892 unsigned int locally_generated = by_ap == NULL;
893
894 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
895 /*
896 * Avoid reporting two disassociation events that could
897 * confuse the core code.
898 */
899 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
900 "event when using userspace SME");
901 return;
902 }
903
904 if (drv->ignore_next_local_disconnect) {
905 drv->ignore_next_local_disconnect = 0;
906 if (locally_generated) {
907 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
908 "event triggered during reassociation");
909 return;
910 }
911 wpa_printf(MSG_WARNING, "nl80211: Was expecting local "
912 "disconnect but got another disconnect "
913 "event first");
914 }
915
916 wpa_printf(MSG_DEBUG, "nl80211: Disconnect event");
917 nl80211_mark_disconnected(drv);
918 os_memset(&data, 0, sizeof(data));
919 if (reason)
920 data.deauth_info.reason_code = nla_get_u16(reason);
921 data.deauth_info.locally_generated = by_ap == NULL;
922
923 #ifdef CONFIG_VENDOR_EXT
924 wpa_vendor_ext_p2p_enhance_set_reason(drv->ctx, drv->first_bss, &data);
925 #endif
926
927 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, &data);
928 }
929
930
931 static int calculate_chan_offset(int width, int freq, int cf1, int cf2)
932 {
933 int freq1 = 0;
934
935 switch (convert2width(width)) {
936 case CHAN_WIDTH_20_NOHT:
937 case CHAN_WIDTH_20:
938 return 0;
939 case CHAN_WIDTH_40:
940 freq1 = cf1 - 10;
941 break;
942 case CHAN_WIDTH_80:
943 freq1 = cf1 - 30;
944 break;
945 case CHAN_WIDTH_160:
946 freq1 = cf1 - 70;
947 break;
948 case CHAN_WIDTH_80P80:
949 freq1 = cf1 - 30;
950 break;
951 case CHAN_WIDTH_UNKNOWN:
952 case CHAN_WIDTH_2160:
953 case CHAN_WIDTH_4320:
954 case CHAN_WIDTH_6480:
955 case CHAN_WIDTH_8640:
956 /* FIXME: implement this */
957 return 0;
958 }
959
960 return (abs(freq - freq1) / 20) % 2 == 0 ? 1 : -1;
961 }
962
963
964 static void mlme_event_ch_switch(struct wpa_driver_nl80211_data *drv,
965 #ifdef CONFIG_MLD_PATCH
966 struct nlattr *ifindex, struct nlattr *link,
967 struct nlattr *freq, struct nlattr *type,
968 struct nlattr *bw, struct nlattr *cf1,
969 struct nlattr *cf2,
970 struct nlattr *punct_bitmap,
971 #else
972 struct nlattr *ifindex, struct nlattr *freq,
973 struct nlattr *type, struct nlattr *bw,
974 struct nlattr *cf1, struct nlattr *cf2,
975 #endif
976 int finished)
977 {
978 struct i802_bss *bss;
979 union wpa_event_data data;
980 int ht_enabled = 1;
981 int chan_offset = 0;
982 int ifidx;
983
984 wpa_printf(MSG_DEBUG, "nl80211: Channel switch%s event",
985 finished ? "" : " started");
986
987 if (!freq)
988 return;
989
990 ifidx = nla_get_u32(ifindex);
991 bss = get_bss_ifindex(drv, ifidx);
992 if (bss == NULL) {
993 wpa_printf(MSG_WARNING, "nl80211: Unknown ifindex (%d) for channel switch, ignoring",
994 ifidx);
995 return;
996 }
997
998 if (type) {
999 enum nl80211_channel_type ch_type = nla_get_u32(type);
1000
1001 wpa_printf(MSG_DEBUG, "nl80211: Channel type: %d", ch_type);
1002 switch (ch_type) {
1003 case NL80211_CHAN_NO_HT:
1004 ht_enabled = 0;
1005 break;
1006 case NL80211_CHAN_HT20:
1007 break;
1008 case NL80211_CHAN_HT40PLUS:
1009 chan_offset = 1;
1010 break;
1011 case NL80211_CHAN_HT40MINUS:
1012 chan_offset = -1;
1013 break;
1014 }
1015 } else if (bw && cf1) {
1016 /* This can happen for example with VHT80 ch switch */
1017 chan_offset = calculate_chan_offset(nla_get_u32(bw),
1018 nla_get_u32(freq),
1019 nla_get_u32(cf1),
1020 cf2 ? nla_get_u32(cf2) : 0);
1021 wpa_printf(MSG_DEBUG, "nl80211: Calculated channel offset: %d",
1022 chan_offset);
1023 } else {
1024 wpa_printf(MSG_WARNING, "nl80211: Unknown secondary channel information - following channel definition calculations may fail");
1025 }
1026
1027 os_memset(&data, 0, sizeof(data));
1028 data.ch_switch.freq = nla_get_u32(freq);
1029 data.ch_switch.ht_enabled = ht_enabled;
1030 data.ch_switch.ch_offset = chan_offset;
1031 #ifdef CONFIG_MLD_PATCH
1032 if (punct_bitmap)
1033 data.ch_switch.punct_bitmap = (u16) nla_get_u32(punct_bitmap);
1034 #endif
1035 if (bw)
1036 data.ch_switch.ch_width = convert2width(nla_get_u32(bw));
1037 if (cf1)
1038 data.ch_switch.cf1 = nla_get_u32(cf1);
1039 if (cf2)
1040 data.ch_switch.cf2 = nla_get_u32(cf2);
1041
1042 #ifdef CONFIG_MLD_PATCH
1043 if (finished)
1044 bss->flink->freq = data.ch_switch.freq;
1045
1046 if (link) {
1047 u8 link_id = nla_get_u8(link);
1048
1049 if (link_id < MAX_NUM_MLD_LINKS &&
1050 drv->sta_mlo_info.valid_links & BIT(link_id)) {
1051 data.ch_switch.link_id = link_id;
1052 drv->sta_mlo_info.links[link_id].freq =
1053 data.ch_switch.freq;
1054 wpa_supplicant_event(
1055 bss->ctx,
1056 finished ? EVENT_LINK_CH_SWITCH :
1057 EVENT_LINK_CH_SWITCH_STARTED, &data);
1058 }
1059
1060 if (link_id != drv->sta_mlo_info.assoc_link_id)
1061 return;
1062 }
1063 #endif
1064 if (finished)
1065 bss->freq = data.ch_switch.freq;
1066 drv->assoc_freq = data.ch_switch.freq;
1067
1068 wpa_supplicant_event(bss->ctx, finished ?
1069 EVENT_CH_SWITCH : EVENT_CH_SWITCH_STARTED, &data);
1070 }
1071
1072
1073 static void mlme_timeout_event(struct wpa_driver_nl80211_data *drv,
1074 enum nl80211_commands cmd, struct nlattr *addr)
1075 {
1076 union wpa_event_data event;
1077 enum wpa_event_type ev;
1078
1079 if (nla_len(addr) != ETH_ALEN)
1080 return;
1081
1082 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d; timeout with " MACSTR_SEC,
1083 cmd, MAC2STR_SEC((u8 *) nla_data(addr)));
1084
1085 if (cmd == NL80211_CMD_AUTHENTICATE)
1086 ev = EVENT_AUTH_TIMED_OUT;
1087 else if (cmd == NL80211_CMD_ASSOCIATE)
1088 ev = EVENT_ASSOC_TIMED_OUT;
1089 else
1090 return;
1091
1092 os_memset(&event, 0, sizeof(event));
1093 os_memcpy(event.timeout_event.addr, nla_data(addr), ETH_ALEN);
1094 wpa_supplicant_event(drv->ctx, ev, &event);
1095 }
1096
1097
1098 static void mlme_event_mgmt(struct i802_bss *bss,
1099 struct nlattr *freq, struct nlattr *sig,
1100 #ifdef CONFIG_MLD_PATCH
1101 const u8 *frame, size_t len, int link_id)
1102 #else
1103 const u8 *frame, size_t len)
1104 #endif
1105 {
1106 struct wpa_driver_nl80211_data *drv = bss->drv;
1107 const struct ieee80211_mgmt *mgmt;
1108 union wpa_event_data event;
1109 u16 fc, stype;
1110 int ssi_signal = 0;
1111 int rx_freq = 0;
1112
1113 wpa_printf(MSG_MSGDUMP, "nl80211: Frame event");
1114 mgmt = (const struct ieee80211_mgmt *) frame;
1115 if (len < 24) {
1116 wpa_printf(MSG_DEBUG, "nl80211: Too short management frame");
1117 return;
1118 }
1119
1120 fc = le_to_host16(mgmt->frame_control);
1121 stype = WLAN_FC_GET_STYPE(fc);
1122
1123 if (sig)
1124 ssi_signal = (s32) nla_get_u32(sig);
1125
1126 os_memset(&event, 0, sizeof(event));
1127 if (freq) {
1128 event.rx_mgmt.freq = nla_get_u32(freq);
1129 rx_freq = drv->last_mgmt_freq = event.rx_mgmt.freq;
1130 }
1131 wpa_printf(MSG_DEBUG,
1132 "nl80211: RX frame da=" MACSTR_SEC " sa=" MACSTR_SEC " bssid=" MACSTR_SEC
1133 " freq=%d ssi_signal=%d fc=0x%x seq_ctrl=0x%x stype=%u (%s) len=%u",
1134 MAC2STR_SEC(mgmt->da), MAC2STR_SEC(mgmt->sa), MAC2STR_SEC(mgmt->bssid),
1135 rx_freq, ssi_signal, fc,
1136 le_to_host16(mgmt->seq_ctrl), stype, fc2str(fc),
1137 (unsigned int) len);
1138 event.rx_mgmt.frame = frame;
1139 event.rx_mgmt.frame_len = len;
1140 event.rx_mgmt.ssi_signal = ssi_signal;
1141 event.rx_mgmt.drv_priv = bss;
1142 #ifdef CONFIG_MLD_PATCH
1143 event.rx_mgmt.link_id = link_id;
1144 #endif
1145 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
1146 }
1147
1148
1149 static void mlme_event_mgmt_tx_status(struct wpa_driver_nl80211_data *drv,
1150 struct nlattr *cookie, const u8 *frame,
1151 size_t len, struct nlattr *ack)
1152 {
1153 union wpa_event_data event;
1154 const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *) frame;
1155 u16 fc = le_to_host16(hdr->frame_control);
1156 u64 cookie_val = 0;
1157
1158 if (cookie)
1159 cookie_val = nla_get_u64(cookie);
1160 wpa_printf(MSG_DEBUG,
1161 "nl80211: Frame TX status event A1=" MACSTR_SEC
1162 " %sstype=%d cookie=0x%llx%s ack=%d",
1163 MAC2STR_SEC(hdr->addr1),
1164 WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT ? "not-mgmt " : "",
1165 WLAN_FC_GET_STYPE(fc), (long long unsigned int) cookie_val,
1166 cookie ? "" : "(N/A)", ack != NULL);
1167
1168 if (cookie_val && cookie_val == drv->eapol_tx_cookie &&
1169 len >= ETH_HLEN &&
1170 WPA_GET_BE16(frame + 2 * ETH_ALEN) == ETH_P_PAE) {
1171 wpa_printf(MSG_DEBUG,
1172 "nl80211: Work around misdelivered control port TX status for EAPOL");
1173 nl80211_control_port_frame_tx_status(drv, frame, len, ack,
1174 cookie);
1175 return;
1176 }
1177
1178 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT)
1179 return;
1180
1181 if (!is_ap_interface(drv->nlmode) &&
1182 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
1183 if (!cookie)
1184 return;
1185
1186 wpa_printf(MSG_DEBUG,
1187 "nl80211: Frame TX status: cookie=0x%llx%s (ack=%d)",
1188 (long long unsigned int) cookie_val,
1189 cookie_val == drv->send_frame_cookie ?
1190 " (match)" : " (unknown)", ack != NULL);
1191 if (cookie_val != drv->send_frame_cookie)
1192 return;
1193 } else if (!is_ap_interface(drv->nlmode) &&
1194 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_AUTH) {
1195 wpa_printf(MSG_DEBUG,
1196 "nl80211: Authentication frame TX status: ack=%d",
1197 !!ack);
1198 }
1199
1200 os_memset(&event, 0, sizeof(event));
1201 event.tx_status.type = WLAN_FC_GET_TYPE(fc);
1202 event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
1203 event.tx_status.dst = hdr->addr1;
1204 event.tx_status.data = frame;
1205 event.tx_status.data_len = len;
1206 event.tx_status.ack = ack != NULL;
1207 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
1208 }
1209
1210
1211 static void mlme_event_deauth_disassoc(struct wpa_driver_nl80211_data *drv,
1212 enum wpa_event_type type,
1213 const u8 *frame, size_t len)
1214 {
1215 const struct ieee80211_mgmt *mgmt;
1216 union wpa_event_data event;
1217 const u8 *bssid = NULL;
1218 u16 reason_code = 0;
1219
1220 if (type == EVENT_DEAUTH)
1221 wpa_printf(MSG_DEBUG, "nl80211: Deauthenticate event");
1222 else
1223 wpa_printf(MSG_DEBUG, "nl80211: Disassociate event");
1224
1225 mgmt = (const struct ieee80211_mgmt *) frame;
1226 if (len >= 24) {
1227 bssid = mgmt->bssid;
1228
1229 if ((drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
1230 !drv->associated &&
1231 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0 &&
1232 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0 &&
1233 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0) {
1234 /*
1235 * Avoid issues with some roaming cases where
1236 * disconnection event for the old AP may show up after
1237 * we have started connection with the new AP.
1238 * In case of locally generated event clear
1239 * ignore_next_local_deauth as well, to avoid next local
1240 * deauth event be wrongly ignored.
1241 */
1242 if (!os_memcmp(mgmt->sa, drv->first_bss->addr,
1243 ETH_ALEN)) {
1244 wpa_printf(MSG_DEBUG,
1245 "nl80211: Received a locally generated deauth event. Clear ignore_next_local_deauth flag");
1246 drv->ignore_next_local_deauth = 0;
1247 } else {
1248 wpa_printf(MSG_DEBUG,
1249 "nl80211: Ignore deauth/disassoc event from old AP " MACSTR_SEC
1250 " when already authenticating with " MACSTR_SEC,
1251 MAC2STR_SEC(bssid),
1252 MAC2STR_SEC(drv->auth_attempt_bssid));
1253 }
1254 return;
1255 }
1256
1257 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
1258 drv->connect_reassoc && drv->associated &&
1259 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0 &&
1260 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0) {
1261 /*
1262 * Avoid issues with some roaming cases where
1263 * disconnection event for the old AP may show up after
1264 * we have started connection with the new AP.
1265 */
1266 wpa_printf(MSG_DEBUG,
1267 "nl80211: Ignore deauth/disassoc event from old AP "
1268 MACSTR_SEC
1269 " when already connecting with " MACSTR_SEC,
1270 MAC2STR_SEC(bssid),
1271 MAC2STR_SEC(drv->auth_attempt_bssid));
1272 return;
1273 }
1274
1275 if (drv->associated != 0 &&
1276 os_memcmp(bssid, drv->bssid, ETH_ALEN) != 0 &&
1277 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0) {
1278 /*
1279 * We have presumably received this deauth as a
1280 * response to a clear_state_mismatch() outgoing
1281 * deauth. Don't let it take us offline!
1282 */
1283 wpa_printf(MSG_DEBUG, "nl80211: Deauth received "
1284 "from Unknown BSSID " MACSTR_SEC " -- ignoring",
1285 MAC2STR_SEC(bssid));
1286 return;
1287 }
1288 }
1289
1290 nl80211_mark_disconnected(drv);
1291 os_memset(&event, 0, sizeof(event));
1292
1293 /* Note: Same offset for Reason Code in both frame subtypes */
1294 if (len >= 24 + sizeof(mgmt->u.deauth))
1295 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
1296
1297 if (type == EVENT_DISASSOC) {
1298 event.disassoc_info.locally_generated =
1299 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
1300 event.disassoc_info.addr = bssid;
1301 event.disassoc_info.reason_code = reason_code;
1302 if (frame + len > mgmt->u.disassoc.variable) {
1303 event.disassoc_info.ie = mgmt->u.disassoc.variable;
1304 event.disassoc_info.ie_len = frame + len -
1305 mgmt->u.disassoc.variable;
1306 }
1307 } else {
1308 event.deauth_info.locally_generated =
1309 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
1310 if (drv->ignore_deauth_event) {
1311 wpa_printf(MSG_DEBUG, "nl80211: Ignore deauth event due to previous forced deauth-during-auth");
1312 drv->ignore_deauth_event = 0;
1313 if (event.deauth_info.locally_generated)
1314 drv->ignore_next_local_deauth = 0;
1315 return;
1316 }
1317 if (drv->ignore_next_local_deauth) {
1318 drv->ignore_next_local_deauth = 0;
1319 if (event.deauth_info.locally_generated) {
1320 wpa_printf(MSG_DEBUG, "nl80211: Ignore deauth event triggered due to own deauth request");
1321 return;
1322 }
1323 wpa_printf(MSG_WARNING, "nl80211: Was expecting local deauth but got another disconnect event first");
1324 }
1325 event.deauth_info.addr = bssid;
1326 event.deauth_info.reason_code = reason_code;
1327 if (frame + len > mgmt->u.deauth.variable) {
1328 event.deauth_info.ie = mgmt->u.deauth.variable;
1329 event.deauth_info.ie_len = frame + len -
1330 mgmt->u.deauth.variable;
1331 }
1332 }
1333
1334 wpa_supplicant_event(drv->ctx, type, &event);
1335 }
1336
1337
1338 static void mlme_event_unprot_disconnect(struct wpa_driver_nl80211_data *drv,
1339 enum wpa_event_type type,
1340 const u8 *frame, size_t len)
1341 {
1342 const struct ieee80211_mgmt *mgmt;
1343 union wpa_event_data event;
1344 u16 reason_code = 0;
1345
1346 if (type == EVENT_UNPROT_DEAUTH)
1347 wpa_printf(MSG_DEBUG, "nl80211: Unprot Deauthenticate event");
1348 else
1349 wpa_printf(MSG_DEBUG, "nl80211: Unprot Disassociate event");
1350
1351 if (len < 24)
1352 return;
1353
1354 mgmt = (const struct ieee80211_mgmt *) frame;
1355
1356 os_memset(&event, 0, sizeof(event));
1357 /* Note: Same offset for Reason Code in both frame subtypes */
1358 if (len >= 24 + sizeof(mgmt->u.deauth))
1359 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
1360
1361 if (type == EVENT_UNPROT_DISASSOC) {
1362 event.unprot_disassoc.sa = mgmt->sa;
1363 event.unprot_disassoc.da = mgmt->da;
1364 event.unprot_disassoc.reason_code = reason_code;
1365 } else {
1366 event.unprot_deauth.sa = mgmt->sa;
1367 event.unprot_deauth.da = mgmt->da;
1368 event.unprot_deauth.reason_code = reason_code;
1369 }
1370
1371 wpa_supplicant_event(drv->ctx, type, &event);
1372 }
1373
1374
1375 static void mlme_event_unprot_beacon(struct wpa_driver_nl80211_data *drv,
1376 const u8 *frame, size_t len)
1377 {
1378 const struct ieee80211_mgmt *mgmt;
1379 union wpa_event_data event;
1380
1381 if (len < 24)
1382 return;
1383
1384 mgmt = (const struct ieee80211_mgmt *) frame;
1385
1386 os_memset(&event, 0, sizeof(event));
1387 event.unprot_beacon.sa = mgmt->sa;
1388 wpa_supplicant_event(drv->ctx, EVENT_UNPROT_BEACON, &event);
1389 }
1390
1391 #ifdef CONFIG_MLD_PATCH
1392 static s8
1393 nl80211_get_link_id_by_freq(struct i802_bss *bss, unsigned int freq)
1394 {
1395 unsigned int i;
1396
1397 for_each_link(bss->valid_links, i) {
1398 if ((unsigned int) bss->links[i].freq == freq)
1399 return i;
1400 }
1401
1402 return NL80211_DRV_LINK_ID_NA;
1403 }
1404 #endif
1405
1406 static void mlme_event(struct i802_bss *bss,
1407 enum nl80211_commands cmd, struct nlattr *frame,
1408 struct nlattr *addr, struct nlattr *timed_out,
1409 struct nlattr *freq, struct nlattr *ack,
1410 struct nlattr *cookie, struct nlattr *sig,
1411 #ifdef CONFIG_MLD_PATCH
1412 struct nlattr *wmm, struct nlattr *req_ie,
1413 struct nlattr *link)
1414 #else
1415 struct nlattr *wmm, struct nlattr *req_ie)
1416 #endif
1417 {
1418 struct wpa_driver_nl80211_data *drv = bss->drv;
1419 const u8 *data;
1420 size_t len;
1421 #ifdef CONFIG_MLD_PATCH
1422 int link_id = -1;
1423 #endif
1424
1425 if (timed_out && addr) {
1426 mlme_timeout_event(drv, cmd, addr);
1427 return;
1428 }
1429
1430 if (frame == NULL) {
1431 wpa_printf(MSG_DEBUG,
1432 "nl80211: MLME event %d (%s) without frame data",
1433 cmd, nl80211_command_to_string(cmd));
1434 return;
1435 }
1436 #ifdef CONFIG_MLD_PATCH
1437 /* Determine the MLD link either by an explicitly provided link id or
1438 * finding a match based on the frequency. */
1439 if (link)
1440 link_id = nla_get_u8(link);
1441 else if (freq)
1442 link_id = nl80211_get_link_id_by_freq(bss, nla_get_u32(freq));
1443 #endif
1444 data = nla_data(frame);
1445 len = nla_len(frame);
1446 if (len < 4 + 2 * ETH_ALEN) {
1447 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s("
1448 MACSTR_SEC ") - too short",
1449 cmd, nl80211_command_to_string(cmd), bss->ifname,
1450 MAC2STR_SEC(bss->addr));
1451 return;
1452 }
1453 #ifdef CONFIG_MLD_PATCH
1454 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s(" MACSTR
1455 ") A1=" MACSTR " A2=" MACSTR " on link_id=%d", cmd,
1456 nl80211_command_to_string(cmd), bss->ifname,
1457 MAC2STR(bss->addr), MAC2STR(data + 4),
1458 MAC2STR(data + 4 + ETH_ALEN), link_id);
1459 #else
1460 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s(" MACSTR_SEC
1461 ") A1=" MACSTR_SEC " A2=" MACSTR_SEC, cmd,
1462 nl80211_command_to_string(cmd), bss->ifname,
1463 MAC2STR_SEC(bss->addr), MAC2STR_SEC(data + 4),
1464 MAC2STR_SEC(data + 4 + ETH_ALEN));
1465 #endif
1466 if (cmd != NL80211_CMD_FRAME_TX_STATUS && !(data[4] & 0x01) &&
1467 os_memcmp(bss->addr, data + 4, ETH_ALEN) != 0 &&
1468 (is_zero_ether_addr(bss->rand_addr) ||
1469 os_memcmp(bss->rand_addr, data + 4, ETH_ALEN) != 0) &&
1470 os_memcmp(bss->addr, data + 4 + ETH_ALEN, ETH_ALEN) != 0) {
1471 wpa_printf(MSG_MSGDUMP, "nl80211: %s: Ignore MLME frame event "
1472 "for foreign address", bss->ifname);
1473 return;
1474 }
1475 wpa_hexdump(MSG_MSGDUMP, "nl80211: MLME event frame",
1476 nla_data(frame), nla_len(frame));
1477
1478 switch (cmd) {
1479 case NL80211_CMD_AUTHENTICATE:
1480 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
1481 break;
1482 case NL80211_CMD_ASSOCIATE:
1483 mlme_event_assoc(drv, nla_data(frame), nla_len(frame), wmm,
1484 req_ie);
1485 break;
1486 case NL80211_CMD_DEAUTHENTICATE:
1487 mlme_event_deauth_disassoc(drv, EVENT_DEAUTH,
1488 nla_data(frame), nla_len(frame));
1489 break;
1490 case NL80211_CMD_DISASSOCIATE:
1491 mlme_event_deauth_disassoc(drv, EVENT_DISASSOC,
1492 nla_data(frame), nla_len(frame));
1493 break;
1494 case NL80211_CMD_FRAME:
1495 mlme_event_mgmt(bss, freq, sig, nla_data(frame),
1496 #ifdef CONFIG_MLD_PATCH
1497 nla_len(frame), link_id);
1498 #else
1499 nla_len(frame));
1500 #endif
1501 break;
1502 case NL80211_CMD_FRAME_TX_STATUS:
1503 mlme_event_mgmt_tx_status(drv, cookie, nla_data(frame),
1504 nla_len(frame), ack);
1505 break;
1506 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
1507 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DEAUTH,
1508 nla_data(frame), nla_len(frame));
1509 break;
1510 case NL80211_CMD_UNPROT_DISASSOCIATE:
1511 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DISASSOC,
1512 nla_data(frame), nla_len(frame));
1513 break;
1514 case NL80211_CMD_UNPROT_BEACON:
1515 mlme_event_unprot_beacon(drv, nla_data(frame), nla_len(frame));
1516 break;
1517 default:
1518 break;
1519 }
1520 }
1521
1522
1523 static void mlme_event_michael_mic_failure(struct i802_bss *bss,
1524 struct nlattr *tb[])
1525 {
1526 union wpa_event_data data;
1527
1528 wpa_printf(MSG_DEBUG, "nl80211: MLME event Michael MIC failure");
1529 os_memset(&data, 0, sizeof(data));
1530 if (tb[NL80211_ATTR_MAC]) {
1531 wpa_hexdump(MSG_DEBUG, "nl80211: Source MAC address",
1532 nla_data(tb[NL80211_ATTR_MAC]),
1533 nla_len(tb[NL80211_ATTR_MAC]));
1534 data.michael_mic_failure.src = nla_data(tb[NL80211_ATTR_MAC]);
1535 }
1536 if (tb[NL80211_ATTR_KEY_SEQ]) {
1537 wpa_hexdump(MSG_DEBUG, "nl80211: TSC",
1538 nla_data(tb[NL80211_ATTR_KEY_SEQ]),
1539 nla_len(tb[NL80211_ATTR_KEY_SEQ]));
1540 }
1541 if (tb[NL80211_ATTR_KEY_TYPE]) {
1542 enum nl80211_key_type key_type =
1543 nla_get_u32(tb[NL80211_ATTR_KEY_TYPE]);
1544 wpa_printf(MSG_DEBUG, "nl80211: Key Type %d", key_type);
1545 if (key_type == NL80211_KEYTYPE_PAIRWISE)
1546 data.michael_mic_failure.unicast = 1;
1547 } else
1548 data.michael_mic_failure.unicast = 1;
1549
1550 if (tb[NL80211_ATTR_KEY_IDX]) {
1551 u8 key_id = nla_get_u8(tb[NL80211_ATTR_KEY_IDX]);
1552 wpa_printf(MSG_DEBUG, "nl80211: Key Id %d", key_id);
1553 }
1554
1555 wpa_supplicant_event(bss->ctx, EVENT_MICHAEL_MIC_FAILURE, &data);
1556 }
1557
1558
1559 static void mlme_event_join_ibss(struct wpa_driver_nl80211_data *drv,
1560 struct nlattr *tb[])
1561 {
1562 unsigned int freq;
1563 union wpa_event_data event;
1564
1565 if (tb[NL80211_ATTR_MAC] == NULL) {
1566 wpa_printf(MSG_DEBUG, "nl80211: No address in IBSS joined "
1567 "event");
1568 return;
1569 }
1570 os_memcpy(drv->bssid, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1571
1572 drv->associated = 1;
1573 wpa_printf(MSG_DEBUG, "nl80211: IBSS " MACSTR_SEC " joined",
1574 MAC2STR_SEC(drv->bssid));
1575
1576 freq = nl80211_get_assoc_freq(drv);
1577 if (freq) {
1578 wpa_printf(MSG_DEBUG, "nl80211: IBSS on frequency %u MHz",
1579 freq);
1580 drv->first_bss->freq = freq;
1581 }
1582
1583 os_memset(&event, 0, sizeof(event));
1584 event.assoc_info.freq = freq;
1585
1586 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1587 }
1588
1589
1590 static void mlme_event_remain_on_channel(struct wpa_driver_nl80211_data *drv,
1591 int cancel_event, struct nlattr *tb[])
1592 {
1593 unsigned int freq, chan_type, duration;
1594 union wpa_event_data data;
1595 u64 cookie;
1596
1597 if (tb[NL80211_ATTR_WIPHY_FREQ])
1598 freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1599 else
1600 freq = 0;
1601
1602 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])
1603 chan_type = nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1604 else
1605 chan_type = 0;
1606
1607 if (tb[NL80211_ATTR_DURATION])
1608 duration = nla_get_u32(tb[NL80211_ATTR_DURATION]);
1609 else
1610 duration = 0;
1611
1612 if (tb[NL80211_ATTR_COOKIE])
1613 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
1614 else
1615 cookie = 0;
1616
1617 wpa_printf(MSG_EXCESSIVE, "nl80211: Remain-on-channel event (cancel=%d "
1618 "freq=%u channel_type=%u duration=%u cookie=0x%llx (%s))",
1619 cancel_event, freq, chan_type, duration,
1620 (long long unsigned int) cookie,
1621 cookie == drv->remain_on_chan_cookie ? "match" : "unknown");
1622
1623 if (cookie != drv->remain_on_chan_cookie)
1624 return; /* not for us */
1625
1626 if (cancel_event)
1627 drv->pending_remain_on_chan = 0;
1628
1629 os_memset(&data, 0, sizeof(data));
1630 data.remain_on_channel.freq = freq;
1631 data.remain_on_channel.duration = duration;
1632 wpa_supplicant_event(drv->ctx, cancel_event ?
1633 EVENT_CANCEL_REMAIN_ON_CHANNEL :
1634 EVENT_REMAIN_ON_CHANNEL, &data);
1635 }
1636
1637
1638 static void mlme_event_ft_event(struct wpa_driver_nl80211_data *drv,
1639 struct nlattr *tb[])
1640 {
1641 union wpa_event_data data;
1642
1643 os_memset(&data, 0, sizeof(data));
1644
1645 if (tb[NL80211_ATTR_IE]) {
1646 data.ft_ies.ies = nla_data(tb[NL80211_ATTR_IE]);
1647 data.ft_ies.ies_len = nla_len(tb[NL80211_ATTR_IE]);
1648 }
1649
1650 if (tb[NL80211_ATTR_IE_RIC]) {
1651 data.ft_ies.ric_ies = nla_data(tb[NL80211_ATTR_IE_RIC]);
1652 data.ft_ies.ric_ies_len = nla_len(tb[NL80211_ATTR_IE_RIC]);
1653 }
1654
1655 if (tb[NL80211_ATTR_MAC])
1656 os_memcpy(data.ft_ies.target_ap,
1657 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1658
1659 wpa_printf(MSG_DEBUG, "nl80211: FT event target_ap " MACSTR_SEC,
1660 MAC2STR_SEC(data.ft_ies.target_ap));
1661
1662 wpa_supplicant_event(drv->ctx, EVENT_FT_RESPONSE, &data);
1663 }
1664
1665
1666 static void mlme_event_dh_event(struct wpa_driver_nl80211_data *drv,
1667 struct i802_bss *bss,
1668 struct nlattr *tb[])
1669 {
1670 union wpa_event_data data;
1671
1672 if (!is_ap_interface(drv->nlmode))
1673 return;
1674 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_IE])
1675 return;
1676
1677 os_memset(&data, 0, sizeof(data));
1678 data.update_dh.peer = nla_data(tb[NL80211_ATTR_MAC]);
1679 data.update_dh.ie = nla_data(tb[NL80211_ATTR_IE]);
1680 data.update_dh.ie_len = nla_len(tb[NL80211_ATTR_IE]);
1681
1682 wpa_printf(MSG_DEBUG, "nl80211: DH event - peer " MACSTR_SEC,
1683 MAC2STR_SEC(data.update_dh.peer));
1684
1685 wpa_supplicant_event(bss->ctx, EVENT_UPDATE_DH, &data);
1686 }
1687
1688
1689 static void send_scan_event(struct wpa_driver_nl80211_data *drv, int aborted,
1690 struct nlattr *tb[], int external_scan)
1691 {
1692 union wpa_event_data event;
1693 struct nlattr *nl;
1694 int rem;
1695 struct scan_info *info;
1696 #define MAX_REPORT_FREQS 100
1697 int freqs[MAX_REPORT_FREQS];
1698 int num_freqs = 0;
1699
1700 if (!external_scan && drv->scan_for_auth) {
1701 drv->scan_for_auth = 0;
1702 wpa_printf(MSG_DEBUG, "nl80211: Scan results for missing "
1703 "cfg80211 BSS entry");
1704 wpa_driver_nl80211_authenticate_retry(drv);
1705 return;
1706 }
1707
1708 os_memset(&event, 0, sizeof(event));
1709 info = &event.scan_info;
1710 info->aborted = aborted;
1711 info->external_scan = external_scan;
1712 info->nl_scan_event = 1;
1713
1714 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
1715 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_SSIDS], rem) {
1716 struct wpa_driver_scan_ssid *s =
1717 &info->ssids[info->num_ssids];
1718 s->ssid = nla_data(nl);
1719 s->ssid_len = nla_len(nl);
1720 wpa_printf(MSG_INFO, "nl80211: Scan probed for SSID '%s'",
1721 anonymize_ssid(wpa_ssid_txt(s->ssid, s->ssid_len)));
1722 info->num_ssids++;
1723 if (info->num_ssids == WPAS_MAX_SCAN_SSIDS)
1724 break;
1725 }
1726 }
1727 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
1728 char msg[500], *pos, *end;
1729 int res;
1730
1731 pos = msg;
1732 end = pos + sizeof(msg);
1733 *pos = '\0';
1734
1735 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem)
1736 {
1737 freqs[num_freqs] = nla_get_u32(nl);
1738 res = os_snprintf(pos, end - pos, " %d",
1739 freqs[num_freqs]);
1740 if (!os_snprintf_error(end - pos, res))
1741 pos += res;
1742 num_freqs++;
1743 if (num_freqs == MAX_REPORT_FREQS - 1)
1744 break;
1745 }
1746 info->freqs = freqs;
1747 info->num_freqs = num_freqs;
1748 wpa_printf(MSG_WARNING, "nl80211: Scan included frequencies:%s",
1749 msg);
1750 }
1751
1752 if (tb[NL80211_ATTR_SCAN_START_TIME_TSF] &&
1753 tb[NL80211_ATTR_SCAN_START_TIME_TSF_BSSID]) {
1754 info->scan_start_tsf =
1755 nla_get_u64(tb[NL80211_ATTR_SCAN_START_TIME_TSF]);
1756 os_memcpy(info->scan_start_tsf_bssid,
1757 nla_data(tb[NL80211_ATTR_SCAN_START_TIME_TSF_BSSID]),
1758 ETH_ALEN);
1759 }
1760
1761 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
1762 }
1763
1764
1765 static void nl80211_cqm_event(struct wpa_driver_nl80211_data *drv,
1766 struct nlattr *tb[])
1767 {
1768 static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
1769 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
1770 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U8 },
1771 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
1772 [NL80211_ATTR_CQM_PKT_LOSS_EVENT] = { .type = NLA_U32 },
1773 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
1774 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
1775 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
1776 [NL80211_ATTR_CQM_BEACON_LOSS_EVENT] = { .type = NLA_FLAG },
1777 };
1778 struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
1779 enum nl80211_cqm_rssi_threshold_event event;
1780 union wpa_event_data ed;
1781 int res;
1782
1783 if (tb[NL80211_ATTR_CQM] == NULL ||
1784 nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, tb[NL80211_ATTR_CQM],
1785 cqm_policy)) {
1786 wpa_printf(MSG_DEBUG, "nl80211: Ignore invalid CQM event");
1787 return;
1788 }
1789
1790 os_memset(&ed, 0, sizeof(ed));
1791
1792 if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]) {
1793 if (!tb[NL80211_ATTR_MAC])
1794 return;
1795 os_memcpy(ed.low_ack.addr, nla_data(tb[NL80211_ATTR_MAC]),
1796 ETH_ALEN);
1797 ed.low_ack.num_packets =
1798 nla_get_u32(cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]);
1799 wpa_printf(MSG_DEBUG, "nl80211: Packet loss event for " MACSTR_SEC
1800 " (num_packets %u)",
1801 MAC2STR_SEC(ed.low_ack.addr), ed.low_ack.num_packets);
1802 wpa_supplicant_event(drv->ctx, EVENT_STATION_LOW_ACK, &ed);
1803 return;
1804 }
1805
1806 if (cqm[NL80211_ATTR_CQM_BEACON_LOSS_EVENT]) {
1807 wpa_printf(MSG_DEBUG, "nl80211: Beacon loss event");
1808 wpa_supplicant_event(drv->ctx, EVENT_BEACON_LOSS, NULL);
1809 return;
1810 }
1811
1812 if (cqm[NL80211_ATTR_CQM_TXE_RATE] &&
1813 cqm[NL80211_ATTR_CQM_TXE_PKTS] &&
1814 cqm[NL80211_ATTR_CQM_TXE_INTVL] &&
1815 cqm[NL80211_ATTR_MAC]) {
1816 wpa_printf(MSG_DEBUG, "nl80211: CQM TXE event for " MACSTR_SEC
1817 " (rate: %u pkts: %u interval: %u)",
1818 MAC2STR_SEC((u8 *) nla_data(cqm[NL80211_ATTR_MAC])),
1819 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_RATE]),
1820 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_PKTS]),
1821 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_INTVL]));
1822 return;
1823 }
1824
1825 if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] == NULL) {
1826 wpa_printf(MSG_DEBUG,
1827 "nl80211: Not a CQM RSSI threshold event");
1828 return;
1829 }
1830 event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
1831
1832 if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH) {
1833 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
1834 "event: RSSI high");
1835 ed.signal_change.above_threshold = 1;
1836 } else if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW) {
1837 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
1838 "event: RSSI low");
1839 ed.signal_change.above_threshold = 0;
1840 } else {
1841 wpa_printf(MSG_DEBUG,
1842 "nl80211: Unknown CQM RSSI threshold event: %d",
1843 event);
1844 return;
1845 }
1846
1847 /*
1848 * nl80211_get_link_signal() and nl80211_get_link_noise() set default
1849 * values in case querying the driver fails.
1850 */
1851 res = nl80211_get_link_signal(drv, &ed.signal_change);
1852 if (res == 0) {
1853 wpa_printf(MSG_DEBUG, "nl80211: Signal: %d dBm txrate: %d",
1854 ed.signal_change.current_signal,
1855 ed.signal_change.current_txrate);
1856 } else {
1857 wpa_printf(MSG_DEBUG,
1858 "nl80211: Querying the driver for signal info failed");
1859 }
1860
1861 res = nl80211_get_link_noise(drv, &ed.signal_change);
1862 if (res == 0) {
1863 wpa_printf(MSG_DEBUG, "nl80211: Noise: %d dBm",
1864 ed.signal_change.current_noise);
1865 } else {
1866 wpa_printf(MSG_DEBUG,
1867 "nl80211: Querying the driver for noise info failed");
1868 }
1869
1870 wpa_supplicant_event(drv->ctx, EVENT_SIGNAL_CHANGE, &ed);
1871 }
1872
1873
1874 static void nl80211_new_peer_candidate(struct wpa_driver_nl80211_data *drv,
1875 struct nlattr **tb)
1876 {
1877 const u8 *addr;
1878 union wpa_event_data data;
1879
1880 if (drv->nlmode != NL80211_IFTYPE_MESH_POINT ||
1881 !tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_IE])
1882 return;
1883
1884 addr = nla_data(tb[NL80211_ATTR_MAC]);
1885 wpa_printf(MSG_DEBUG, "nl80211: New peer candidate " MACSTR_SEC,
1886 MAC2STR_SEC(addr));
1887
1888 os_memset(&data, 0, sizeof(data));
1889 data.mesh_peer.peer = addr;
1890 data.mesh_peer.ies = nla_data(tb[NL80211_ATTR_IE]);
1891 data.mesh_peer.ie_len = nla_len(tb[NL80211_ATTR_IE]);
1892 wpa_supplicant_event(drv->ctx, EVENT_NEW_PEER_CANDIDATE, &data);
1893 }
1894
1895
1896 static void nl80211_new_station_event(struct wpa_driver_nl80211_data *drv,
1897 struct i802_bss *bss,
1898 struct nlattr **tb)
1899 {
1900 u8 *addr;
1901 union wpa_event_data data;
1902
1903 if (tb[NL80211_ATTR_MAC] == NULL)
1904 return;
1905 addr = nla_data(tb[NL80211_ATTR_MAC]);
1906 wpa_printf(MSG_DEBUG, "nl80211: New station " MACSTR_SEC, MAC2STR_SEC(addr));
1907
1908 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
1909 u8 *ies = NULL;
1910 size_t ies_len = 0;
1911 if (tb[NL80211_ATTR_IE]) {
1912 ies = nla_data(tb[NL80211_ATTR_IE]);
1913 ies_len = nla_len(tb[NL80211_ATTR_IE]);
1914 }
1915 wpa_hexdump(MSG_DEBUG, "nl80211: Assoc Req IEs", ies, ies_len);
1916 drv_event_assoc(bss->ctx, addr, ies, ies_len, 0);
1917 return;
1918 }
1919
1920 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
1921 return;
1922
1923 os_memset(&data, 0, sizeof(data));
1924 os_memcpy(data.ibss_rsn_start.peer, addr, ETH_ALEN);
1925 wpa_supplicant_event(bss->ctx, EVENT_IBSS_RSN_START, &data);
1926 }
1927
1928
1929 void nl80211_del_station_event(struct wpa_driver_nl80211_data *drv,
1930 struct i802_bss *bss,
1931 struct nlattr **tb)
1932 {
1933 u8 *addr;
1934 union wpa_event_data data;
1935
1936 if (tb[NL80211_ATTR_MAC] == NULL)
1937 return;
1938 addr = nla_data(tb[NL80211_ATTR_MAC]);
1939 wpa_printf(MSG_DEBUG, "nl80211: Delete station " MACSTR_SEC,
1940 MAC2STR_SEC(addr));
1941
1942 #ifdef CONFIG_VENDOR_EXT
1943 if (tb[NL80211_ATTR_REASON_CODE]) {
1944 wpa_vendor_ext_nl80211_set_disconnect_reason(drv, nla_get_u16(tb[NL80211_ATTR_REASON_CODE]));
1945 }
1946 #endif
1947
1948 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
1949 drv_event_disassoc(bss->ctx, addr);
1950 return;
1951 }
1952
1953 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
1954 return;
1955
1956 os_memset(&data, 0, sizeof(data));
1957 os_memcpy(data.ibss_peer_lost.peer, addr, ETH_ALEN);
1958 wpa_supplicant_event(bss->ctx, EVENT_IBSS_PEER_LOST, &data);
1959 }
1960
1961
1962 static void nl80211_rekey_offload_event(struct wpa_driver_nl80211_data *drv,
1963 struct nlattr **tb)
1964 {
1965 struct nlattr *rekey_info[NUM_NL80211_REKEY_DATA];
1966 static struct nla_policy rekey_policy[NUM_NL80211_REKEY_DATA] = {
1967 [NL80211_REKEY_DATA_KEK] = {
1968 .minlen = NL80211_KEK_LEN,
1969 .maxlen = NL80211_KEK_LEN,
1970 },
1971 [NL80211_REKEY_DATA_KCK] = {
1972 .minlen = NL80211_KCK_LEN,
1973 .maxlen = NL80211_KCK_LEN,
1974 },
1975 [NL80211_REKEY_DATA_REPLAY_CTR] = {
1976 .minlen = NL80211_REPLAY_CTR_LEN,
1977 .maxlen = NL80211_REPLAY_CTR_LEN,
1978 },
1979 };
1980 union wpa_event_data data;
1981
1982 if (!tb[NL80211_ATTR_MAC] ||
1983 !tb[NL80211_ATTR_REKEY_DATA] ||
1984 nla_parse_nested(rekey_info, MAX_NL80211_REKEY_DATA,
1985 tb[NL80211_ATTR_REKEY_DATA], rekey_policy) ||
1986 !rekey_info[NL80211_REKEY_DATA_REPLAY_CTR])
1987 return;
1988
1989 os_memset(&data, 0, sizeof(data));
1990 data.driver_gtk_rekey.bssid = nla_data(tb[NL80211_ATTR_MAC]);
1991 wpa_printf(MSG_DEBUG, "nl80211: Rekey offload event for BSSID " MACSTR_SEC,
1992 MAC2STR_SEC(data.driver_gtk_rekey.bssid));
1993 data.driver_gtk_rekey.replay_ctr =
1994 nla_data(rekey_info[NL80211_REKEY_DATA_REPLAY_CTR]);
1995 wpa_hexdump(MSG_DEBUG, "nl80211: Rekey offload - Replay Counter",
1996 data.driver_gtk_rekey.replay_ctr, NL80211_REPLAY_CTR_LEN);
1997 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_GTK_REKEY, &data);
1998 }
1999
2000
2001 static void nl80211_pmksa_candidate_event(struct wpa_driver_nl80211_data *drv,
2002 struct nlattr **tb)
2003 {
2004 struct nlattr *cand[NUM_NL80211_PMKSA_CANDIDATE];
2005 static struct nla_policy cand_policy[NUM_NL80211_PMKSA_CANDIDATE] = {
2006 [NL80211_PMKSA_CANDIDATE_INDEX] = { .type = NLA_U32 },
2007 [NL80211_PMKSA_CANDIDATE_BSSID] = {
2008 .minlen = ETH_ALEN,
2009 .maxlen = ETH_ALEN,
2010 },
2011 [NL80211_PMKSA_CANDIDATE_PREAUTH] = { .type = NLA_FLAG },
2012 };
2013 union wpa_event_data data;
2014
2015 wpa_printf(MSG_DEBUG, "nl80211: PMKSA candidate event");
2016
2017 if (!tb[NL80211_ATTR_PMKSA_CANDIDATE] ||
2018 nla_parse_nested(cand, MAX_NL80211_PMKSA_CANDIDATE,
2019 tb[NL80211_ATTR_PMKSA_CANDIDATE], cand_policy) ||
2020 !cand[NL80211_PMKSA_CANDIDATE_INDEX] ||
2021 !cand[NL80211_PMKSA_CANDIDATE_BSSID])
2022 return;
2023
2024 os_memset(&data, 0, sizeof(data));
2025 os_memcpy(data.pmkid_candidate.bssid,
2026 nla_data(cand[NL80211_PMKSA_CANDIDATE_BSSID]), ETH_ALEN);
2027 data.pmkid_candidate.index =
2028 nla_get_u32(cand[NL80211_PMKSA_CANDIDATE_INDEX]);
2029 data.pmkid_candidate.preauth =
2030 cand[NL80211_PMKSA_CANDIDATE_PREAUTH] != NULL;
2031 wpa_supplicant_event(drv->ctx, EVENT_PMKID_CANDIDATE, &data);
2032 }
2033
2034
2035 static void nl80211_client_probe_event(struct wpa_driver_nl80211_data *drv,
2036 struct nlattr **tb)
2037 {
2038 union wpa_event_data data;
2039 const u8 *addr;
2040 u64 cookie = 0;
2041
2042 addr = nla_data(tb[NL80211_ATTR_MAC]);
2043 if (!addr)
2044 return;
2045 if (tb[NL80211_ATTR_COOKIE])
2046 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
2047 wpa_printf(MSG_DEBUG, "nl80211: Probe client event (addr=" MACSTR_SEC
2048 " ack=%d cookie=%llu)", MAC2STR_SEC(addr),
2049 tb[NL80211_ATTR_ACK] != NULL,
2050 (long long unsigned int) cookie);
2051 if (!tb[NL80211_ATTR_ACK])
2052 return;
2053
2054 os_memset(&data, 0, sizeof(data));
2055 os_memcpy(data.client_poll.addr, addr, ETH_ALEN);
2056 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_CLIENT_POLL_OK, &data);
2057 }
2058
2059
2060 static void nl80211_tdls_oper_event(struct wpa_driver_nl80211_data *drv,
2061 struct nlattr **tb)
2062 {
2063 union wpa_event_data data;
2064
2065 wpa_printf(MSG_DEBUG, "nl80211: TDLS operation event");
2066
2067 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_TDLS_OPERATION])
2068 return;
2069
2070 os_memset(&data, 0, sizeof(data));
2071 os_memcpy(data.tdls.peer, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2072 switch (nla_get_u8(tb[NL80211_ATTR_TDLS_OPERATION])) {
2073 case NL80211_TDLS_SETUP:
2074 wpa_printf(MSG_DEBUG, "nl80211: TDLS setup request for peer "
2075 MACSTR_SEC, MAC2STR_SEC(data.tdls.peer));
2076 data.tdls.oper = TDLS_REQUEST_SETUP;
2077 break;
2078 case NL80211_TDLS_TEARDOWN:
2079 wpa_printf(MSG_DEBUG, "nl80211: TDLS teardown request for peer "
2080 MACSTR_SEC, MAC2STR_SEC(data.tdls.peer));
2081 data.tdls.oper = TDLS_REQUEST_TEARDOWN;
2082 break;
2083 case NL80211_TDLS_DISCOVERY_REQ:
2084 wpa_printf(MSG_DEBUG,
2085 "nl80211: TDLS discovery request for peer " MACSTR_SEC,
2086 MAC2STR_SEC(data.tdls.peer));
2087 data.tdls.oper = TDLS_REQUEST_DISCOVER;
2088 break;
2089 default:
2090 wpa_printf(MSG_DEBUG, "nl80211: Unsupported TDLS operatione "
2091 "event");
2092 return;
2093 }
2094 if (tb[NL80211_ATTR_REASON_CODE]) {
2095 data.tdls.reason_code =
2096 nla_get_u16(tb[NL80211_ATTR_REASON_CODE]);
2097 }
2098
2099 wpa_supplicant_event(drv->ctx, EVENT_TDLS, &data);
2100 }
2101
2102
2103 static void nl80211_stop_ap(struct wpa_driver_nl80211_data *drv,
2104 struct nlattr **tb)
2105 {
2106 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_UNAVAILABLE, NULL);
2107 }
2108
2109
2110 static void nl80211_connect_failed_event(struct wpa_driver_nl80211_data *drv,
2111 struct nlattr **tb)
2112 {
2113 union wpa_event_data data;
2114 u32 reason;
2115
2116 wpa_printf(MSG_DEBUG, "nl80211: Connect failed event");
2117
2118 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_CONN_FAILED_REASON])
2119 return;
2120
2121 os_memset(&data, 0, sizeof(data));
2122 os_memcpy(data.connect_failed_reason.addr,
2123 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2124
2125 reason = nla_get_u32(tb[NL80211_ATTR_CONN_FAILED_REASON]);
2126 switch (reason) {
2127 case NL80211_CONN_FAIL_MAX_CLIENTS:
2128 wpa_printf(MSG_DEBUG, "nl80211: Max client reached");
2129 data.connect_failed_reason.code = MAX_CLIENT_REACHED;
2130 break;
2131 case NL80211_CONN_FAIL_BLOCKED_CLIENT:
2132 wpa_printf(MSG_DEBUG, "nl80211: Blocked client " MACSTR_SEC
2133 " tried to connect",
2134 MAC2STR_SEC(data.connect_failed_reason.addr));
2135 data.connect_failed_reason.code = BLOCKED_CLIENT;
2136 break;
2137 default:
2138 wpa_printf(MSG_DEBUG, "nl8021l: Unknown connect failed reason "
2139 "%u", reason);
2140 return;
2141 }
2142
2143 wpa_supplicant_event(drv->ctx, EVENT_CONNECT_FAILED_REASON, &data);
2144 }
2145
2146
2147 static void nl80211_radar_event(struct wpa_driver_nl80211_data *drv,
2148 struct nlattr **tb)
2149 {
2150 union wpa_event_data data;
2151 enum nl80211_radar_event event_type;
2152
2153 if (!tb[NL80211_ATTR_WIPHY_FREQ] || !tb[NL80211_ATTR_RADAR_EVENT])
2154 return;
2155
2156 os_memset(&data, 0, sizeof(data));
2157 data.dfs_event.freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
2158 event_type = nla_get_u32(tb[NL80211_ATTR_RADAR_EVENT]);
2159
2160 /* Check HT params */
2161 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2162 data.dfs_event.ht_enabled = 1;
2163 data.dfs_event.chan_offset = 0;
2164
2165 switch (nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
2166 case NL80211_CHAN_NO_HT:
2167 data.dfs_event.ht_enabled = 0;
2168 break;
2169 case NL80211_CHAN_HT20:
2170 break;
2171 case NL80211_CHAN_HT40PLUS:
2172 data.dfs_event.chan_offset = 1;
2173 break;
2174 case NL80211_CHAN_HT40MINUS:
2175 data.dfs_event.chan_offset = -1;
2176 break;
2177 }
2178 }
2179
2180 /* Get VHT params */
2181 if (tb[NL80211_ATTR_CHANNEL_WIDTH])
2182 data.dfs_event.chan_width =
2183 convert2width(nla_get_u32(
2184 tb[NL80211_ATTR_CHANNEL_WIDTH]));
2185 if (tb[NL80211_ATTR_CENTER_FREQ1])
2186 data.dfs_event.cf1 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
2187 if (tb[NL80211_ATTR_CENTER_FREQ2])
2188 data.dfs_event.cf2 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
2189
2190 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz, ht: %d, offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
2191 data.dfs_event.freq, data.dfs_event.ht_enabled,
2192 data.dfs_event.chan_offset, data.dfs_event.chan_width,
2193 data.dfs_event.cf1, data.dfs_event.cf2);
2194
2195 switch (event_type) {
2196 case NL80211_RADAR_DETECTED:
2197 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
2198 break;
2199 case NL80211_RADAR_CAC_FINISHED:
2200 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
2201 break;
2202 case NL80211_RADAR_CAC_ABORTED:
2203 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
2204 break;
2205 case NL80211_RADAR_NOP_FINISHED:
2206 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
2207 break;
2208 case NL80211_RADAR_PRE_CAC_EXPIRED:
2209 wpa_supplicant_event(drv->ctx, EVENT_DFS_PRE_CAC_EXPIRED,
2210 &data);
2211 break;
2212 case NL80211_RADAR_CAC_STARTED:
2213 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_STARTED, &data);
2214 break;
2215 default:
2216 wpa_printf(MSG_DEBUG, "nl80211: Unknown radar event %d "
2217 "received", event_type);
2218 break;
2219 }
2220 }
2221
2222
2223 static void nl80211_spurious_frame(struct i802_bss *bss, struct nlattr **tb,
2224 int wds)
2225 {
2226 struct wpa_driver_nl80211_data *drv = bss->drv;
2227 union wpa_event_data event;
2228
2229 if (!tb[NL80211_ATTR_MAC])
2230 return;
2231
2232 os_memset(&event, 0, sizeof(event));
2233 event.rx_from_unknown.bssid = bss->addr;
2234 event.rx_from_unknown.addr = nla_data(tb[NL80211_ATTR_MAC]);
2235 event.rx_from_unknown.wds = wds;
2236
2237 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
2238 }
2239
2240
2241 #ifdef CONFIG_DRIVER_NL80211_QCA
2242
2243 static void qca_nl80211_avoid_freq(struct wpa_driver_nl80211_data *drv,
2244 const u8 *data, size_t len)
2245 {
2246 u32 i, count;
2247 union wpa_event_data event;
2248 struct wpa_freq_range *range = NULL;
2249 const struct qca_avoid_freq_list *freq_range;
2250
2251 freq_range = (const struct qca_avoid_freq_list *) data;
2252 if (len < sizeof(freq_range->count))
2253 return;
2254
2255 count = freq_range->count;
2256 if (len < sizeof(freq_range->count) +
2257 count * sizeof(struct qca_avoid_freq_range)) {
2258 wpa_printf(MSG_DEBUG, "nl80211: Ignored too short avoid frequency list (len=%u)",
2259 (unsigned int) len);
2260 return;
2261 }
2262
2263 if (count > 0) {
2264 range = os_calloc(count, sizeof(struct wpa_freq_range));
2265 if (range == NULL)
2266 return;
2267 }
2268
2269 os_memset(&event, 0, sizeof(event));
2270 for (i = 0; i < count; i++) {
2271 unsigned int idx = event.freq_range.num;
2272 range[idx].min = freq_range->range[i].start_freq;
2273 range[idx].max = freq_range->range[i].end_freq;
2274 wpa_printf(MSG_DEBUG, "nl80211: Avoid frequency range: %u-%u",
2275 range[idx].min, range[idx].max);
2276 if (range[idx].min > range[idx].max) {
2277 wpa_printf(MSG_DEBUG, "nl80211: Ignore invalid frequency range");
2278 continue;
2279 }
2280 event.freq_range.num++;
2281 }
2282 event.freq_range.range = range;
2283
2284 wpa_supplicant_event(drv->ctx, EVENT_AVOID_FREQUENCIES, &event);
2285
2286 os_free(range);
2287 }
2288
2289
2290 static enum hostapd_hw_mode get_qca_hw_mode(u8 hw_mode)
2291 {
2292 switch (hw_mode) {
2293 case QCA_ACS_MODE_IEEE80211B:
2294 return HOSTAPD_MODE_IEEE80211B;
2295 case QCA_ACS_MODE_IEEE80211G:
2296 return HOSTAPD_MODE_IEEE80211G;
2297 case QCA_ACS_MODE_IEEE80211A:
2298 return HOSTAPD_MODE_IEEE80211A;
2299 case QCA_ACS_MODE_IEEE80211AD:
2300 return HOSTAPD_MODE_IEEE80211AD;
2301 case QCA_ACS_MODE_IEEE80211ANY:
2302 return HOSTAPD_MODE_IEEE80211ANY;
2303 default:
2304 return NUM_HOSTAPD_MODES;
2305 }
2306 }
2307
2308
2309 static unsigned int chan_to_freq(struct wpa_driver_nl80211_data *drv,
2310 u8 chan, enum hostapd_hw_mode hw_mode)
2311 {
2312 if (hw_mode == NUM_HOSTAPD_MODES) {
2313 /* For drivers that do not report ACS_HW_MODE */
2314 u16 num_modes, flags;
2315 struct hostapd_hw_modes *modes;
2316 u8 dfs_domain;
2317 int i;
2318
2319 modes = nl80211_get_hw_feature_data(drv->first_bss, &num_modes,
2320 &flags, &dfs_domain);
2321 if (!modes) {
2322 wpa_printf(MSG_DEBUG,
2323 "nl80211: Fetching hardware mode failed");
2324 goto try_2_4_or_5;
2325 }
2326 if (num_modes == 1)
2327 hw_mode = modes[0].mode;
2328
2329 for (i = 0; i < num_modes; i++) {
2330 os_free(modes[i].channels);
2331 os_free(modes[i].rates);
2332 }
2333
2334 os_free(modes);
2335 }
2336
2337 if (hw_mode == HOSTAPD_MODE_IEEE80211AD) {
2338 if (chan >= 1 && chan <= 6)
2339 return 56160 + (2160 * chan);
2340 return 0;
2341 }
2342
2343 try_2_4_or_5:
2344 if (chan >= 1 && chan <= 13)
2345 return 2407 + 5 * chan;
2346 if (chan == 14)
2347 return 2484;
2348 if (chan >= 36 && chan <= 177)
2349 return 5000 + 5 * chan;
2350
2351 return 0;
2352 }
2353
2354
2355 static void qca_nl80211_acs_select_ch(struct wpa_driver_nl80211_data *drv,
2356 const u8 *data, size_t len)
2357 {
2358 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_ACS_MAX + 1];
2359 union wpa_event_data event;
2360 u8 chan;
2361
2362 wpa_printf(MSG_DEBUG,
2363 "nl80211: ACS channel selection vendor event received");
2364
2365 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_ACS_MAX,
2366 (struct nlattr *) data, len, NULL) ||
2367 (!tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY] &&
2368 !tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_CHANNEL]) ||
2369 (!tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY] &&
2370 !tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_CHANNEL]))
2371 return;
2372
2373 os_memset(&event, 0, sizeof(event));
2374 event.acs_selected_channels.hw_mode = NUM_HOSTAPD_MODES;
2375
2376 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_HW_MODE]) {
2377 u8 hw_mode = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_HW_MODE]);
2378
2379 event.acs_selected_channels.hw_mode = get_qca_hw_mode(hw_mode);
2380 if (event.acs_selected_channels.hw_mode == NUM_HOSTAPD_MODES ||
2381 event.acs_selected_channels.hw_mode ==
2382 HOSTAPD_MODE_IEEE80211ANY) {
2383 wpa_printf(MSG_DEBUG,
2384 "nl80211: Invalid hw_mode %d in ACS selection event",
2385 hw_mode);
2386 return;
2387 }
2388 }
2389
2390 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY]) {
2391 event.acs_selected_channels.pri_freq = nla_get_u32(
2392 tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY]);
2393 } else {
2394 chan = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_CHANNEL]);
2395 event.acs_selected_channels.pri_freq =
2396 chan_to_freq(drv, chan,
2397 event.acs_selected_channels.hw_mode);
2398 }
2399
2400 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY]) {
2401 event.acs_selected_channels.sec_freq = nla_get_u32(
2402 tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY]);
2403 } else {
2404 chan = nla_get_u8(
2405 tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_CHANNEL]);
2406 event.acs_selected_channels.sec_freq =
2407 chan_to_freq(drv, chan,
2408 event.acs_selected_channels.hw_mode);
2409 }
2410
2411 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_EDMG_CHANNEL])
2412 event.acs_selected_channels.edmg_channel =
2413 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_EDMG_CHANNEL]);
2414 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL])
2415 event.acs_selected_channels.vht_seg0_center_ch =
2416 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL]);
2417 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG1_CENTER_CHANNEL])
2418 event.acs_selected_channels.vht_seg1_center_ch =
2419 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG1_CENTER_CHANNEL]);
2420 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_CHWIDTH])
2421 event.acs_selected_channels.ch_width =
2422 nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_ACS_CHWIDTH]);
2423 wpa_printf(MSG_INFO,
2424 "nl80211: ACS Results: PFreq: %d SFreq: %d BW: %d VHT0: %d VHT1: %d HW_MODE: %d EDMGCH: %d",
2425 event.acs_selected_channels.pri_freq,
2426 event.acs_selected_channels.sec_freq,
2427 event.acs_selected_channels.ch_width,
2428 event.acs_selected_channels.vht_seg0_center_ch,
2429 event.acs_selected_channels.vht_seg1_center_ch,
2430 event.acs_selected_channels.hw_mode,
2431 event.acs_selected_channels.edmg_channel);
2432
2433 /* Ignore ACS channel list check for backwards compatibility */
2434
2435 wpa_supplicant_event(drv->ctx, EVENT_ACS_CHANNEL_SELECTED, &event);
2436 }
2437
2438
2439 static void qca_nl80211_key_mgmt_auth(struct wpa_driver_nl80211_data *drv,
2440 const u8 *data, size_t len)
2441 {
2442 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_MAX + 1];
2443 u8 *bssid;
2444
2445 wpa_printf(MSG_DEBUG,
2446 "nl80211: Key management roam+auth vendor event received");
2447
2448 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_MAX,
2449 (struct nlattr *) data, len, NULL) ||
2450 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID] ||
2451 nla_len(tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID]) != ETH_ALEN ||
2452 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_REQ_IE] ||
2453 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_RESP_IE] ||
2454 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_AUTHORIZED])
2455 return;
2456
2457 bssid = nla_data(tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID]);
2458 wpa_printf(MSG_DEBUG, " * roam BSSID " MACSTR_SEC, MAC2STR_SEC(bssid));
2459
2460 mlme_event_connect(drv, NL80211_CMD_ROAM, NULL,
2461 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID],
2462 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_REQ_IE],
2463 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_RESP_IE],
2464 NULL, NULL,
2465 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_AUTHORIZED],
2466 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_KEY_REPLAY_CTR],
2467 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PTK_KCK],
2468 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PTK_KEK],
2469 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_SUBNET_STATUS],
2470 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_FILS_ERP_NEXT_SEQ_NUM],
2471 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PMK],
2472 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PMKID]);
2473 }
2474
2475
2476 static void
2477 qca_nl80211_key_mgmt_auth_handler(struct wpa_driver_nl80211_data *drv,
2478 const u8 *data, size_t len)
2479 {
2480 if (!drv->roam_indication_done) {
2481 wpa_printf(MSG_DEBUG,
2482 "nl80211: Pending roam indication, delay processing roam+auth vendor event");
2483 os_get_reltime(&drv->pending_roam_ind_time);
2484
2485 os_free(drv->pending_roam_data);
2486 drv->pending_roam_data = os_memdup(data, len);
2487 if (!drv->pending_roam_data)
2488 return;
2489 drv->pending_roam_data_len = len;
2490 return;
2491 }
2492 drv->roam_indication_done = false;
2493 qca_nl80211_key_mgmt_auth(drv, data, len);
2494 }
2495
2496
2497 static void qca_nl80211_dfs_offload_radar_event(
2498 struct wpa_driver_nl80211_data *drv, u32 subcmd, u8 *msg, int length)
2499 {
2500 union wpa_event_data data;
2501 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2502
2503 wpa_printf(MSG_DEBUG,
2504 "nl80211: DFS offload radar vendor event received");
2505
2506 if (nla_parse(tb, NL80211_ATTR_MAX,
2507 (struct nlattr *) msg, length, NULL))
2508 return;
2509
2510 if (!tb[NL80211_ATTR_WIPHY_FREQ]) {
2511 wpa_printf(MSG_INFO,
2512 "nl80211: Error parsing WIPHY_FREQ in FS offload radar vendor event");
2513 return;
2514 }
2515
2516 os_memset(&data, 0, sizeof(data));
2517 data.dfs_event.freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
2518
2519 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz",
2520 data.dfs_event.freq);
2521
2522 /* Check HT params */
2523 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2524 data.dfs_event.ht_enabled = 1;
2525 data.dfs_event.chan_offset = 0;
2526
2527 switch (nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
2528 case NL80211_CHAN_NO_HT:
2529 data.dfs_event.ht_enabled = 0;
2530 break;
2531 case NL80211_CHAN_HT20:
2532 break;
2533 case NL80211_CHAN_HT40PLUS:
2534 data.dfs_event.chan_offset = 1;
2535 break;
2536 case NL80211_CHAN_HT40MINUS:
2537 data.dfs_event.chan_offset = -1;
2538 break;
2539 }
2540 }
2541
2542 /* Get VHT params */
2543 if (tb[NL80211_ATTR_CHANNEL_WIDTH])
2544 data.dfs_event.chan_width =
2545 convert2width(nla_get_u32(
2546 tb[NL80211_ATTR_CHANNEL_WIDTH]));
2547 if (tb[NL80211_ATTR_CENTER_FREQ1])
2548 data.dfs_event.cf1 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
2549 if (tb[NL80211_ATTR_CENTER_FREQ2])
2550 data.dfs_event.cf2 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
2551
2552 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz, ht: %d, "
2553 "offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
2554 data.dfs_event.freq, data.dfs_event.ht_enabled,
2555 data.dfs_event.chan_offset, data.dfs_event.chan_width,
2556 data.dfs_event.cf1, data.dfs_event.cf2);
2557
2558 switch (subcmd) {
2559 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_RADAR_DETECTED:
2560 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
2561 break;
2562 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_STARTED:
2563 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_STARTED, &data);
2564 break;
2565 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_FINISHED:
2566 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
2567 break;
2568 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_ABORTED:
2569 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
2570 break;
2571 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_NOP_FINISHED:
2572 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
2573 break;
2574 default:
2575 wpa_printf(MSG_DEBUG,
2576 "nl80211: Unknown DFS offload radar event %d received",
2577 subcmd);
2578 break;
2579 }
2580 }
2581
2582
2583 static void qca_nl80211_scan_trigger_event(struct wpa_driver_nl80211_data *drv,
2584 u8 *data, size_t len)
2585 {
2586 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SCAN_MAX + 1];
2587 u64 cookie = 0;
2588 union wpa_event_data event;
2589 struct scan_info *info;
2590
2591 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_SCAN_MAX,
2592 (struct nlattr *) data, len, NULL) ||
2593 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE])
2594 return;
2595
2596 cookie = nla_get_u64(tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE]);
2597 if (cookie != drv->vendor_scan_cookie) {
2598 /* External scan trigger event, ignore */
2599 return;
2600 }
2601
2602 /* Cookie match, own scan */
2603 os_memset(&event, 0, sizeof(event));
2604 info = &event.scan_info;
2605 info->external_scan = 0;
2606 info->nl_scan_event = 0;
2607
2608 drv->scan_state = SCAN_STARTED;
2609 wpa_supplicant_event(drv->ctx, EVENT_SCAN_STARTED, &event);
2610 }
2611
2612
2613 static void send_vendor_scan_event(struct wpa_driver_nl80211_data *drv,
2614 int aborted, struct nlattr *tb[],
2615 int external_scan)
2616 {
2617 union wpa_event_data event;
2618 struct nlattr *nl;
2619 int rem;
2620 struct scan_info *info;
2621 int freqs[MAX_REPORT_FREQS];
2622 int num_freqs = 0;
2623
2624 os_memset(&event, 0, sizeof(event));
2625 info = &event.scan_info;
2626 info->aborted = aborted;
2627 info->external_scan = external_scan;
2628
2629 if (tb[QCA_WLAN_VENDOR_ATTR_SCAN_SSIDS]) {
2630 nla_for_each_nested(nl,
2631 tb[QCA_WLAN_VENDOR_ATTR_SCAN_SSIDS], rem) {
2632 struct wpa_driver_scan_ssid *s =
2633 &info->ssids[info->num_ssids];
2634 s->ssid = nla_data(nl);
2635 s->ssid_len = nla_len(nl);
2636 wpa_printf(MSG_INFO,
2637 "nl80211: Scan probed for SSID '%s'",
2638 anonymize_ssid(wpa_ssid_txt(s->ssid, s->ssid_len)));
2639 info->num_ssids++;
2640 if (info->num_ssids == WPAS_MAX_SCAN_SSIDS)
2641 break;
2642 }
2643 }
2644
2645 if (tb[QCA_WLAN_VENDOR_ATTR_SCAN_FREQUENCIES]) {
2646 char msg[500], *pos, *end;
2647 int res;
2648
2649 pos = msg;
2650 end = pos + sizeof(msg);
2651 *pos = '\0';
2652
2653 nla_for_each_nested(nl,
2654 tb[QCA_WLAN_VENDOR_ATTR_SCAN_FREQUENCIES],
2655 rem) {
2656 freqs[num_freqs] = nla_get_u32(nl);
2657 res = os_snprintf(pos, end - pos, " %d",
2658 freqs[num_freqs]);
2659 if (!os_snprintf_error(end - pos, res))
2660 pos += res;
2661 num_freqs++;
2662 if (num_freqs == MAX_REPORT_FREQS - 1)
2663 break;
2664 }
2665
2666 info->freqs = freqs;
2667 info->num_freqs = num_freqs;
2668 wpa_printf(MSG_WARNING, "nl80211: Scan included frequencies:%s",
2669 msg);
2670 }
2671 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
2672 }
2673
2674
2675 static void qca_nl80211_scan_done_event(struct wpa_driver_nl80211_data *drv,
2676 u8 *data, size_t len)
2677 {
2678 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SCAN_MAX + 1];
2679 u64 cookie = 0;
2680 enum scan_status status;
2681 int external_scan;
2682
2683 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_SCAN_MAX,
2684 (struct nlattr *) data, len, NULL) ||
2685 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_STATUS] ||
2686 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE])
2687 return;
2688
2689 status = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_SCAN_STATUS]);
2690 if (status >= VENDOR_SCAN_STATUS_MAX)
2691 return; /* invalid status */
2692
2693 cookie = nla_get_u64(tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE]);
2694 if (cookie != drv->vendor_scan_cookie) {
2695 /* Event from an external scan, get scan results */
2696 external_scan = 1;
2697 } else {
2698 external_scan = 0;
2699 if (status == VENDOR_SCAN_STATUS_NEW_RESULTS)
2700 drv->scan_state = SCAN_COMPLETED;
2701 else
2702 drv->scan_state = SCAN_ABORTED;
2703
2704 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2705 drv->ctx);
2706 drv->vendor_scan_cookie = 0;
2707 drv->last_scan_cmd = 0;
2708 }
2709
2710 send_vendor_scan_event(drv, (status == VENDOR_SCAN_STATUS_ABORTED), tb,
2711 external_scan);
2712 }
2713
2714
2715 static void qca_nl80211_p2p_lo_stop_event(struct wpa_driver_nl80211_data *drv,
2716 u8 *data, size_t len)
2717 {
2718 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_MAX + 1];
2719 union wpa_event_data event;
2720
2721 wpa_printf(MSG_DEBUG,
2722 "nl80211: P2P listen offload stop vendor event received");
2723
2724 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_MAX,
2725 (struct nlattr *) data, len, NULL) ||
2726 !tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_STOP_REASON])
2727 return;
2728
2729 os_memset(&event, 0, sizeof(event));
2730 event.p2p_lo_stop.reason_code =
2731 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_STOP_REASON]);
2732
2733 wpa_printf(MSG_DEBUG,
2734 "nl80211: P2P Listen offload stop reason: %d",
2735 event.p2p_lo_stop.reason_code);
2736 wpa_supplicant_event(drv->ctx, EVENT_P2P_LO_STOP, &event);
2737 }
2738
2739 #endif /* CONFIG_DRIVER_NL80211_QCA */
2740
2741
2742 static void nl80211_vendor_event_qca(struct wpa_driver_nl80211_data *drv,
2743 u32 subcmd, u8 *data, size_t len)
2744 {
2745 switch (subcmd) {
2746 case QCA_NL80211_VENDOR_SUBCMD_TEST:
2747 wpa_hexdump(MSG_DEBUG, "nl80211: QCA test event", data, len);
2748 break;
2749 #ifdef CONFIG_DRIVER_NL80211_QCA
2750 case QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY:
2751 qca_nl80211_avoid_freq(drv, data, len);
2752 break;
2753 case QCA_NL80211_VENDOR_SUBCMD_KEY_MGMT_ROAM_AUTH:
2754 qca_nl80211_key_mgmt_auth_handler(drv, data, len);
2755 break;
2756 case QCA_NL80211_VENDOR_SUBCMD_DO_ACS:
2757 qca_nl80211_acs_select_ch(drv, data, len);
2758 break;
2759 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_STARTED:
2760 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_FINISHED:
2761 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_ABORTED:
2762 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_NOP_FINISHED:
2763 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_RADAR_DETECTED:
2764 qca_nl80211_dfs_offload_radar_event(drv, subcmd, data, len);
2765 break;
2766 case QCA_NL80211_VENDOR_SUBCMD_TRIGGER_SCAN:
2767 qca_nl80211_scan_trigger_event(drv, data, len);
2768 break;
2769 case QCA_NL80211_VENDOR_SUBCMD_SCAN_DONE:
2770 qca_nl80211_scan_done_event(drv, data, len);
2771 break;
2772 case QCA_NL80211_VENDOR_SUBCMD_P2P_LISTEN_OFFLOAD_STOP:
2773 qca_nl80211_p2p_lo_stop_event(drv, data, len);
2774 break;
2775 #endif /* CONFIG_DRIVER_NL80211_QCA */
2776 default:
2777 wpa_printf(MSG_DEBUG,
2778 "nl80211: Ignore unsupported QCA vendor event %u",
2779 subcmd);
2780 break;
2781 }
2782 }
2783
2784
2785 #ifdef CONFIG_DRIVER_NL80211_BRCM
2786
2787 static void brcm_nl80211_acs_select_ch(struct wpa_driver_nl80211_data *drv,
2788 const u8 *data, size_t len)
2789 {
2790 struct nlattr *tb[BRCM_VENDOR_ATTR_ACS_LAST + 1];
2791 union wpa_event_data event;
2792
2793 wpa_printf(MSG_DEBUG,
2794 "nl80211: BRCM ACS channel selection vendor event received");
2795
2796 if (nla_parse(tb, BRCM_VENDOR_ATTR_ACS_LAST, (struct nlattr *) data,
2797 len, NULL) ||
2798 !tb[BRCM_VENDOR_ATTR_ACS_PRIMARY_FREQ] ||
2799 !tb[BRCM_VENDOR_ATTR_ACS_SECONDARY_FREQ])
2800 return;
2801
2802 os_memset(&event, 0, sizeof(event));
2803 if (tb[BRCM_VENDOR_ATTR_ACS_PRIMARY_FREQ])
2804 event.acs_selected_channels.pri_freq =
2805 nla_get_u32(tb[BRCM_VENDOR_ATTR_ACS_PRIMARY_FREQ]);
2806 if (tb[BRCM_VENDOR_ATTR_ACS_SECONDARY_FREQ])
2807 event.acs_selected_channels.sec_freq =
2808 nla_get_u32(tb[BRCM_VENDOR_ATTR_ACS_SECONDARY_FREQ]);
2809 if (tb[BRCM_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL])
2810 event.acs_selected_channels.vht_seg0_center_ch =
2811 nla_get_u8(tb[BRCM_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL]);
2812 if (tb[BRCM_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL])
2813 event.acs_selected_channels.vht_seg1_center_ch =
2814 nla_get_u8(tb[BRCM_VENDOR_ATTR_ACS_VHT_SEG1_CENTER_CHANNEL]);
2815 if (tb[BRCM_VENDOR_ATTR_ACS_CHWIDTH])
2816 event.acs_selected_channels.ch_width =
2817 nla_get_u16(tb[BRCM_VENDOR_ATTR_ACS_CHWIDTH]);
2818 if (tb[BRCM_VENDOR_ATTR_ACS_HW_MODE]) {
2819 event.acs_selected_channels.hw_mode = nla_get_u8(tb[BRCM_VENDOR_ATTR_ACS_HW_MODE]);
2820 if (event.acs_selected_channels.hw_mode == NUM_HOSTAPD_MODES ||
2821 event.acs_selected_channels.hw_mode ==
2822 HOSTAPD_MODE_IEEE80211ANY) {
2823 wpa_printf(MSG_DEBUG,
2824 "nl80211: Invalid hw_mode %d in ACS selection event",
2825 event.acs_selected_channels.hw_mode);
2826 return;
2827 }
2828 }
2829
2830 wpa_printf(MSG_DEBUG,
2831 "nl80211: ACS Results: PCH: %d SCH: %d BW: %d VHT0: %d VHT1: %d HW_MODE: %d",
2832 event.acs_selected_channels.pri_freq,
2833 event.acs_selected_channels.sec_freq,
2834 event.acs_selected_channels.ch_width,
2835 event.acs_selected_channels.vht_seg0_center_ch,
2836 event.acs_selected_channels.vht_seg1_center_ch,
2837 event.acs_selected_channels.hw_mode);
2838 wpa_supplicant_event(drv->ctx, EVENT_ACS_CHANNEL_SELECTED, &event);
2839 }
2840
2841
2842 static void nl80211_vendor_event_brcm(struct wpa_driver_nl80211_data *drv,
2843 u32 subcmd, u8 *data, size_t len)
2844 {
2845 wpa_printf(MSG_DEBUG, "nl80211: Got BRCM vendor event %u", subcmd);
2846 switch (subcmd) {
2847 case BRCM_VENDOR_EVENT_PRIV_STR:
2848 case BRCM_VENDOR_EVENT_HANGED:
2849 /* Dump the event on to the console */
2850 wpa_msg(NULL, MSG_INFO, "%s", data);
2851 break;
2852 case BRCM_VENDOR_EVENT_ACS:
2853 brcm_nl80211_acs_select_ch(drv, data, len);
2854 break;
2855 default:
2856 wpa_printf(MSG_DEBUG,
2857 "%s: Ignore unsupported BRCM vendor event %u",
2858 __func__, subcmd);
2859 break;
2860 }
2861 }
2862
2863 #endif /* CONFIG_DRIVER_NL80211_BRCM */
2864
2865
2866 static void nl80211_vendor_event(struct wpa_driver_nl80211_data *drv,
2867 struct nlattr **tb)
2868 {
2869 u32 vendor_id, subcmd, wiphy = 0;
2870 int wiphy_idx;
2871 u8 *data = NULL;
2872 size_t len = 0;
2873
2874 if (!tb[NL80211_ATTR_VENDOR_ID] ||
2875 !tb[NL80211_ATTR_VENDOR_SUBCMD])
2876 return;
2877
2878 vendor_id = nla_get_u32(tb[NL80211_ATTR_VENDOR_ID]);
2879 subcmd = nla_get_u32(tb[NL80211_ATTR_VENDOR_SUBCMD]);
2880
2881 if (tb[NL80211_ATTR_WIPHY])
2882 wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2883
2884 wpa_printf(MSG_EXCESSIVE, "nl80211: Vendor event: wiphy=%u vendor_id=0x%x subcmd=%u",
2885 wiphy, vendor_id, subcmd);
2886
2887 if (tb[NL80211_ATTR_VENDOR_DATA]) {
2888 data = nla_data(tb[NL80211_ATTR_VENDOR_DATA]);
2889 len = nla_len(tb[NL80211_ATTR_VENDOR_DATA]);
2890 wpa_hexdump(MSG_MSGDUMP, "nl80211: Vendor data", data, len);
2891 }
2892
2893 wiphy_idx = nl80211_get_wiphy_index(drv->first_bss);
2894 if (wiphy_idx >= 0 && wiphy_idx != (int) wiphy) {
2895 wpa_printf(MSG_EXCESSIVE, "nl80211: Ignore vendor event for foreign wiphy %u (own: %d)",
2896 wiphy, wiphy_idx);
2897 return;
2898 }
2899
2900 #ifdef ANDROID
2901 #ifdef ANDROID_LIB_EVENT
2902 wpa_driver_nl80211_driver_event(drv, vendor_id, subcmd, data, len);
2903 #endif /* ANDROID_LIB_EVENT */
2904 #endif /* ANDROID */
2905
2906 switch (vendor_id) {
2907 case OUI_QCA:
2908 nl80211_vendor_event_qca(drv, subcmd, data, len);
2909 break;
2910 #ifdef CONFIG_DRIVER_NL80211_BRCM
2911 case OUI_BRCM:
2912 nl80211_vendor_event_brcm(drv, subcmd, data, len);
2913 break;
2914 #endif /* CONFIG_DRIVER_NL80211_BRCM */
2915 default:
2916 #ifdef CONFIG_VENDOR_EXT
2917 if (wpa_vendor_ext_nl80211_process_vendor_event(drv, vendor_id, subcmd, data, len)) {
2918 break;
2919 }
2920 #endif
2921 wpa_printf(MSG_DEBUG, "nl80211: Ignore unsupported vendor event");
2922 break;
2923 }
2924 }
2925
2926 static void nl80211_reg_change_event(struct wpa_driver_nl80211_data *drv,
2927 struct nlattr *tb[])
2928 {
2929 union wpa_event_data data;
2930 enum nl80211_reg_initiator init;
2931
2932 wpa_printf(MSG_DEBUG, "nl80211: Regulatory domain change");
2933
2934 if (tb[NL80211_ATTR_REG_INITIATOR] == NULL)
2935 return;
2936
2937 os_memset(&data, 0, sizeof(data));
2938 init = nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR]);
2939 wpa_printf(MSG_DEBUG, " * initiator=%d", init);
2940 switch (init) {
2941 case NL80211_REGDOM_SET_BY_CORE:
2942 data.channel_list_changed.initiator = REGDOM_SET_BY_CORE;
2943 break;
2944 case NL80211_REGDOM_SET_BY_USER:
2945 data.channel_list_changed.initiator = REGDOM_SET_BY_USER;
2946 break;
2947 case NL80211_REGDOM_SET_BY_DRIVER:
2948 data.channel_list_changed.initiator = REGDOM_SET_BY_DRIVER;
2949 break;
2950 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2951 data.channel_list_changed.initiator = REGDOM_SET_BY_COUNTRY_IE;
2952 break;
2953 }
2954
2955 if (tb[NL80211_ATTR_REG_TYPE]) {
2956 enum nl80211_reg_type type;
2957 type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
2958 wpa_printf(MSG_DEBUG, " * type=%d", type);
2959 switch (type) {
2960 case NL80211_REGDOM_TYPE_COUNTRY:
2961 data.channel_list_changed.type = REGDOM_TYPE_COUNTRY;
2962 break;
2963 case NL80211_REGDOM_TYPE_WORLD:
2964 data.channel_list_changed.type = REGDOM_TYPE_WORLD;
2965 break;
2966 case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
2967 data.channel_list_changed.type =
2968 REGDOM_TYPE_CUSTOM_WORLD;
2969 break;
2970 case NL80211_REGDOM_TYPE_INTERSECTION:
2971 data.channel_list_changed.type =
2972 REGDOM_TYPE_INTERSECTION;
2973 break;
2974 }
2975 }
2976
2977 if (tb[NL80211_ATTR_REG_ALPHA2]) {
2978 os_strlcpy(data.channel_list_changed.alpha2,
2979 nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
2980 sizeof(data.channel_list_changed.alpha2));
2981 wpa_printf(MSG_DEBUG, " * alpha2=%s",
2982 data.channel_list_changed.alpha2);
2983 }
2984
2985 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED, &data);
2986 }
2987
2988
2989 static void nl80211_dump_freq(const char *title, struct nlattr *nl_freq)
2990 {
2991 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
2992 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
2993 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
2994 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
2995 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
2996 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
2997 };
2998 struct nlattr *tb[NL80211_FREQUENCY_ATTR_MAX + 1];
2999 u32 freq = 0, max_tx_power = 0;
3000
3001 nla_parse(tb, NL80211_FREQUENCY_ATTR_MAX,
3002 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
3003
3004 if (tb[NL80211_FREQUENCY_ATTR_FREQ])
3005 freq = nla_get_u32(tb[NL80211_FREQUENCY_ATTR_FREQ]);
3006 if (tb[NL80211_FREQUENCY_ATTR_MAX_TX_POWER])
3007 max_tx_power =
3008 nla_get_u32(tb[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]);
3009
3010 wpa_printf(MSG_DEBUG,
3011 "nl80211: Channel (%s): freq=%u max_tx_power=%u%s%s%s",
3012 title, freq, max_tx_power,
3013 tb[NL80211_FREQUENCY_ATTR_DISABLED] ? " disabled" : "",
3014 tb[NL80211_FREQUENCY_ATTR_NO_IR] ? " no-IR" : "",
3015 tb[NL80211_FREQUENCY_ATTR_RADAR] ? " radar" : "");
3016 }
3017
3018
3019 static void nl80211_reg_beacon_hint_event(struct wpa_driver_nl80211_data *drv,
3020 struct nlattr *tb[])
3021 {
3022 union wpa_event_data data;
3023
3024 wpa_printf(MSG_DEBUG, "nl80211: Regulatory beacon hint");
3025 os_memset(&data, 0, sizeof(data));
3026 data.channel_list_changed.initiator = REGDOM_BEACON_HINT;
3027
3028 if (tb[NL80211_ATTR_FREQ_BEFORE])
3029 nl80211_dump_freq("before", tb[NL80211_ATTR_FREQ_BEFORE]);
3030 if (tb[NL80211_ATTR_FREQ_AFTER])
3031 nl80211_dump_freq("after", tb[NL80211_ATTR_FREQ_AFTER]);
3032
3033 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED, &data);
3034 }
3035
3036
3037 static void nl80211_external_auth(struct wpa_driver_nl80211_data *drv,
3038 struct nlattr **tb)
3039 {
3040 union wpa_event_data event;
3041 enum nl80211_external_auth_action act;
3042 #ifdef CONFIG_MLD_PATCH
3043 char mld_addr[50];
3044 #endif
3045
3046 if (!tb[NL80211_ATTR_AKM_SUITES] ||
3047 !tb[NL80211_ATTR_EXTERNAL_AUTH_ACTION] ||
3048 !tb[NL80211_ATTR_BSSID] ||
3049 !tb[NL80211_ATTR_SSID])
3050 return;
3051
3052 os_memset(&event, 0, sizeof(event));
3053 act = nla_get_u32(tb[NL80211_ATTR_EXTERNAL_AUTH_ACTION]);
3054 switch (act) {
3055 case NL80211_EXTERNAL_AUTH_START:
3056 event.external_auth.action = EXT_AUTH_START;
3057 break;
3058 case NL80211_EXTERNAL_AUTH_ABORT:
3059 event.external_auth.action = EXT_AUTH_ABORT;
3060 break;
3061 default:
3062 return;
3063 }
3064
3065 event.external_auth.key_mgmt_suite =
3066 nla_get_u32(tb[NL80211_ATTR_AKM_SUITES]);
3067
3068 event.external_auth.ssid_len = nla_len(tb[NL80211_ATTR_SSID]);
3069 if (event.external_auth.ssid_len > SSID_MAX_LEN)
3070 return;
3071 event.external_auth.ssid = nla_data(tb[NL80211_ATTR_SSID]);
3072
3073 event.external_auth.bssid = nla_data(tb[NL80211_ATTR_BSSID]);
3074 #ifdef CONFIG_MLD_PATCH
3075 mld_addr[0] = '\0';
3076 if (tb[NL80211_ATTR_MLD_ADDR]) {
3077 event.external_auth.mld_addr =
3078 nla_data(tb[NL80211_ATTR_MLD_ADDR]);
3079 os_snprintf(mld_addr, sizeof(mld_addr), ", MLD ADDR: " MACSTR,
3080 MAC2STR(event.external_auth.mld_addr));
3081 }
3082
3083 wpa_printf(MSG_DEBUG,
3084 "nl80211: External auth action: %u, AKM: 0x%x, SSID: %s, BSSID: " MACSTR_SEC "%s",
3085 event.external_auth.action,
3086 event.external_auth.key_mgmt_suite,
3087 wpa_ssid_txt(event.external_auth.ssid,
3088 event.external_auth.ssid_len),
3089 MAC2STR_SEC(event.external_auth.bssid), mld_addr);
3090 #endif
3091 wpa_printf(MSG_DEBUG,
3092 "nl80211: External auth action: %u, AKM: 0x%x",
3093 event.external_auth.action,
3094 event.external_auth.key_mgmt_suite);
3095 wpa_supplicant_event(drv->ctx, EVENT_EXTERNAL_AUTH, &event);
3096 }
3097
3098
3099 static void nl80211_port_authorized(struct wpa_driver_nl80211_data *drv,
3100 struct nlattr **tb)
3101 {
3102 const u8 *addr;
3103
3104 if (!tb[NL80211_ATTR_MAC] ||
3105 nla_len(tb[NL80211_ATTR_MAC]) != ETH_ALEN) {
3106 wpa_printf(MSG_DEBUG,
3107 "nl80211: Ignore port authorized event without BSSID");
3108 return;
3109 }
3110
3111 addr = nla_data(tb[NL80211_ATTR_MAC]);
3112 if (os_memcmp(addr, drv->bssid, ETH_ALEN) != 0) {
3113 wpa_printf(MSG_DEBUG,
3114 "nl80211: Ignore port authorized event for " MACSTR_SEC
3115 " (not the currently connected BSSID " MACSTR_SEC ")",
3116 MAC2STR_SEC(addr), MAC2STR_SEC(drv->bssid));
3117 return;
3118 }
3119
3120 wpa_supplicant_event(drv->ctx, EVENT_PORT_AUTHORIZED, NULL);
3121 }
3122
3123
3124 static void nl80211_sta_opmode_change_event(struct wpa_driver_nl80211_data *drv,
3125 struct nlattr **tb)
3126 {
3127 union wpa_event_data ed;
3128 u8 smps_mode, max_bw;
3129
3130 if (!tb[NL80211_ATTR_MAC] ||
3131 (!tb[NL80211_ATTR_CHANNEL_WIDTH] &&
3132 !tb[NL80211_ATTR_SMPS_MODE] &&
3133 !tb[NL80211_ATTR_NSS]))
3134 return;
3135
3136 ed.sta_opmode.smps_mode = SMPS_INVALID;
3137 ed.sta_opmode.chan_width = CHAN_WIDTH_UNKNOWN;
3138 ed.sta_opmode.rx_nss = 0xff;
3139 ed.sta_opmode.addr = nla_data(tb[NL80211_ATTR_MAC]);
3140
3141 if (tb[NL80211_ATTR_SMPS_MODE]) {
3142 smps_mode = nla_get_u8(tb[NL80211_ATTR_SMPS_MODE]);
3143 switch (smps_mode) {
3144 case NL80211_SMPS_OFF:
3145 ed.sta_opmode.smps_mode = SMPS_OFF;
3146 break;
3147 case NL80211_SMPS_STATIC:
3148 ed.sta_opmode.smps_mode = SMPS_STATIC;
3149 break;
3150 case NL80211_SMPS_DYNAMIC:
3151 ed.sta_opmode.smps_mode = SMPS_DYNAMIC;
3152 break;
3153 default:
3154 ed.sta_opmode.smps_mode = SMPS_INVALID;
3155 break;
3156 }
3157 }
3158
3159 if (tb[NL80211_ATTR_CHANNEL_WIDTH]) {
3160 max_bw = nla_get_u32(tb[NL80211_ATTR_CHANNEL_WIDTH]);
3161 switch (max_bw) {
3162 case NL80211_CHAN_WIDTH_20_NOHT:
3163 ed.sta_opmode.chan_width = CHAN_WIDTH_20_NOHT;
3164 break;
3165 case NL80211_CHAN_WIDTH_20:
3166 ed.sta_opmode.chan_width = CHAN_WIDTH_20;
3167 break;
3168 case NL80211_CHAN_WIDTH_40:
3169 ed.sta_opmode.chan_width = CHAN_WIDTH_40;
3170 break;
3171 case NL80211_CHAN_WIDTH_80:
3172 ed.sta_opmode.chan_width = CHAN_WIDTH_80;
3173 break;
3174 case NL80211_CHAN_WIDTH_80P80:
3175 ed.sta_opmode.chan_width = CHAN_WIDTH_80P80;
3176 break;
3177 case NL80211_CHAN_WIDTH_160:
3178 ed.sta_opmode.chan_width = CHAN_WIDTH_160;
3179 break;
3180 default:
3181 ed.sta_opmode.chan_width = CHAN_WIDTH_UNKNOWN;
3182 break;
3183
3184 }
3185 }
3186
3187 if (tb[NL80211_ATTR_NSS])
3188 ed.sta_opmode.rx_nss = nla_get_u8(tb[NL80211_ATTR_NSS]);
3189
3190 wpa_supplicant_event(drv->ctx, EVENT_STATION_OPMODE_CHANGED, &ed);
3191 }
3192
3193
3194 static void nl80211_control_port_frame(struct wpa_driver_nl80211_data *drv,
3195 struct nlattr **tb)
3196 {
3197 u8 *src_addr;
3198 u16 ethertype;
3199
3200 if (!tb[NL80211_ATTR_MAC] ||
3201 !tb[NL80211_ATTR_FRAME] ||
3202 !tb[NL80211_ATTR_CONTROL_PORT_ETHERTYPE])
3203 return;
3204
3205 src_addr = nla_data(tb[NL80211_ATTR_MAC]);
3206 ethertype = nla_get_u16(tb[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
3207
3208 switch (ethertype) {
3209 case ETH_P_RSN_PREAUTH:
3210 wpa_printf(MSG_INFO, "nl80211: Got pre-auth frame from "
3211 MACSTR_SEC " over control port unexpectedly",
3212 MAC2STR_SEC(src_addr));
3213 break;
3214 case ETH_P_PAE:
3215 drv_event_eapol_rx(drv->ctx, src_addr,
3216 nla_data(tb[NL80211_ATTR_FRAME]),
3217 nla_len(tb[NL80211_ATTR_FRAME]));
3218 break;
3219 default:
3220 wpa_printf(MSG_INFO, "nl80211: Unxpected ethertype 0x%04x from "
3221 MACSTR_SEC " over control port",
3222 ethertype, MAC2STR_SEC(src_addr));
3223 break;
3224 }
3225 }
3226
3227
3228 static void
3229 nl80211_control_port_frame_tx_status(struct wpa_driver_nl80211_data *drv,
3230 const u8 *frame, size_t len,
3231 struct nlattr *ack, struct nlattr *cookie)
3232 {
3233 union wpa_event_data event;
3234
3235 if (!cookie || len < ETH_HLEN)
3236 return;
3237
3238 wpa_printf(MSG_DEBUG,
3239 "nl80211: Control port TX status (ack=%d), cookie=%llu",
3240 ack != NULL, (long long unsigned int) nla_get_u64(cookie));
3241
3242 os_memset(&event, 0, sizeof(event));
3243 event.eapol_tx_status.dst = frame;
3244 event.eapol_tx_status.data = frame + ETH_HLEN;
3245 event.eapol_tx_status.data_len = len - ETH_HLEN;
3246 event.eapol_tx_status.ack = ack != NULL;
3247 wpa_supplicant_event(drv->ctx, EVENT_EAPOL_TX_STATUS, &event);
3248 }
3249
3250 #ifdef CONFIG_MLD_PATCH
3251 static void nl80211_mlo_link_switch_event(struct wpa_driver_nl80211_data *drv, struct nlattr **tb)
3252 {
3253 union wpa_event_data event;
3254 u8 assoc_link_id;
3255 u8 *mlo_bssid;
3256 if (!tb[NL80211_ATTR_MLO_LINK_SWITCH_LINK_ID] || !tb[NL80211_ATTR_MLO_LINK_SWITCH_WORK_BSSID]) {
3257 return;
3258 }
3259 assoc_link_id = nla_get_u8(tb[NL80211_ATTR_MLO_LINK_SWITCH_LINK_ID]);
3260 mlo_bssid = nla_data(tb[NL80211_ATTR_MLO_LINK_SWITCH_WORK_BSSID]);
3261
3262 os_memset(&event, 0, sizeof(event));
3263 event.mlo_link_switch_event.link_id = assoc_link_id;
3264 os_memcpy(event.mlo_link_switch_event.addr, mlo_bssid, ETH_ALEN);
3265 wpa_supplicant_event(drv->ctx, EVENT_MLO_LINK_SWITCH, &event);
3266 }
3267 #endif
3268
3269 static void do_process_drv_event(struct i802_bss *bss, int cmd,
3270 struct nlattr **tb)
3271 {
3272 struct wpa_driver_nl80211_data *drv = bss->drv;
3273 int external_scan_event = 0;
3274 struct nlattr *frame = tb[NL80211_ATTR_FRAME];
3275
3276 wpa_printf(MSG_INFO, "nl80211: Drv Event %d (%s) received for %s",
3277 cmd, nl80211_command_to_string(cmd), bss->ifname);
3278
3279 #ifdef CONFIG_DRIVER_NL80211_QCA
3280 if (cmd == NL80211_CMD_ROAM &&
3281 (drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
3282 if (drv->pending_roam_data) {
3283 struct os_reltime now, age;
3284
3285 os_get_reltime(&now);
3286 os_reltime_sub(&now, &drv->pending_roam_ind_time, &age);
3287 if (age.sec == 0 && age.usec < 100000) {
3288 wpa_printf(MSG_DEBUG,
3289 "nl80211: Process pending roam+auth vendor event");
3290 qca_nl80211_key_mgmt_auth(
3291 drv, drv->pending_roam_data,
3292 drv->pending_roam_data_len);
3293 }
3294 os_free(drv->pending_roam_data);
3295 drv->pending_roam_data = NULL;
3296 return;
3297 }
3298 /*
3299 * Device will use roam+auth vendor event to indicate
3300 * roaming, so ignore the regular roam event.
3301 */
3302 drv->roam_indication_done = true;
3303 wpa_printf(MSG_DEBUG,
3304 "nl80211: Ignore roam event (cmd=%d), device will use vendor event roam+auth",
3305 cmd);
3306 return;
3307 }
3308 #endif /* CONFIG_DRIVER_NL80211_QCA */
3309
3310 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED &&
3311 (cmd == NL80211_CMD_NEW_SCAN_RESULTS ||
3312 cmd == NL80211_CMD_SCAN_ABORTED))
3313 nl80211_restore_ap_mode(bss);
3314
3315 switch (cmd) {
3316 case NL80211_CMD_TRIGGER_SCAN:
3317 wpa_dbg(drv->ctx, MSG_EXCESSIVE, "nl80211: Scan trigger");
3318 drv->scan_state = SCAN_STARTED;
3319 if (drv->scan_for_auth) {
3320 /*
3321 * Cannot indicate EVENT_SCAN_STARTED here since we skip
3322 * EVENT_SCAN_RESULTS in scan_for_auth case and the
3323 * upper layer implementation could get confused about
3324 * scanning state.
3325 */
3326 wpa_printf(MSG_INFO, "nl80211: Do not indicate scan-start event due to internal scan_for_auth");
3327 break;
3328 }
3329 wpa_supplicant_event(drv->ctx, EVENT_SCAN_STARTED, NULL);
3330 break;
3331 case NL80211_CMD_START_SCHED_SCAN:
3332 wpa_dbg(drv->ctx, MSG_EXCESSIVE, "nl80211: Sched scan started");
3333 drv->scan_state = SCHED_SCAN_STARTED;
3334 break;
3335 case NL80211_CMD_SCHED_SCAN_STOPPED:
3336 wpa_dbg(drv->ctx, MSG_EXCESSIVE, "nl80211: Sched scan stopped");
3337 drv->scan_state = SCHED_SCAN_STOPPED;
3338 wpa_supplicant_event(drv->ctx, EVENT_SCHED_SCAN_STOPPED, NULL);
3339 break;
3340 case NL80211_CMD_NEW_SCAN_RESULTS:
3341 wpa_dbg(drv->ctx, MSG_EXCESSIVE,
3342 "nl80211: New scan results available");
3343 if (drv->last_scan_cmd != NL80211_CMD_VENDOR)
3344 drv->scan_state = SCAN_COMPLETED;
3345 drv->scan_complete_events = 1;
3346 if (drv->last_scan_cmd == NL80211_CMD_TRIGGER_SCAN) {
3347 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout,
3348 drv, drv->ctx);
3349 drv->last_scan_cmd = 0;
3350 } else {
3351 external_scan_event = 1;
3352 }
3353 send_scan_event(drv, 0, tb, external_scan_event);
3354 break;
3355 case NL80211_CMD_SCHED_SCAN_RESULTS:
3356 wpa_dbg(drv->ctx, MSG_INFO,
3357 "nl80211: New sched scan results available");
3358 drv->scan_state = SCHED_SCAN_RESULTS;
3359 send_scan_event(drv, 0, tb, 0);
3360 break;
3361 case NL80211_CMD_SCAN_ABORTED:
3362 wpa_dbg(drv->ctx, MSG_INFO, "nl80211: Scan aborted");
3363 if (drv->last_scan_cmd != NL80211_CMD_VENDOR)
3364 drv->scan_state = SCAN_ABORTED;
3365 if (drv->last_scan_cmd == NL80211_CMD_TRIGGER_SCAN) {
3366 /*
3367 * Need to indicate that scan results are available in
3368 * order not to make wpa_supplicant stop its scanning.
3369 */
3370 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout,
3371 drv, drv->ctx);
3372 drv->last_scan_cmd = 0;
3373 } else {
3374 external_scan_event = 1;
3375 }
3376 send_scan_event(drv, 1, tb, external_scan_event);
3377 break;
3378 case NL80211_CMD_AUTHENTICATE:
3379 case NL80211_CMD_ASSOCIATE:
3380 case NL80211_CMD_DEAUTHENTICATE:
3381 case NL80211_CMD_DISASSOCIATE:
3382 case NL80211_CMD_FRAME_TX_STATUS:
3383 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
3384 case NL80211_CMD_UNPROT_DISASSOCIATE:
3385 mlme_event(bss, cmd, tb[NL80211_ATTR_FRAME],
3386 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
3387 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
3388 tb[NL80211_ATTR_COOKIE],
3389 tb[NL80211_ATTR_RX_SIGNAL_DBM],
3390 tb[NL80211_ATTR_STA_WME],
3391 #ifdef CONFIG_MLD_PATCH
3392 tb[NL80211_ATTR_REQ_IE],
3393 tb[NL80211_ATTR_MLO_LINK_ID]);
3394 #else
3395 tb[NL80211_ATTR_REQ_IE]);
3396 #endif
3397 break;
3398 case NL80211_CMD_CONNECT:
3399 case NL80211_CMD_ROAM:
3400 #ifdef CONFIG_VENDOR_EXT
3401 if (wpa_vendor_ext_nl80211_filter_connect_msg(drv->ctx, cmd)) {
3402 break;
3403 }
3404 #endif
3405 mlme_event_connect(drv, cmd,
3406 tb[NL80211_ATTR_STATUS_CODE],
3407 tb[NL80211_ATTR_MAC],
3408 tb[NL80211_ATTR_REQ_IE],
3409 tb[NL80211_ATTR_RESP_IE],
3410 tb[NL80211_ATTR_TIMED_OUT],
3411 tb[NL80211_ATTR_TIMEOUT_REASON],
3412 NULL, NULL, NULL,
3413 tb[NL80211_ATTR_FILS_KEK],
3414 NULL,
3415 tb[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM],
3416 tb[NL80211_ATTR_PMK],
3417 #ifdef CONFIG_MLD_PATCH
3418 tb[NL80211_ATTR_PMKID],
3419 tb[NL80211_ATTR_MLO_LINKS]);
3420 #else
3421 tb[NL80211_ATTR_PMKID]);
3422 #endif
3423 break;
3424 case NL80211_CMD_CH_SWITCH_STARTED_NOTIFY:
3425 mlme_event_ch_switch(drv,
3426 tb[NL80211_ATTR_IFINDEX],
3427 #ifdef CONFIG_MLD_PATCH
3428 tb[NL80211_ATTR_MLO_LINK_ID],
3429 #endif
3430 tb[NL80211_ATTR_WIPHY_FREQ],
3431 tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
3432 tb[NL80211_ATTR_CHANNEL_WIDTH],
3433 tb[NL80211_ATTR_CENTER_FREQ1],
3434 tb[NL80211_ATTR_CENTER_FREQ2],
3435 #ifdef CONFIG_MLD_PATCH
3436 tb[NL80211_ATTR_PUNCT_BITMAP],
3437 #endif
3438 0);
3439 break;
3440 case NL80211_CMD_CH_SWITCH_NOTIFY:
3441 mlme_event_ch_switch(drv,
3442 tb[NL80211_ATTR_IFINDEX],
3443 #ifdef CONFIG_MLD_PATCH
3444 tb[NL80211_ATTR_MLO_LINK_ID],
3445 #endif
3446 tb[NL80211_ATTR_WIPHY_FREQ],
3447 tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
3448 tb[NL80211_ATTR_CHANNEL_WIDTH],
3449 tb[NL80211_ATTR_CENTER_FREQ1],
3450 tb[NL80211_ATTR_CENTER_FREQ2],
3451 #ifdef CONFIG_MLD_PATCH
3452 tb[NL80211_ATTR_PUNCT_BITMAP],
3453 #endif
3454 1);
3455 break;
3456 case NL80211_CMD_DISCONNECT:
3457 mlme_event_disconnect(drv, tb[NL80211_ATTR_REASON_CODE],
3458 tb[NL80211_ATTR_MAC],
3459 tb[NL80211_ATTR_DISCONNECTED_BY_AP]);
3460 break;
3461 case NL80211_CMD_MICHAEL_MIC_FAILURE:
3462 mlme_event_michael_mic_failure(bss, tb);
3463 break;
3464 case NL80211_CMD_JOIN_IBSS:
3465 mlme_event_join_ibss(drv, tb);
3466 break;
3467 case NL80211_CMD_REMAIN_ON_CHANNEL:
3468 mlme_event_remain_on_channel(drv, 0, tb);
3469 break;
3470 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
3471 mlme_event_remain_on_channel(drv, 1, tb);
3472 break;
3473 case NL80211_CMD_NOTIFY_CQM:
3474 nl80211_cqm_event(drv, tb);
3475 break;
3476 case NL80211_CMD_REG_CHANGE:
3477 case NL80211_CMD_WIPHY_REG_CHANGE:
3478 nl80211_reg_change_event(drv, tb);
3479 break;
3480 case NL80211_CMD_REG_BEACON_HINT:
3481 nl80211_reg_beacon_hint_event(drv, tb);
3482 break;
3483 case NL80211_CMD_NEW_STATION:
3484 nl80211_new_station_event(drv, bss, tb);
3485 break;
3486 case NL80211_CMD_DEL_STATION:
3487 #ifdef CONFIG_VENDOR_EXT
3488 wpa_vendor_ext_nl80211_del_station_event(drv, bss, tb);
3489 #else
3490 nl80211_del_station_event(drv, bss, tb);
3491 #endif
3492 break;
3493 case NL80211_CMD_SET_REKEY_OFFLOAD:
3494 nl80211_rekey_offload_event(drv, tb);
3495 break;
3496 case NL80211_CMD_PMKSA_CANDIDATE:
3497 nl80211_pmksa_candidate_event(drv, tb);
3498 break;
3499 case NL80211_CMD_PROBE_CLIENT:
3500 nl80211_client_probe_event(drv, tb);
3501 break;
3502 case NL80211_CMD_TDLS_OPER:
3503 nl80211_tdls_oper_event(drv, tb);
3504 break;
3505 case NL80211_CMD_CONN_FAILED:
3506 nl80211_connect_failed_event(drv, tb);
3507 break;
3508 case NL80211_CMD_FT_EVENT:
3509 mlme_event_ft_event(drv, tb);
3510 break;
3511 case NL80211_CMD_RADAR_DETECT:
3512 nl80211_radar_event(drv, tb);
3513 break;
3514 case NL80211_CMD_STOP_AP:
3515 nl80211_stop_ap(drv, tb);
3516 break;
3517 case NL80211_CMD_VENDOR:
3518 nl80211_vendor_event(drv, tb);
3519 break;
3520 case NL80211_CMD_NEW_PEER_CANDIDATE:
3521 nl80211_new_peer_candidate(drv, tb);
3522 break;
3523 case NL80211_CMD_PORT_AUTHORIZED:
3524 nl80211_port_authorized(drv, tb);
3525 break;
3526 case NL80211_CMD_STA_OPMODE_CHANGED:
3527 nl80211_sta_opmode_change_event(drv, tb);
3528 break;
3529 case NL80211_CMD_UPDATE_OWE_INFO:
3530 mlme_event_dh_event(drv, bss, tb);
3531 break;
3532 case NL80211_CMD_UNPROT_BEACON:
3533 if (frame)
3534 mlme_event_unprot_beacon(drv, nla_data(frame),
3535 nla_len(frame));
3536 break;
3537 case NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS:
3538 if (!frame)
3539 break;
3540 nl80211_control_port_frame_tx_status(drv,
3541 nla_data(frame),
3542 nla_len(frame),
3543 tb[NL80211_ATTR_ACK],
3544 tb[NL80211_ATTR_COOKIE]);
3545 break;
3546 #ifdef CONFIG_MLD_PATCH
3547 case NL80211_CMD_LINK_SWITCH_EVENT:
3548 nl80211_mlo_link_switch_event(drv, tb);
3549 break;
3550 #endif
3551 default:
3552 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Ignored unknown event "
3553 "(cmd=%d)", cmd);
3554 break;
3555 }
3556 }
3557
3558
3559 int process_global_event(struct nl_msg *msg, void *arg)
3560 {
3561 struct nl80211_global *global = arg;
3562 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
3563 struct nlattr *tb[NL80211_ATTR_MAX + 1];
3564 struct wpa_driver_nl80211_data *drv, *tmp;
3565 int ifidx = -1, wiphy_idx = -1, wiphy_idx_rx = -1;
3566 struct i802_bss *bss;
3567 u64 wdev_id = 0;
3568 int wdev_id_set = 0;
3569 int wiphy_idx_set = 0;
3570
3571 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
3572 genlmsg_attrlen(gnlh, 0), NULL);
3573
3574 if (tb[NL80211_ATTR_IFINDEX])
3575 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
3576 else if (tb[NL80211_ATTR_WDEV]) {
3577 wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
3578 wdev_id_set = 1;
3579 } else if (tb[NL80211_ATTR_WIPHY]) {
3580 wiphy_idx_rx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
3581 wiphy_idx_set = 1;
3582 }
3583
3584 dl_list_for_each_safe(drv, tmp, &global->interfaces,
3585 struct wpa_driver_nl80211_data, list) {
3586 for (bss = drv->first_bss; bss; bss = bss->next) {
3587 if (wiphy_idx_set)
3588 wiphy_idx = nl80211_get_wiphy_index(bss);
3589 if ((ifidx == -1 && !wiphy_idx_set && !wdev_id_set) ||
3590 ifidx == bss->ifindex ||
3591 (wiphy_idx_set && wiphy_idx == wiphy_idx_rx) ||
3592 (wdev_id_set && bss->wdev_id_set &&
3593 wdev_id == bss->wdev_id)) {
3594 #ifdef CONFIG_VENDOR_EXT
3595 if (wpa_vendor_ext_nl80211_is_match_iface(bss, gnlh->cmd, tb)) {
3596 do_process_drv_event(bss, gnlh->cmd, tb);
3597 return NL_SKIP;
3598 }
3599 #else
3600 do_process_drv_event(bss, gnlh->cmd, tb);
3601 return NL_SKIP;
3602 #endif
3603 }
3604 }
3605 wpa_printf(MSG_EXCESSIVE,
3606 "nl80211: Ignored event %d (%s) for foreign interface (ifindex %d wdev 0x%llx)",
3607 gnlh->cmd, nl80211_command_to_string(gnlh->cmd),
3608 ifidx, (long long unsigned int) wdev_id);
3609 }
3610
3611 return NL_SKIP;
3612 }
3613
3614
3615 int process_bss_event(struct nl_msg *msg, void *arg)
3616 {
3617 struct i802_bss *bss = arg;
3618 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
3619 struct nlattr *tb[NL80211_ATTR_MAX + 1];
3620
3621 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
3622 genlmsg_attrlen(gnlh, 0), NULL);
3623
3624 wpa_printf(MSG_DEBUG, "nl80211: BSS Event %d (%s) received for %s",
3625 gnlh->cmd, nl80211_command_to_string(gnlh->cmd),
3626 bss->ifname);
3627
3628 #ifdef CONFIG_VENDOR_EXT
3629 bss = wpa_vendor_nl80211_get_processing_bss(bss, gnlh->cmd, tb);
3630 #endif
3631
3632 switch (gnlh->cmd) {
3633 case NL80211_CMD_FRAME:
3634 case NL80211_CMD_FRAME_TX_STATUS:
3635 mlme_event(bss, gnlh->cmd, tb[NL80211_ATTR_FRAME],
3636 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
3637 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
3638 tb[NL80211_ATTR_COOKIE],
3639 tb[NL80211_ATTR_RX_SIGNAL_DBM],
3640 #ifdef CONFIG_MLD_PATCH
3641 tb[NL80211_ATTR_STA_WME], NULL,
3642 tb[NL80211_ATTR_MLO_LINK_ID]);
3643 #else
3644 tb[NL80211_ATTR_STA_WME], NULL);
3645 #endif
3646 break;
3647 case NL80211_CMD_UNEXPECTED_FRAME:
3648 nl80211_spurious_frame(bss, tb, 0);
3649 break;
3650 case NL80211_CMD_UNEXPECTED_4ADDR_FRAME:
3651 nl80211_spurious_frame(bss, tb, 1);
3652 break;
3653 case NL80211_CMD_EXTERNAL_AUTH:
3654 nl80211_external_auth(bss->drv, tb);
3655 break;
3656 case NL80211_CMD_CONTROL_PORT_FRAME:
3657 nl80211_control_port_frame(bss->drv, tb);
3658 break;
3659 default:
3660 wpa_printf(MSG_DEBUG, "nl80211: Ignored unknown event "
3661 "(cmd=%d)", gnlh->cmd);
3662 break;
3663 }
3664
3665 return NL_SKIP;
3666 }
3667