Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
6039f6d2 JM |
2 | /* |
3 | * cfg80211 MLME SAP interface | |
4 | * | |
5 | * Copyright (c) 2009, Jouni Malinen <j@w1.fi> | |
33d8783c | 6 | * Copyright (c) 2015 Intel Deutschland GmbH |
3bb02143 | 7 | * Copyright (C) 2019-2020 Intel Corporation |
6039f6d2 JM |
8 | */ |
9 | ||
10 | #include <linux/kernel.h> | |
11 | #include <linux/module.h> | |
c6fb08aa | 12 | #include <linux/etherdevice.h> |
6039f6d2 JM |
13 | #include <linux/netdevice.h> |
14 | #include <linux/nl80211.h> | |
5a0e3ad6 | 15 | #include <linux/slab.h> |
a9a11622 | 16 | #include <linux/wireless.h> |
6039f6d2 | 17 | #include <net/cfg80211.h> |
a9a11622 | 18 | #include <net/iw_handler.h> |
6039f6d2 JM |
19 | #include "core.h" |
20 | #include "nl80211.h" | |
e35e4d28 HG |
21 | #include "rdev-ops.h" |
22 | ||
6039f6d2 | 23 | |
6ff57cf8 | 24 | void cfg80211_rx_assoc_resp(struct net_device *dev, struct cfg80211_bss *bss, |
4d9ec73d JM |
25 | const u8 *buf, size_t len, int uapsd_queues, |
26 | const u8 *req_ies, size_t req_ies_len) | |
6039f6d2 | 27 | { |
6829c878 JB |
28 | struct wireless_dev *wdev = dev->ieee80211_ptr; |
29 | struct wiphy *wiphy = wdev->wiphy; | |
f26cbf40 | 30 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
6829c878 | 31 | struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf; |
5349a0f7 | 32 | struct cfg80211_connect_resp_params cr; |
80ca2571 TP |
33 | const u8 *resp_ie = mgmt->u.assoc_resp.variable; |
34 | size_t resp_ie_len = len - offsetof(struct ieee80211_mgmt, | |
35 | u.assoc_resp.variable); | |
36 | ||
37 | if (bss->channel->band == NL80211_BAND_S1GHZ) { | |
38 | resp_ie = (u8 *)&mgmt->u.s1g_assoc_resp.variable; | |
39 | resp_ie_len = len - offsetof(struct ieee80211_mgmt, | |
40 | u.s1g_assoc_resp.variable); | |
41 | } | |
5349a0f7 VK |
42 | |
43 | memset(&cr, 0, sizeof(cr)); | |
44 | cr.status = (int)le16_to_cpu(mgmt->u.assoc_resp.status_code); | |
45 | cr.bssid = mgmt->bssid; | |
46 | cr.bss = bss; | |
4d9ec73d JM |
47 | cr.req_ie = req_ies; |
48 | cr.req_ie_len = req_ies_len; | |
80ca2571 TP |
49 | cr.resp_ie = resp_ie; |
50 | cr.resp_ie_len = resp_ie_len; | |
5349a0f7 | 51 | cr.timeout_reason = NL80211_TIMEOUT_UNSPECIFIED; |
6829c878 | 52 | |
4ee3e063 | 53 | trace_cfg80211_send_rx_assoc(dev, bss); |
cb0b4beb | 54 | |
f401a6f7 JB |
55 | /* |
56 | * This is a bit of a hack, we don't notify userspace of | |
57 | * a (re-)association reply if we tried to send a reassoc | |
58 | * and got a reject -- we only try again with an assoc | |
59 | * frame instead of reassoc. | |
60 | */ | |
5349a0f7 | 61 | if (cfg80211_sme_rx_assoc_resp(wdev, cr.status)) { |
f1940c57 | 62 | cfg80211_unhold_bss(bss_from_pub(bss)); |
5b112d3d | 63 | cfg80211_put_bss(wiphy, bss); |
8d61ffa5 | 64 | return; |
95de817b | 65 | } |
f401a6f7 | 66 | |
4d9ec73d JM |
67 | nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL, uapsd_queues, |
68 | req_ies, req_ies_len); | |
ceca7b71 | 69 | /* update current_bss etc., consumes the bss reference */ |
5349a0f7 | 70 | __cfg80211_connect_result(dev, &cr, cr.status == WLAN_STATUS_SUCCESS); |
6039f6d2 | 71 | } |
6ff57cf8 | 72 | EXPORT_SYMBOL(cfg80211_rx_assoc_resp); |
6039f6d2 | 73 | |
ceca7b71 JB |
74 | static void cfg80211_process_auth(struct wireless_dev *wdev, |
75 | const u8 *buf, size_t len) | |
76 | { | |
f26cbf40 | 77 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); |
ceca7b71 JB |
78 | |
79 | nl80211_send_rx_auth(rdev, wdev->netdev, buf, len, GFP_KERNEL); | |
80 | cfg80211_sme_rx_auth(wdev, buf, len); | |
81 | } | |
82 | ||
83 | static void cfg80211_process_deauth(struct wireless_dev *wdev, | |
3bb02143 JB |
84 | const u8 *buf, size_t len, |
85 | bool reconnect) | |
6039f6d2 | 86 | { |
f26cbf40 | 87 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); |
6829c878 | 88 | struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf; |
19957bb3 | 89 | const u8 *bssid = mgmt->bssid; |
ceca7b71 JB |
90 | u16 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code); |
91 | bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr); | |
6829c878 | 92 | |
3bb02143 | 93 | nl80211_send_deauth(rdev, wdev->netdev, buf, len, reconnect, GFP_KERNEL); |
19957bb3 | 94 | |
ceca7b71 JB |
95 | if (!wdev->current_bss || |
96 | !ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) | |
97 | return; | |
6829c878 | 98 | |
ceca7b71 JB |
99 | __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap); |
100 | cfg80211_sme_deauth(wdev); | |
667503dd | 101 | } |
6039f6d2 | 102 | |
ceca7b71 | 103 | static void cfg80211_process_disassoc(struct wireless_dev *wdev, |
3bb02143 JB |
104 | const u8 *buf, size_t len, |
105 | bool reconnect) | |
6039f6d2 | 106 | { |
f26cbf40 | 107 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); |
6829c878 | 108 | struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf; |
19957bb3 | 109 | const u8 *bssid = mgmt->bssid; |
ceca7b71 JB |
110 | u16 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code); |
111 | bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr); | |
6829c878 | 112 | |
3bb02143 JB |
113 | nl80211_send_disassoc(rdev, wdev->netdev, buf, len, reconnect, |
114 | GFP_KERNEL); | |
a3b8b056 | 115 | |
ceca7b71 JB |
116 | if (WARN_ON(!wdev->current_bss || |
117 | !ether_addr_equal(wdev->current_bss->pub.bssid, bssid))) | |
596a07c1 | 118 | return; |
6829c878 | 119 | |
ceca7b71 JB |
120 | __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap); |
121 | cfg80211_sme_disassoc(wdev); | |
667503dd | 122 | } |
1965c853 | 123 | |
6ff57cf8 JB |
124 | void cfg80211_rx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len) |
125 | { | |
126 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
6ff57cf8 JB |
127 | struct ieee80211_mgmt *mgmt = (void *)buf; |
128 | ||
129 | ASSERT_WDEV_LOCK(wdev); | |
130 | ||
131 | trace_cfg80211_rx_mlme_mgmt(dev, buf, len); | |
132 | ||
133 | if (WARN_ON(len < 2)) | |
134 | return; | |
135 | ||
ceca7b71 JB |
136 | if (ieee80211_is_auth(mgmt->frame_control)) |
137 | cfg80211_process_auth(wdev, buf, len); | |
138 | else if (ieee80211_is_deauth(mgmt->frame_control)) | |
3bb02143 | 139 | cfg80211_process_deauth(wdev, buf, len, false); |
ceca7b71 | 140 | else if (ieee80211_is_disassoc(mgmt->frame_control)) |
3bb02143 | 141 | cfg80211_process_disassoc(wdev, buf, len, false); |
6ff57cf8 JB |
142 | } |
143 | EXPORT_SYMBOL(cfg80211_rx_mlme_mgmt); | |
144 | ||
145 | void cfg80211_auth_timeout(struct net_device *dev, const u8 *addr) | |
a58ce43f JB |
146 | { |
147 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
148 | struct wiphy *wiphy = wdev->wiphy; | |
f26cbf40 | 149 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
a58ce43f | 150 | |
4ee3e063 | 151 | trace_cfg80211_send_auth_timeout(dev, addr); |
a58ce43f JB |
152 | |
153 | nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL); | |
ceca7b71 | 154 | cfg80211_sme_auth_timeout(wdev); |
1965c853 | 155 | } |
6ff57cf8 | 156 | EXPORT_SYMBOL(cfg80211_auth_timeout); |
1965c853 | 157 | |
959867fa | 158 | void cfg80211_assoc_timeout(struct net_device *dev, struct cfg80211_bss *bss) |
1965c853 | 159 | { |
6829c878 JB |
160 | struct wireless_dev *wdev = dev->ieee80211_ptr; |
161 | struct wiphy *wiphy = wdev->wiphy; | |
f26cbf40 | 162 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
19957bb3 | 163 | |
959867fa | 164 | trace_cfg80211_send_assoc_timeout(dev, bss->bssid); |
cb0b4beb | 165 | |
959867fa | 166 | nl80211_send_assoc_timeout(rdev, dev, bss->bssid, GFP_KERNEL); |
ceca7b71 | 167 | cfg80211_sme_assoc_timeout(wdev); |
959867fa | 168 | |
f1940c57 | 169 | cfg80211_unhold_bss(bss_from_pub(bss)); |
959867fa | 170 | cfg80211_put_bss(wiphy, bss); |
1965c853 | 171 | } |
6ff57cf8 JB |
172 | EXPORT_SYMBOL(cfg80211_assoc_timeout); |
173 | ||
e6f462df JB |
174 | void cfg80211_abandon_assoc(struct net_device *dev, struct cfg80211_bss *bss) |
175 | { | |
176 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
177 | struct wiphy *wiphy = wdev->wiphy; | |
178 | ||
179 | cfg80211_sme_abandon_assoc(wdev); | |
180 | ||
181 | cfg80211_unhold_bss(bss_from_pub(bss)); | |
182 | cfg80211_put_bss(wiphy, bss); | |
183 | } | |
184 | EXPORT_SYMBOL(cfg80211_abandon_assoc); | |
185 | ||
3bb02143 JB |
186 | void cfg80211_tx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len, |
187 | bool reconnect) | |
6ff57cf8 JB |
188 | { |
189 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
190 | struct ieee80211_mgmt *mgmt = (void *)buf; | |
191 | ||
192 | ASSERT_WDEV_LOCK(wdev); | |
193 | ||
3bb02143 | 194 | trace_cfg80211_tx_mlme_mgmt(dev, buf, len, reconnect); |
6ff57cf8 JB |
195 | |
196 | if (WARN_ON(len < 2)) | |
197 | return; | |
198 | ||
199 | if (ieee80211_is_deauth(mgmt->frame_control)) | |
3bb02143 | 200 | cfg80211_process_deauth(wdev, buf, len, reconnect); |
6ff57cf8 | 201 | else |
3bb02143 | 202 | cfg80211_process_disassoc(wdev, buf, len, reconnect); |
6ff57cf8 JB |
203 | } |
204 | EXPORT_SYMBOL(cfg80211_tx_mlme_mgmt); | |
1965c853 | 205 | |
a3b8b056 JM |
206 | void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr, |
207 | enum nl80211_key_type key_type, int key_id, | |
e6d6e342 | 208 | const u8 *tsc, gfp_t gfp) |
a3b8b056 JM |
209 | { |
210 | struct wiphy *wiphy = dev->ieee80211_ptr->wiphy; | |
f26cbf40 | 211 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
3d23e349 | 212 | #ifdef CONFIG_CFG80211_WEXT |
f58d4ed9 | 213 | union iwreq_data wrqu; |
e6d6e342 | 214 | char *buf = kmalloc(128, gfp); |
f58d4ed9 JB |
215 | |
216 | if (buf) { | |
217 | sprintf(buf, "MLME-MICHAELMICFAILURE.indication(" | |
218 | "keyid=%d %scast addr=%pM)", key_id, | |
219 | key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni", | |
220 | addr); | |
221 | memset(&wrqu, 0, sizeof(wrqu)); | |
222 | wrqu.data.length = strlen(buf); | |
223 | wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf); | |
224 | kfree(buf); | |
225 | } | |
226 | #endif | |
227 | ||
4ee3e063 | 228 | trace_cfg80211_michael_mic_failure(dev, addr, key_type, key_id, tsc); |
e6d6e342 | 229 | nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp); |
a3b8b056 JM |
230 | } |
231 | EXPORT_SYMBOL(cfg80211_michael_mic_failure); | |
19957bb3 JB |
232 | |
233 | /* some MLME handling for userspace SME */ | |
91bf9b26 JB |
234 | int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev, |
235 | struct net_device *dev, | |
236 | struct ieee80211_channel *chan, | |
237 | enum nl80211_auth_type auth_type, | |
238 | const u8 *bssid, | |
239 | const u8 *ssid, int ssid_len, | |
240 | const u8 *ie, int ie_len, | |
241 | const u8 *key, int key_len, int key_idx, | |
11b6b5a4 | 242 | const u8 *auth_data, int auth_data_len) |
19957bb3 JB |
243 | { |
244 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
7ade7036 JB |
245 | struct cfg80211_auth_request req = { |
246 | .ie = ie, | |
247 | .ie_len = ie_len, | |
11b6b5a4 JM |
248 | .auth_data = auth_data, |
249 | .auth_data_len = auth_data_len, | |
7ade7036 JB |
250 | .auth_type = auth_type, |
251 | .key = key, | |
252 | .key_len = key_len, | |
253 | .key_idx = key_idx, | |
254 | }; | |
95de817b | 255 | int err; |
19957bb3 | 256 | |
667503dd JB |
257 | ASSERT_WDEV_LOCK(wdev); |
258 | ||
fffd0934 | 259 | if (auth_type == NL80211_AUTHTYPE_SHARED_KEY) |
b6b5555b | 260 | if (!key || !key_len || key_idx < 0 || key_idx > 3) |
fffd0934 JB |
261 | return -EINVAL; |
262 | ||
0a9b5e17 | 263 | if (wdev->current_bss && |
ac422d3c | 264 | ether_addr_equal(bssid, wdev->current_bss->pub.bssid)) |
0a9b5e17 JB |
265 | return -EALREADY; |
266 | ||
19957bb3 | 267 | req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len, |
6eb18137 DL |
268 | IEEE80211_BSS_TYPE_ESS, |
269 | IEEE80211_PRIVACY_ANY); | |
19957bb3 JB |
270 | if (!req.bss) |
271 | return -ENOENT; | |
272 | ||
e35e4d28 | 273 | err = rdev_auth(rdev, dev, &req); |
19957bb3 | 274 | |
5b112d3d | 275 | cfg80211_put_bss(&rdev->wiphy, req.bss); |
19957bb3 JB |
276 | return err; |
277 | } | |
278 | ||
7e7c8926 BG |
279 | /* Do a logical ht_capa &= ht_capa_mask. */ |
280 | void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa, | |
281 | const struct ieee80211_ht_cap *ht_capa_mask) | |
282 | { | |
283 | int i; | |
284 | u8 *p1, *p2; | |
285 | if (!ht_capa_mask) { | |
286 | memset(ht_capa, 0, sizeof(*ht_capa)); | |
287 | return; | |
288 | } | |
289 | ||
290 | p1 = (u8*)(ht_capa); | |
291 | p2 = (u8*)(ht_capa_mask); | |
81c5dce2 | 292 | for (i = 0; i < sizeof(*ht_capa); i++) |
7e7c8926 BG |
293 | p1[i] &= p2[i]; |
294 | } | |
295 | ||
81c5dce2 | 296 | /* Do a logical vht_capa &= vht_capa_mask. */ |
ee2aca34 JB |
297 | void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa, |
298 | const struct ieee80211_vht_cap *vht_capa_mask) | |
299 | { | |
300 | int i; | |
301 | u8 *p1, *p2; | |
302 | if (!vht_capa_mask) { | |
303 | memset(vht_capa, 0, sizeof(*vht_capa)); | |
304 | return; | |
305 | } | |
306 | ||
307 | p1 = (u8*)(vht_capa); | |
308 | p2 = (u8*)(vht_capa_mask); | |
309 | for (i = 0; i < sizeof(*vht_capa); i++) | |
310 | p1[i] &= p2[i]; | |
311 | } | |
312 | ||
91bf9b26 JB |
313 | int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev, |
314 | struct net_device *dev, | |
315 | struct ieee80211_channel *chan, | |
316 | const u8 *bssid, | |
317 | const u8 *ssid, int ssid_len, | |
318 | struct cfg80211_assoc_request *req) | |
19957bb3 JB |
319 | { |
320 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
95de817b | 321 | int err; |
19957bb3 | 322 | |
667503dd JB |
323 | ASSERT_WDEV_LOCK(wdev); |
324 | ||
ceca7b71 JB |
325 | if (wdev->current_bss && |
326 | (!req->prev_bssid || !ether_addr_equal(wdev->current_bss->pub.bssid, | |
327 | req->prev_bssid))) | |
19957bb3 JB |
328 | return -EALREADY; |
329 | ||
f62fab73 | 330 | cfg80211_oper_and_ht_capa(&req->ht_capa_mask, |
7e7c8926 | 331 | rdev->wiphy.ht_capa_mod_mask); |
f62fab73 | 332 | cfg80211_oper_and_vht_capa(&req->vht_capa_mask, |
ee2aca34 | 333 | rdev->wiphy.vht_capa_mod_mask); |
7e7c8926 | 334 | |
f62fab73 | 335 | req->bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len, |
6eb18137 DL |
336 | IEEE80211_BSS_TYPE_ESS, |
337 | IEEE80211_PRIVACY_ANY); | |
ceca7b71 | 338 | if (!req->bss) |
19957bb3 JB |
339 | return -ENOENT; |
340 | ||
f62fab73 | 341 | err = rdev_assoc(rdev, dev, req); |
f1940c57 JB |
342 | if (!err) |
343 | cfg80211_hold_bss(bss_from_pub(req->bss)); | |
73de86a3 | 344 | else |
f62fab73 | 345 | cfg80211_put_bss(&rdev->wiphy, req->bss); |
19957bb3 | 346 | |
19957bb3 JB |
347 | return err; |
348 | } | |
349 | ||
91bf9b26 JB |
350 | int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev, |
351 | struct net_device *dev, const u8 *bssid, | |
352 | const u8 *ie, int ie_len, u16 reason, | |
353 | bool local_state_change) | |
19957bb3 JB |
354 | { |
355 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
95de817b JB |
356 | struct cfg80211_deauth_request req = { |
357 | .bssid = bssid, | |
358 | .reason_code = reason, | |
359 | .ie = ie, | |
360 | .ie_len = ie_len, | |
6863255b | 361 | .local_state_change = local_state_change, |
95de817b | 362 | }; |
19957bb3 | 363 | |
667503dd JB |
364 | ASSERT_WDEV_LOCK(wdev); |
365 | ||
ceca7b71 JB |
366 | if (local_state_change && |
367 | (!wdev->current_bss || | |
368 | !ether_addr_equal(wdev->current_bss->pub.bssid, bssid))) | |
95de817b | 369 | return 0; |
19957bb3 | 370 | |
bd2522b1 AZ |
371 | if (ether_addr_equal(wdev->disconnect_bssid, bssid) || |
372 | (wdev->current_bss && | |
373 | ether_addr_equal(wdev->current_bss->pub.bssid, bssid))) | |
374 | wdev->conn_owner_nlportid = 0; | |
375 | ||
e35e4d28 | 376 | return rdev_deauth(rdev, dev, &req); |
19957bb3 JB |
377 | } |
378 | ||
91bf9b26 JB |
379 | int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev, |
380 | struct net_device *dev, const u8 *bssid, | |
381 | const u8 *ie, int ie_len, u16 reason, | |
382 | bool local_state_change) | |
19957bb3 JB |
383 | { |
384 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
7ade7036 JB |
385 | struct cfg80211_disassoc_request req = { |
386 | .reason_code = reason, | |
387 | .local_state_change = local_state_change, | |
388 | .ie = ie, | |
389 | .ie_len = ie_len, | |
390 | }; | |
ceca7b71 | 391 | int err; |
19957bb3 | 392 | |
667503dd JB |
393 | ASSERT_WDEV_LOCK(wdev); |
394 | ||
ceca7b71 | 395 | if (!wdev->current_bss) |
f9d6b402 JB |
396 | return -ENOTCONN; |
397 | ||
ac422d3c | 398 | if (ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) |
19957bb3 JB |
399 | req.bss = &wdev->current_bss->pub; |
400 | else | |
401 | return -ENOTCONN; | |
402 | ||
ceca7b71 JB |
403 | err = rdev_disassoc(rdev, dev, &req); |
404 | if (err) | |
405 | return err; | |
406 | ||
407 | /* driver should have reported the disassoc */ | |
408 | WARN_ON(wdev->current_bss); | |
409 | return 0; | |
667503dd JB |
410 | } |
411 | ||
19957bb3 JB |
412 | void cfg80211_mlme_down(struct cfg80211_registered_device *rdev, |
413 | struct net_device *dev) | |
414 | { | |
415 | struct wireless_dev *wdev = dev->ieee80211_ptr; | |
95de817b | 416 | u8 bssid[ETH_ALEN]; |
19957bb3 | 417 | |
667503dd JB |
418 | ASSERT_WDEV_LOCK(wdev); |
419 | ||
19957bb3 JB |
420 | if (!rdev->ops->deauth) |
421 | return; | |
422 | ||
95de817b JB |
423 | if (!wdev->current_bss) |
424 | return; | |
19957bb3 | 425 | |
95de817b | 426 | memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN); |
ceca7b71 JB |
427 | cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0, |
428 | WLAN_REASON_DEAUTH_LEAVING, false); | |
19957bb3 | 429 | } |
9588bbd5 | 430 | |
2e161f78 | 431 | struct cfg80211_mgmt_registration { |
026331c4 | 432 | struct list_head list; |
33d8783c | 433 | struct wireless_dev *wdev; |
026331c4 | 434 | |
15e47304 | 435 | u32 nlportid; |
026331c4 JM |
436 | |
437 | int match_len; | |
438 | ||
2e161f78 JB |
439 | __le16 frame_type; |
440 | ||
9dba48a6 JB |
441 | bool multicast_rx; |
442 | ||
026331c4 JM |
443 | u8 match[]; |
444 | }; | |
445 | ||
6cd536fe | 446 | static void cfg80211_mgmt_registrations_update(struct wireless_dev *wdev) |
33d8783c | 447 | { |
6cd536fe JB |
448 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); |
449 | struct wireless_dev *tmp; | |
33d8783c | 450 | struct cfg80211_mgmt_registration *reg; |
6cd536fe | 451 | struct mgmt_frame_regs upd = {}; |
33d8783c | 452 | |
a05829a7 | 453 | lockdep_assert_held(&rdev->wiphy.mtx); |
33d8783c | 454 | |
79ea1e12 JB |
455 | spin_lock_bh(&wdev->mgmt_registrations_lock); |
456 | if (!wdev->mgmt_registrations_need_update) { | |
457 | spin_unlock_bh(&wdev->mgmt_registrations_lock); | |
458 | return; | |
459 | } | |
460 | ||
6cd536fe JB |
461 | rcu_read_lock(); |
462 | list_for_each_entry_rcu(tmp, &rdev->wiphy.wdev_list, list) { | |
79ea1e12 | 463 | list_for_each_entry(reg, &tmp->mgmt_registrations, list) { |
6cd536fe | 464 | u32 mask = BIT(le16_to_cpu(reg->frame_type) >> 4); |
9dba48a6 JB |
465 | u32 mcast_mask = 0; |
466 | ||
467 | if (reg->multicast_rx) | |
468 | mcast_mask = mask; | |
33d8783c | 469 | |
6cd536fe | 470 | upd.global_stypes |= mask; |
9dba48a6 JB |
471 | upd.global_mcast_stypes |= mcast_mask; |
472 | ||
473 | if (tmp == wdev) { | |
6cd536fe | 474 | upd.interface_stypes |= mask; |
9dba48a6 JB |
475 | upd.interface_mcast_stypes |= mcast_mask; |
476 | } | |
33d8783c | 477 | } |
33d8783c | 478 | } |
6cd536fe JB |
479 | rcu_read_unlock(); |
480 | ||
79ea1e12 JB |
481 | wdev->mgmt_registrations_need_update = 0; |
482 | spin_unlock_bh(&wdev->mgmt_registrations_lock); | |
483 | ||
6cd536fe | 484 | rdev_update_mgmt_frame_registrations(rdev, wdev, &upd); |
33d8783c JB |
485 | } |
486 | ||
6cd536fe | 487 | void cfg80211_mgmt_registrations_update_wk(struct work_struct *wk) |
33d8783c | 488 | { |
79ea1e12 JB |
489 | struct cfg80211_registered_device *rdev; |
490 | struct wireless_dev *wdev; | |
491 | ||
492 | rdev = container_of(wk, struct cfg80211_registered_device, | |
493 | mgmt_registrations_update_wk); | |
33d8783c | 494 | |
a05829a7 | 495 | wiphy_lock(&rdev->wiphy); |
79ea1e12 JB |
496 | list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) |
497 | cfg80211_mgmt_registrations_update(wdev); | |
a05829a7 | 498 | wiphy_unlock(&rdev->wiphy); |
33d8783c JB |
499 | } |
500 | ||
15e47304 | 501 | int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_portid, |
2e161f78 | 502 | u16 frame_type, const u8 *match_data, |
9dba48a6 JB |
503 | int match_len, bool multicast_rx, |
504 | struct netlink_ext_ack *extack) | |
026331c4 | 505 | { |
2e161f78 | 506 | struct cfg80211_mgmt_registration *reg, *nreg; |
026331c4 | 507 | int err = 0; |
2e161f78 | 508 | u16 mgmt_type; |
9dba48a6 | 509 | bool update_multicast = false; |
2e161f78 JB |
510 | |
511 | if (!wdev->wiphy->mgmt_stypes) | |
512 | return -EOPNOTSUPP; | |
513 | ||
ff74c51e IP |
514 | if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT) { |
515 | NL_SET_ERR_MSG(extack, "frame type not management"); | |
2e161f78 | 516 | return -EINVAL; |
ff74c51e | 517 | } |
2e161f78 | 518 | |
ff74c51e IP |
519 | if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) { |
520 | NL_SET_ERR_MSG(extack, "Invalid frame type"); | |
2e161f78 | 521 | return -EINVAL; |
ff74c51e | 522 | } |
2e161f78 JB |
523 | |
524 | mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4; | |
ff74c51e IP |
525 | if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type))) { |
526 | NL_SET_ERR_MSG(extack, | |
527 | "Registration to specific type not supported"); | |
528 | return -EINVAL; | |
529 | } | |
530 | ||
531 | /* | |
532 | * To support Pre Association Security Negotiation (PASN), registration | |
533 | * for authentication frames should be supported. However, as some | |
534 | * versions of the user space daemons wrongly register to all types of | |
535 | * authentication frames (which might result in unexpected behavior) | |
536 | * allow such registration if the request is for a specific | |
537 | * authentication algorithm number. | |
538 | */ | |
539 | if (wdev->iftype == NL80211_IFTYPE_STATION && | |
540 | (frame_type & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_AUTH && | |
541 | !(match_data && match_len >= 2)) { | |
542 | NL_SET_ERR_MSG(extack, | |
543 | "Authentication algorithm number required"); | |
2e161f78 | 544 | return -EINVAL; |
ff74c51e | 545 | } |
026331c4 JM |
546 | |
547 | nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL); | |
548 | if (!nreg) | |
549 | return -ENOMEM; | |
550 | ||
2e161f78 | 551 | spin_lock_bh(&wdev->mgmt_registrations_lock); |
026331c4 | 552 | |
2e161f78 | 553 | list_for_each_entry(reg, &wdev->mgmt_registrations, list) { |
026331c4 JM |
554 | int mlen = min(match_len, reg->match_len); |
555 | ||
2e161f78 JB |
556 | if (frame_type != le16_to_cpu(reg->frame_type)) |
557 | continue; | |
558 | ||
026331c4 | 559 | if (memcmp(reg->match, match_data, mlen) == 0) { |
9dba48a6 JB |
560 | if (reg->multicast_rx != multicast_rx) { |
561 | update_multicast = true; | |
562 | reg->multicast_rx = multicast_rx; | |
563 | break; | |
564 | } | |
ff74c51e | 565 | NL_SET_ERR_MSG(extack, "Match already configured"); |
026331c4 JM |
566 | err = -EALREADY; |
567 | break; | |
568 | } | |
569 | } | |
570 | ||
6cd536fe | 571 | if (err) |
026331c4 | 572 | goto out; |
026331c4 | 573 | |
9dba48a6 JB |
574 | if (update_multicast) { |
575 | kfree(nreg); | |
576 | } else { | |
577 | memcpy(nreg->match, match_data, match_len); | |
578 | nreg->match_len = match_len; | |
579 | nreg->nlportid = snd_portid; | |
580 | nreg->frame_type = cpu_to_le16(frame_type); | |
581 | nreg->wdev = wdev; | |
582 | nreg->multicast_rx = multicast_rx; | |
583 | list_add(&nreg->list, &wdev->mgmt_registrations); | |
584 | } | |
79ea1e12 | 585 | wdev->mgmt_registrations_need_update = 1; |
33d8783c JB |
586 | spin_unlock_bh(&wdev->mgmt_registrations_lock); |
587 | ||
6cd536fe | 588 | cfg80211_mgmt_registrations_update(wdev); |
271733cf | 589 | |
33d8783c JB |
590 | return 0; |
591 | ||
026331c4 | 592 | out: |
6cd536fe | 593 | kfree(nreg); |
2e161f78 | 594 | spin_unlock_bh(&wdev->mgmt_registrations_lock); |
271733cf | 595 | |
026331c4 JM |
596 | return err; |
597 | } | |
598 | ||
15e47304 | 599 | void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlportid) |
026331c4 | 600 | { |
271733cf | 601 | struct wiphy *wiphy = wdev->wiphy; |
f26cbf40 | 602 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
2e161f78 | 603 | struct cfg80211_mgmt_registration *reg, *tmp; |
026331c4 | 604 | |
2e161f78 | 605 | spin_lock_bh(&wdev->mgmt_registrations_lock); |
026331c4 | 606 | |
2e161f78 | 607 | list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) { |
15e47304 | 608 | if (reg->nlportid != nlportid) |
271733cf JB |
609 | continue; |
610 | ||
271733cf | 611 | list_del(®->list); |
6cd536fe | 612 | kfree(reg); |
33d8783c | 613 | |
79ea1e12 JB |
614 | wdev->mgmt_registrations_need_update = 1; |
615 | schedule_work(&rdev->mgmt_registrations_update_wk); | |
026331c4 JM |
616 | } |
617 | ||
2e161f78 | 618 | spin_unlock_bh(&wdev->mgmt_registrations_lock); |
28946da7 | 619 | |
5de17984 AS |
620 | if (nlportid && rdev->crit_proto_nlportid == nlportid) { |
621 | rdev->crit_proto_nlportid = 0; | |
622 | rdev_crit_proto_stop(rdev, wdev); | |
623 | } | |
624 | ||
15e47304 EB |
625 | if (nlportid == wdev->ap_unexpected_nlportid) |
626 | wdev->ap_unexpected_nlportid = 0; | |
026331c4 JM |
627 | } |
628 | ||
2e161f78 | 629 | void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev) |
026331c4 | 630 | { |
6cd536fe | 631 | struct cfg80211_mgmt_registration *reg, *tmp; |
026331c4 | 632 | |
2e161f78 | 633 | spin_lock_bh(&wdev->mgmt_registrations_lock); |
6cd536fe JB |
634 | list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) { |
635 | list_del(®->list); | |
636 | kfree(reg); | |
637 | } | |
79ea1e12 | 638 | wdev->mgmt_registrations_need_update = 1; |
2e161f78 | 639 | spin_unlock_bh(&wdev->mgmt_registrations_lock); |
33d8783c | 640 | |
6cd536fe | 641 | cfg80211_mgmt_registrations_update(wdev); |
026331c4 JM |
642 | } |
643 | ||
2e161f78 | 644 | int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev, |
71bbc994 | 645 | struct wireless_dev *wdev, |
b176e629 | 646 | struct cfg80211_mgmt_tx_params *params, u64 *cookie) |
026331c4 | 647 | { |
026331c4 | 648 | const struct ieee80211_mgmt *mgmt; |
2e161f78 JB |
649 | u16 stype; |
650 | ||
651 | if (!wdev->wiphy->mgmt_stypes) | |
652 | return -EOPNOTSUPP; | |
026331c4 | 653 | |
2e161f78 | 654 | if (!rdev->ops->mgmt_tx) |
026331c4 | 655 | return -EOPNOTSUPP; |
2e161f78 | 656 | |
b176e629 | 657 | if (params->len < 24 + 1) |
026331c4 JM |
658 | return -EINVAL; |
659 | ||
b176e629 | 660 | mgmt = (const struct ieee80211_mgmt *)params->buf; |
2e161f78 JB |
661 | |
662 | if (!ieee80211_is_mgmt(mgmt->frame_control)) | |
026331c4 | 663 | return -EINVAL; |
2e161f78 JB |
664 | |
665 | stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE; | |
666 | if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4))) | |
667 | return -EINVAL; | |
668 | ||
669 | if (ieee80211_is_action(mgmt->frame_control) && | |
670 | mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) { | |
663fcafd JB |
671 | int err = 0; |
672 | ||
fe100acd JB |
673 | wdev_lock(wdev); |
674 | ||
663fcafd JB |
675 | switch (wdev->iftype) { |
676 | case NL80211_IFTYPE_ADHOC: | |
677 | case NL80211_IFTYPE_STATION: | |
678 | case NL80211_IFTYPE_P2P_CLIENT: | |
679 | if (!wdev->current_bss) { | |
680 | err = -ENOTCONN; | |
681 | break; | |
682 | } | |
683 | ||
ac422d3c JP |
684 | if (!ether_addr_equal(wdev->current_bss->pub.bssid, |
685 | mgmt->bssid)) { | |
663fcafd JB |
686 | err = -ENOTCONN; |
687 | break; | |
688 | } | |
689 | ||
690 | /* | |
691 | * check for IBSS DA must be done by driver as | |
692 | * cfg80211 doesn't track the stations | |
693 | */ | |
694 | if (wdev->iftype == NL80211_IFTYPE_ADHOC) | |
695 | break; | |
fe100acd | 696 | |
663fcafd | 697 | /* for station, check that DA is the AP */ |
ac422d3c JP |
698 | if (!ether_addr_equal(wdev->current_bss->pub.bssid, |
699 | mgmt->da)) { | |
663fcafd JB |
700 | err = -ENOTCONN; |
701 | break; | |
702 | } | |
703 | break; | |
704 | case NL80211_IFTYPE_AP: | |
705 | case NL80211_IFTYPE_P2P_GO: | |
706 | case NL80211_IFTYPE_AP_VLAN: | |
98104fde | 707 | if (!ether_addr_equal(mgmt->bssid, wdev_address(wdev))) |
663fcafd JB |
708 | err = -EINVAL; |
709 | break; | |
0778a6a3 | 710 | case NL80211_IFTYPE_MESH_POINT: |
ac422d3c | 711 | if (!ether_addr_equal(mgmt->sa, mgmt->bssid)) { |
0778a6a3 JC |
712 | err = -EINVAL; |
713 | break; | |
714 | } | |
715 | /* | |
716 | * check for mesh DA must be done by driver as | |
717 | * cfg80211 doesn't track the stations | |
718 | */ | |
719 | break; | |
98104fde JB |
720 | case NL80211_IFTYPE_P2P_DEVICE: |
721 | /* | |
722 | * fall through, P2P device only supports | |
723 | * public action frames | |
724 | */ | |
cb3b7d87 | 725 | case NL80211_IFTYPE_NAN: |
663fcafd JB |
726 | default: |
727 | err = -EOPNOTSUPP; | |
728 | break; | |
729 | } | |
fe100acd | 730 | wdev_unlock(wdev); |
663fcafd JB |
731 | |
732 | if (err) | |
733 | return err; | |
026331c4 JM |
734 | } |
735 | ||
ab5bb2d5 | 736 | if (!ether_addr_equal(mgmt->sa, wdev_address(wdev))) { |
737 | /* Allow random TA to be used with Public Action frames if the | |
738 | * driver has indicated support for this. Otherwise, only allow | |
739 | * the local address to be used. | |
740 | */ | |
741 | if (!ieee80211_is_action(mgmt->frame_control) || | |
742 | mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) | |
743 | return -EINVAL; | |
744 | if (!wdev->current_bss && | |
745 | !wiphy_ext_feature_isset( | |
746 | &rdev->wiphy, | |
747 | NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA)) | |
748 | return -EINVAL; | |
749 | if (wdev->current_bss && | |
750 | !wiphy_ext_feature_isset( | |
751 | &rdev->wiphy, | |
752 | NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED)) | |
753 | return -EINVAL; | |
754 | } | |
026331c4 JM |
755 | |
756 | /* Transmit the Action frame as requested by user space */ | |
b176e629 | 757 | return rdev_mgmt_tx(rdev, wdev, params, cookie); |
026331c4 JM |
758 | } |
759 | ||
e76fede8 TP |
760 | bool cfg80211_rx_mgmt_khz(struct wireless_dev *wdev, int freq, int sig_dbm, |
761 | const u8 *buf, size_t len, u32 flags) | |
026331c4 | 762 | { |
026331c4 | 763 | struct wiphy *wiphy = wdev->wiphy; |
f26cbf40 | 764 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
2e161f78 JB |
765 | struct cfg80211_mgmt_registration *reg; |
766 | const struct ieee80211_txrx_stypes *stypes = | |
767 | &wiphy->mgmt_stypes[wdev->iftype]; | |
768 | struct ieee80211_mgmt *mgmt = (void *)buf; | |
769 | const u8 *data; | |
770 | int data_len; | |
026331c4 | 771 | bool result = false; |
2e161f78 JB |
772 | __le16 ftype = mgmt->frame_control & |
773 | cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE); | |
774 | u16 stype; | |
026331c4 | 775 | |
6c2fb1e6 | 776 | trace_cfg80211_rx_mgmt(wdev, freq, sig_dbm); |
2e161f78 | 777 | stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4; |
026331c4 | 778 | |
4ee3e063 BL |
779 | if (!(stypes->rx & BIT(stype))) { |
780 | trace_cfg80211_return_bool(false); | |
2e161f78 | 781 | return false; |
4ee3e063 | 782 | } |
026331c4 | 783 | |
2e161f78 JB |
784 | data = buf + ieee80211_hdrlen(mgmt->frame_control); |
785 | data_len = len - ieee80211_hdrlen(mgmt->frame_control); | |
786 | ||
787 | spin_lock_bh(&wdev->mgmt_registrations_lock); | |
788 | ||
789 | list_for_each_entry(reg, &wdev->mgmt_registrations, list) { | |
790 | if (reg->frame_type != ftype) | |
791 | continue; | |
026331c4 | 792 | |
2e161f78 | 793 | if (reg->match_len > data_len) |
026331c4 JM |
794 | continue; |
795 | ||
2e161f78 | 796 | if (memcmp(reg->match, data, reg->match_len)) |
026331c4 JM |
797 | continue; |
798 | ||
799 | /* found match! */ | |
800 | ||
801 | /* Indicate the received Action frame to user space */ | |
15e47304 | 802 | if (nl80211_send_mgmt(rdev, wdev, reg->nlportid, |
6c2fb1e6 | 803 | freq, sig_dbm, |
970fdfa8 | 804 | buf, len, flags, GFP_ATOMIC)) |
026331c4 JM |
805 | continue; |
806 | ||
807 | result = true; | |
808 | break; | |
809 | } | |
810 | ||
2e161f78 | 811 | spin_unlock_bh(&wdev->mgmt_registrations_lock); |
026331c4 | 812 | |
4ee3e063 | 813 | trace_cfg80211_return_bool(result); |
026331c4 JM |
814 | return result; |
815 | } | |
e76fede8 | 816 | EXPORT_SYMBOL(cfg80211_rx_mgmt_khz); |
026331c4 | 817 | |
b35a51c7 VT |
818 | void cfg80211_sched_dfs_chan_update(struct cfg80211_registered_device *rdev) |
819 | { | |
820 | cancel_delayed_work(&rdev->dfs_update_channels_wk); | |
821 | queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk, 0); | |
822 | } | |
823 | ||
04f39047 SW |
824 | void cfg80211_dfs_channels_update_work(struct work_struct *work) |
825 | { | |
a85a7e28 | 826 | struct delayed_work *delayed_work = to_delayed_work(work); |
04f39047 SW |
827 | struct cfg80211_registered_device *rdev; |
828 | struct cfg80211_chan_def chandef; | |
829 | struct ieee80211_supported_band *sband; | |
830 | struct ieee80211_channel *c; | |
831 | struct wiphy *wiphy; | |
832 | bool check_again = false; | |
833 | unsigned long timeout, next_time = 0; | |
b35a51c7 VT |
834 | unsigned long time_dfs_update; |
835 | enum nl80211_radar_event radar_event; | |
04f39047 SW |
836 | int bandid, i; |
837 | ||
04f39047 SW |
838 | rdev = container_of(delayed_work, struct cfg80211_registered_device, |
839 | dfs_update_channels_wk); | |
840 | wiphy = &rdev->wiphy; | |
841 | ||
5fe231e8 | 842 | rtnl_lock(); |
57fbcce3 | 843 | for (bandid = 0; bandid < NUM_NL80211_BANDS; bandid++) { |
04f39047 SW |
844 | sband = wiphy->bands[bandid]; |
845 | if (!sband) | |
846 | continue; | |
847 | ||
848 | for (i = 0; i < sband->n_channels; i++) { | |
849 | c = &sband->channels[i]; | |
850 | ||
b35a51c7 VT |
851 | if (!(c->flags & IEEE80211_CHAN_RADAR)) |
852 | continue; | |
853 | ||
854 | if (c->dfs_state != NL80211_DFS_UNAVAILABLE && | |
855 | c->dfs_state != NL80211_DFS_AVAILABLE) | |
04f39047 SW |
856 | continue; |
857 | ||
b35a51c7 VT |
858 | if (c->dfs_state == NL80211_DFS_UNAVAILABLE) { |
859 | time_dfs_update = IEEE80211_DFS_MIN_NOP_TIME_MS; | |
860 | radar_event = NL80211_RADAR_NOP_FINISHED; | |
861 | } else { | |
862 | if (regulatory_pre_cac_allowed(wiphy) || | |
863 | cfg80211_any_wiphy_oper_chan(wiphy, c)) | |
864 | continue; | |
865 | ||
866 | time_dfs_update = REG_PRE_CAC_EXPIRY_GRACE_MS; | |
867 | radar_event = NL80211_RADAR_PRE_CAC_EXPIRED; | |
868 | } | |
869 | ||
870 | timeout = c->dfs_state_entered + | |
871 | msecs_to_jiffies(time_dfs_update); | |
04f39047 SW |
872 | |
873 | if (time_after_eq(jiffies, timeout)) { | |
874 | c->dfs_state = NL80211_DFS_USABLE; | |
bbe09bbc MK |
875 | c->dfs_state_entered = jiffies; |
876 | ||
04f39047 SW |
877 | cfg80211_chandef_create(&chandef, c, |
878 | NL80211_CHAN_NO_HT); | |
879 | ||
880 | nl80211_radar_notify(rdev, &chandef, | |
b35a51c7 VT |
881 | radar_event, NULL, |
882 | GFP_ATOMIC); | |
89766727 VT |
883 | |
884 | regulatory_propagate_dfs_state(wiphy, &chandef, | |
885 | c->dfs_state, | |
886 | radar_event); | |
04f39047 SW |
887 | continue; |
888 | } | |
889 | ||
890 | if (!check_again) | |
891 | next_time = timeout - jiffies; | |
892 | else | |
893 | next_time = min(next_time, timeout - jiffies); | |
894 | check_again = true; | |
895 | } | |
896 | } | |
5fe231e8 | 897 | rtnl_unlock(); |
04f39047 SW |
898 | |
899 | /* reschedule if there are other channels waiting to be cleared again */ | |
900 | if (check_again) | |
901 | queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk, | |
902 | next_time); | |
903 | } | |
904 | ||
905 | ||
906 | void cfg80211_radar_event(struct wiphy *wiphy, | |
907 | struct cfg80211_chan_def *chandef, | |
908 | gfp_t gfp) | |
909 | { | |
f26cbf40 | 910 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
04f39047 SW |
911 | |
912 | trace_cfg80211_radar_event(wiphy, chandef); | |
913 | ||
914 | /* only set the chandef supplied channel to unavailable, in | |
915 | * case the radar is detected on only one of multiple channels | |
916 | * spanned by the chandef. | |
917 | */ | |
918 | cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_UNAVAILABLE); | |
919 | ||
b35a51c7 | 920 | cfg80211_sched_dfs_chan_update(rdev); |
04f39047 SW |
921 | |
922 | nl80211_radar_notify(rdev, chandef, NL80211_RADAR_DETECTED, NULL, gfp); | |
89766727 VT |
923 | |
924 | memcpy(&rdev->radar_chandef, chandef, sizeof(struct cfg80211_chan_def)); | |
925 | queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk); | |
04f39047 SW |
926 | } |
927 | EXPORT_SYMBOL(cfg80211_radar_event); | |
928 | ||
929 | void cfg80211_cac_event(struct net_device *netdev, | |
d2859df5 | 930 | const struct cfg80211_chan_def *chandef, |
04f39047 SW |
931 | enum nl80211_radar_event event, gfp_t gfp) |
932 | { | |
933 | struct wireless_dev *wdev = netdev->ieee80211_ptr; | |
934 | struct wiphy *wiphy = wdev->wiphy; | |
f26cbf40 | 935 | struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); |
04f39047 SW |
936 | unsigned long timeout; |
937 | ||
938 | trace_cfg80211_cac_event(netdev, event); | |
939 | ||
85096451 | 940 | if (WARN_ON(!wdev->cac_started && event != NL80211_RADAR_CAC_STARTED)) |
04f39047 SW |
941 | return; |
942 | ||
9e0e2961 | 943 | if (WARN_ON(!wdev->chandef.chan)) |
04f39047 SW |
944 | return; |
945 | ||
04f39047 SW |
946 | switch (event) { |
947 | case NL80211_RADAR_CAC_FINISHED: | |
948 | timeout = wdev->cac_start_time + | |
31559f35 | 949 | msecs_to_jiffies(wdev->cac_time_ms); |
04f39047 | 950 | WARN_ON(!time_after_eq(jiffies, timeout)); |
d2859df5 | 951 | cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE); |
89766727 VT |
952 | memcpy(&rdev->cac_done_chandef, chandef, |
953 | sizeof(struct cfg80211_chan_def)); | |
954 | queue_work(cfg80211_wq, &rdev->propagate_cac_done_wk); | |
b35a51c7 | 955 | cfg80211_sched_dfs_chan_update(rdev); |
7b506ff6 | 956 | fallthrough; |
04f39047 | 957 | case NL80211_RADAR_CAC_ABORTED: |
2cb021f5 DL |
958 | wdev->cac_started = false; |
959 | break; | |
960 | case NL80211_RADAR_CAC_STARTED: | |
961 | wdev->cac_started = true; | |
04f39047 SW |
962 | break; |
963 | default: | |
964 | WARN_ON(1); | |
965 | return; | |
966 | } | |
04f39047 | 967 | |
d2859df5 | 968 | nl80211_radar_notify(rdev, chandef, event, netdev, gfp); |
04f39047 SW |
969 | } |
970 | EXPORT_SYMBOL(cfg80211_cac_event); |