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
;