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 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
300 } else if (wdev->sme_state == CFG80211_SME_CONNECTING &&
301 wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
302 wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
303 schedule_work(&rdev->conn_work);
307 void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
308 const u8 *req_ie, size_t req_ie_len,
309 const u8 *resp_ie, size_t resp_ie_len,
310 u16 status, bool wextev)
312 struct wireless_dev *wdev = dev->ieee80211_ptr;
313 struct cfg80211_bss *bss;
314 #ifdef CONFIG_WIRELESS_EXT
315 union iwreq_data wrqu;
318 ASSERT_WDEV_LOCK(wdev);
320 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
323 if (wdev->sme_state == CFG80211_SME_CONNECTED)
324 nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), dev,
325 bssid, req_ie, req_ie_len,
326 resp_ie, resp_ie_len, GFP_KERNEL);
328 nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev,
329 bssid, req_ie, req_ie_len,
330 resp_ie, resp_ie_len,
333 #ifdef CONFIG_WIRELESS_EXT
335 if (req_ie && status == WLAN_STATUS_SUCCESS) {
336 memset(&wrqu, 0, sizeof(wrqu));
337 wrqu.data.length = req_ie_len;
338 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, req_ie);
341 if (resp_ie && status == WLAN_STATUS_SUCCESS) {
342 memset(&wrqu, 0, sizeof(wrqu));
343 wrqu.data.length = resp_ie_len;
344 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
347 memset(&wrqu, 0, sizeof(wrqu));
348 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
349 if (bssid && status == WLAN_STATUS_SUCCESS)
350 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
351 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
355 if (status == WLAN_STATUS_SUCCESS &&
356 wdev->sme_state == CFG80211_SME_IDLE) {
357 wdev->sme_state = CFG80211_SME_CONNECTED;
361 if (wdev->sme_state != CFG80211_SME_CONNECTING)
364 if (wdev->current_bss) {
365 cfg80211_unhold_bss(wdev->current_bss);
366 cfg80211_put_bss(&wdev->current_bss->pub);
367 wdev->current_bss = NULL;
371 wdev->conn->state = CFG80211_CONN_IDLE;
373 if (status == WLAN_STATUS_SUCCESS) {
374 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
375 wdev->ssid, wdev->ssid_len,
377 WLAN_CAPABILITY_ESS);
382 cfg80211_hold_bss(bss_from_pub(bss));
383 wdev->current_bss = bss_from_pub(bss);
385 wdev->sme_state = CFG80211_SME_CONNECTED;
387 wdev->sme_state = CFG80211_SME_IDLE;
393 void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
394 const u8 *req_ie, size_t req_ie_len,
395 const u8 *resp_ie, size_t resp_ie_len,
396 u16 status, gfp_t gfp)
398 struct wireless_dev *wdev = dev->ieee80211_ptr;
399 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
400 struct cfg80211_event *ev;
403 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
407 ev->type = EVENT_CONNECT_RESULT;
408 memcpy(ev->cr.bssid, bssid, ETH_ALEN);
409 ev->cr.req_ie = ((u8 *)ev) + sizeof(*ev);
410 ev->cr.req_ie_len = req_ie_len;
411 memcpy((void *)ev->cr.req_ie, req_ie, req_ie_len);
412 ev->cr.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
413 ev->cr.resp_ie_len = resp_ie_len;
414 memcpy((void *)ev->cr.resp_ie, resp_ie, resp_ie_len);
415 ev->cr.status = status;
417 spin_lock_irqsave(&wdev->event_lock, flags);
418 list_add_tail(&ev->list, &wdev->event_list);
419 spin_unlock_irqrestore(&wdev->event_lock, flags);
420 schedule_work(&rdev->event_work);
422 EXPORT_SYMBOL(cfg80211_connect_result);
424 void __cfg80211_roamed(struct wireless_dev *wdev, const u8 *bssid,
425 const u8 *req_ie, size_t req_ie_len,
426 const u8 *resp_ie, size_t resp_ie_len)
428 struct cfg80211_bss *bss;
429 #ifdef CONFIG_WIRELESS_EXT
430 union iwreq_data wrqu;
433 ASSERT_WDEV_LOCK(wdev);
435 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
438 if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
441 /* internal error -- how did we get to CONNECTED w/o BSS? */
442 if (WARN_ON(!wdev->current_bss)) {
446 cfg80211_unhold_bss(wdev->current_bss);
447 cfg80211_put_bss(&wdev->current_bss->pub);
448 wdev->current_bss = NULL;
450 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
451 wdev->ssid, wdev->ssid_len,
452 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
457 cfg80211_hold_bss(bss_from_pub(bss));
458 wdev->current_bss = bss_from_pub(bss);
460 nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), wdev->netdev, bssid,
461 req_ie, req_ie_len, resp_ie, resp_ie_len,
464 #ifdef CONFIG_WIRELESS_EXT
466 memset(&wrqu, 0, sizeof(wrqu));
467 wrqu.data.length = req_ie_len;
468 wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
473 memset(&wrqu, 0, sizeof(wrqu));
474 wrqu.data.length = resp_ie_len;
475 wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
479 memset(&wrqu, 0, sizeof(wrqu));
480 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
481 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
482 wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
486 void cfg80211_roamed(struct net_device *dev, const u8 *bssid,
487 const u8 *req_ie, size_t req_ie_len,
488 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
490 struct wireless_dev *wdev = dev->ieee80211_ptr;
491 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
492 struct cfg80211_event *ev;
495 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
499 ev->type = EVENT_ROAMED;
500 memcpy(ev->rm.bssid, bssid, ETH_ALEN);
501 ev->rm.req_ie = ((u8 *)ev) + sizeof(*ev);
502 ev->rm.req_ie_len = req_ie_len;
503 memcpy((void *)ev->rm.req_ie, req_ie, req_ie_len);
504 ev->rm.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
505 ev->rm.resp_ie_len = resp_ie_len;
506 memcpy((void *)ev->rm.resp_ie, resp_ie, resp_ie_len);
508 spin_lock_irqsave(&wdev->event_lock, flags);
509 list_add_tail(&ev->list, &wdev->event_list);
510 spin_unlock_irqrestore(&wdev->event_lock, flags);
511 schedule_work(&rdev->event_work);
513 EXPORT_SYMBOL(cfg80211_roamed);
515 void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
516 size_t ie_len, u16 reason, bool from_ap)
518 struct wireless_dev *wdev = dev->ieee80211_ptr;
519 #ifdef CONFIG_WIRELESS_EXT
520 union iwreq_data wrqu;
523 ASSERT_WDEV_LOCK(wdev);
525 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
528 if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
531 if (wdev->current_bss) {
532 cfg80211_unhold_bss(wdev->current_bss);
533 cfg80211_put_bss(&wdev->current_bss->pub);
536 wdev->current_bss = NULL;
537 wdev->sme_state = CFG80211_SME_IDLE;
540 kfree(wdev->conn->ie);
541 wdev->conn->ie = NULL;
546 nl80211_send_disconnected(wiphy_to_dev(wdev->wiphy), dev,
547 reason, ie, ie_len, from_ap);
549 #ifdef CONFIG_WIRELESS_EXT
550 memset(&wrqu, 0, sizeof(wrqu));
551 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
552 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
556 void cfg80211_disconnected(struct net_device *dev, u16 reason,
557 u8 *ie, size_t ie_len, gfp_t gfp)
559 struct wireless_dev *wdev = dev->ieee80211_ptr;
560 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
561 struct cfg80211_event *ev;
564 ev = kzalloc(sizeof(*ev) + ie_len, gfp);
568 ev->type = EVENT_DISCONNECTED;
569 ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
570 ev->dc.ie_len = ie_len;
571 memcpy((void *)ev->dc.ie, ie, ie_len);
572 ev->dc.reason = reason;
574 spin_lock_irqsave(&wdev->event_lock, flags);
575 list_add_tail(&ev->list, &wdev->event_list);
576 spin_unlock_irqrestore(&wdev->event_lock, flags);
577 schedule_work(&rdev->event_work);
579 EXPORT_SYMBOL(cfg80211_disconnected);
581 int __cfg80211_connect(struct cfg80211_registered_device *rdev,
582 struct net_device *dev,
583 struct cfg80211_connect_params *connect)
585 struct wireless_dev *wdev = dev->ieee80211_ptr;
588 ASSERT_WDEV_LOCK(wdev);
590 if (wdev->sme_state != CFG80211_SME_IDLE)
593 if (!rdev->ops->connect) {
594 if (!rdev->ops->auth || !rdev->ops->assoc)
597 if (WARN_ON(wdev->conn))
600 wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
605 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
607 memcpy(&wdev->conn->params, connect, sizeof(*connect));
608 if (connect->bssid) {
609 wdev->conn->params.bssid = wdev->conn->bssid;
610 memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
614 wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
616 wdev->conn->params.ie = wdev->conn->ie;
617 if (!wdev->conn->ie) {
624 if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
625 wdev->conn->auto_auth = true;
626 /* start with open system ... should mostly work */
627 wdev->conn->params.auth_type =
628 NL80211_AUTHTYPE_OPEN_SYSTEM;
630 wdev->conn->auto_auth = false;
633 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
634 wdev->ssid_len = connect->ssid_len;
635 wdev->conn->params.ssid = wdev->ssid;
636 wdev->conn->params.ssid_len = connect->ssid_len;
638 /* don't care about result -- but fill bssid & channel */
639 if (!wdev->conn->params.bssid || !wdev->conn->params.channel)
640 cfg80211_get_conn_bss(wdev);
642 wdev->sme_state = CFG80211_SME_CONNECTING;
644 /* we're good if we have both BSSID and channel */
645 if (wdev->conn->params.bssid && wdev->conn->params.channel) {
646 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
647 err = cfg80211_conn_do_work(wdev);
649 /* otherwise we'll need to scan for the AP first */
650 err = cfg80211_conn_scan(wdev);
652 * If we can't scan right now, then we need to scan again
653 * after the current scan finished, since the parameters
654 * changed (unless we find a good AP anyway).
658 wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
664 wdev->sme_state = CFG80211_SME_IDLE;
669 wdev->sme_state = CFG80211_SME_CONNECTING;
670 err = rdev->ops->connect(&rdev->wiphy, dev, connect);
672 wdev->sme_state = CFG80211_SME_IDLE;
676 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
677 wdev->ssid_len = connect->ssid_len;
683 int cfg80211_connect(struct cfg80211_registered_device *rdev,
684 struct net_device *dev,
685 struct cfg80211_connect_params *connect)
689 wdev_lock(dev->ieee80211_ptr);
690 err = __cfg80211_connect(rdev, dev, connect);
691 wdev_unlock(dev->ieee80211_ptr);
696 int __cfg80211_disconnect(struct cfg80211_registered_device *rdev,
697 struct net_device *dev, u16 reason, bool wextev)
699 struct wireless_dev *wdev = dev->ieee80211_ptr;
702 ASSERT_WDEV_LOCK(wdev);
704 if (wdev->sme_state == CFG80211_SME_IDLE)
707 if (!rdev->ops->disconnect) {
708 if (!rdev->ops->deauth)
711 /* was it connected by userspace SME? */
713 cfg80211_mlme_down(rdev, dev);
717 if (wdev->sme_state == CFG80211_SME_CONNECTING &&
718 (wdev->conn->state == CFG80211_CONN_SCANNING ||
719 wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)) {
720 wdev->sme_state = CFG80211_SME_IDLE;
726 /* wdev->conn->params.bssid must be set if > SCANNING */
727 err = __cfg80211_mlme_deauth(rdev, dev,
728 wdev->conn->params.bssid,
733 err = rdev->ops->disconnect(&rdev->wiphy, dev, reason);
738 if (wdev->sme_state == CFG80211_SME_CONNECTED)
739 __cfg80211_disconnected(dev, NULL, 0, 0, false);
740 else if (wdev->sme_state == CFG80211_SME_CONNECTING)
741 __cfg80211_connect_result(dev, NULL, NULL, 0, NULL, 0,
742 WLAN_STATUS_UNSPECIFIED_FAILURE,
748 int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
749 struct net_device *dev,
750 u16 reason, bool wextev)
754 wdev_lock(dev->ieee80211_ptr);
755 err = __cfg80211_disconnect(rdev, dev, reason, wextev);
756 wdev_unlock(dev->ieee80211_ptr);
761 void cfg80211_sme_disassoc(struct net_device *dev, int idx)
763 struct wireless_dev *wdev = dev->ieee80211_ptr;
764 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
767 ASSERT_WDEV_LOCK(wdev);
772 if (wdev->conn->state == CFG80211_CONN_IDLE)
776 * Ok, so the association was made by this SME -- we don't
777 * want it any more so deauthenticate too.
780 if (!wdev->auth_bsses[idx])
783 memcpy(bssid, wdev->auth_bsses[idx]->pub.bssid, ETH_ALEN);
784 if (cfg80211_mlme_deauth(rdev, dev, bssid,
785 NULL, 0, WLAN_REASON_DEAUTH_LEAVING)) {
786 /* whatever -- assume gone anyway */
787 cfg80211_unhold_bss(wdev->auth_bsses[idx]);
788 cfg80211_put_bss(&wdev->auth_bsses[idx]->pub);
789 wdev->auth_bsses[idx] = NULL;