]> git.ipfire.org Git - thirdparty/hostap.git/blob - src/drivers/driver_nl80211_event.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use a shared helper function for RSN supplicant capabilities
[thirdparty/hostap.git] / src / drivers / driver_nl80211_event.c
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/ieee802_11_defs.h"
19 #include "common/ieee802_11_common.h"
20 #include "driver_nl80211.h"
21
22
23 static const char * nl80211_command_to_string(enum nl80211_commands cmd)
24 {
25 #define C2S(x) case x: return #x;
26 switch (cmd) {
27 C2S(NL80211_CMD_UNSPEC)
28 C2S(NL80211_CMD_GET_WIPHY)
29 C2S(NL80211_CMD_SET_WIPHY)
30 C2S(NL80211_CMD_NEW_WIPHY)
31 C2S(NL80211_CMD_DEL_WIPHY)
32 C2S(NL80211_CMD_GET_INTERFACE)
33 C2S(NL80211_CMD_SET_INTERFACE)
34 C2S(NL80211_CMD_NEW_INTERFACE)
35 C2S(NL80211_CMD_DEL_INTERFACE)
36 C2S(NL80211_CMD_GET_KEY)
37 C2S(NL80211_CMD_SET_KEY)
38 C2S(NL80211_CMD_NEW_KEY)
39 C2S(NL80211_CMD_DEL_KEY)
40 C2S(NL80211_CMD_GET_BEACON)
41 C2S(NL80211_CMD_SET_BEACON)
42 C2S(NL80211_CMD_START_AP)
43 C2S(NL80211_CMD_STOP_AP)
44 C2S(NL80211_CMD_GET_STATION)
45 C2S(NL80211_CMD_SET_STATION)
46 C2S(NL80211_CMD_NEW_STATION)
47 C2S(NL80211_CMD_DEL_STATION)
48 C2S(NL80211_CMD_GET_MPATH)
49 C2S(NL80211_CMD_SET_MPATH)
50 C2S(NL80211_CMD_NEW_MPATH)
51 C2S(NL80211_CMD_DEL_MPATH)
52 C2S(NL80211_CMD_SET_BSS)
53 C2S(NL80211_CMD_SET_REG)
54 C2S(NL80211_CMD_REQ_SET_REG)
55 C2S(NL80211_CMD_GET_MESH_CONFIG)
56 C2S(NL80211_CMD_SET_MESH_CONFIG)
57 C2S(NL80211_CMD_SET_MGMT_EXTRA_IE)
58 C2S(NL80211_CMD_GET_REG)
59 C2S(NL80211_CMD_GET_SCAN)
60 C2S(NL80211_CMD_TRIGGER_SCAN)
61 C2S(NL80211_CMD_NEW_SCAN_RESULTS)
62 C2S(NL80211_CMD_SCAN_ABORTED)
63 C2S(NL80211_CMD_REG_CHANGE)
64 C2S(NL80211_CMD_AUTHENTICATE)
65 C2S(NL80211_CMD_ASSOCIATE)
66 C2S(NL80211_CMD_DEAUTHENTICATE)
67 C2S(NL80211_CMD_DISASSOCIATE)
68 C2S(NL80211_CMD_MICHAEL_MIC_FAILURE)
69 C2S(NL80211_CMD_REG_BEACON_HINT)
70 C2S(NL80211_CMD_JOIN_IBSS)
71 C2S(NL80211_CMD_LEAVE_IBSS)
72 C2S(NL80211_CMD_TESTMODE)
73 C2S(NL80211_CMD_CONNECT)
74 C2S(NL80211_CMD_ROAM)
75 C2S(NL80211_CMD_DISCONNECT)
76 C2S(NL80211_CMD_SET_WIPHY_NETNS)
77 C2S(NL80211_CMD_GET_SURVEY)
78 C2S(NL80211_CMD_NEW_SURVEY_RESULTS)
79 C2S(NL80211_CMD_SET_PMKSA)
80 C2S(NL80211_CMD_DEL_PMKSA)
81 C2S(NL80211_CMD_FLUSH_PMKSA)
82 C2S(NL80211_CMD_REMAIN_ON_CHANNEL)
83 C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL)
84 C2S(NL80211_CMD_SET_TX_BITRATE_MASK)
85 C2S(NL80211_CMD_REGISTER_FRAME)
86 C2S(NL80211_CMD_FRAME)
87 C2S(NL80211_CMD_FRAME_TX_STATUS)
88 C2S(NL80211_CMD_SET_POWER_SAVE)
89 C2S(NL80211_CMD_GET_POWER_SAVE)
90 C2S(NL80211_CMD_SET_CQM)
91 C2S(NL80211_CMD_NOTIFY_CQM)
92 C2S(NL80211_CMD_SET_CHANNEL)
93 C2S(NL80211_CMD_SET_WDS_PEER)
94 C2S(NL80211_CMD_FRAME_WAIT_CANCEL)
95 C2S(NL80211_CMD_JOIN_MESH)
96 C2S(NL80211_CMD_LEAVE_MESH)
97 C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE)
98 C2S(NL80211_CMD_UNPROT_DISASSOCIATE)
99 C2S(NL80211_CMD_NEW_PEER_CANDIDATE)
100 C2S(NL80211_CMD_GET_WOWLAN)
101 C2S(NL80211_CMD_SET_WOWLAN)
102 C2S(NL80211_CMD_START_SCHED_SCAN)
103 C2S(NL80211_CMD_STOP_SCHED_SCAN)
104 C2S(NL80211_CMD_SCHED_SCAN_RESULTS)
105 C2S(NL80211_CMD_SCHED_SCAN_STOPPED)
106 C2S(NL80211_CMD_SET_REKEY_OFFLOAD)
107 C2S(NL80211_CMD_PMKSA_CANDIDATE)
108 C2S(NL80211_CMD_TDLS_OPER)
109 C2S(NL80211_CMD_TDLS_MGMT)
110 C2S(NL80211_CMD_UNEXPECTED_FRAME)
111 C2S(NL80211_CMD_PROBE_CLIENT)
112 C2S(NL80211_CMD_REGISTER_BEACONS)
113 C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME)
114 C2S(NL80211_CMD_SET_NOACK_MAP)
115 C2S(NL80211_CMD_CH_SWITCH_NOTIFY)
116 C2S(NL80211_CMD_START_P2P_DEVICE)
117 C2S(NL80211_CMD_STOP_P2P_DEVICE)
118 C2S(NL80211_CMD_CONN_FAILED)
119 C2S(NL80211_CMD_SET_MCAST_RATE)
120 C2S(NL80211_CMD_SET_MAC_ACL)
121 C2S(NL80211_CMD_RADAR_DETECT)
122 C2S(NL80211_CMD_GET_PROTOCOL_FEATURES)
123 C2S(NL80211_CMD_UPDATE_FT_IES)
124 C2S(NL80211_CMD_FT_EVENT)
125 C2S(NL80211_CMD_CRIT_PROTOCOL_START)
126 C2S(NL80211_CMD_CRIT_PROTOCOL_STOP)
127 C2S(NL80211_CMD_GET_COALESCE)
128 C2S(NL80211_CMD_SET_COALESCE)
129 C2S(NL80211_CMD_CHANNEL_SWITCH)
130 C2S(NL80211_CMD_VENDOR)
131 C2S(NL80211_CMD_SET_QOS_MAP)
132 C2S(NL80211_CMD_ADD_TX_TS)
133 C2S(NL80211_CMD_DEL_TX_TS)
134 C2S(NL80211_CMD_WIPHY_REG_CHANGE)
135 C2S(NL80211_CMD_PORT_AUTHORIZED)
136 C2S(NL80211_CMD_EXTERNAL_AUTH)
137 C2S(NL80211_CMD_STA_OPMODE_CHANGED)
138 C2S(NL80211_CMD_CONTROL_PORT_FRAME)
139 C2S(NL80211_CMD_UPDATE_OWE_INFO)
140 default:
141 return "NL80211_CMD_UNKNOWN";
142 }
143 #undef C2S
144 }
145
146
147 static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
148 const u8 *frame, size_t len)
149 {
150 const struct ieee80211_mgmt *mgmt;
151 union wpa_event_data event;
152
153 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
154 drv->force_connect_cmd) {
155 /*
156 * Avoid reporting two association events that would confuse
157 * the core code.
158 */
159 wpa_printf(MSG_DEBUG,
160 "nl80211: Ignore auth event when using driver SME");
161 return;
162 }
163
164 wpa_printf(MSG_DEBUG, "nl80211: Authenticate event");
165 mgmt = (const struct ieee80211_mgmt *) frame;
166 if (len < 24 + sizeof(mgmt->u.auth)) {
167 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
168 "frame");
169 return;
170 }
171
172 os_memcpy(drv->auth_bssid, mgmt->sa, ETH_ALEN);
173 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
174 os_memset(&event, 0, sizeof(event));
175 os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
176 event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
177 event.auth.auth_transaction =
178 le_to_host16(mgmt->u.auth.auth_transaction);
179 event.auth.status_code = le_to_host16(mgmt->u.auth.status_code);
180 if (len > 24 + sizeof(mgmt->u.auth)) {
181 event.auth.ies = mgmt->u.auth.variable;
182 event.auth.ies_len = len - 24 - sizeof(mgmt->u.auth);
183 }
184
185 wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
186 }
187
188
189 static void nl80211_parse_wmm_params(struct nlattr *wmm_attr,
190 struct wmm_params *wmm_params)
191 {
192 struct nlattr *wmm_info[NL80211_STA_WME_MAX + 1];
193 static struct nla_policy wme_policy[NL80211_STA_WME_MAX + 1] = {
194 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
195 };
196
197 if (!wmm_attr ||
198 nla_parse_nested(wmm_info, NL80211_STA_WME_MAX, wmm_attr,
199 wme_policy) ||
200 !wmm_info[NL80211_STA_WME_UAPSD_QUEUES])
201 return;
202
203 wmm_params->uapsd_queues =
204 nla_get_u8(wmm_info[NL80211_STA_WME_UAPSD_QUEUES]);
205 wmm_params->info_bitmap |= WMM_PARAMS_UAPSD_QUEUES_INFO;
206 }
207
208
209 static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
210 const u8 *frame, size_t len, struct nlattr *wmm,
211 struct nlattr *req_ie)
212 {
213 const struct ieee80211_mgmt *mgmt;
214 union wpa_event_data event;
215 u16 status;
216 int ssid_len;
217
218 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
219 drv->force_connect_cmd) {
220 /*
221 * Avoid reporting two association events that would confuse
222 * the core code.
223 */
224 wpa_printf(MSG_DEBUG,
225 "nl80211: Ignore assoc event when using driver SME");
226 return;
227 }
228
229 wpa_printf(MSG_DEBUG, "nl80211: Associate event");
230 mgmt = (const struct ieee80211_mgmt *) frame;
231 if (len < 24 + sizeof(mgmt->u.assoc_resp)) {
232 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
233 "frame");
234 return;
235 }
236
237 status = le_to_host16(mgmt->u.assoc_resp.status_code);
238 if (status != WLAN_STATUS_SUCCESS) {
239 os_memset(&event, 0, sizeof(event));
240 event.assoc_reject.bssid = mgmt->bssid;
241 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
242 event.assoc_reject.resp_ies =
243 (u8 *) mgmt->u.assoc_resp.variable;
244 event.assoc_reject.resp_ies_len =
245 len - 24 - sizeof(mgmt->u.assoc_resp);
246 }
247 event.assoc_reject.status_code = status;
248
249 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
250 return;
251 }
252
253 drv->associated = 1;
254 os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
255 os_memcpy(drv->prev_bssid, mgmt->sa, ETH_ALEN);
256
257 os_memset(&event, 0, sizeof(event));
258 event.assoc_info.resp_frame = frame;
259 event.assoc_info.resp_frame_len = len;
260 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
261 event.assoc_info.resp_ies = (u8 *) mgmt->u.assoc_resp.variable;
262 event.assoc_info.resp_ies_len =
263 len - 24 - sizeof(mgmt->u.assoc_resp);
264 }
265
266 if (req_ie) {
267 event.assoc_info.req_ies = nla_data(req_ie);
268 event.assoc_info.req_ies_len = nla_len(req_ie);
269 }
270
271 /* When this association was initiated outside of wpa_supplicant,
272 * drv->ssid needs to be set here to satisfy later checking. */
273 ssid_len = nl80211_get_assoc_ssid(drv, drv->ssid);
274 if (ssid_len > 0) {
275 drv->ssid_len = ssid_len;
276 wpa_printf(MSG_DEBUG,
277 "nl80211: Set drv->ssid based on scan res info to '%s'",
278 wpa_ssid_txt(drv->ssid, drv->ssid_len));
279 }
280
281 event.assoc_info.freq = drv->assoc_freq;
282 drv->first_bss->freq = drv->assoc_freq;
283
284 nl80211_parse_wmm_params(wmm, &event.assoc_info.wmm_params);
285
286 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
287 }
288
289
290 static void mlme_event_connect(struct wpa_driver_nl80211_data *drv,
291 enum nl80211_commands cmd, struct nlattr *status,
292 struct nlattr *addr, struct nlattr *req_ie,
293 struct nlattr *resp_ie,
294 struct nlattr *timed_out,
295 struct nlattr *timeout_reason,
296 struct nlattr *authorized,
297 struct nlattr *key_replay_ctr,
298 struct nlattr *ptk_kck,
299 struct nlattr *ptk_kek,
300 struct nlattr *subnet_status,
301 struct nlattr *fils_erp_next_seq_num,
302 struct nlattr *fils_pmk,
303 struct nlattr *fils_pmkid)
304 {
305 union wpa_event_data event;
306 const u8 *ssid = NULL;
307 u16 status_code;
308 int ssid_len;
309
310 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
311 /*
312 * Avoid reporting two association events that would confuse
313 * the core code.
314 */
315 wpa_printf(MSG_DEBUG, "nl80211: Ignore connect event (cmd=%d) "
316 "when using userspace SME", cmd);
317 return;
318 }
319
320 drv->connect_reassoc = 0;
321
322 status_code = status ? nla_get_u16(status) : WLAN_STATUS_SUCCESS;
323
324 if (cmd == NL80211_CMD_CONNECT) {
325 wpa_printf(MSG_DEBUG,
326 "nl80211: Connect event (status=%u ignore_next_local_disconnect=%d)",
327 status_code, drv->ignore_next_local_disconnect);
328 } else if (cmd == NL80211_CMD_ROAM) {
329 wpa_printf(MSG_DEBUG, "nl80211: Roam event");
330 }
331
332 os_memset(&event, 0, sizeof(event));
333 if (cmd == NL80211_CMD_CONNECT && status_code != WLAN_STATUS_SUCCESS) {
334 if (addr)
335 event.assoc_reject.bssid = nla_data(addr);
336 if (drv->ignore_next_local_disconnect) {
337 drv->ignore_next_local_disconnect = 0;
338 if (!event.assoc_reject.bssid ||
339 (os_memcmp(event.assoc_reject.bssid,
340 drv->auth_attempt_bssid,
341 ETH_ALEN) != 0)) {
342 /*
343 * Ignore the event that came without a BSSID or
344 * for the old connection since this is likely
345 * not relevant to the new Connect command.
346 */
347 wpa_printf(MSG_DEBUG,
348 "nl80211: Ignore connection failure event triggered during reassociation");
349 return;
350 }
351 }
352 if (resp_ie) {
353 event.assoc_reject.resp_ies = nla_data(resp_ie);
354 event.assoc_reject.resp_ies_len = nla_len(resp_ie);
355 }
356 event.assoc_reject.status_code = status_code;
357 event.assoc_reject.timed_out = timed_out != NULL;
358 if (timed_out && timeout_reason) {
359 enum nl80211_timeout_reason reason;
360
361 reason = nla_get_u32(timeout_reason);
362 switch (reason) {
363 case NL80211_TIMEOUT_SCAN:
364 event.assoc_reject.timeout_reason = "scan";
365 break;
366 case NL80211_TIMEOUT_AUTH:
367 event.assoc_reject.timeout_reason = "auth";
368 break;
369 case NL80211_TIMEOUT_ASSOC:
370 event.assoc_reject.timeout_reason = "assoc";
371 break;
372 default:
373 break;
374 }
375 }
376 if (fils_erp_next_seq_num)
377 event.assoc_reject.fils_erp_next_seq_num =
378 nla_get_u16(fils_erp_next_seq_num);
379 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
380 return;
381 }
382
383 drv->associated = 1;
384 if (addr) {
385 os_memcpy(drv->bssid, nla_data(addr), ETH_ALEN);
386 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
387 }
388
389 if (req_ie) {
390 event.assoc_info.req_ies = nla_data(req_ie);
391 event.assoc_info.req_ies_len = nla_len(req_ie);
392
393 if (cmd == NL80211_CMD_ROAM) {
394 ssid = get_ie(event.assoc_info.req_ies,
395 event.assoc_info.req_ies_len,
396 WLAN_EID_SSID);
397 if (ssid && ssid[1] > 0 && ssid[1] <= 32) {
398 drv->ssid_len = ssid[1];
399 os_memcpy(drv->ssid, ssid + 2, ssid[1]);
400 wpa_printf(MSG_DEBUG,
401 "nl80211: Set drv->ssid based on req_ie to '%s'",
402 wpa_ssid_txt(drv->ssid,
403 drv->ssid_len));
404 }
405 }
406 }
407 if (resp_ie) {
408 event.assoc_info.resp_ies = nla_data(resp_ie);
409 event.assoc_info.resp_ies_len = nla_len(resp_ie);
410 }
411
412 event.assoc_info.freq = nl80211_get_assoc_freq(drv);
413 drv->first_bss->freq = drv->assoc_freq;
414
415 if ((!ssid || ssid[1] == 0 || ssid[1] > 32) &&
416 (ssid_len = nl80211_get_assoc_ssid(drv, drv->ssid)) > 0) {
417 /* When this connection was initiated outside of wpa_supplicant,
418 * drv->ssid needs to be set here to satisfy later checking. */
419 drv->ssid_len = ssid_len;
420 wpa_printf(MSG_DEBUG,
421 "nl80211: Set drv->ssid based on scan res info to '%s'",
422 wpa_ssid_txt(drv->ssid, drv->ssid_len));
423 }
424
425 if (authorized && nla_get_u8(authorized)) {
426 event.assoc_info.authorized = 1;
427 wpa_printf(MSG_DEBUG, "nl80211: connection authorized");
428 }
429 if (key_replay_ctr) {
430 event.assoc_info.key_replay_ctr = nla_data(key_replay_ctr);
431 event.assoc_info.key_replay_ctr_len = nla_len(key_replay_ctr);
432 }
433 if (ptk_kck) {
434 event.assoc_info.ptk_kck = nla_data(ptk_kck);
435 event.assoc_info.ptk_kck_len = nla_len(ptk_kck);
436 }
437 if (ptk_kek) {
438 event.assoc_info.ptk_kek = nla_data(ptk_kek);
439 event.assoc_info.ptk_kek_len = nla_len(ptk_kek);
440 }
441
442 if (subnet_status) {
443 /*
444 * At least for now, this is only available from
445 * QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_SUBNET_STATUS and that
446 * attribute has the same values 0, 1, 2 as are used in the
447 * variable here, so no mapping between different values are
448 * needed.
449 */
450 event.assoc_info.subnet_status = nla_get_u8(subnet_status);
451 }
452
453 if (fils_erp_next_seq_num)
454 event.assoc_info.fils_erp_next_seq_num =
455 nla_get_u16(fils_erp_next_seq_num);
456
457 if (fils_pmk) {
458 event.assoc_info.fils_pmk = nla_data(fils_pmk);
459 event.assoc_info.fils_pmk_len = nla_len(fils_pmk);
460 }
461
462 if (fils_pmkid)
463 event.assoc_info.fils_pmkid = nla_data(fils_pmkid);
464
465 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
466 }
467
468
469 static void mlme_event_disconnect(struct wpa_driver_nl80211_data *drv,
470 struct nlattr *reason, struct nlattr *addr,
471 struct nlattr *by_ap)
472 {
473 union wpa_event_data data;
474 unsigned int locally_generated = by_ap == NULL;
475
476 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
477 /*
478 * Avoid reporting two disassociation events that could
479 * confuse the core code.
480 */
481 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
482 "event when using userspace SME");
483 return;
484 }
485
486 if (drv->ignore_next_local_disconnect) {
487 drv->ignore_next_local_disconnect = 0;
488 if (locally_generated) {
489 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
490 "event triggered during reassociation");
491 return;
492 }
493 wpa_printf(MSG_WARNING, "nl80211: Was expecting local "
494 "disconnect but got another disconnect "
495 "event first");
496 }
497
498 wpa_printf(MSG_DEBUG, "nl80211: Disconnect event");
499 nl80211_mark_disconnected(drv);
500 os_memset(&data, 0, sizeof(data));
501 if (reason)
502 data.deauth_info.reason_code = nla_get_u16(reason);
503 data.deauth_info.locally_generated = by_ap == NULL;
504 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, &data);
505 }
506
507
508 static int calculate_chan_offset(int width, int freq, int cf1, int cf2)
509 {
510 int freq1 = 0;
511
512 switch (convert2width(width)) {
513 case CHAN_WIDTH_20_NOHT:
514 case CHAN_WIDTH_20:
515 return 0;
516 case CHAN_WIDTH_40:
517 freq1 = cf1 - 10;
518 break;
519 case CHAN_WIDTH_80:
520 freq1 = cf1 - 30;
521 break;
522 case CHAN_WIDTH_160:
523 freq1 = cf1 - 70;
524 break;
525 case CHAN_WIDTH_UNKNOWN:
526 case CHAN_WIDTH_80P80:
527 case CHAN_WIDTH_2160:
528 case CHAN_WIDTH_4320:
529 case CHAN_WIDTH_6480:
530 case CHAN_WIDTH_8640:
531 /* FIXME: implement this */
532 return 0;
533 }
534
535 return (abs(freq - freq1) / 20) % 2 == 0 ? 1 : -1;
536 }
537
538
539 static void mlme_event_ch_switch(struct wpa_driver_nl80211_data *drv,
540 struct nlattr *ifindex, struct nlattr *freq,
541 struct nlattr *type, struct nlattr *bw,
542 struct nlattr *cf1, struct nlattr *cf2,
543 int finished)
544 {
545 struct i802_bss *bss;
546 union wpa_event_data data;
547 int ht_enabled = 1;
548 int chan_offset = 0;
549 int ifidx;
550
551 wpa_printf(MSG_DEBUG, "nl80211: Channel switch%s event",
552 finished ? "" : " started");
553
554 if (!freq)
555 return;
556
557 ifidx = nla_get_u32(ifindex);
558 bss = get_bss_ifindex(drv, ifidx);
559 if (bss == NULL) {
560 wpa_printf(MSG_WARNING, "nl80211: Unknown ifindex (%d) for channel switch, ignoring",
561 ifidx);
562 return;
563 }
564
565 if (type) {
566 enum nl80211_channel_type ch_type = nla_get_u32(type);
567
568 wpa_printf(MSG_DEBUG, "nl80211: Channel type: %d", ch_type);
569 switch (ch_type) {
570 case NL80211_CHAN_NO_HT:
571 ht_enabled = 0;
572 break;
573 case NL80211_CHAN_HT20:
574 break;
575 case NL80211_CHAN_HT40PLUS:
576 chan_offset = 1;
577 break;
578 case NL80211_CHAN_HT40MINUS:
579 chan_offset = -1;
580 break;
581 }
582 } else if (bw && cf1) {
583 /* This can happen for example with VHT80 ch switch */
584 chan_offset = calculate_chan_offset(nla_get_u32(bw),
585 nla_get_u32(freq),
586 nla_get_u32(cf1),
587 cf2 ? nla_get_u32(cf2) : 0);
588 } else {
589 wpa_printf(MSG_WARNING, "nl80211: Unknown secondary channel information - following channel definition calculations may fail");
590 }
591
592 os_memset(&data, 0, sizeof(data));
593 data.ch_switch.freq = nla_get_u32(freq);
594 data.ch_switch.ht_enabled = ht_enabled;
595 data.ch_switch.ch_offset = chan_offset;
596 if (bw)
597 data.ch_switch.ch_width = convert2width(nla_get_u32(bw));
598 if (cf1)
599 data.ch_switch.cf1 = nla_get_u32(cf1);
600 if (cf2)
601 data.ch_switch.cf2 = nla_get_u32(cf2);
602
603 if (finished)
604 bss->freq = data.ch_switch.freq;
605 drv->assoc_freq = data.ch_switch.freq;
606
607 wpa_supplicant_event(bss->ctx, finished ?
608 EVENT_CH_SWITCH : EVENT_CH_SWITCH_STARTED, &data);
609 }
610
611
612 static void mlme_timeout_event(struct wpa_driver_nl80211_data *drv,
613 enum nl80211_commands cmd, struct nlattr *addr)
614 {
615 union wpa_event_data event;
616 enum wpa_event_type ev;
617
618 if (nla_len(addr) != ETH_ALEN)
619 return;
620
621 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d; timeout with " MACSTR,
622 cmd, MAC2STR((u8 *) nla_data(addr)));
623
624 if (cmd == NL80211_CMD_AUTHENTICATE)
625 ev = EVENT_AUTH_TIMED_OUT;
626 else if (cmd == NL80211_CMD_ASSOCIATE)
627 ev = EVENT_ASSOC_TIMED_OUT;
628 else
629 return;
630
631 os_memset(&event, 0, sizeof(event));
632 os_memcpy(event.timeout_event.addr, nla_data(addr), ETH_ALEN);
633 wpa_supplicant_event(drv->ctx, ev, &event);
634 }
635
636
637 static void mlme_event_mgmt(struct i802_bss *bss,
638 struct nlattr *freq, struct nlattr *sig,
639 const u8 *frame, size_t len)
640 {
641 struct wpa_driver_nl80211_data *drv = bss->drv;
642 const struct ieee80211_mgmt *mgmt;
643 union wpa_event_data event;
644 u16 fc, stype;
645 int ssi_signal = 0;
646 int rx_freq = 0;
647
648 wpa_printf(MSG_MSGDUMP, "nl80211: Frame event");
649 mgmt = (const struct ieee80211_mgmt *) frame;
650 if (len < 24) {
651 wpa_printf(MSG_DEBUG, "nl80211: Too short management frame");
652 return;
653 }
654
655 fc = le_to_host16(mgmt->frame_control);
656 stype = WLAN_FC_GET_STYPE(fc);
657
658 if (sig)
659 ssi_signal = (s32) nla_get_u32(sig);
660
661 os_memset(&event, 0, sizeof(event));
662 if (freq) {
663 event.rx_mgmt.freq = nla_get_u32(freq);
664 rx_freq = drv->last_mgmt_freq = event.rx_mgmt.freq;
665 }
666 wpa_printf(MSG_DEBUG,
667 "nl80211: RX frame da=" MACSTR " sa=" MACSTR " bssid=" MACSTR
668 " freq=%d ssi_signal=%d fc=0x%x seq_ctrl=0x%x stype=%u (%s) len=%u",
669 MAC2STR(mgmt->da), MAC2STR(mgmt->sa), MAC2STR(mgmt->bssid),
670 rx_freq, ssi_signal, fc,
671 le_to_host16(mgmt->seq_ctrl), stype, fc2str(fc),
672 (unsigned int) len);
673 event.rx_mgmt.frame = frame;
674 event.rx_mgmt.frame_len = len;
675 event.rx_mgmt.ssi_signal = ssi_signal;
676 event.rx_mgmt.drv_priv = bss;
677 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
678 }
679
680
681 static void mlme_event_mgmt_tx_status(struct wpa_driver_nl80211_data *drv,
682 struct nlattr *cookie, const u8 *frame,
683 size_t len, struct nlattr *ack)
684 {
685 union wpa_event_data event;
686 const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *) frame;
687 u16 fc = le_to_host16(hdr->frame_control);
688 u64 cookie_val = 0;
689
690 if (cookie)
691 cookie_val = nla_get_u64(cookie);
692 wpa_printf(MSG_DEBUG,
693 "nl80211: Frame TX status event A1=" MACSTR
694 " %sstype=%d cookie=0x%llx%s ack=%d",
695 MAC2STR(hdr->addr1),
696 WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT ? "not-mgmt " : "",
697 WLAN_FC_GET_STYPE(fc), (long long unsigned int) cookie_val,
698 cookie ? "" : "(N/A)", ack != NULL);
699
700 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT)
701 return;
702
703 if (!is_ap_interface(drv->nlmode) &&
704 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
705 if (!cookie)
706 return;
707
708 wpa_printf(MSG_DEBUG,
709 "nl80211: Frame TX status: cookie=0x%llx%s (ack=%d)",
710 (long long unsigned int) cookie_val,
711 cookie_val == drv->send_frame_cookie ?
712 " (match)" : " (unknown)", ack != NULL);
713 if (cookie_val != drv->send_frame_cookie)
714 return;
715 } else if (!is_ap_interface(drv->nlmode) &&
716 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_AUTH) {
717 wpa_printf(MSG_DEBUG,
718 "nl80211: Authentication frame TX status: ack=%d",
719 !!ack);
720 }
721
722 os_memset(&event, 0, sizeof(event));
723 event.tx_status.type = WLAN_FC_GET_TYPE(fc);
724 event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
725 event.tx_status.dst = hdr->addr1;
726 event.tx_status.data = frame;
727 event.tx_status.data_len = len;
728 event.tx_status.ack = ack != NULL;
729 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
730 }
731
732
733 static void mlme_event_deauth_disassoc(struct wpa_driver_nl80211_data *drv,
734 enum wpa_event_type type,
735 const u8 *frame, size_t len)
736 {
737 const struct ieee80211_mgmt *mgmt;
738 union wpa_event_data event;
739 const u8 *bssid = NULL;
740 u16 reason_code = 0;
741
742 if (type == EVENT_DEAUTH)
743 wpa_printf(MSG_DEBUG, "nl80211: Deauthenticate event");
744 else
745 wpa_printf(MSG_DEBUG, "nl80211: Disassociate event");
746
747 mgmt = (const struct ieee80211_mgmt *) frame;
748 if (len >= 24) {
749 bssid = mgmt->bssid;
750
751 if ((drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
752 !drv->associated &&
753 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0 &&
754 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0 &&
755 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0) {
756 /*
757 * Avoid issues with some roaming cases where
758 * disconnection event for the old AP may show up after
759 * we have started connection with the new AP.
760 * In case of locally generated event clear
761 * ignore_next_local_deauth as well, to avoid next local
762 * deauth event be wrongly ignored.
763 */
764 if (!os_memcmp(mgmt->sa, drv->first_bss->addr,
765 ETH_ALEN)) {
766 wpa_printf(MSG_DEBUG,
767 "nl80211: Received a locally generated deauth event. Clear ignore_next_local_deauth flag");
768 drv->ignore_next_local_deauth = 0;
769 } else {
770 wpa_printf(MSG_DEBUG,
771 "nl80211: Ignore deauth/disassoc event from old AP " MACSTR " when already authenticating with " MACSTR,
772 MAC2STR(bssid),
773 MAC2STR(drv->auth_attempt_bssid));
774 }
775 return;
776 }
777
778 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
779 drv->connect_reassoc && drv->associated &&
780 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0 &&
781 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0) {
782 /*
783 * Avoid issues with some roaming cases where
784 * disconnection event for the old AP may show up after
785 * we have started connection with the new AP.
786 */
787 wpa_printf(MSG_DEBUG,
788 "nl80211: Ignore deauth/disassoc event from old AP "
789 MACSTR
790 " when already connecting with " MACSTR,
791 MAC2STR(bssid),
792 MAC2STR(drv->auth_attempt_bssid));
793 return;
794 }
795
796 if (drv->associated != 0 &&
797 os_memcmp(bssid, drv->bssid, ETH_ALEN) != 0 &&
798 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0) {
799 /*
800 * We have presumably received this deauth as a
801 * response to a clear_state_mismatch() outgoing
802 * deauth. Don't let it take us offline!
803 */
804 wpa_printf(MSG_DEBUG, "nl80211: Deauth received "
805 "from Unknown BSSID " MACSTR " -- ignoring",
806 MAC2STR(bssid));
807 return;
808 }
809 }
810
811 nl80211_mark_disconnected(drv);
812 os_memset(&event, 0, sizeof(event));
813
814 /* Note: Same offset for Reason Code in both frame subtypes */
815 if (len >= 24 + sizeof(mgmt->u.deauth))
816 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
817
818 if (type == EVENT_DISASSOC) {
819 event.disassoc_info.locally_generated =
820 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
821 event.disassoc_info.addr = bssid;
822 event.disassoc_info.reason_code = reason_code;
823 if (frame + len > mgmt->u.disassoc.variable) {
824 event.disassoc_info.ie = mgmt->u.disassoc.variable;
825 event.disassoc_info.ie_len = frame + len -
826 mgmt->u.disassoc.variable;
827 }
828 } else {
829 event.deauth_info.locally_generated =
830 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
831 if (drv->ignore_deauth_event) {
832 wpa_printf(MSG_DEBUG, "nl80211: Ignore deauth event due to previous forced deauth-during-auth");
833 drv->ignore_deauth_event = 0;
834 if (event.deauth_info.locally_generated)
835 drv->ignore_next_local_deauth = 0;
836 return;
837 }
838 if (drv->ignore_next_local_deauth) {
839 drv->ignore_next_local_deauth = 0;
840 if (event.deauth_info.locally_generated) {
841 wpa_printf(MSG_DEBUG, "nl80211: Ignore deauth event triggered due to own deauth request");
842 return;
843 }
844 wpa_printf(MSG_WARNING, "nl80211: Was expecting local deauth but got another disconnect event first");
845 }
846 event.deauth_info.addr = bssid;
847 event.deauth_info.reason_code = reason_code;
848 if (frame + len > mgmt->u.deauth.variable) {
849 event.deauth_info.ie = mgmt->u.deauth.variable;
850 event.deauth_info.ie_len = frame + len -
851 mgmt->u.deauth.variable;
852 }
853 }
854
855 wpa_supplicant_event(drv->ctx, type, &event);
856 }
857
858
859 static void mlme_event_unprot_disconnect(struct wpa_driver_nl80211_data *drv,
860 enum wpa_event_type type,
861 const u8 *frame, size_t len)
862 {
863 const struct ieee80211_mgmt *mgmt;
864 union wpa_event_data event;
865 u16 reason_code = 0;
866
867 if (type == EVENT_UNPROT_DEAUTH)
868 wpa_printf(MSG_DEBUG, "nl80211: Unprot Deauthenticate event");
869 else
870 wpa_printf(MSG_DEBUG, "nl80211: Unprot Disassociate event");
871
872 if (len < 24)
873 return;
874
875 mgmt = (const struct ieee80211_mgmt *) frame;
876
877 os_memset(&event, 0, sizeof(event));
878 /* Note: Same offset for Reason Code in both frame subtypes */
879 if (len >= 24 + sizeof(mgmt->u.deauth))
880 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
881
882 if (type == EVENT_UNPROT_DISASSOC) {
883 event.unprot_disassoc.sa = mgmt->sa;
884 event.unprot_disassoc.da = mgmt->da;
885 event.unprot_disassoc.reason_code = reason_code;
886 } else {
887 event.unprot_deauth.sa = mgmt->sa;
888 event.unprot_deauth.da = mgmt->da;
889 event.unprot_deauth.reason_code = reason_code;
890 }
891
892 wpa_supplicant_event(drv->ctx, type, &event);
893 }
894
895
896 static void mlme_event(struct i802_bss *bss,
897 enum nl80211_commands cmd, struct nlattr *frame,
898 struct nlattr *addr, struct nlattr *timed_out,
899 struct nlattr *freq, struct nlattr *ack,
900 struct nlattr *cookie, struct nlattr *sig,
901 struct nlattr *wmm, struct nlattr *req_ie)
902 {
903 struct wpa_driver_nl80211_data *drv = bss->drv;
904 const u8 *data;
905 size_t len;
906
907 if (timed_out && addr) {
908 mlme_timeout_event(drv, cmd, addr);
909 return;
910 }
911
912 if (frame == NULL) {
913 wpa_printf(MSG_DEBUG,
914 "nl80211: MLME event %d (%s) without frame data",
915 cmd, nl80211_command_to_string(cmd));
916 return;
917 }
918
919 data = nla_data(frame);
920 len = nla_len(frame);
921 if (len < 4 + 2 * ETH_ALEN) {
922 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s("
923 MACSTR ") - too short",
924 cmd, nl80211_command_to_string(cmd), bss->ifname,
925 MAC2STR(bss->addr));
926 return;
927 }
928 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s(" MACSTR
929 ") A1=" MACSTR " A2=" MACSTR, cmd,
930 nl80211_command_to_string(cmd), bss->ifname,
931 MAC2STR(bss->addr), MAC2STR(data + 4),
932 MAC2STR(data + 4 + ETH_ALEN));
933 if (cmd != NL80211_CMD_FRAME_TX_STATUS && !(data[4] & 0x01) &&
934 os_memcmp(bss->addr, data + 4, ETH_ALEN) != 0 &&
935 (is_zero_ether_addr(bss->rand_addr) ||
936 os_memcmp(bss->rand_addr, data + 4, ETH_ALEN) != 0) &&
937 os_memcmp(bss->addr, data + 4 + ETH_ALEN, ETH_ALEN) != 0) {
938 wpa_printf(MSG_MSGDUMP, "nl80211: %s: Ignore MLME frame event "
939 "for foreign address", bss->ifname);
940 return;
941 }
942 wpa_hexdump(MSG_MSGDUMP, "nl80211: MLME event frame",
943 nla_data(frame), nla_len(frame));
944
945 switch (cmd) {
946 case NL80211_CMD_AUTHENTICATE:
947 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
948 break;
949 case NL80211_CMD_ASSOCIATE:
950 mlme_event_assoc(drv, nla_data(frame), nla_len(frame), wmm,
951 req_ie);
952 break;
953 case NL80211_CMD_DEAUTHENTICATE:
954 mlme_event_deauth_disassoc(drv, EVENT_DEAUTH,
955 nla_data(frame), nla_len(frame));
956 break;
957 case NL80211_CMD_DISASSOCIATE:
958 mlme_event_deauth_disassoc(drv, EVENT_DISASSOC,
959 nla_data(frame), nla_len(frame));
960 break;
961 case NL80211_CMD_FRAME:
962 mlme_event_mgmt(bss, freq, sig, nla_data(frame),
963 nla_len(frame));
964 break;
965 case NL80211_CMD_FRAME_TX_STATUS:
966 mlme_event_mgmt_tx_status(drv, cookie, nla_data(frame),
967 nla_len(frame), ack);
968 break;
969 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
970 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DEAUTH,
971 nla_data(frame), nla_len(frame));
972 break;
973 case NL80211_CMD_UNPROT_DISASSOCIATE:
974 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DISASSOC,
975 nla_data(frame), nla_len(frame));
976 break;
977 default:
978 break;
979 }
980 }
981
982
983 static void mlme_event_michael_mic_failure(struct i802_bss *bss,
984 struct nlattr *tb[])
985 {
986 union wpa_event_data data;
987
988 wpa_printf(MSG_DEBUG, "nl80211: MLME event Michael MIC failure");
989 os_memset(&data, 0, sizeof(data));
990 if (tb[NL80211_ATTR_MAC]) {
991 wpa_hexdump(MSG_DEBUG, "nl80211: Source MAC address",
992 nla_data(tb[NL80211_ATTR_MAC]),
993 nla_len(tb[NL80211_ATTR_MAC]));
994 data.michael_mic_failure.src = nla_data(tb[NL80211_ATTR_MAC]);
995 }
996 if (tb[NL80211_ATTR_KEY_SEQ]) {
997 wpa_hexdump(MSG_DEBUG, "nl80211: TSC",
998 nla_data(tb[NL80211_ATTR_KEY_SEQ]),
999 nla_len(tb[NL80211_ATTR_KEY_SEQ]));
1000 }
1001 if (tb[NL80211_ATTR_KEY_TYPE]) {
1002 enum nl80211_key_type key_type =
1003 nla_get_u32(tb[NL80211_ATTR_KEY_TYPE]);
1004 wpa_printf(MSG_DEBUG, "nl80211: Key Type %d", key_type);
1005 if (key_type == NL80211_KEYTYPE_PAIRWISE)
1006 data.michael_mic_failure.unicast = 1;
1007 } else
1008 data.michael_mic_failure.unicast = 1;
1009
1010 if (tb[NL80211_ATTR_KEY_IDX]) {
1011 u8 key_id = nla_get_u8(tb[NL80211_ATTR_KEY_IDX]);
1012 wpa_printf(MSG_DEBUG, "nl80211: Key Id %d", key_id);
1013 }
1014
1015 wpa_supplicant_event(bss->ctx, EVENT_MICHAEL_MIC_FAILURE, &data);
1016 }
1017
1018
1019 static void mlme_event_join_ibss(struct wpa_driver_nl80211_data *drv,
1020 struct nlattr *tb[])
1021 {
1022 unsigned int freq;
1023 union wpa_event_data event;
1024
1025 if (tb[NL80211_ATTR_MAC] == NULL) {
1026 wpa_printf(MSG_DEBUG, "nl80211: No address in IBSS joined "
1027 "event");
1028 return;
1029 }
1030 os_memcpy(drv->bssid, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1031
1032 drv->associated = 1;
1033 wpa_printf(MSG_DEBUG, "nl80211: IBSS " MACSTR " joined",
1034 MAC2STR(drv->bssid));
1035
1036 freq = nl80211_get_assoc_freq(drv);
1037 if (freq) {
1038 wpa_printf(MSG_DEBUG, "nl80211: IBSS on frequency %u MHz",
1039 freq);
1040 drv->first_bss->freq = freq;
1041 }
1042
1043 os_memset(&event, 0, sizeof(event));
1044 event.assoc_info.freq = freq;
1045
1046 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1047 }
1048
1049
1050 static void mlme_event_remain_on_channel(struct wpa_driver_nl80211_data *drv,
1051 int cancel_event, struct nlattr *tb[])
1052 {
1053 unsigned int freq, chan_type, duration;
1054 union wpa_event_data data;
1055 u64 cookie;
1056
1057 if (tb[NL80211_ATTR_WIPHY_FREQ])
1058 freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1059 else
1060 freq = 0;
1061
1062 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])
1063 chan_type = nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1064 else
1065 chan_type = 0;
1066
1067 if (tb[NL80211_ATTR_DURATION])
1068 duration = nla_get_u32(tb[NL80211_ATTR_DURATION]);
1069 else
1070 duration = 0;
1071
1072 if (tb[NL80211_ATTR_COOKIE])
1073 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
1074 else
1075 cookie = 0;
1076
1077 wpa_printf(MSG_DEBUG, "nl80211: Remain-on-channel event (cancel=%d "
1078 "freq=%u channel_type=%u duration=%u cookie=0x%llx (%s))",
1079 cancel_event, freq, chan_type, duration,
1080 (long long unsigned int) cookie,
1081 cookie == drv->remain_on_chan_cookie ? "match" : "unknown");
1082
1083 if (cookie != drv->remain_on_chan_cookie)
1084 return; /* not for us */
1085
1086 if (cancel_event)
1087 drv->pending_remain_on_chan = 0;
1088
1089 os_memset(&data, 0, sizeof(data));
1090 data.remain_on_channel.freq = freq;
1091 data.remain_on_channel.duration = duration;
1092 wpa_supplicant_event(drv->ctx, cancel_event ?
1093 EVENT_CANCEL_REMAIN_ON_CHANNEL :
1094 EVENT_REMAIN_ON_CHANNEL, &data);
1095 }
1096
1097
1098 static void mlme_event_ft_event(struct wpa_driver_nl80211_data *drv,
1099 struct nlattr *tb[])
1100 {
1101 union wpa_event_data data;
1102
1103 os_memset(&data, 0, sizeof(data));
1104
1105 if (tb[NL80211_ATTR_IE]) {
1106 data.ft_ies.ies = nla_data(tb[NL80211_ATTR_IE]);
1107 data.ft_ies.ies_len = nla_len(tb[NL80211_ATTR_IE]);
1108 }
1109
1110 if (tb[NL80211_ATTR_IE_RIC]) {
1111 data.ft_ies.ric_ies = nla_data(tb[NL80211_ATTR_IE_RIC]);
1112 data.ft_ies.ric_ies_len = nla_len(tb[NL80211_ATTR_IE_RIC]);
1113 }
1114
1115 if (tb[NL80211_ATTR_MAC])
1116 os_memcpy(data.ft_ies.target_ap,
1117 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1118
1119 wpa_printf(MSG_DEBUG, "nl80211: FT event target_ap " MACSTR,
1120 MAC2STR(data.ft_ies.target_ap));
1121
1122 wpa_supplicant_event(drv->ctx, EVENT_FT_RESPONSE, &data);
1123 }
1124
1125
1126 static void mlme_event_dh_event(struct wpa_driver_nl80211_data *drv,
1127 struct i802_bss *bss,
1128 struct nlattr *tb[])
1129 {
1130 union wpa_event_data data;
1131
1132 if (!is_ap_interface(drv->nlmode))
1133 return;
1134 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_IE])
1135 return;
1136
1137 os_memset(&data, 0, sizeof(data));
1138 data.update_dh.peer = nla_data(tb[NL80211_ATTR_MAC]);
1139 data.update_dh.ie = nla_data(tb[NL80211_ATTR_IE]);
1140 data.update_dh.ie_len = nla_len(tb[NL80211_ATTR_IE]);
1141
1142 wpa_printf(MSG_DEBUG, "nl80211: DH event - peer " MACSTR,
1143 MAC2STR(data.update_dh.peer));
1144
1145 wpa_supplicant_event(bss->ctx, EVENT_UPDATE_DH, &data);
1146 }
1147
1148
1149 static void send_scan_event(struct wpa_driver_nl80211_data *drv, int aborted,
1150 struct nlattr *tb[], int external_scan)
1151 {
1152 union wpa_event_data event;
1153 struct nlattr *nl;
1154 int rem;
1155 struct scan_info *info;
1156 #define MAX_REPORT_FREQS 50
1157 int freqs[MAX_REPORT_FREQS];
1158 int num_freqs = 0;
1159
1160 if (!external_scan && drv->scan_for_auth) {
1161 drv->scan_for_auth = 0;
1162 wpa_printf(MSG_DEBUG, "nl80211: Scan results for missing "
1163 "cfg80211 BSS entry");
1164 wpa_driver_nl80211_authenticate_retry(drv);
1165 return;
1166 }
1167
1168 os_memset(&event, 0, sizeof(event));
1169 info = &event.scan_info;
1170 info->aborted = aborted;
1171 info->external_scan = external_scan;
1172 info->nl_scan_event = 1;
1173
1174 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
1175 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_SSIDS], rem) {
1176 struct wpa_driver_scan_ssid *s =
1177 &info->ssids[info->num_ssids];
1178 s->ssid = nla_data(nl);
1179 s->ssid_len = nla_len(nl);
1180 wpa_printf(MSG_DEBUG, "nl80211: Scan probed for SSID '%s'",
1181 wpa_ssid_txt(s->ssid, s->ssid_len));
1182 info->num_ssids++;
1183 if (info->num_ssids == WPAS_MAX_SCAN_SSIDS)
1184 break;
1185 }
1186 }
1187 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
1188 char msg[300], *pos, *end;
1189 int res;
1190
1191 pos = msg;
1192 end = pos + sizeof(msg);
1193 *pos = '\0';
1194
1195 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem)
1196 {
1197 freqs[num_freqs] = nla_get_u32(nl);
1198 res = os_snprintf(pos, end - pos, " %d",
1199 freqs[num_freqs]);
1200 if (!os_snprintf_error(end - pos, res))
1201 pos += res;
1202 num_freqs++;
1203 if (num_freqs == MAX_REPORT_FREQS - 1)
1204 break;
1205 }
1206 info->freqs = freqs;
1207 info->num_freqs = num_freqs;
1208 wpa_printf(MSG_DEBUG, "nl80211: Scan included frequencies:%s",
1209 msg);
1210 }
1211
1212 if (tb[NL80211_ATTR_SCAN_START_TIME_TSF] &&
1213 tb[NL80211_ATTR_SCAN_START_TIME_TSF_BSSID]) {
1214 info->scan_start_tsf =
1215 nla_get_u64(tb[NL80211_ATTR_SCAN_START_TIME_TSF]);
1216 os_memcpy(info->scan_start_tsf_bssid,
1217 nla_data(tb[NL80211_ATTR_SCAN_START_TIME_TSF_BSSID]),
1218 ETH_ALEN);
1219 }
1220
1221 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
1222 }
1223
1224
1225 static void nl80211_cqm_event(struct wpa_driver_nl80211_data *drv,
1226 struct nlattr *tb[])
1227 {
1228 static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
1229 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
1230 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U8 },
1231 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
1232 [NL80211_ATTR_CQM_PKT_LOSS_EVENT] = { .type = NLA_U32 },
1233 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
1234 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
1235 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
1236 [NL80211_ATTR_CQM_BEACON_LOSS_EVENT] = { .type = NLA_FLAG },
1237 };
1238 struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
1239 enum nl80211_cqm_rssi_threshold_event event;
1240 union wpa_event_data ed;
1241 struct wpa_signal_info sig;
1242 int res;
1243
1244 if (tb[NL80211_ATTR_CQM] == NULL ||
1245 nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, tb[NL80211_ATTR_CQM],
1246 cqm_policy)) {
1247 wpa_printf(MSG_DEBUG, "nl80211: Ignore invalid CQM event");
1248 return;
1249 }
1250
1251 os_memset(&ed, 0, sizeof(ed));
1252
1253 if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]) {
1254 if (!tb[NL80211_ATTR_MAC])
1255 return;
1256 os_memcpy(ed.low_ack.addr, nla_data(tb[NL80211_ATTR_MAC]),
1257 ETH_ALEN);
1258 ed.low_ack.num_packets =
1259 nla_get_u32(cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]);
1260 wpa_printf(MSG_DEBUG, "nl80211: Packet loss event for " MACSTR
1261 " (num_packets %u)",
1262 MAC2STR(ed.low_ack.addr), ed.low_ack.num_packets);
1263 wpa_supplicant_event(drv->ctx, EVENT_STATION_LOW_ACK, &ed);
1264 return;
1265 }
1266
1267 if (cqm[NL80211_ATTR_CQM_BEACON_LOSS_EVENT]) {
1268 wpa_printf(MSG_DEBUG, "nl80211: Beacon loss event");
1269 wpa_supplicant_event(drv->ctx, EVENT_BEACON_LOSS, NULL);
1270 return;
1271 }
1272
1273 if (cqm[NL80211_ATTR_CQM_TXE_RATE] &&
1274 cqm[NL80211_ATTR_CQM_TXE_PKTS] &&
1275 cqm[NL80211_ATTR_CQM_TXE_INTVL] &&
1276 cqm[NL80211_ATTR_MAC]) {
1277 wpa_printf(MSG_DEBUG, "nl80211: CQM TXE event for " MACSTR
1278 " (rate: %u pkts: %u interval: %u)",
1279 MAC2STR((u8 *) nla_data(cqm[NL80211_ATTR_MAC])),
1280 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_RATE]),
1281 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_PKTS]),
1282 nla_get_u32(cqm[NL80211_ATTR_CQM_TXE_INTVL]));
1283 return;
1284 }
1285
1286 if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] == NULL) {
1287 wpa_printf(MSG_DEBUG,
1288 "nl80211: Not a CQM RSSI threshold event");
1289 return;
1290 }
1291 event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
1292
1293 if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH) {
1294 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
1295 "event: RSSI high");
1296 ed.signal_change.above_threshold = 1;
1297 } else if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW) {
1298 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
1299 "event: RSSI low");
1300 ed.signal_change.above_threshold = 0;
1301 } else {
1302 wpa_printf(MSG_DEBUG,
1303 "nl80211: Unknown CQM RSSI threshold event: %d",
1304 event);
1305 return;
1306 }
1307
1308 res = nl80211_get_link_signal(drv, &sig);
1309 if (res == 0) {
1310 ed.signal_change.current_signal = sig.current_signal;
1311 ed.signal_change.current_txrate = sig.current_txrate;
1312 wpa_printf(MSG_DEBUG, "nl80211: Signal: %d dBm txrate: %d",
1313 sig.current_signal, sig.current_txrate);
1314 }
1315
1316 res = nl80211_get_link_noise(drv, &sig);
1317 if (res == 0) {
1318 ed.signal_change.current_noise = sig.current_noise;
1319 wpa_printf(MSG_DEBUG, "nl80211: Noise: %d dBm",
1320 sig.current_noise);
1321 }
1322
1323 wpa_supplicant_event(drv->ctx, EVENT_SIGNAL_CHANGE, &ed);
1324 }
1325
1326
1327 static void nl80211_new_peer_candidate(struct wpa_driver_nl80211_data *drv,
1328 struct nlattr **tb)
1329 {
1330 const u8 *addr;
1331 union wpa_event_data data;
1332
1333 if (drv->nlmode != NL80211_IFTYPE_MESH_POINT ||
1334 !tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_IE])
1335 return;
1336
1337 addr = nla_data(tb[NL80211_ATTR_MAC]);
1338 wpa_printf(MSG_DEBUG, "nl80211: New peer candidate " MACSTR,
1339 MAC2STR(addr));
1340
1341 os_memset(&data, 0, sizeof(data));
1342 data.mesh_peer.peer = addr;
1343 data.mesh_peer.ies = nla_data(tb[NL80211_ATTR_IE]);
1344 data.mesh_peer.ie_len = nla_len(tb[NL80211_ATTR_IE]);
1345 wpa_supplicant_event(drv->ctx, EVENT_NEW_PEER_CANDIDATE, &data);
1346 }
1347
1348
1349 static void nl80211_new_station_event(struct wpa_driver_nl80211_data *drv,
1350 struct i802_bss *bss,
1351 struct nlattr **tb)
1352 {
1353 u8 *addr;
1354 union wpa_event_data data;
1355
1356 if (tb[NL80211_ATTR_MAC] == NULL)
1357 return;
1358 addr = nla_data(tb[NL80211_ATTR_MAC]);
1359 wpa_printf(MSG_DEBUG, "nl80211: New station " MACSTR, MAC2STR(addr));
1360
1361 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
1362 u8 *ies = NULL;
1363 size_t ies_len = 0;
1364 if (tb[NL80211_ATTR_IE]) {
1365 ies = nla_data(tb[NL80211_ATTR_IE]);
1366 ies_len = nla_len(tb[NL80211_ATTR_IE]);
1367 }
1368 wpa_hexdump(MSG_DEBUG, "nl80211: Assoc Req IEs", ies, ies_len);
1369 drv_event_assoc(bss->ctx, addr, ies, ies_len, 0);
1370 return;
1371 }
1372
1373 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
1374 return;
1375
1376 os_memset(&data, 0, sizeof(data));
1377 os_memcpy(data.ibss_rsn_start.peer, addr, ETH_ALEN);
1378 wpa_supplicant_event(bss->ctx, EVENT_IBSS_RSN_START, &data);
1379 }
1380
1381
1382 static void nl80211_del_station_event(struct wpa_driver_nl80211_data *drv,
1383 struct i802_bss *bss,
1384 struct nlattr **tb)
1385 {
1386 u8 *addr;
1387 union wpa_event_data data;
1388
1389 if (tb[NL80211_ATTR_MAC] == NULL)
1390 return;
1391 addr = nla_data(tb[NL80211_ATTR_MAC]);
1392 wpa_printf(MSG_DEBUG, "nl80211: Delete station " MACSTR,
1393 MAC2STR(addr));
1394
1395 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
1396 drv_event_disassoc(bss->ctx, addr);
1397 return;
1398 }
1399
1400 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
1401 return;
1402
1403 os_memset(&data, 0, sizeof(data));
1404 os_memcpy(data.ibss_peer_lost.peer, addr, ETH_ALEN);
1405 wpa_supplicant_event(bss->ctx, EVENT_IBSS_PEER_LOST, &data);
1406 }
1407
1408
1409 static void nl80211_rekey_offload_event(struct wpa_driver_nl80211_data *drv,
1410 struct nlattr **tb)
1411 {
1412 struct nlattr *rekey_info[NUM_NL80211_REKEY_DATA];
1413 static struct nla_policy rekey_policy[NUM_NL80211_REKEY_DATA] = {
1414 [NL80211_REKEY_DATA_KEK] = {
1415 .minlen = NL80211_KEK_LEN,
1416 .maxlen = NL80211_KEK_LEN,
1417 },
1418 [NL80211_REKEY_DATA_KCK] = {
1419 .minlen = NL80211_KCK_LEN,
1420 .maxlen = NL80211_KCK_LEN,
1421 },
1422 [NL80211_REKEY_DATA_REPLAY_CTR] = {
1423 .minlen = NL80211_REPLAY_CTR_LEN,
1424 .maxlen = NL80211_REPLAY_CTR_LEN,
1425 },
1426 };
1427 union wpa_event_data data;
1428
1429 if (!tb[NL80211_ATTR_MAC] ||
1430 !tb[NL80211_ATTR_REKEY_DATA] ||
1431 nla_parse_nested(rekey_info, MAX_NL80211_REKEY_DATA,
1432 tb[NL80211_ATTR_REKEY_DATA], rekey_policy) ||
1433 !rekey_info[NL80211_REKEY_DATA_REPLAY_CTR])
1434 return;
1435
1436 os_memset(&data, 0, sizeof(data));
1437 data.driver_gtk_rekey.bssid = nla_data(tb[NL80211_ATTR_MAC]);
1438 wpa_printf(MSG_DEBUG, "nl80211: Rekey offload event for BSSID " MACSTR,
1439 MAC2STR(data.driver_gtk_rekey.bssid));
1440 data.driver_gtk_rekey.replay_ctr =
1441 nla_data(rekey_info[NL80211_REKEY_DATA_REPLAY_CTR]);
1442 wpa_hexdump(MSG_DEBUG, "nl80211: Rekey offload - Replay Counter",
1443 data.driver_gtk_rekey.replay_ctr, NL80211_REPLAY_CTR_LEN);
1444 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_GTK_REKEY, &data);
1445 }
1446
1447
1448 static void nl80211_pmksa_candidate_event(struct wpa_driver_nl80211_data *drv,
1449 struct nlattr **tb)
1450 {
1451 struct nlattr *cand[NUM_NL80211_PMKSA_CANDIDATE];
1452 static struct nla_policy cand_policy[NUM_NL80211_PMKSA_CANDIDATE] = {
1453 [NL80211_PMKSA_CANDIDATE_INDEX] = { .type = NLA_U32 },
1454 [NL80211_PMKSA_CANDIDATE_BSSID] = {
1455 .minlen = ETH_ALEN,
1456 .maxlen = ETH_ALEN,
1457 },
1458 [NL80211_PMKSA_CANDIDATE_PREAUTH] = { .type = NLA_FLAG },
1459 };
1460 union wpa_event_data data;
1461
1462 wpa_printf(MSG_DEBUG, "nl80211: PMKSA candidate event");
1463
1464 if (!tb[NL80211_ATTR_PMKSA_CANDIDATE] ||
1465 nla_parse_nested(cand, MAX_NL80211_PMKSA_CANDIDATE,
1466 tb[NL80211_ATTR_PMKSA_CANDIDATE], cand_policy) ||
1467 !cand[NL80211_PMKSA_CANDIDATE_INDEX] ||
1468 !cand[NL80211_PMKSA_CANDIDATE_BSSID])
1469 return;
1470
1471 os_memset(&data, 0, sizeof(data));
1472 os_memcpy(data.pmkid_candidate.bssid,
1473 nla_data(cand[NL80211_PMKSA_CANDIDATE_BSSID]), ETH_ALEN);
1474 data.pmkid_candidate.index =
1475 nla_get_u32(cand[NL80211_PMKSA_CANDIDATE_INDEX]);
1476 data.pmkid_candidate.preauth =
1477 cand[NL80211_PMKSA_CANDIDATE_PREAUTH] != NULL;
1478 wpa_supplicant_event(drv->ctx, EVENT_PMKID_CANDIDATE, &data);
1479 }
1480
1481
1482 static void nl80211_client_probe_event(struct wpa_driver_nl80211_data *drv,
1483 struct nlattr **tb)
1484 {
1485 union wpa_event_data data;
1486 const u8 *addr;
1487 u64 cookie = 0;
1488
1489 addr = nla_data(tb[NL80211_ATTR_MAC]);
1490 if (!addr)
1491 return;
1492 if (tb[NL80211_ATTR_COOKIE])
1493 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
1494 wpa_printf(MSG_DEBUG, "nl80211: Probe client event (addr=" MACSTR
1495 " ack=%d cookie=%llu)", MAC2STR(addr),
1496 tb[NL80211_ATTR_ACK] != NULL,
1497 (long long unsigned int) cookie);
1498 if (!tb[NL80211_ATTR_ACK])
1499 return;
1500
1501 os_memset(&data, 0, sizeof(data));
1502 os_memcpy(data.client_poll.addr, addr, ETH_ALEN);
1503 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_CLIENT_POLL_OK, &data);
1504 }
1505
1506
1507 static void nl80211_tdls_oper_event(struct wpa_driver_nl80211_data *drv,
1508 struct nlattr **tb)
1509 {
1510 union wpa_event_data data;
1511
1512 wpa_printf(MSG_DEBUG, "nl80211: TDLS operation event");
1513
1514 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_TDLS_OPERATION])
1515 return;
1516
1517 os_memset(&data, 0, sizeof(data));
1518 os_memcpy(data.tdls.peer, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1519 switch (nla_get_u8(tb[NL80211_ATTR_TDLS_OPERATION])) {
1520 case NL80211_TDLS_SETUP:
1521 wpa_printf(MSG_DEBUG, "nl80211: TDLS setup request for peer "
1522 MACSTR, MAC2STR(data.tdls.peer));
1523 data.tdls.oper = TDLS_REQUEST_SETUP;
1524 break;
1525 case NL80211_TDLS_TEARDOWN:
1526 wpa_printf(MSG_DEBUG, "nl80211: TDLS teardown request for peer "
1527 MACSTR, MAC2STR(data.tdls.peer));
1528 data.tdls.oper = TDLS_REQUEST_TEARDOWN;
1529 break;
1530 case NL80211_TDLS_DISCOVERY_REQ:
1531 wpa_printf(MSG_DEBUG,
1532 "nl80211: TDLS discovery request for peer " MACSTR,
1533 MAC2STR(data.tdls.peer));
1534 data.tdls.oper = TDLS_REQUEST_DISCOVER;
1535 break;
1536 default:
1537 wpa_printf(MSG_DEBUG, "nl80211: Unsupported TDLS operatione "
1538 "event");
1539 return;
1540 }
1541 if (tb[NL80211_ATTR_REASON_CODE]) {
1542 data.tdls.reason_code =
1543 nla_get_u16(tb[NL80211_ATTR_REASON_CODE]);
1544 }
1545
1546 wpa_supplicant_event(drv->ctx, EVENT_TDLS, &data);
1547 }
1548
1549
1550 static void nl80211_stop_ap(struct wpa_driver_nl80211_data *drv,
1551 struct nlattr **tb)
1552 {
1553 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_UNAVAILABLE, NULL);
1554 }
1555
1556
1557 static void nl80211_connect_failed_event(struct wpa_driver_nl80211_data *drv,
1558 struct nlattr **tb)
1559 {
1560 union wpa_event_data data;
1561 u32 reason;
1562
1563 wpa_printf(MSG_DEBUG, "nl80211: Connect failed event");
1564
1565 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_CONN_FAILED_REASON])
1566 return;
1567
1568 os_memset(&data, 0, sizeof(data));
1569 os_memcpy(data.connect_failed_reason.addr,
1570 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1571
1572 reason = nla_get_u32(tb[NL80211_ATTR_CONN_FAILED_REASON]);
1573 switch (reason) {
1574 case NL80211_CONN_FAIL_MAX_CLIENTS:
1575 wpa_printf(MSG_DEBUG, "nl80211: Max client reached");
1576 data.connect_failed_reason.code = MAX_CLIENT_REACHED;
1577 break;
1578 case NL80211_CONN_FAIL_BLOCKED_CLIENT:
1579 wpa_printf(MSG_DEBUG, "nl80211: Blocked client " MACSTR
1580 " tried to connect",
1581 MAC2STR(data.connect_failed_reason.addr));
1582 data.connect_failed_reason.code = BLOCKED_CLIENT;
1583 break;
1584 default:
1585 wpa_printf(MSG_DEBUG, "nl8021l: Unknown connect failed reason "
1586 "%u", reason);
1587 return;
1588 }
1589
1590 wpa_supplicant_event(drv->ctx, EVENT_CONNECT_FAILED_REASON, &data);
1591 }
1592
1593
1594 static void nl80211_radar_event(struct wpa_driver_nl80211_data *drv,
1595 struct nlattr **tb)
1596 {
1597 union wpa_event_data data;
1598 enum nl80211_radar_event event_type;
1599
1600 if (!tb[NL80211_ATTR_WIPHY_FREQ] || !tb[NL80211_ATTR_RADAR_EVENT])
1601 return;
1602
1603 os_memset(&data, 0, sizeof(data));
1604 data.dfs_event.freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1605 event_type = nla_get_u32(tb[NL80211_ATTR_RADAR_EVENT]);
1606
1607 /* Check HT params */
1608 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1609 data.dfs_event.ht_enabled = 1;
1610 data.dfs_event.chan_offset = 0;
1611
1612 switch (nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
1613 case NL80211_CHAN_NO_HT:
1614 data.dfs_event.ht_enabled = 0;
1615 break;
1616 case NL80211_CHAN_HT20:
1617 break;
1618 case NL80211_CHAN_HT40PLUS:
1619 data.dfs_event.chan_offset = 1;
1620 break;
1621 case NL80211_CHAN_HT40MINUS:
1622 data.dfs_event.chan_offset = -1;
1623 break;
1624 }
1625 }
1626
1627 /* Get VHT params */
1628 if (tb[NL80211_ATTR_CHANNEL_WIDTH])
1629 data.dfs_event.chan_width =
1630 convert2width(nla_get_u32(
1631 tb[NL80211_ATTR_CHANNEL_WIDTH]));
1632 if (tb[NL80211_ATTR_CENTER_FREQ1])
1633 data.dfs_event.cf1 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
1634 if (tb[NL80211_ATTR_CENTER_FREQ2])
1635 data.dfs_event.cf2 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
1636
1637 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz, ht: %d, offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
1638 data.dfs_event.freq, data.dfs_event.ht_enabled,
1639 data.dfs_event.chan_offset, data.dfs_event.chan_width,
1640 data.dfs_event.cf1, data.dfs_event.cf2);
1641
1642 switch (event_type) {
1643 case NL80211_RADAR_DETECTED:
1644 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
1645 break;
1646 case NL80211_RADAR_CAC_FINISHED:
1647 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
1648 break;
1649 case NL80211_RADAR_CAC_ABORTED:
1650 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
1651 break;
1652 case NL80211_RADAR_NOP_FINISHED:
1653 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
1654 break;
1655 case NL80211_RADAR_PRE_CAC_EXPIRED:
1656 wpa_supplicant_event(drv->ctx, EVENT_DFS_PRE_CAC_EXPIRED,
1657 &data);
1658 break;
1659 case NL80211_RADAR_CAC_STARTED:
1660 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_STARTED, &data);
1661 break;
1662 default:
1663 wpa_printf(MSG_DEBUG, "nl80211: Unknown radar event %d "
1664 "received", event_type);
1665 break;
1666 }
1667 }
1668
1669
1670 static void nl80211_spurious_frame(struct i802_bss *bss, struct nlattr **tb,
1671 int wds)
1672 {
1673 struct wpa_driver_nl80211_data *drv = bss->drv;
1674 union wpa_event_data event;
1675
1676 if (!tb[NL80211_ATTR_MAC])
1677 return;
1678
1679 os_memset(&event, 0, sizeof(event));
1680 event.rx_from_unknown.bssid = bss->addr;
1681 event.rx_from_unknown.addr = nla_data(tb[NL80211_ATTR_MAC]);
1682 event.rx_from_unknown.wds = wds;
1683
1684 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
1685 }
1686
1687
1688 #ifdef CONFIG_DRIVER_NL80211_QCA
1689
1690 static void qca_nl80211_avoid_freq(struct wpa_driver_nl80211_data *drv,
1691 const u8 *data, size_t len)
1692 {
1693 u32 i, count;
1694 union wpa_event_data event;
1695 struct wpa_freq_range *range = NULL;
1696 const struct qca_avoid_freq_list *freq_range;
1697
1698 freq_range = (const struct qca_avoid_freq_list *) data;
1699 if (len < sizeof(freq_range->count))
1700 return;
1701
1702 count = freq_range->count;
1703 if (len < sizeof(freq_range->count) +
1704 count * sizeof(struct qca_avoid_freq_range)) {
1705 wpa_printf(MSG_DEBUG, "nl80211: Ignored too short avoid frequency list (len=%u)",
1706 (unsigned int) len);
1707 return;
1708 }
1709
1710 if (count > 0) {
1711 range = os_calloc(count, sizeof(struct wpa_freq_range));
1712 if (range == NULL)
1713 return;
1714 }
1715
1716 os_memset(&event, 0, sizeof(event));
1717 for (i = 0; i < count; i++) {
1718 unsigned int idx = event.freq_range.num;
1719 range[idx].min = freq_range->range[i].start_freq;
1720 range[idx].max = freq_range->range[i].end_freq;
1721 wpa_printf(MSG_DEBUG, "nl80211: Avoid frequency range: %u-%u",
1722 range[idx].min, range[idx].max);
1723 if (range[idx].min > range[idx].max) {
1724 wpa_printf(MSG_DEBUG, "nl80211: Ignore invalid frequency range");
1725 continue;
1726 }
1727 event.freq_range.num++;
1728 }
1729 event.freq_range.range = range;
1730
1731 wpa_supplicant_event(drv->ctx, EVENT_AVOID_FREQUENCIES, &event);
1732
1733 os_free(range);
1734 }
1735
1736
1737 static enum hostapd_hw_mode get_qca_hw_mode(u8 hw_mode)
1738 {
1739 switch (hw_mode) {
1740 case QCA_ACS_MODE_IEEE80211B:
1741 return HOSTAPD_MODE_IEEE80211B;
1742 case QCA_ACS_MODE_IEEE80211G:
1743 return HOSTAPD_MODE_IEEE80211G;
1744 case QCA_ACS_MODE_IEEE80211A:
1745 return HOSTAPD_MODE_IEEE80211A;
1746 case QCA_ACS_MODE_IEEE80211AD:
1747 return HOSTAPD_MODE_IEEE80211AD;
1748 case QCA_ACS_MODE_IEEE80211ANY:
1749 return HOSTAPD_MODE_IEEE80211ANY;
1750 default:
1751 return NUM_HOSTAPD_MODES;
1752 }
1753 }
1754
1755
1756 static unsigned int chan_2ghz_or_5ghz_to_freq(u8 chan)
1757 {
1758 if (chan >= 1 && chan <= 13)
1759 return 2407 + 5 * chan;
1760 if (chan == 14)
1761 return 2484;
1762 if (chan >= 36 && chan <= 169)
1763 return 5000 + 5 * chan;
1764
1765 return 0;
1766 }
1767
1768
1769 static void qca_nl80211_acs_select_ch(struct wpa_driver_nl80211_data *drv,
1770 const u8 *data, size_t len)
1771 {
1772 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_ACS_MAX + 1];
1773 union wpa_event_data event;
1774 u8 chan;
1775
1776 wpa_printf(MSG_DEBUG,
1777 "nl80211: ACS channel selection vendor event received");
1778
1779 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_ACS_MAX,
1780 (struct nlattr *) data, len, NULL) ||
1781 (!tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY] &&
1782 !tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_CHANNEL]) ||
1783 (!tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY] &&
1784 !tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_CHANNEL]))
1785 return;
1786
1787 os_memset(&event, 0, sizeof(event));
1788 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY]) {
1789 event.acs_selected_channels.pri_freq = nla_get_u32(
1790 tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_FREQUENCY]);
1791 } else {
1792 chan = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_PRIMARY_CHANNEL]);
1793 event.acs_selected_channels.pri_freq =
1794 chan_2ghz_or_5ghz_to_freq(chan);
1795 }
1796
1797 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY]) {
1798 event.acs_selected_channels.sec_freq = nla_get_u32(
1799 tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_FREQUENCY]);
1800 } else {
1801 chan = nla_get_u8(
1802 tb[QCA_WLAN_VENDOR_ATTR_ACS_SECONDARY_CHANNEL]);
1803 event.acs_selected_channels.sec_freq =
1804 chan_2ghz_or_5ghz_to_freq(chan);
1805 }
1806
1807 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL])
1808 event.acs_selected_channels.vht_seg0_center_ch =
1809 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG0_CENTER_CHANNEL]);
1810 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG1_CENTER_CHANNEL])
1811 event.acs_selected_channels.vht_seg1_center_ch =
1812 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_VHT_SEG1_CENTER_CHANNEL]);
1813 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_CHWIDTH])
1814 event.acs_selected_channels.ch_width =
1815 nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_ACS_CHWIDTH]);
1816 if (tb[QCA_WLAN_VENDOR_ATTR_ACS_HW_MODE]) {
1817 u8 hw_mode = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_ACS_HW_MODE]);
1818
1819 event.acs_selected_channels.hw_mode = get_qca_hw_mode(hw_mode);
1820 if (event.acs_selected_channels.hw_mode == NUM_HOSTAPD_MODES ||
1821 event.acs_selected_channels.hw_mode ==
1822 HOSTAPD_MODE_IEEE80211ANY) {
1823 wpa_printf(MSG_DEBUG,
1824 "nl80211: Invalid hw_mode %d in ACS selection event",
1825 hw_mode);
1826 return;
1827 }
1828 }
1829
1830 wpa_printf(MSG_INFO,
1831 "nl80211: ACS Results: PFreq: %d SFreq: %d BW: %d VHT0: %d VHT1: %d HW_MODE: %d",
1832 event.acs_selected_channels.pri_freq,
1833 event.acs_selected_channels.sec_freq,
1834 event.acs_selected_channels.ch_width,
1835 event.acs_selected_channels.vht_seg0_center_ch,
1836 event.acs_selected_channels.vht_seg1_center_ch,
1837 event.acs_selected_channels.hw_mode);
1838
1839 /* Ignore ACS channel list check for backwards compatibility */
1840
1841 wpa_supplicant_event(drv->ctx, EVENT_ACS_CHANNEL_SELECTED, &event);
1842 }
1843
1844
1845 static void qca_nl80211_key_mgmt_auth(struct wpa_driver_nl80211_data *drv,
1846 const u8 *data, size_t len)
1847 {
1848 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_MAX + 1];
1849 u8 *bssid;
1850
1851 wpa_printf(MSG_DEBUG,
1852 "nl80211: Key management roam+auth vendor event received");
1853
1854 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_MAX,
1855 (struct nlattr *) data, len, NULL) ||
1856 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID] ||
1857 nla_len(tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID]) != ETH_ALEN ||
1858 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_REQ_IE] ||
1859 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_RESP_IE] ||
1860 !tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_AUTHORIZED])
1861 return;
1862
1863 bssid = nla_data(tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID]);
1864 wpa_printf(MSG_DEBUG, " * roam BSSID " MACSTR, MAC2STR(bssid));
1865
1866 mlme_event_connect(drv, NL80211_CMD_ROAM, NULL,
1867 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_BSSID],
1868 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_REQ_IE],
1869 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_RESP_IE],
1870 NULL, NULL,
1871 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_AUTHORIZED],
1872 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_KEY_REPLAY_CTR],
1873 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PTK_KCK],
1874 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PTK_KEK],
1875 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_SUBNET_STATUS],
1876 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_FILS_ERP_NEXT_SEQ_NUM],
1877 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PMK],
1878 tb[QCA_WLAN_VENDOR_ATTR_ROAM_AUTH_PMKID]);
1879 }
1880
1881
1882 static void qca_nl80211_dfs_offload_radar_event(
1883 struct wpa_driver_nl80211_data *drv, u32 subcmd, u8 *msg, int length)
1884 {
1885 union wpa_event_data data;
1886 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1887
1888 wpa_printf(MSG_DEBUG,
1889 "nl80211: DFS offload radar vendor event received");
1890
1891 if (nla_parse(tb, NL80211_ATTR_MAX,
1892 (struct nlattr *) msg, length, NULL))
1893 return;
1894
1895 if (!tb[NL80211_ATTR_WIPHY_FREQ]) {
1896 wpa_printf(MSG_INFO,
1897 "nl80211: Error parsing WIPHY_FREQ in FS offload radar vendor event");
1898 return;
1899 }
1900
1901 os_memset(&data, 0, sizeof(data));
1902 data.dfs_event.freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1903
1904 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz",
1905 data.dfs_event.freq);
1906
1907 /* Check HT params */
1908 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1909 data.dfs_event.ht_enabled = 1;
1910 data.dfs_event.chan_offset = 0;
1911
1912 switch (nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
1913 case NL80211_CHAN_NO_HT:
1914 data.dfs_event.ht_enabled = 0;
1915 break;
1916 case NL80211_CHAN_HT20:
1917 break;
1918 case NL80211_CHAN_HT40PLUS:
1919 data.dfs_event.chan_offset = 1;
1920 break;
1921 case NL80211_CHAN_HT40MINUS:
1922 data.dfs_event.chan_offset = -1;
1923 break;
1924 }
1925 }
1926
1927 /* Get VHT params */
1928 if (tb[NL80211_ATTR_CHANNEL_WIDTH])
1929 data.dfs_event.chan_width =
1930 convert2width(nla_get_u32(
1931 tb[NL80211_ATTR_CHANNEL_WIDTH]));
1932 if (tb[NL80211_ATTR_CENTER_FREQ1])
1933 data.dfs_event.cf1 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
1934 if (tb[NL80211_ATTR_CENTER_FREQ2])
1935 data.dfs_event.cf2 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
1936
1937 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz, ht: %d, "
1938 "offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
1939 data.dfs_event.freq, data.dfs_event.ht_enabled,
1940 data.dfs_event.chan_offset, data.dfs_event.chan_width,
1941 data.dfs_event.cf1, data.dfs_event.cf2);
1942
1943 switch (subcmd) {
1944 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_RADAR_DETECTED:
1945 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
1946 break;
1947 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_STARTED:
1948 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_STARTED, &data);
1949 break;
1950 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_FINISHED:
1951 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
1952 break;
1953 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_ABORTED:
1954 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
1955 break;
1956 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_NOP_FINISHED:
1957 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
1958 break;
1959 default:
1960 wpa_printf(MSG_DEBUG,
1961 "nl80211: Unknown DFS offload radar event %d received",
1962 subcmd);
1963 break;
1964 }
1965 }
1966
1967
1968 static void qca_nl80211_scan_trigger_event(struct wpa_driver_nl80211_data *drv,
1969 u8 *data, size_t len)
1970 {
1971 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SCAN_MAX + 1];
1972 u64 cookie = 0;
1973 union wpa_event_data event;
1974 struct scan_info *info;
1975
1976 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_SCAN_MAX,
1977 (struct nlattr *) data, len, NULL) ||
1978 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE])
1979 return;
1980
1981 cookie = nla_get_u64(tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE]);
1982 if (cookie != drv->vendor_scan_cookie) {
1983 /* External scan trigger event, ignore */
1984 return;
1985 }
1986
1987 /* Cookie match, own scan */
1988 os_memset(&event, 0, sizeof(event));
1989 info = &event.scan_info;
1990 info->external_scan = 0;
1991 info->nl_scan_event = 0;
1992
1993 drv->scan_state = SCAN_STARTED;
1994 wpa_supplicant_event(drv->ctx, EVENT_SCAN_STARTED, &event);
1995 }
1996
1997
1998 static void send_vendor_scan_event(struct wpa_driver_nl80211_data *drv,
1999 int aborted, struct nlattr *tb[],
2000 int external_scan)
2001 {
2002 union wpa_event_data event;
2003 struct nlattr *nl;
2004 int rem;
2005 struct scan_info *info;
2006 int freqs[MAX_REPORT_FREQS];
2007 int num_freqs = 0;
2008
2009 os_memset(&event, 0, sizeof(event));
2010 info = &event.scan_info;
2011 info->aborted = aborted;
2012 info->external_scan = external_scan;
2013
2014 if (tb[QCA_WLAN_VENDOR_ATTR_SCAN_SSIDS]) {
2015 nla_for_each_nested(nl,
2016 tb[QCA_WLAN_VENDOR_ATTR_SCAN_SSIDS], rem) {
2017 struct wpa_driver_scan_ssid *s =
2018 &info->ssids[info->num_ssids];
2019 s->ssid = nla_data(nl);
2020 s->ssid_len = nla_len(nl);
2021 wpa_printf(MSG_DEBUG,
2022 "nl80211: Scan probed for SSID '%s'",
2023 wpa_ssid_txt(s->ssid, s->ssid_len));
2024 info->num_ssids++;
2025 if (info->num_ssids == WPAS_MAX_SCAN_SSIDS)
2026 break;
2027 }
2028 }
2029
2030 if (tb[QCA_WLAN_VENDOR_ATTR_SCAN_FREQUENCIES]) {
2031 char msg[300], *pos, *end;
2032 int res;
2033
2034 pos = msg;
2035 end = pos + sizeof(msg);
2036 *pos = '\0';
2037
2038 nla_for_each_nested(nl,
2039 tb[QCA_WLAN_VENDOR_ATTR_SCAN_FREQUENCIES],
2040 rem) {
2041 freqs[num_freqs] = nla_get_u32(nl);
2042 res = os_snprintf(pos, end - pos, " %d",
2043 freqs[num_freqs]);
2044 if (!os_snprintf_error(end - pos, res))
2045 pos += res;
2046 num_freqs++;
2047 if (num_freqs == MAX_REPORT_FREQS - 1)
2048 break;
2049 }
2050
2051 info->freqs = freqs;
2052 info->num_freqs = num_freqs;
2053 wpa_printf(MSG_DEBUG, "nl80211: Scan included frequencies:%s",
2054 msg);
2055 }
2056 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
2057 }
2058
2059
2060 static void qca_nl80211_scan_done_event(struct wpa_driver_nl80211_data *drv,
2061 u8 *data, size_t len)
2062 {
2063 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SCAN_MAX + 1];
2064 u64 cookie = 0;
2065 enum scan_status status;
2066 int external_scan;
2067
2068 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_SCAN_MAX,
2069 (struct nlattr *) data, len, NULL) ||
2070 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_STATUS] ||
2071 !tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE])
2072 return;
2073
2074 status = nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_SCAN_STATUS]);
2075 if (status >= VENDOR_SCAN_STATUS_MAX)
2076 return; /* invalid status */
2077
2078 cookie = nla_get_u64(tb[QCA_WLAN_VENDOR_ATTR_SCAN_COOKIE]);
2079 if (cookie != drv->vendor_scan_cookie) {
2080 /* Event from an external scan, get scan results */
2081 external_scan = 1;
2082 } else {
2083 external_scan = 0;
2084 if (status == VENDOR_SCAN_STATUS_NEW_RESULTS)
2085 drv->scan_state = SCAN_COMPLETED;
2086 else
2087 drv->scan_state = SCAN_ABORTED;
2088
2089 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2090 drv->ctx);
2091 drv->vendor_scan_cookie = 0;
2092 drv->last_scan_cmd = 0;
2093 }
2094
2095 send_vendor_scan_event(drv, (status == VENDOR_SCAN_STATUS_ABORTED), tb,
2096 external_scan);
2097 }
2098
2099
2100 static void qca_nl80211_p2p_lo_stop_event(struct wpa_driver_nl80211_data *drv,
2101 u8 *data, size_t len)
2102 {
2103 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_MAX + 1];
2104 union wpa_event_data event;
2105
2106 wpa_printf(MSG_DEBUG,
2107 "nl80211: P2P listen offload stop vendor event received");
2108
2109 if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_MAX,
2110 (struct nlattr *) data, len, NULL) ||
2111 !tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_STOP_REASON])
2112 return;
2113
2114 os_memset(&event, 0, sizeof(event));
2115 event.p2p_lo_stop.reason_code =
2116 nla_get_u8(tb[QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_STOP_REASON]);
2117
2118 wpa_printf(MSG_DEBUG,
2119 "nl80211: P2P Listen offload stop reason: %d",
2120 event.p2p_lo_stop.reason_code);
2121 wpa_supplicant_event(drv->ctx, EVENT_P2P_LO_STOP, &event);
2122 }
2123
2124 #endif /* CONFIG_DRIVER_NL80211_QCA */
2125
2126
2127 static void nl80211_vendor_event_qca(struct wpa_driver_nl80211_data *drv,
2128 u32 subcmd, u8 *data, size_t len)
2129 {
2130 switch (subcmd) {
2131 case QCA_NL80211_VENDOR_SUBCMD_TEST:
2132 wpa_hexdump(MSG_DEBUG, "nl80211: QCA test event", data, len);
2133 break;
2134 #ifdef CONFIG_DRIVER_NL80211_QCA
2135 case QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY:
2136 qca_nl80211_avoid_freq(drv, data, len);
2137 break;
2138 case QCA_NL80211_VENDOR_SUBCMD_KEY_MGMT_ROAM_AUTH:
2139 qca_nl80211_key_mgmt_auth(drv, data, len);
2140 break;
2141 case QCA_NL80211_VENDOR_SUBCMD_DO_ACS:
2142 qca_nl80211_acs_select_ch(drv, data, len);
2143 break;
2144 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_STARTED:
2145 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_FINISHED:
2146 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_ABORTED:
2147 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_CAC_NOP_FINISHED:
2148 case QCA_NL80211_VENDOR_SUBCMD_DFS_OFFLOAD_RADAR_DETECTED:
2149 qca_nl80211_dfs_offload_radar_event(drv, subcmd, data, len);
2150 break;
2151 case QCA_NL80211_VENDOR_SUBCMD_TRIGGER_SCAN:
2152 qca_nl80211_scan_trigger_event(drv, data, len);
2153 break;
2154 case QCA_NL80211_VENDOR_SUBCMD_SCAN_DONE:
2155 qca_nl80211_scan_done_event(drv, data, len);
2156 break;
2157 case QCA_NL80211_VENDOR_SUBCMD_P2P_LISTEN_OFFLOAD_STOP:
2158 qca_nl80211_p2p_lo_stop_event(drv, data, len);
2159 break;
2160 #endif /* CONFIG_DRIVER_NL80211_QCA */
2161 default:
2162 wpa_printf(MSG_DEBUG,
2163 "nl80211: Ignore unsupported QCA vendor event %u",
2164 subcmd);
2165 break;
2166 }
2167 }
2168
2169
2170 static void nl80211_vendor_event(struct wpa_driver_nl80211_data *drv,
2171 struct nlattr **tb)
2172 {
2173 u32 vendor_id, subcmd, wiphy = 0;
2174 int wiphy_idx;
2175 u8 *data = NULL;
2176 size_t len = 0;
2177
2178 if (!tb[NL80211_ATTR_VENDOR_ID] ||
2179 !tb[NL80211_ATTR_VENDOR_SUBCMD])
2180 return;
2181
2182 vendor_id = nla_get_u32(tb[NL80211_ATTR_VENDOR_ID]);
2183 subcmd = nla_get_u32(tb[NL80211_ATTR_VENDOR_SUBCMD]);
2184
2185 if (tb[NL80211_ATTR_WIPHY])
2186 wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2187
2188 wpa_printf(MSG_DEBUG, "nl80211: Vendor event: wiphy=%u vendor_id=0x%x subcmd=%u",
2189 wiphy, vendor_id, subcmd);
2190
2191 if (tb[NL80211_ATTR_VENDOR_DATA]) {
2192 data = nla_data(tb[NL80211_ATTR_VENDOR_DATA]);
2193 len = nla_len(tb[NL80211_ATTR_VENDOR_DATA]);
2194 wpa_hexdump(MSG_MSGDUMP, "nl80211: Vendor data", data, len);
2195 }
2196
2197 wiphy_idx = nl80211_get_wiphy_index(drv->first_bss);
2198 if (wiphy_idx >= 0 && wiphy_idx != (int) wiphy) {
2199 wpa_printf(MSG_DEBUG, "nl80211: Ignore vendor event for foreign wiphy %u (own: %d)",
2200 wiphy, wiphy_idx);
2201 return;
2202 }
2203
2204 switch (vendor_id) {
2205 case OUI_QCA:
2206 nl80211_vendor_event_qca(drv, subcmd, data, len);
2207 break;
2208 default:
2209 wpa_printf(MSG_DEBUG, "nl80211: Ignore unsupported vendor event");
2210 break;
2211 }
2212 }
2213
2214
2215 static void nl80211_reg_change_event(struct wpa_driver_nl80211_data *drv,
2216 struct nlattr *tb[])
2217 {
2218 union wpa_event_data data;
2219 enum nl80211_reg_initiator init;
2220
2221 wpa_printf(MSG_DEBUG, "nl80211: Regulatory domain change");
2222
2223 if (tb[NL80211_ATTR_REG_INITIATOR] == NULL)
2224 return;
2225
2226 os_memset(&data, 0, sizeof(data));
2227 init = nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR]);
2228 wpa_printf(MSG_DEBUG, " * initiator=%d", init);
2229 switch (init) {
2230 case NL80211_REGDOM_SET_BY_CORE:
2231 data.channel_list_changed.initiator = REGDOM_SET_BY_CORE;
2232 break;
2233 case NL80211_REGDOM_SET_BY_USER:
2234 data.channel_list_changed.initiator = REGDOM_SET_BY_USER;
2235 break;
2236 case NL80211_REGDOM_SET_BY_DRIVER:
2237 data.channel_list_changed.initiator = REGDOM_SET_BY_DRIVER;
2238 break;
2239 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2240 data.channel_list_changed.initiator = REGDOM_SET_BY_COUNTRY_IE;
2241 break;
2242 }
2243
2244 if (tb[NL80211_ATTR_REG_TYPE]) {
2245 enum nl80211_reg_type type;
2246 type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
2247 wpa_printf(MSG_DEBUG, " * type=%d", type);
2248 switch (type) {
2249 case NL80211_REGDOM_TYPE_COUNTRY:
2250 data.channel_list_changed.type = REGDOM_TYPE_COUNTRY;
2251 break;
2252 case NL80211_REGDOM_TYPE_WORLD:
2253 data.channel_list_changed.type = REGDOM_TYPE_WORLD;
2254 break;
2255 case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
2256 data.channel_list_changed.type =
2257 REGDOM_TYPE_CUSTOM_WORLD;
2258 break;
2259 case NL80211_REGDOM_TYPE_INTERSECTION:
2260 data.channel_list_changed.type =
2261 REGDOM_TYPE_INTERSECTION;
2262 break;
2263 }
2264 }
2265
2266 if (tb[NL80211_ATTR_REG_ALPHA2]) {
2267 os_strlcpy(data.channel_list_changed.alpha2,
2268 nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
2269 sizeof(data.channel_list_changed.alpha2));
2270 wpa_printf(MSG_DEBUG, " * alpha2=%s",
2271 data.channel_list_changed.alpha2);
2272 }
2273
2274 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED, &data);
2275 }
2276
2277
2278 static void nl80211_dump_freq(const char *title, struct nlattr *nl_freq)
2279 {
2280 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
2281 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
2282 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
2283 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
2284 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
2285 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
2286 };
2287 struct nlattr *tb[NL80211_FREQUENCY_ATTR_MAX + 1];
2288 u32 freq = 0, max_tx_power = 0;
2289
2290 nla_parse(tb, NL80211_FREQUENCY_ATTR_MAX,
2291 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
2292
2293 if (tb[NL80211_FREQUENCY_ATTR_FREQ])
2294 freq = nla_get_u32(tb[NL80211_FREQUENCY_ATTR_FREQ]);
2295 if (tb[NL80211_FREQUENCY_ATTR_MAX_TX_POWER])
2296 max_tx_power =
2297 nla_get_u32(tb[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]);
2298
2299 wpa_printf(MSG_DEBUG,
2300 "nl80211: Channel (%s): freq=%u max_tx_power=%u%s%s%s",
2301 title, freq, max_tx_power,
2302 tb[NL80211_FREQUENCY_ATTR_DISABLED] ? " disabled" : "",
2303 tb[NL80211_FREQUENCY_ATTR_NO_IR] ? " no-IR" : "",
2304 tb[NL80211_FREQUENCY_ATTR_RADAR] ? " radar" : "");
2305 }
2306
2307
2308 static void nl80211_reg_beacon_hint_event(struct wpa_driver_nl80211_data *drv,
2309 struct nlattr *tb[])
2310 {
2311 union wpa_event_data data;
2312
2313 wpa_printf(MSG_DEBUG, "nl80211: Regulatory beacon hint");
2314 os_memset(&data, 0, sizeof(data));
2315 data.channel_list_changed.initiator = REGDOM_BEACON_HINT;
2316
2317 if (tb[NL80211_ATTR_FREQ_BEFORE])
2318 nl80211_dump_freq("before", tb[NL80211_ATTR_FREQ_BEFORE]);
2319 if (tb[NL80211_ATTR_FREQ_AFTER])
2320 nl80211_dump_freq("after", tb[NL80211_ATTR_FREQ_AFTER]);
2321
2322 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED, &data);
2323 }
2324
2325
2326 static void nl80211_external_auth(struct wpa_driver_nl80211_data *drv,
2327 struct nlattr **tb)
2328 {
2329 union wpa_event_data event;
2330 enum nl80211_external_auth_action act;
2331
2332 if (!tb[NL80211_ATTR_AKM_SUITES] ||
2333 !tb[NL80211_ATTR_EXTERNAL_AUTH_ACTION] ||
2334 !tb[NL80211_ATTR_BSSID] ||
2335 !tb[NL80211_ATTR_SSID])
2336 return;
2337
2338 os_memset(&event, 0, sizeof(event));
2339 act = nla_get_u32(tb[NL80211_ATTR_EXTERNAL_AUTH_ACTION]);
2340 switch (act) {
2341 case NL80211_EXTERNAL_AUTH_START:
2342 event.external_auth.action = EXT_AUTH_START;
2343 break;
2344 case NL80211_EXTERNAL_AUTH_ABORT:
2345 event.external_auth.action = EXT_AUTH_ABORT;
2346 break;
2347 default:
2348 return;
2349 }
2350
2351 event.external_auth.key_mgmt_suite =
2352 nla_get_u32(tb[NL80211_ATTR_AKM_SUITES]);
2353
2354 event.external_auth.ssid_len = nla_len(tb[NL80211_ATTR_SSID]);
2355 if (event.external_auth.ssid_len > SSID_MAX_LEN)
2356 return;
2357 event.external_auth.ssid = nla_data(tb[NL80211_ATTR_SSID]);
2358
2359 event.external_auth.bssid = nla_data(tb[NL80211_ATTR_BSSID]);
2360
2361 wpa_printf(MSG_DEBUG,
2362 "nl80211: External auth action: %u, AKM: 0x%x",
2363 event.external_auth.action,
2364 event.external_auth.key_mgmt_suite);
2365 wpa_supplicant_event(drv->ctx, EVENT_EXTERNAL_AUTH, &event);
2366 }
2367
2368
2369 static void nl80211_port_authorized(struct wpa_driver_nl80211_data *drv,
2370 struct nlattr **tb)
2371 {
2372 const u8 *addr;
2373
2374 if (!tb[NL80211_ATTR_MAC] ||
2375 nla_len(tb[NL80211_ATTR_MAC]) != ETH_ALEN) {
2376 wpa_printf(MSG_DEBUG,
2377 "nl80211: Ignore port authorized event without BSSID");
2378 return;
2379 }
2380
2381 addr = nla_data(tb[NL80211_ATTR_MAC]);
2382 if (os_memcmp(addr, drv->bssid, ETH_ALEN) != 0) {
2383 wpa_printf(MSG_DEBUG,
2384 "nl80211: Ignore port authorized event for " MACSTR
2385 " (not the currently connected BSSID " MACSTR ")",
2386 MAC2STR(addr), MAC2STR(drv->bssid));
2387 return;
2388 }
2389
2390 wpa_supplicant_event(drv->ctx, EVENT_PORT_AUTHORIZED, NULL);
2391 }
2392
2393
2394 static void nl80211_sta_opmode_change_event(struct wpa_driver_nl80211_data *drv,
2395 struct nlattr **tb)
2396 {
2397 union wpa_event_data ed;
2398 u8 smps_mode, max_bw;
2399
2400 if (!tb[NL80211_ATTR_MAC] ||
2401 (!tb[NL80211_ATTR_CHANNEL_WIDTH] &&
2402 !tb[NL80211_ATTR_SMPS_MODE] &&
2403 !tb[NL80211_ATTR_NSS]))
2404 return;
2405
2406 ed.sta_opmode.smps_mode = SMPS_INVALID;
2407 ed.sta_opmode.chan_width = CHAN_WIDTH_UNKNOWN;
2408 ed.sta_opmode.rx_nss = 0xff;
2409 ed.sta_opmode.addr = nla_data(tb[NL80211_ATTR_MAC]);
2410
2411 if (tb[NL80211_ATTR_SMPS_MODE]) {
2412 smps_mode = nla_get_u8(tb[NL80211_ATTR_SMPS_MODE]);
2413 switch (smps_mode) {
2414 case NL80211_SMPS_OFF:
2415 ed.sta_opmode.smps_mode = SMPS_OFF;
2416 break;
2417 case NL80211_SMPS_STATIC:
2418 ed.sta_opmode.smps_mode = SMPS_STATIC;
2419 break;
2420 case NL80211_SMPS_DYNAMIC:
2421 ed.sta_opmode.smps_mode = SMPS_DYNAMIC;
2422 break;
2423 default:
2424 ed.sta_opmode.smps_mode = SMPS_INVALID;
2425 break;
2426 }
2427 }
2428
2429 if (tb[NL80211_ATTR_CHANNEL_WIDTH]) {
2430 max_bw = nla_get_u32(tb[NL80211_ATTR_CHANNEL_WIDTH]);
2431 switch (max_bw) {
2432 case NL80211_CHAN_WIDTH_20_NOHT:
2433 ed.sta_opmode.chan_width = CHAN_WIDTH_20_NOHT;
2434 break;
2435 case NL80211_CHAN_WIDTH_20:
2436 ed.sta_opmode.chan_width = CHAN_WIDTH_20;
2437 break;
2438 case NL80211_CHAN_WIDTH_40:
2439 ed.sta_opmode.chan_width = CHAN_WIDTH_40;
2440 break;
2441 case NL80211_CHAN_WIDTH_80:
2442 ed.sta_opmode.chan_width = CHAN_WIDTH_80;
2443 break;
2444 case NL80211_CHAN_WIDTH_80P80:
2445 ed.sta_opmode.chan_width = CHAN_WIDTH_80P80;
2446 break;
2447 case NL80211_CHAN_WIDTH_160:
2448 ed.sta_opmode.chan_width = CHAN_WIDTH_160;
2449 break;
2450 default:
2451 ed.sta_opmode.chan_width = CHAN_WIDTH_UNKNOWN;
2452 break;
2453
2454 }
2455 }
2456
2457 if (tb[NL80211_ATTR_NSS])
2458 ed.sta_opmode.rx_nss = nla_get_u8(tb[NL80211_ATTR_NSS]);
2459
2460 wpa_supplicant_event(drv->ctx, EVENT_STATION_OPMODE_CHANGED, &ed);
2461 }
2462
2463
2464 static void nl80211_control_port_frame(struct wpa_driver_nl80211_data *drv,
2465 struct nlattr **tb)
2466 {
2467 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_FRAME])
2468 return;
2469
2470 drv_event_eapol_rx(drv->ctx, nla_data(tb[NL80211_ATTR_MAC]),
2471 nla_data(tb[NL80211_ATTR_FRAME]),
2472 nla_len(tb[NL80211_ATTR_FRAME]));
2473 }
2474
2475
2476 static void do_process_drv_event(struct i802_bss *bss, int cmd,
2477 struct nlattr **tb)
2478 {
2479 struct wpa_driver_nl80211_data *drv = bss->drv;
2480 int external_scan_event = 0;
2481
2482 wpa_printf(MSG_DEBUG, "nl80211: Drv Event %d (%s) received for %s",
2483 cmd, nl80211_command_to_string(cmd), bss->ifname);
2484
2485 if (cmd == NL80211_CMD_ROAM &&
2486 (drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
2487 /*
2488 * Device will use roam+auth vendor event to indicate
2489 * roaming, so ignore the regular roam event.
2490 */
2491 wpa_printf(MSG_DEBUG,
2492 "nl80211: Ignore roam event (cmd=%d), device will use vendor event roam+auth",
2493 cmd);
2494 return;
2495 }
2496
2497 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED &&
2498 (cmd == NL80211_CMD_NEW_SCAN_RESULTS ||
2499 cmd == NL80211_CMD_SCAN_ABORTED)) {
2500 wpa_driver_nl80211_set_mode(drv->first_bss,
2501 drv->ap_scan_as_station);
2502 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
2503 }
2504
2505 switch (cmd) {
2506 case NL80211_CMD_TRIGGER_SCAN:
2507 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan trigger");
2508 drv->scan_state = SCAN_STARTED;
2509 if (drv->scan_for_auth) {
2510 /*
2511 * Cannot indicate EVENT_SCAN_STARTED here since we skip
2512 * EVENT_SCAN_RESULTS in scan_for_auth case and the
2513 * upper layer implementation could get confused about
2514 * scanning state.
2515 */
2516 wpa_printf(MSG_DEBUG, "nl80211: Do not indicate scan-start event due to internal scan_for_auth");
2517 break;
2518 }
2519 wpa_supplicant_event(drv->ctx, EVENT_SCAN_STARTED, NULL);
2520 break;
2521 case NL80211_CMD_START_SCHED_SCAN:
2522 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan started");
2523 drv->scan_state = SCHED_SCAN_STARTED;
2524 break;
2525 case NL80211_CMD_SCHED_SCAN_STOPPED:
2526 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan stopped");
2527 drv->scan_state = SCHED_SCAN_STOPPED;
2528 wpa_supplicant_event(drv->ctx, EVENT_SCHED_SCAN_STOPPED, NULL);
2529 break;
2530 case NL80211_CMD_NEW_SCAN_RESULTS:
2531 wpa_dbg(drv->ctx, MSG_DEBUG,
2532 "nl80211: New scan results available");
2533 if (drv->last_scan_cmd != NL80211_CMD_VENDOR)
2534 drv->scan_state = SCAN_COMPLETED;
2535 drv->scan_complete_events = 1;
2536 if (drv->last_scan_cmd == NL80211_CMD_TRIGGER_SCAN) {
2537 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout,
2538 drv, drv->ctx);
2539 drv->last_scan_cmd = 0;
2540 } else {
2541 external_scan_event = 1;
2542 }
2543 send_scan_event(drv, 0, tb, external_scan_event);
2544 break;
2545 case NL80211_CMD_SCHED_SCAN_RESULTS:
2546 wpa_dbg(drv->ctx, MSG_DEBUG,
2547 "nl80211: New sched scan results available");
2548 drv->scan_state = SCHED_SCAN_RESULTS;
2549 send_scan_event(drv, 0, tb, 0);
2550 break;
2551 case NL80211_CMD_SCAN_ABORTED:
2552 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan aborted");
2553 if (drv->last_scan_cmd != NL80211_CMD_VENDOR)
2554 drv->scan_state = SCAN_ABORTED;
2555 if (drv->last_scan_cmd == NL80211_CMD_TRIGGER_SCAN) {
2556 /*
2557 * Need to indicate that scan results are available in
2558 * order not to make wpa_supplicant stop its scanning.
2559 */
2560 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout,
2561 drv, drv->ctx);
2562 drv->last_scan_cmd = 0;
2563 } else {
2564 external_scan_event = 1;
2565 }
2566 send_scan_event(drv, 1, tb, external_scan_event);
2567 break;
2568 case NL80211_CMD_AUTHENTICATE:
2569 case NL80211_CMD_ASSOCIATE:
2570 case NL80211_CMD_DEAUTHENTICATE:
2571 case NL80211_CMD_DISASSOCIATE:
2572 case NL80211_CMD_FRAME_TX_STATUS:
2573 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
2574 case NL80211_CMD_UNPROT_DISASSOCIATE:
2575 mlme_event(bss, cmd, tb[NL80211_ATTR_FRAME],
2576 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
2577 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
2578 tb[NL80211_ATTR_COOKIE],
2579 tb[NL80211_ATTR_RX_SIGNAL_DBM],
2580 tb[NL80211_ATTR_STA_WME],
2581 tb[NL80211_ATTR_REQ_IE]);
2582 break;
2583 case NL80211_CMD_CONNECT:
2584 case NL80211_CMD_ROAM:
2585 mlme_event_connect(drv, cmd,
2586 tb[NL80211_ATTR_STATUS_CODE],
2587 tb[NL80211_ATTR_MAC],
2588 tb[NL80211_ATTR_REQ_IE],
2589 tb[NL80211_ATTR_RESP_IE],
2590 tb[NL80211_ATTR_TIMED_OUT],
2591 tb[NL80211_ATTR_TIMEOUT_REASON],
2592 NULL, NULL, NULL,
2593 tb[NL80211_ATTR_FILS_KEK],
2594 NULL,
2595 tb[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM],
2596 tb[NL80211_ATTR_PMK],
2597 tb[NL80211_ATTR_PMKID]);
2598 break;
2599 case NL80211_CMD_CH_SWITCH_STARTED_NOTIFY:
2600 mlme_event_ch_switch(drv,
2601 tb[NL80211_ATTR_IFINDEX],
2602 tb[NL80211_ATTR_WIPHY_FREQ],
2603 tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2604 tb[NL80211_ATTR_CHANNEL_WIDTH],
2605 tb[NL80211_ATTR_CENTER_FREQ1],
2606 tb[NL80211_ATTR_CENTER_FREQ2],
2607 0);
2608 break;
2609 case NL80211_CMD_CH_SWITCH_NOTIFY:
2610 mlme_event_ch_switch(drv,
2611 tb[NL80211_ATTR_IFINDEX],
2612 tb[NL80211_ATTR_WIPHY_FREQ],
2613 tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2614 tb[NL80211_ATTR_CHANNEL_WIDTH],
2615 tb[NL80211_ATTR_CENTER_FREQ1],
2616 tb[NL80211_ATTR_CENTER_FREQ2],
2617 1);
2618 break;
2619 case NL80211_CMD_DISCONNECT:
2620 mlme_event_disconnect(drv, tb[NL80211_ATTR_REASON_CODE],
2621 tb[NL80211_ATTR_MAC],
2622 tb[NL80211_ATTR_DISCONNECTED_BY_AP]);
2623 break;
2624 case NL80211_CMD_MICHAEL_MIC_FAILURE:
2625 mlme_event_michael_mic_failure(bss, tb);
2626 break;
2627 case NL80211_CMD_JOIN_IBSS:
2628 mlme_event_join_ibss(drv, tb);
2629 break;
2630 case NL80211_CMD_REMAIN_ON_CHANNEL:
2631 mlme_event_remain_on_channel(drv, 0, tb);
2632 break;
2633 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
2634 mlme_event_remain_on_channel(drv, 1, tb);
2635 break;
2636 case NL80211_CMD_NOTIFY_CQM:
2637 nl80211_cqm_event(drv, tb);
2638 break;
2639 case NL80211_CMD_REG_CHANGE:
2640 case NL80211_CMD_WIPHY_REG_CHANGE:
2641 nl80211_reg_change_event(drv, tb);
2642 break;
2643 case NL80211_CMD_REG_BEACON_HINT:
2644 nl80211_reg_beacon_hint_event(drv, tb);
2645 break;
2646 case NL80211_CMD_NEW_STATION:
2647 nl80211_new_station_event(drv, bss, tb);
2648 break;
2649 case NL80211_CMD_DEL_STATION:
2650 nl80211_del_station_event(drv, bss, tb);
2651 break;
2652 case NL80211_CMD_SET_REKEY_OFFLOAD:
2653 nl80211_rekey_offload_event(drv, tb);
2654 break;
2655 case NL80211_CMD_PMKSA_CANDIDATE:
2656 nl80211_pmksa_candidate_event(drv, tb);
2657 break;
2658 case NL80211_CMD_PROBE_CLIENT:
2659 nl80211_client_probe_event(drv, tb);
2660 break;
2661 case NL80211_CMD_TDLS_OPER:
2662 nl80211_tdls_oper_event(drv, tb);
2663 break;
2664 case NL80211_CMD_CONN_FAILED:
2665 nl80211_connect_failed_event(drv, tb);
2666 break;
2667 case NL80211_CMD_FT_EVENT:
2668 mlme_event_ft_event(drv, tb);
2669 break;
2670 case NL80211_CMD_RADAR_DETECT:
2671 nl80211_radar_event(drv, tb);
2672 break;
2673 case NL80211_CMD_STOP_AP:
2674 nl80211_stop_ap(drv, tb);
2675 break;
2676 case NL80211_CMD_VENDOR:
2677 nl80211_vendor_event(drv, tb);
2678 break;
2679 case NL80211_CMD_NEW_PEER_CANDIDATE:
2680 nl80211_new_peer_candidate(drv, tb);
2681 break;
2682 case NL80211_CMD_PORT_AUTHORIZED:
2683 nl80211_port_authorized(drv, tb);
2684 break;
2685 case NL80211_CMD_STA_OPMODE_CHANGED:
2686 nl80211_sta_opmode_change_event(drv, tb);
2687 break;
2688 case NL80211_CMD_UPDATE_OWE_INFO:
2689 mlme_event_dh_event(drv, bss, tb);
2690 break;
2691 case NL80211_CMD_CONTROL_PORT_FRAME:
2692 nl80211_control_port_frame(drv, tb);
2693 break;
2694 default:
2695 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Ignored unknown event "
2696 "(cmd=%d)", cmd);
2697 break;
2698 }
2699 }
2700
2701
2702 int process_global_event(struct nl_msg *msg, void *arg)
2703 {
2704 struct nl80211_global *global = arg;
2705 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2706 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2707 struct wpa_driver_nl80211_data *drv, *tmp;
2708 int ifidx = -1, wiphy_idx = -1, wiphy_idx_rx = -1;
2709 struct i802_bss *bss;
2710 u64 wdev_id = 0;
2711 int wdev_id_set = 0;
2712 int wiphy_idx_set = 0;
2713
2714 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2715 genlmsg_attrlen(gnlh, 0), NULL);
2716
2717 if (tb[NL80211_ATTR_IFINDEX])
2718 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2719 else if (tb[NL80211_ATTR_WDEV]) {
2720 wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
2721 wdev_id_set = 1;
2722 } else if (tb[NL80211_ATTR_WIPHY]) {
2723 wiphy_idx_rx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2724 wiphy_idx_set = 1;
2725 }
2726
2727 dl_list_for_each_safe(drv, tmp, &global->interfaces,
2728 struct wpa_driver_nl80211_data, list) {
2729 for (bss = drv->first_bss; bss; bss = bss->next) {
2730 if (wiphy_idx_set)
2731 wiphy_idx = nl80211_get_wiphy_index(bss);
2732 if ((ifidx == -1 && !wiphy_idx_set && !wdev_id_set) ||
2733 ifidx == bss->ifindex ||
2734 (wiphy_idx_set && wiphy_idx == wiphy_idx_rx) ||
2735 (wdev_id_set && bss->wdev_id_set &&
2736 wdev_id == bss->wdev_id)) {
2737 do_process_drv_event(bss, gnlh->cmd, tb);
2738 return NL_SKIP;
2739 }
2740 }
2741 wpa_printf(MSG_DEBUG,
2742 "nl80211: Ignored event %d (%s) for foreign interface (ifindex %d wdev 0x%llx)",
2743 gnlh->cmd, nl80211_command_to_string(gnlh->cmd),
2744 ifidx, (long long unsigned int) wdev_id);
2745 }
2746
2747 return NL_SKIP;
2748 }
2749
2750
2751 int process_bss_event(struct nl_msg *msg, void *arg)
2752 {
2753 struct i802_bss *bss = arg;
2754 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2755 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2756
2757 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2758 genlmsg_attrlen(gnlh, 0), NULL);
2759
2760 wpa_printf(MSG_DEBUG, "nl80211: BSS Event %d (%s) received for %s",
2761 gnlh->cmd, nl80211_command_to_string(gnlh->cmd),
2762 bss->ifname);
2763
2764 switch (gnlh->cmd) {
2765 case NL80211_CMD_FRAME:
2766 case NL80211_CMD_FRAME_TX_STATUS:
2767 mlme_event(bss, gnlh->cmd, tb[NL80211_ATTR_FRAME],
2768 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
2769 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
2770 tb[NL80211_ATTR_COOKIE],
2771 tb[NL80211_ATTR_RX_SIGNAL_DBM],
2772 tb[NL80211_ATTR_STA_WME], NULL);
2773 break;
2774 case NL80211_CMD_UNEXPECTED_FRAME:
2775 nl80211_spurious_frame(bss, tb, 0);
2776 break;
2777 case NL80211_CMD_UNEXPECTED_4ADDR_FRAME:
2778 nl80211_spurious_frame(bss, tb, 1);
2779 break;
2780 case NL80211_CMD_EXTERNAL_AUTH:
2781 nl80211_external_auth(bss->drv, tb);
2782 break;
2783 default:
2784 wpa_printf(MSG_DEBUG, "nl80211: Ignored unknown event "
2785 "(cmd=%d)", gnlh->cmd);
2786 break;
2787 }
2788
2789 return NL_SKIP;
2790 }
Unnamed repository; edit this file 'description' to name the repository.