2 * SME code for cfg80211's connect emulation.
4 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright (C) 2009 Intel Corporation. All rights reserved.
8 #include <linux/etherdevice.h>
9 #include <linux/if_arp.h>
10 #include <linux/workqueue.h>
11 #include <net/cfg80211.h>
12 #include <net/rtnetlink.h>
15 struct cfg80211_conn {
16 struct cfg80211_connect_params params;
17 /* these are sub-states of the _CONNECTING sme_state */
20 CFG80211_CONN_SCANNING,
21 CFG80211_CONN_SCAN_AGAIN,
22 CFG80211_CONN_AUTHENTICATE_NEXT,
23 CFG80211_CONN_AUTHENTICATING,
24 CFG80211_CONN_ASSOCIATE_NEXT,
25 CFG80211_CONN_ASSOCIATING,
34 static int cfg80211_conn_scan(struct wireless_dev *wdev)
36 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
37 struct cfg80211_scan_request *request;
41 ASSERT_RDEV_LOCK(rdev);
42 ASSERT_WDEV_LOCK(wdev);
47 if (wdev->conn->params.channel) {
50 enum ieee80211_band band;
53 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
54 if (!wdev->wiphy->bands[band])
56 n_channels += wdev->wiphy->bands[band]->n_channels;
59 request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
60 sizeof(request->channels[0]) * n_channels,
65 request->channels = (void *)((char *)request + sizeof(*request));
66 if (wdev->conn->params.channel)
67 request->channels[0] = wdev->conn->params.channel;
70 enum ieee80211_band band;
72 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
73 if (!wdev->wiphy->bands[band])
75 for (j = 0; j < wdev->wiphy->bands[band]->n_channels;
77 request->channels[i] =
78 &wdev->wiphy->bands[band]->channels[j];
81 request->n_channels = n_channels;
82 request->ssids = (void *)(request->channels + n_channels);
85 memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
86 wdev->conn->params.ssid_len);
87 request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
89 request->ifidx = wdev->netdev->ifindex;
90 request->wiphy = &rdev->wiphy;
92 rdev->scan_req = request;
94 err = rdev->ops->scan(wdev->wiphy, wdev->netdev, request);
96 wdev->conn->state = CFG80211_CONN_SCANNING;
97 nl80211_send_scan_start(rdev, wdev->netdev);
99 rdev->scan_req = NULL;
105 static int cfg80211_conn_do_work(struct wireless_dev *wdev)
107 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
108 struct cfg80211_connect_params *params;
111 ASSERT_WDEV_LOCK(wdev);
116 params = &wdev->conn->params;
118 switch (wdev->conn->state) {
119 case CFG80211_CONN_SCAN_AGAIN:
120 return cfg80211_conn_scan(wdev);
121 case CFG80211_CONN_AUTHENTICATE_NEXT:
122 BUG_ON(!rdev->ops->auth);
123 wdev->conn->state = CFG80211_CONN_AUTHENTICATING;
124 return __cfg80211_mlme_auth(rdev, wdev->netdev,
125 params->channel, params->auth_type,
127 params->ssid, params->ssid_len,
129 case CFG80211_CONN_ASSOCIATE_NEXT:
130 BUG_ON(!rdev->ops->assoc);
131 wdev->conn->state = CFG80211_CONN_ASSOCIATING;
133 * We could, later, implement roaming here and then actually
134 * set prev_bssid to non-NULL. But then we need to be aware
135 * that some APs don't like that -- so we'd need to retry
138 err = __cfg80211_mlme_assoc(rdev, wdev->netdev,
139 params->channel, params->bssid,
141 params->ssid, params->ssid_len,
142 params->ie, params->ie_len,
143 false, ¶ms->crypto);
145 __cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
147 WLAN_REASON_DEAUTH_LEAVING);
154 void cfg80211_conn_work(struct work_struct *work)
156 struct cfg80211_registered_device *rdev =
157 container_of(work, struct cfg80211_registered_device, conn_work);
158 struct wireless_dev *wdev;
161 cfg80211_lock_rdev(rdev);
162 mutex_lock(&rdev->devlist_mtx);
164 list_for_each_entry(wdev, &rdev->netdev_list, list) {
166 if (!netif_running(wdev->netdev)) {
170 if (wdev->sme_state != CFG80211_SME_CONNECTING) {
174 if (cfg80211_conn_do_work(wdev))
175 __cfg80211_connect_result(
177 wdev->conn->params.bssid,
179 WLAN_STATUS_UNSPECIFIED_FAILURE,
184 mutex_unlock(&rdev->devlist_mtx);
185 cfg80211_unlock_rdev(rdev);
189 static bool cfg80211_get_conn_bss(struct wireless_dev *wdev)
191 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
192 struct cfg80211_bss *bss;
193 u16 capa = WLAN_CAPABILITY_ESS;
195 ASSERT_WDEV_LOCK(wdev);
197 if (wdev->conn->params.privacy)
198 capa |= WLAN_CAPABILITY_PRIVACY;
200 bss = cfg80211_get_bss(wdev->wiphy, NULL, wdev->conn->params.bssid,
201 wdev->conn->params.ssid,
202 wdev->conn->params.ssid_len,
203 WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_PRIVACY,
208 memcpy(wdev->conn->bssid, bss->bssid, ETH_ALEN);
209 wdev->conn->params.bssid = wdev->conn->bssid;
210 wdev->conn->params.channel = bss->channel;
211 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
212 schedule_work(&rdev->conn_work);
214 cfg80211_put_bss(bss);
218 static void __cfg80211_sme_scan_done(struct net_device *dev)
220 struct wireless_dev *wdev = dev->ieee80211_ptr;
221 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
223 ASSERT_WDEV_LOCK(wdev);
225 if (wdev->sme_state != CFG80211_SME_CONNECTING)
228 if (WARN_ON(!wdev->conn))
231 if (wdev->conn->state != CFG80211_CONN_SCANNING &&
232 wdev->conn->state != CFG80211_CONN_SCAN_AGAIN)
235 if (!cfg80211_get_conn_bss(wdev)) {
237 if (wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)
238 schedule_work(&rdev->conn_work);
240 __cfg80211_connect_result(
242 wdev->conn->params.bssid,
244 WLAN_STATUS_UNSPECIFIED_FAILURE,
249 void cfg80211_sme_scan_done(struct net_device *dev)
251 struct wireless_dev *wdev = dev->ieee80211_ptr;
254 __cfg80211_sme_scan_done(dev);
258 void cfg80211_sme_rx_auth(struct net_device *dev,
259 const u8 *buf, size_t len)
261 struct wireless_dev *wdev = dev->ieee80211_ptr;
262 struct wiphy *wiphy = wdev->wiphy;
263 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
264 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
265 u16 status_code = le16_to_cpu(mgmt->u.auth.status_code);
267 ASSERT_WDEV_LOCK(wdev);
269 /* should only RX auth frames when connecting */
270 if (wdev->sme_state != CFG80211_SME_CONNECTING)
273 if (WARN_ON(!wdev->conn))
276 if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
277 wdev->conn->auto_auth &&
278 wdev->conn->params.auth_type != NL80211_AUTHTYPE_NETWORK_EAP) {
279 /* select automatically between only open, shared, leap */
280 switch (wdev->conn->params.auth_type) {
281 case NL80211_AUTHTYPE_OPEN_SYSTEM:
282 wdev->conn->params.auth_type =
283 NL80211_AUTHTYPE_SHARED_KEY;
285 case NL80211_AUTHTYPE_SHARED_KEY:
286 wdev->conn->params.auth_type =
287 NL80211_AUTHTYPE_NETWORK_EAP;
291 wdev->conn->params.auth_type =
292 NL80211_AUTHTYPE_OPEN_SYSTEM;
295 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
296 schedule_work(&rdev->conn_work);
297 } else if (status_code != WLAN_STATUS_SUCCESS) {
298 wdev->sme_state = CFG80211_SME_IDLE;
301 } else if (wdev->sme_state == CFG80211_SME_CONNECTING &&
302 wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
303 wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
304 schedule_work(&rdev->conn_work);
308 void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
309 const u8 *req_ie, size_t req_ie_len,
310 const u8 *resp_ie, size_t resp_ie_len,
311 u16 status, bool wextev)
313 struct wireless_dev *wdev = dev->ieee80211_ptr;
314 struct cfg80211_bss *bss;
315 #ifdef CONFIG_WIRELESS_EXT
316 union iwreq_data wrqu;
319 ASSERT_WDEV_LOCK(wdev);
321 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
324 if (wdev->sme_state == CFG80211_SME_CONNECTED)
325 nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), dev,
326 bssid, req_ie, req_ie_len,
327 resp_ie, resp_ie_len, GFP_KERNEL);
329 nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev,
330 bssid, req_ie, req_ie_len,
331 resp_ie, resp_ie_len,
334 #ifdef CONFIG_WIRELESS_EXT
336 if (req_ie && status == WLAN_STATUS_SUCCESS) {
337 memset(&wrqu, 0, sizeof(wrqu));
338 wrqu.data.length = req_ie_len;
339 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, req_ie);
342 if (resp_ie && status == WLAN_STATUS_SUCCESS) {
343 memset(&wrqu, 0, sizeof(wrqu));
344 wrqu.data.length = resp_ie_len;
345 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
348 memset(&wrqu, 0, sizeof(wrqu));
349 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
350 if (bssid && status == WLAN_STATUS_SUCCESS)
351 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
352 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
356 if (status == WLAN_STATUS_SUCCESS &&
357 wdev->sme_state == CFG80211_SME_IDLE) {
358 wdev->sme_state = CFG80211_SME_CONNECTED;
362 if (wdev->sme_state != CFG80211_SME_CONNECTING)
365 if (wdev->current_bss) {
366 cfg80211_unhold_bss(wdev->current_bss);
367 cfg80211_put_bss(&wdev->current_bss->pub);
368 wdev->current_bss = NULL;
372 wdev->conn->state = CFG80211_CONN_IDLE;
374 if (status == WLAN_STATUS_SUCCESS) {
375 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
376 wdev->ssid, wdev->ssid_len,
378 WLAN_CAPABILITY_ESS);
383 cfg80211_hold_bss(bss_from_pub(bss));
384 wdev->current_bss = bss_from_pub(bss);
386 wdev->sme_state = CFG80211_SME_CONNECTED;
388 wdev->sme_state = CFG80211_SME_IDLE;
394 void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
395 const u8 *req_ie, size_t req_ie_len,
396 const u8 *resp_ie, size_t resp_ie_len,
397 u16 status, gfp_t gfp)
399 struct wireless_dev *wdev = dev->ieee80211_ptr;
400 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
401 struct cfg80211_event *ev;
404 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
408 ev->type = EVENT_CONNECT_RESULT;
409 memcpy(ev->cr.bssid, bssid, ETH_ALEN);
410 ev->cr.req_ie = ((u8 *)ev) + sizeof(*ev);
411 ev->cr.req_ie_len = req_ie_len;
412 memcpy((void *)ev->cr.req_ie, req_ie, req_ie_len);
413 ev->cr.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
414 ev->cr.resp_ie_len = resp_ie_len;
415 memcpy((void *)ev->cr.resp_ie, resp_ie, resp_ie_len);
416 ev->cr.status = status;
418 spin_lock_irqsave(&wdev->event_lock, flags);
419 list_add_tail(&ev->list, &wdev->event_list);
420 spin_unlock_irqrestore(&wdev->event_lock, flags);
421 schedule_work(&rdev->event_work);
423 EXPORT_SYMBOL(cfg80211_connect_result);
425 void __cfg80211_roamed(struct wireless_dev *wdev, const u8 *bssid,
426 const u8 *req_ie, size_t req_ie_len,
427 const u8 *resp_ie, size_t resp_ie_len)
429 struct cfg80211_bss *bss;
430 #ifdef CONFIG_WIRELESS_EXT
431 union iwreq_data wrqu;
434 ASSERT_WDEV_LOCK(wdev);
436 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
439 if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
442 /* internal error -- how did we get to CONNECTED w/o BSS? */
443 if (WARN_ON(!wdev->current_bss)) {
447 cfg80211_unhold_bss(wdev->current_bss);
448 cfg80211_put_bss(&wdev->current_bss->pub);
449 wdev->current_bss = NULL;
451 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
452 wdev->ssid, wdev->ssid_len,
453 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
458 cfg80211_hold_bss(bss_from_pub(bss));
459 wdev->current_bss = bss_from_pub(bss);
461 nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), wdev->netdev, bssid,
462 req_ie, req_ie_len, resp_ie, resp_ie_len,
465 #ifdef CONFIG_WIRELESS_EXT
467 memset(&wrqu, 0, sizeof(wrqu));
468 wrqu.data.length = req_ie_len;
469 wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
474 memset(&wrqu, 0, sizeof(wrqu));
475 wrqu.data.length = resp_ie_len;
476 wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
480 memset(&wrqu, 0, sizeof(wrqu));
481 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
482 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
483 wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
487 void cfg80211_roamed(struct net_device *dev, const u8 *bssid,
488 const u8 *req_ie, size_t req_ie_len,
489 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
491 struct wireless_dev *wdev = dev->ieee80211_ptr;
492 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
493 struct cfg80211_event *ev;
496 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
500 ev->type = EVENT_ROAMED;
501 memcpy(ev->rm.bssid, bssid, ETH_ALEN);
502 ev->rm.req_ie = ((u8 *)ev) + sizeof(*ev);
503 ev->rm.req_ie_len = req_ie_len;
504 memcpy((void *)ev->rm.req_ie, req_ie, req_ie_len);
505 ev->rm.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
506 ev->rm.resp_ie_len = resp_ie_len;
507 memcpy((void *)ev->rm.resp_ie, resp_ie, resp_ie_len);
509 spin_lock_irqsave(&wdev->event_lock, flags);
510 list_add_tail(&ev->list, &wdev->event_list);
511 spin_unlock_irqrestore(&wdev->event_lock, flags);
512 schedule_work(&rdev->event_work);
514 EXPORT_SYMBOL(cfg80211_roamed);
516 void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
517 size_t ie_len, u16 reason, bool from_ap)
519 struct wireless_dev *wdev = dev->ieee80211_ptr;
520 #ifdef CONFIG_WIRELESS_EXT
521 union iwreq_data wrqu;
524 ASSERT_WDEV_LOCK(wdev);
526 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
529 if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
532 if (wdev->current_bss) {
533 cfg80211_unhold_bss(wdev->current_bss);
534 cfg80211_put_bss(&wdev->current_bss->pub);
537 wdev->current_bss = NULL;
538 wdev->sme_state = CFG80211_SME_IDLE;
541 kfree(wdev->conn->ie);
542 wdev->conn->ie = NULL;
547 nl80211_send_disconnected(wiphy_to_dev(wdev->wiphy), dev,
548 reason, ie, ie_len, from_ap);
550 #ifdef CONFIG_WIRELESS_EXT
551 memset(&wrqu, 0, sizeof(wrqu));
552 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
553 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
557 void cfg80211_disconnected(struct net_device *dev, u16 reason,
558 u8 *ie, size_t ie_len, gfp_t gfp)
560 struct wireless_dev *wdev = dev->ieee80211_ptr;
561 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
562 struct cfg80211_event *ev;
565 ev = kzalloc(sizeof(*ev) + ie_len, gfp);
569 ev->type = EVENT_DISCONNECTED;
570 ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
571 ev->dc.ie_len = ie_len;
572 memcpy((void *)ev->dc.ie, ie, ie_len);
573 ev->dc.reason = reason;
575 spin_lock_irqsave(&wdev->event_lock, flags);
576 list_add_tail(&ev->list, &wdev->event_list);
577 spin_unlock_irqrestore(&wdev->event_lock, flags);
578 schedule_work(&rdev->event_work);
580 EXPORT_SYMBOL(cfg80211_disconnected);
582 int __cfg80211_connect(struct cfg80211_registered_device *rdev,
583 struct net_device *dev,
584 struct cfg80211_connect_params *connect)
586 struct wireless_dev *wdev = dev->ieee80211_ptr;
589 ASSERT_WDEV_LOCK(wdev);
591 if (wdev->sme_state != CFG80211_SME_IDLE)
594 if (!rdev->ops->connect) {
595 if (!rdev->ops->auth || !rdev->ops->assoc)
598 if (WARN_ON(wdev->conn))
601 wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
606 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
608 memcpy(&wdev->conn->params, connect, sizeof(*connect));
609 if (connect->bssid) {
610 wdev->conn->params.bssid = wdev->conn->bssid;
611 memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
615 wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
617 wdev->conn->params.ie = wdev->conn->ie;
618 if (!wdev->conn->ie) {
625 if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
626 wdev->conn->auto_auth = true;
627 /* start with open system ... should mostly work */
628 wdev->conn->params.auth_type =
629 NL80211_AUTHTYPE_OPEN_SYSTEM;
631 wdev->conn->auto_auth = false;
634 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
635 wdev->ssid_len = connect->ssid_len;
636 wdev->conn->params.ssid = wdev->ssid;
637 wdev->conn->params.ssid_len = connect->ssid_len;
639 /* don't care about result -- but fill bssid & channel */
640 if (!wdev->conn->params.bssid || !wdev->conn->params.channel)
641 cfg80211_get_conn_bss(wdev);
643 wdev->sme_state = CFG80211_SME_CONNECTING;
645 /* we're good if we have both BSSID and channel */
646 if (wdev->conn->params.bssid && wdev->conn->params.channel) {
647 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
648 err = cfg80211_conn_do_work(wdev);
650 /* otherwise we'll need to scan for the AP first */
651 err = cfg80211_conn_scan(wdev);
653 * If we can't scan right now, then we need to scan again
654 * after the current scan finished, since the parameters
655 * changed (unless we find a good AP anyway).
659 wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
665 wdev->sme_state = CFG80211_SME_IDLE;
670 wdev->sme_state = CFG80211_SME_CONNECTING;
671 err = rdev->ops->connect(&rdev->wiphy, dev, connect);
673 wdev->sme_state = CFG80211_SME_IDLE;
677 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
678 wdev->ssid_len = connect->ssid_len;
684 int cfg80211_connect(struct cfg80211_registered_device *rdev,
685 struct net_device *dev,
686 struct cfg80211_connect_params *connect)
690 wdev_lock(dev->ieee80211_ptr);
691 err = __cfg80211_connect(rdev, dev, connect);
692 wdev_unlock(dev->ieee80211_ptr);
697 int __cfg80211_disconnect(struct cfg80211_registered_device *rdev,
698 struct net_device *dev, u16 reason, bool wextev)
700 struct wireless_dev *wdev = dev->ieee80211_ptr;
703 ASSERT_WDEV_LOCK(wdev);
705 if (wdev->sme_state == CFG80211_SME_IDLE)
708 if (!rdev->ops->disconnect) {
709 if (!rdev->ops->deauth)
712 /* was it connected by userspace SME? */
714 cfg80211_mlme_down(rdev, dev);
718 if (wdev->sme_state == CFG80211_SME_CONNECTING &&
719 (wdev->conn->state == CFG80211_CONN_SCANNING ||
720 wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)) {
721 wdev->sme_state = CFG80211_SME_IDLE;
727 /* wdev->conn->params.bssid must be set if > SCANNING */
728 err = __cfg80211_mlme_deauth(rdev, dev,
729 wdev->conn->params.bssid,
734 err = rdev->ops->disconnect(&rdev->wiphy, dev, reason);
739 if (wdev->sme_state == CFG80211_SME_CONNECTED)
740 __cfg80211_disconnected(dev, NULL, 0, 0, false);
741 else if (wdev->sme_state == CFG80211_SME_CONNECTING)
742 __cfg80211_connect_result(dev, NULL, NULL, 0, NULL, 0,
743 WLAN_STATUS_UNSPECIFIED_FAILURE,
749 int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
750 struct net_device *dev,
751 u16 reason, bool wextev)
755 wdev_lock(dev->ieee80211_ptr);
756 err = __cfg80211_disconnect(rdev, dev, reason, wextev);
757 wdev_unlock(dev->ieee80211_ptr);
762 void cfg80211_sme_disassoc(struct net_device *dev, int idx)
764 struct wireless_dev *wdev = dev->ieee80211_ptr;
765 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
768 ASSERT_WDEV_LOCK(wdev);
773 if (wdev->conn->state == CFG80211_CONN_IDLE)
777 * Ok, so the association was made by this SME -- we don't
778 * want it any more so deauthenticate too.
781 if (!wdev->auth_bsses[idx])
784 memcpy(bssid, wdev->auth_bsses[idx]->pub.bssid, ETH_ALEN);
785 if (cfg80211_mlme_deauth(rdev, dev, bssid,
786 NULL, 0, WLAN_REASON_DEAUTH_LEAVING)) {
787 /* whatever -- assume gone anyway */
788 cfg80211_unhold_bss(wdev->auth_bsses[idx]);
789 cfg80211_put_bss(&wdev->auth_bsses[idx]->pub);
790 wdev->auth_bsses[idx] = NULL;