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
*drv
= wiphy_to_dev(wdev
->wiphy
);
37 struct cfg80211_scan_request
*request
;
41 ASSERT_RDEV_LOCK(drv
);
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
= &drv
->wiphy
;
92 drv
->scan_req
= request
;
94 err
= drv
->ops
->scan(wdev
->wiphy
, wdev
->netdev
, request
);
96 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
97 nl80211_send_scan_start(drv
, wdev
->netdev
);
105 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
)
107 struct cfg80211_registered_device
*drv
= 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(!drv
->ops
->auth
);
123 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATING
;
124 return __cfg80211_mlme_auth(drv
, wdev
->netdev
,
125 params
->channel
, params
->auth_type
,
127 params
->ssid
, params
->ssid_len
,
129 case CFG80211_CONN_ASSOCIATE_NEXT
:
130 BUG_ON(!drv
->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(drv
, 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(drv
, wdev
->netdev
, params
->bssid
,
147 WLAN_REASON_DEAUTH_LEAVING
);
154 void cfg80211_conn_work(struct work_struct
*work
)
156 struct cfg80211_registered_device
*drv
=
157 container_of(work
, struct cfg80211_registered_device
, conn_work
);
158 struct wireless_dev
*wdev
;
161 cfg80211_lock_rdev(drv
);
162 mutex_lock(&drv
->devlist_mtx
);
164 list_for_each_entry(wdev
, &drv
->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(&drv
->devlist_mtx
);
185 cfg80211_unlock_rdev(drv
);
189 static bool cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
191 struct cfg80211_registered_device
*drv
= 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(&drv
->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
*drv
= 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(&drv
->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
;