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