projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wireless: remove remaining qual code
[deliverable/linux.git] / net / wireless / mlme.c
CommitLineData
6039f6d2
JM		 1/*
2 * cfg80211 MLME SAP interface
3 *
4 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
5 */
6
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/netdevice.h>
10#include <linux/nl80211.h>
a9a11622 11#include <linux/wireless.h>
6039f6d2 12#include <net/cfg80211.h>
a9a11622 13#include <net/iw_handler.h>
6039f6d2
JM		 14#include "core.h"
15#include "nl80211.h"
16
cb0b4beb 17void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len)
6039f6d2 18{
19957bb3
JB		 19 struct wireless_dev *wdev = dev->ieee80211_ptr;
20 struct wiphy *wiphy = wdev->wiphy;
6039f6d2 21 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
19957bb3
JB		 22 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
23 u8 *bssid = mgmt->bssid;
24 int i;
25 u16 status = le16_to_cpu(mgmt->u.auth.status_code);
26 bool done = false;
27
667503dd 28 wdev_lock(wdev);
cb0b4beb 29
19957bb3
JB		 30 for (i = 0; i < MAX_AUTH_BSSES; i++) {
31 if (wdev->authtry_bsses[i] &&
32 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid,
33 ETH_ALEN) == 0) {
34 if (status == WLAN_STATUS_SUCCESS) {
35 wdev->auth_bsses[i] = wdev->authtry_bsses[i];
36 } else {
37 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
38 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
39 }
40 wdev->authtry_bsses[i] = NULL;
41 done = true;
42 break;
43 }
44 }
45
46 WARN_ON(!done);
6829c878 47
cb0b4beb 48 nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
6829c878 49 cfg80211_sme_rx_auth(dev, buf, len);
667503dd
JB		 50
51 wdev_unlock(wdev);
6039f6d2
JM		 52}
53EXPORT_SYMBOL(cfg80211_send_rx_auth);
54
cb0b4beb 55void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len)
6039f6d2 56{
6829c878
JB		 57 u16 status_code;
58 struct wireless_dev *wdev = dev->ieee80211_ptr;
59 struct wiphy *wiphy = wdev->wiphy;
6039f6d2 60 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6829c878
JB		 61 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
62 u8 *ie = mgmt->u.assoc_resp.variable;
19957bb3 63 int i, ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
df7fc0f9 64 struct cfg80211_internal_bss *bss = NULL;
6829c878 65
667503dd 66 wdev_lock(wdev);
cb0b4beb 67
6829c878
JB		 68 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
69
f401a6f7
JB		 70 /*
71 * This is a bit of a hack, we don't notify userspace of
72 * a (re-)association reply if we tried to send a reassoc
73 * and got a reject -- we only try again with an assoc
74 * frame instead of reassoc.
75 */
76 if (status_code != WLAN_STATUS_SUCCESS && wdev->conn &&
77 cfg80211_sme_failed_reassoc(wdev))
78 goto out;
79
cb0b4beb 80 nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL);
6829c878 81
19957bb3 82 if (status_code == WLAN_STATUS_SUCCESS) {
df7fc0f9
JB		 83 for (i = 0; i < MAX_AUTH_BSSES; i++) {
84 if (!wdev->auth_bsses[i])
85 continue;
86 if (memcmp(wdev->auth_bsses[i]->pub.bssid, mgmt->bssid,
87 ETH_ALEN) == 0) {
88 bss = wdev->auth_bsses[i];
19957bb3 89 wdev->auth_bsses[i] = NULL;
df7fc0f9
JB		 90 /* additional reference to drop hold */
91 cfg80211_ref_bss(bss);
19957bb3
JB		 92 break;
93 }
94 }
95
df7fc0f9 96 WARN_ON(!bss);
7d930bc3
JB		 97 } else if (wdev->conn) {
98 cfg80211_sme_failed_assoc(wdev);
7d930bc3
JB		 99 /*
100 * do not call connect_result() now because the
101 * sme will schedule work that does it later.
102 */
103 goto out;
df7fc0f9
JB		 104 }
105
ea416a79
JB		 106 if (!wdev->conn && wdev->sme_state == CFG80211_SME_IDLE) {
107 /*
108 * This is for the userspace SME, the CONNECTING
109 * state will be changed to CONNECTED by
110 * __cfg80211_connect_result() below.
111 */
112 wdev->sme_state = CFG80211_SME_CONNECTING;
113 }
114
df7fc0f9
JB		 115 /* this consumes one bss reference (unless bss is NULL) */
116 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
117 status_code,
118 status_code == WLAN_STATUS_SUCCESS,
119 bss ? &bss->pub : NULL);
120 /* drop hold now, and also reference acquired above */
121 if (bss) {
122 cfg80211_unhold_bss(bss);
123 cfg80211_put_bss(&bss->pub);
19957bb3 124 }
667503dd 125
f401a6f7 126 out:
667503dd 127 wdev_unlock(wdev);
6039f6d2
JM		 128}
129EXPORT_SYMBOL(cfg80211_send_rx_assoc);
130
ce470613 131void __cfg80211_send_deauth(struct net_device *dev,
667503dd 132 const u8 *buf, size_t len)
6039f6d2 133{
6829c878
JB		 134 struct wireless_dev *wdev = dev->ieee80211_ptr;
135 struct wiphy *wiphy = wdev->wiphy;
6039f6d2 136 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6829c878 137 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
19957bb3
JB		 138 const u8 *bssid = mgmt->bssid;
139 int i;
6829c878 140
667503dd 141 ASSERT_WDEV_LOCK(wdev);
cb0b4beb
JB		 142
143 nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
6829c878 144
19957bb3
JB		 145 if (wdev->current_bss &&
146 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
19957bb3
JB		 147 cfg80211_unhold_bss(wdev->current_bss);
148 cfg80211_put_bss(&wdev->current_bss->pub);
149 wdev->current_bss = NULL;
150 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
151 if (wdev->auth_bsses[i] &&
152 memcmp(wdev->auth_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
153 cfg80211_unhold_bss(wdev->auth_bsses[i]);
154 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
155 wdev->auth_bsses[i] = NULL;
19957bb3
JB		 156 break;
157 }
158 if (wdev->authtry_bsses[i] &&
159 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
160 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
161 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
162 wdev->authtry_bsses[i] = NULL;
19957bb3
JB		 163 break;
164 }
165 }
19957bb3 166
6829c878
JB		 167 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
168 u16 reason_code;
169 bool from_ap;
170
171 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
172
e458b8a2 173 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
667503dd 174 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
6829c878 175 } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
667503dd
JB		 176 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
177 WLAN_STATUS_UNSPECIFIED_FAILURE,
df7fc0f9 178 false, NULL);
667503dd
JB		 179 }
180}
ce470613 181EXPORT_SYMBOL(__cfg80211_send_deauth);
667503dd 182
ce470613 183void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
667503dd
JB		 184{
185 struct wireless_dev *wdev = dev->ieee80211_ptr;
186
ce470613
HS		 187 wdev_lock(wdev);
188 __cfg80211_send_deauth(dev, buf, len);
189 wdev_unlock(wdev);
6039f6d2 190}
53b46b84 191EXPORT_SYMBOL(cfg80211_send_deauth);
6039f6d2 192
ce470613 193void __cfg80211_send_disassoc(struct net_device *dev,
667503dd 194 const u8 *buf, size_t len)
6039f6d2 195{
6829c878
JB		 196 struct wireless_dev *wdev = dev->ieee80211_ptr;
197 struct wiphy *wiphy = wdev->wiphy;
6039f6d2 198 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6829c878 199 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
19957bb3
JB		 200 const u8 *bssid = mgmt->bssid;
201 int i;
202 u16 reason_code;
203 bool from_ap;
204 bool done = false;
6829c878 205
596a07c1 206 ASSERT_WDEV_LOCK(wdev);
cb0b4beb
JB		 207
208 nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
a3b8b056 209
596a07c1
JB		 210 if (wdev->sme_state != CFG80211_SME_CONNECTED)
211 return;
6829c878 212
19957bb3 213 if (wdev->current_bss &&
b935df01 214 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
19957bb3
JB		 215 for (i = 0; i < MAX_AUTH_BSSES; i++) {
216 if (wdev->authtry_bsses[i] || wdev->auth_bsses[i])
217 continue;
218 wdev->auth_bsses[i] = wdev->current_bss;
219 wdev->current_bss = NULL;
220 done = true;
221 cfg80211_sme_disassoc(dev, i);
222 break;
223 }
224 WARN_ON(!done);
225 } else
226 WARN_ON(1);
6829c878 227
6829c878 228
19957bb3
JB		 229 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
230
e458b8a2 231 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
667503dd 232 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
667503dd 233}
ce470613 234EXPORT_SYMBOL(__cfg80211_send_disassoc);
667503dd 235
ce470613 236void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
667503dd
JB		 237{
238 struct wireless_dev *wdev = dev->ieee80211_ptr;
239
ce470613
HS		 240 wdev_lock(wdev);
241 __cfg80211_send_disassoc(dev, buf, len);
242 wdev_unlock(wdev);
1965c853 243}
6829c878 244EXPORT_SYMBOL(cfg80211_send_disassoc);
1965c853 245
a58ce43f 246static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
1965c853 247{
19957bb3
JB		 248 int i;
249 bool done = false;
250
a58ce43f 251 ASSERT_WDEV_LOCK(wdev);
19957bb3
JB		 252
253 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
254 if (wdev->authtry_bsses[i] &&
255 memcmp(wdev->authtry_bsses[i]->pub.bssid,
256 addr, ETH_ALEN) == 0) {
257 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
258 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
259 wdev->authtry_bsses[i] = NULL;
260 done = true;
261 break;
262 }
263 }
264
265 WARN_ON(!done);
a58ce43f
JB		 266}
267
268void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
269{
270 __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
271}
272EXPORT_SYMBOL(__cfg80211_auth_canceled);
273
274void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
275{
276 struct wireless_dev *wdev = dev->ieee80211_ptr;
277 struct wiphy *wiphy = wdev->wiphy;
278 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
279
280 wdev_lock(wdev);
281
282 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
283 if (wdev->sme_state == CFG80211_SME_CONNECTING)
284 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
285 WLAN_STATUS_UNSPECIFIED_FAILURE,
286 false, NULL);
287
288 __cfg80211_auth_remove(wdev, addr);
667503dd
JB		 289
290 wdev_unlock(wdev);
1965c853
JM		 291}
292EXPORT_SYMBOL(cfg80211_send_auth_timeout);
293
cb0b4beb 294void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
1965c853 295{
6829c878
JB		 296 struct wireless_dev *wdev = dev->ieee80211_ptr;
297 struct wiphy *wiphy = wdev->wiphy;
1965c853 298 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
19957bb3
JB		 299 int i;
300 bool done = false;
301
667503dd 302 wdev_lock(wdev);
cb0b4beb
JB		 303
304 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
6829c878 305 if (wdev->sme_state == CFG80211_SME_CONNECTING)
667503dd
JB		 306 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
307 WLAN_STATUS_UNSPECIFIED_FAILURE,
df7fc0f9 308 false, NULL);
19957bb3
JB		 309
310 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
311 if (wdev->auth_bsses[i] &&
312 memcmp(wdev->auth_bsses[i]->pub.bssid,
313 addr, ETH_ALEN) == 0) {
314 cfg80211_unhold_bss(wdev->auth_bsses[i]);
315 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
316 wdev->auth_bsses[i] = NULL;
317 done = true;
318 break;
319 }
320 }
321
322 WARN_ON(!done);
667503dd
JB		 323
324 wdev_unlock(wdev);
1965c853
JM		 325}
326EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
327
a3b8b056
JM		 328void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
329 enum nl80211_key_type key_type, int key_id,
e6d6e342 330 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 331{
332 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
333 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3d23e349 334#ifdef CONFIG_CFG80211_WEXT
f58d4ed9 335 union iwreq_data wrqu;
e6d6e342 336 char *buf = kmalloc(128, gfp);
f58d4ed9
JB		 337
338 if (buf) {
339 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
340 "keyid=%d %scast addr=%pM)", key_id,
341 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
342 addr);
343 memset(&wrqu, 0, sizeof(wrqu));
344 wrqu.data.length = strlen(buf);
345 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
346 kfree(buf);
347 }
348#endif
349
e6d6e342 350 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
a3b8b056
JM		 351}
352EXPORT_SYMBOL(cfg80211_michael_mic_failure);
19957bb3
JB		 353
354/* some MLME handling for userspace SME */
667503dd
JB		 355int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
356 struct net_device *dev,
357 struct ieee80211_channel *chan,
358 enum nl80211_auth_type auth_type,
359 const u8 *bssid,
360 const u8 *ssid, int ssid_len,
fffd0934
JB		 361 const u8 *ie, int ie_len,
362 const u8 *key, int key_len, int key_idx)
19957bb3
JB		 363{
364 struct wireless_dev *wdev = dev->ieee80211_ptr;
365 struct cfg80211_auth_request req;
366 struct cfg80211_internal_bss *bss;
367 int i, err, slot = -1, nfree = 0;
368
667503dd
JB		 369 ASSERT_WDEV_LOCK(wdev);
370
fffd0934
JB		 371 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
372 if (!key || !key_len || key_idx < 0 || key_idx > 4)
373 return -EINVAL;
374
0a9b5e17
JB		 375 if (wdev->current_bss &&
376 memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
377 return -EALREADY;
378
379 for (i = 0; i < MAX_AUTH_BSSES; i++) {
380 if (wdev->authtry_bsses[i] &&
381 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
382 ETH_ALEN) == 0)
383 return -EALREADY;
384 if (wdev->auth_bsses[i] &&
385 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
386 ETH_ALEN) == 0)
387 return -EALREADY;
388 }
389
19957bb3
JB		 390 memset(&req, 0, sizeof(req));
391
392 req.ie = ie;
393 req.ie_len = ie_len;
394 req.auth_type = auth_type;
395 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
396 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
fffd0934
JB		 397 req.key = key;
398 req.key_len = key_len;
399 req.key_idx = key_idx;
19957bb3
JB		 400 if (!req.bss)
401 return -ENOENT;
402
403 bss = bss_from_pub(req.bss);
404
19957bb3
JB		 405 for (i = 0; i < MAX_AUTH_BSSES; i++) {
406 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
407 slot = i;
408 nfree++;
409 }
410 }
411
412 /* we need one free slot for disassoc and one for this auth */
413 if (nfree < 2) {
414 err = -ENOSPC;
415 goto out;
416 }
417
418 wdev->authtry_bsses[slot] = bss;
419 cfg80211_hold_bss(bss);
420
421 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
422 if (err) {
423 wdev->authtry_bsses[slot] = NULL;
424 cfg80211_unhold_bss(bss);
425 }
426
427 out:
428 if (err)
429 cfg80211_put_bss(req.bss);
430 return err;
431}
432
667503dd
JB		 433int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
434 struct net_device *dev, struct ieee80211_channel *chan,
435 enum nl80211_auth_type auth_type, const u8 *bssid,
436 const u8 *ssid, int ssid_len,
fffd0934
JB		 437 const u8 *ie, int ie_len,
438 const u8 *key, int key_len, int key_idx)
667503dd
JB		 439{
440 int err;
441
442 wdev_lock(dev->ieee80211_ptr);
443 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
fffd0934
JB		 444 ssid, ssid_len, ie, ie_len,
445 key, key_len, key_idx);
667503dd
JB		 446 wdev_unlock(dev->ieee80211_ptr);
447
448 return err;
449}
450
451int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
452 struct net_device *dev,
453 struct ieee80211_channel *chan,
454 const u8 *bssid, const u8 *prev_bssid,
455 const u8 *ssid, int ssid_len,
456 const u8 *ie, int ie_len, bool use_mfp,
457 struct cfg80211_crypto_settings *crypt)
19957bb3
JB		 458{
459 struct wireless_dev *wdev = dev->ieee80211_ptr;
460 struct cfg80211_assoc_request req;
461 struct cfg80211_internal_bss *bss;
462 int i, err, slot = -1;
24b6b15f 463 bool was_connected = false;
19957bb3 464
667503dd
JB		 465 ASSERT_WDEV_LOCK(wdev);
466
19957bb3
JB		 467 memset(&req, 0, sizeof(req));
468
24b6b15f
JM		 469 if (wdev->current_bss && prev_bssid &&
470 memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
471 /*
472 * Trying to reassociate: Allow this to proceed and let the old
473 * association to be dropped when the new one is completed.
474 */
475 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
476 was_connected = true;
477 wdev->sme_state = CFG80211_SME_CONNECTING;
478 }
479 } else if (wdev->current_bss)
19957bb3
JB		 480 return -EALREADY;
481
482 req.ie = ie;
483 req.ie_len = ie_len;
484 memcpy(&req.crypto, crypt, sizeof(req.crypto));
485 req.use_mfp = use_mfp;
3e5d7649 486 req.prev_bssid = prev_bssid;
19957bb3
JB		 487 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
488 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
24b6b15f
JM		 489 if (!req.bss) {
490 if (was_connected)
491 wdev->sme_state = CFG80211_SME_CONNECTED;
19957bb3 492 return -ENOENT;
24b6b15f 493 }
19957bb3
JB		 494
495 bss = bss_from_pub(req.bss);
496
497 for (i = 0; i < MAX_AUTH_BSSES; i++) {
498 if (bss == wdev->auth_bsses[i]) {
499 slot = i;
500 break;
501 }
502 }
503
504 if (slot < 0) {
505 err = -ENOTCONN;
506 goto out;
507 }
508
509 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
510 out:
24b6b15f
JM		 511 if (err && was_connected)
512 wdev->sme_state = CFG80211_SME_CONNECTED;
19957bb3
JB		 513 /* still a reference in wdev->auth_bsses[slot] */
514 cfg80211_put_bss(req.bss);
515 return err;
516}
517
667503dd
JB		 518int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
519 struct net_device *dev,
520 struct ieee80211_channel *chan,
521 const u8 *bssid, const u8 *prev_bssid,
522 const u8 *ssid, int ssid_len,
523 const u8 *ie, int ie_len, bool use_mfp,
524 struct cfg80211_crypto_settings *crypt)
525{
526 struct wireless_dev *wdev = dev->ieee80211_ptr;
527 int err;
528
529 wdev_lock(wdev);
530 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
531 ssid, ssid_len, ie, ie_len, use_mfp, crypt);
532 wdev_unlock(wdev);
533
534 return err;
535}
536
537int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
538 struct net_device *dev, const u8 *bssid,
539 const u8 *ie, int ie_len, u16 reason)
19957bb3
JB		 540{
541 struct wireless_dev *wdev = dev->ieee80211_ptr;
542 struct cfg80211_deauth_request req;
543 int i;
544
667503dd
JB		 545 ASSERT_WDEV_LOCK(wdev);
546
19957bb3
JB		 547 memset(&req, 0, sizeof(req));
548 req.reason_code = reason;
549 req.ie = ie;
550 req.ie_len = ie_len;
551 if (wdev->current_bss &&
552 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
553 req.bss = &wdev->current_bss->pub;
554 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
555 if (wdev->auth_bsses[i] &&
556 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
557 req.bss = &wdev->auth_bsses[i]->pub;
558 break;
559 }
560 if (wdev->authtry_bsses[i] &&
561 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
562 req.bss = &wdev->authtry_bsses[i]->pub;
563 break;
564 }
565 }
566
567 if (!req.bss)
568 return -ENOTCONN;
569
667503dd 570 return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
19957bb3
JB		 571}
572
667503dd
JB		 573int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
574 struct net_device *dev, const u8 *bssid,
575 const u8 *ie, int ie_len, u16 reason)
576{
577 struct wireless_dev *wdev = dev->ieee80211_ptr;
578 int err;
579
580 wdev_lock(wdev);
581 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason);
582 wdev_unlock(wdev);
583
584 return err;
585}
586
587static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
588 struct net_device *dev, const u8 *bssid,
589 const u8 *ie, int ie_len, u16 reason)
19957bb3
JB		 590{
591 struct wireless_dev *wdev = dev->ieee80211_ptr;
592 struct cfg80211_disassoc_request req;
593
667503dd
JB		 594 ASSERT_WDEV_LOCK(wdev);
595
f9d6b402
JB		 596 if (wdev->sme_state != CFG80211_SME_CONNECTED)
597 return -ENOTCONN;
598
599 if (WARN_ON(!wdev->current_bss))
600 return -ENOTCONN;
601
19957bb3
JB		 602 memset(&req, 0, sizeof(req));
603 req.reason_code = reason;
604 req.ie = ie;
605 req.ie_len = ie_len;
606 if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
607 req.bss = &wdev->current_bss->pub;
608 else
609 return -ENOTCONN;
610
667503dd
JB		 611 return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
612}
613
614int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
615 struct net_device *dev, const u8 *bssid,
616 const u8 *ie, int ie_len, u16 reason)
617{
618 struct wireless_dev *wdev = dev->ieee80211_ptr;
619 int err;
620
621 wdev_lock(wdev);
622 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason);
623 wdev_unlock(wdev);
624
625 return err;
19957bb3
JB		 626}
627
628void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
629 struct net_device *dev)
630{
631 struct wireless_dev *wdev = dev->ieee80211_ptr;
632 struct cfg80211_deauth_request req;
633 int i;
634
667503dd
JB		 635 ASSERT_WDEV_LOCK(wdev);
636
19957bb3
JB		 637 if (!rdev->ops->deauth)
638 return;
639
640 memset(&req, 0, sizeof(req));
641 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
642 req.ie = NULL;
643 req.ie_len = 0;
644
645 if (wdev->current_bss) {
646 req.bss = &wdev->current_bss->pub;
667503dd 647 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
19957bb3
JB		 648 if (wdev->current_bss) {
649 cfg80211_unhold_bss(wdev->current_bss);
650 cfg80211_put_bss(&wdev->current_bss->pub);
651 wdev->current_bss = NULL;
652 }
653 }
654
655 for (i = 0; i < MAX_AUTH_BSSES; i++) {
656 if (wdev->auth_bsses[i]) {
657 req.bss = &wdev->auth_bsses[i]->pub;
667503dd 658 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
19957bb3
JB		 659 if (wdev->auth_bsses[i]) {
660 cfg80211_unhold_bss(wdev->auth_bsses[i]);
661 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
662 wdev->auth_bsses[i] = NULL;
663 }
664 }
665 if (wdev->authtry_bsses[i]) {
666 req.bss = &wdev->authtry_bsses[i]->pub;
667503dd 667 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
19957bb3
JB		 668 if (wdev->authtry_bsses[i]) {
669 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
670 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
671 wdev->authtry_bsses[i] = NULL;
672 }
673 }
674 }
675}
Linux kernel - Deliverables
This page took 0.185091 seconds and 5 git commands to generate.