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