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 <linux/wireless.h>
12 #include <net/iw_handler.h>
13 #include <net/cfg80211.h>
14 #include <net/rtnetlink.h>
18 struct cfg80211_conn
{
19 struct cfg80211_connect_params params
;
20 /* these are sub-states of the _CONNECTING sme_state */
23 CFG80211_CONN_SCANNING
,
24 CFG80211_CONN_SCAN_AGAIN
,
25 CFG80211_CONN_AUTHENTICATE_NEXT
,
26 CFG80211_CONN_AUTHENTICATING
,
27 CFG80211_CONN_ASSOCIATE_NEXT
,
28 CFG80211_CONN_ASSOCIATING
,
37 static int cfg80211_conn_scan(struct wireless_dev
*wdev
)
39 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
40 struct cfg80211_scan_request
*request
;
44 ASSERT_RDEV_LOCK(rdev
);
45 ASSERT_WDEV_LOCK(wdev
);
50 if (wdev
->conn
->params
.channel
) {
53 enum ieee80211_band band
;
56 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
57 if (!wdev
->wiphy
->bands
[band
])
59 n_channels
+= wdev
->wiphy
->bands
[band
]->n_channels
;
62 request
= kzalloc(sizeof(*request
) + sizeof(request
->ssids
[0]) +
63 sizeof(request
->channels
[0]) * n_channels
,
68 request
->channels
= (void *)((char *)request
+ sizeof(*request
));
69 if (wdev
->conn
->params
.channel
)
70 request
->channels
[0] = wdev
->conn
->params
.channel
;
73 enum ieee80211_band band
;
75 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
76 if (!wdev
->wiphy
->bands
[band
])
78 for (j
= 0; j
< wdev
->wiphy
->bands
[band
]->n_channels
;
80 request
->channels
[i
] =
81 &wdev
->wiphy
->bands
[band
]->channels
[j
];
84 request
->n_channels
= n_channels
;
85 request
->ssids
= (void *)(request
->channels
+ n_channels
);
88 memcpy(request
->ssids
[0].ssid
, wdev
->conn
->params
.ssid
,
89 wdev
->conn
->params
.ssid_len
);
90 request
->ssids
[0].ssid_len
= wdev
->conn
->params
.ssid_len
;
92 request
->dev
= wdev
->netdev
;
93 request
->wiphy
= &rdev
->wiphy
;
95 rdev
->scan_req
= request
;
97 err
= rdev
->ops
->scan(wdev
->wiphy
, wdev
->netdev
, request
);
99 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
100 nl80211_send_scan_start(rdev
, wdev
->netdev
);
101 dev_hold(wdev
->netdev
);
103 rdev
->scan_req
= NULL
;
109 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
)
111 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
112 struct cfg80211_connect_params
*params
;
115 ASSERT_WDEV_LOCK(wdev
);
120 params
= &wdev
->conn
->params
;
122 switch (wdev
->conn
->state
) {
123 case CFG80211_CONN_SCAN_AGAIN
:
124 return cfg80211_conn_scan(wdev
);
125 case CFG80211_CONN_AUTHENTICATE_NEXT
:
126 BUG_ON(!rdev
->ops
->auth
);
127 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATING
;
128 return __cfg80211_mlme_auth(rdev
, wdev
->netdev
,
129 params
->channel
, params
->auth_type
,
131 params
->ssid
, params
->ssid_len
,
133 params
->key
, params
->key_len
,
135 case CFG80211_CONN_ASSOCIATE_NEXT
:
136 BUG_ON(!rdev
->ops
->assoc
);
137 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATING
;
139 * We could, later, implement roaming here and then actually
140 * set prev_bssid to non-NULL. But then we need to be aware
141 * that some APs don't like that -- so we'd need to retry
144 err
= __cfg80211_mlme_assoc(rdev
, wdev
->netdev
,
145 params
->channel
, params
->bssid
,
147 params
->ssid
, params
->ssid_len
,
148 params
->ie
, params
->ie_len
,
149 false, ¶ms
->crypto
);
151 __cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
153 WLAN_REASON_DEAUTH_LEAVING
);
160 void cfg80211_conn_work(struct work_struct
*work
)
162 struct cfg80211_registered_device
*rdev
=
163 container_of(work
, struct cfg80211_registered_device
, conn_work
);
164 struct wireless_dev
*wdev
;
167 cfg80211_lock_rdev(rdev
);
168 mutex_lock(&rdev
->devlist_mtx
);
170 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
172 if (!netif_running(wdev
->netdev
)) {
176 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
) {
180 if (cfg80211_conn_do_work(wdev
))
181 __cfg80211_connect_result(
183 wdev
->conn
->params
.bssid
,
185 WLAN_STATUS_UNSPECIFIED_FAILURE
,
190 mutex_unlock(&rdev
->devlist_mtx
);
191 cfg80211_unlock_rdev(rdev
);
195 static bool cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
197 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
198 struct cfg80211_bss
*bss
;
199 u16 capa
= WLAN_CAPABILITY_ESS
;
201 ASSERT_WDEV_LOCK(wdev
);
203 if (wdev
->conn
->params
.privacy
)
204 capa
|= WLAN_CAPABILITY_PRIVACY
;
206 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, wdev
->conn
->params
.bssid
,
207 wdev
->conn
->params
.ssid
,
208 wdev
->conn
->params
.ssid_len
,
209 WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_PRIVACY
,
214 memcpy(wdev
->conn
->bssid
, bss
->bssid
, ETH_ALEN
);
215 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
216 wdev
->conn
->params
.channel
= bss
->channel
;
217 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
218 schedule_work(&rdev
->conn_work
);
220 cfg80211_put_bss(bss
);
224 static void __cfg80211_sme_scan_done(struct net_device
*dev
)
226 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
227 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
229 ASSERT_WDEV_LOCK(wdev
);
231 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
237 if (wdev
->conn
->state
!= CFG80211_CONN_SCANNING
&&
238 wdev
->conn
->state
!= CFG80211_CONN_SCAN_AGAIN
)
241 if (!cfg80211_get_conn_bss(wdev
)) {
243 if (wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
)
244 schedule_work(&rdev
->conn_work
);
246 __cfg80211_connect_result(
248 wdev
->conn
->params
.bssid
,
250 WLAN_STATUS_UNSPECIFIED_FAILURE
,
255 void cfg80211_sme_scan_done(struct net_device
*dev
)
257 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
260 __cfg80211_sme_scan_done(dev
);
264 void cfg80211_sme_rx_auth(struct net_device
*dev
,
265 const u8
*buf
, size_t len
)
267 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
268 struct wiphy
*wiphy
= wdev
->wiphy
;
269 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
270 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
271 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
273 ASSERT_WDEV_LOCK(wdev
);
275 /* should only RX auth frames when connecting */
276 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
279 if (WARN_ON(!wdev
->conn
))
282 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
283 wdev
->conn
->auto_auth
&&
284 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
285 /* select automatically between only open, shared, leap */
286 switch (wdev
->conn
->params
.auth_type
) {
287 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
288 if (wdev
->connect_keys
)
289 wdev
->conn
->params
.auth_type
=
290 NL80211_AUTHTYPE_SHARED_KEY
;
292 wdev
->conn
->params
.auth_type
=
293 NL80211_AUTHTYPE_NETWORK_EAP
;
295 case NL80211_AUTHTYPE_SHARED_KEY
:
296 wdev
->conn
->params
.auth_type
=
297 NL80211_AUTHTYPE_NETWORK_EAP
;
301 wdev
->conn
->params
.auth_type
=
302 NL80211_AUTHTYPE_OPEN_SYSTEM
;
305 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
306 schedule_work(&rdev
->conn_work
);
307 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
308 __cfg80211_connect_result(dev
, mgmt
->bssid
, NULL
, 0, NULL
, 0,
309 status_code
, false, NULL
);
310 } else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
311 wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
312 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
313 schedule_work(&rdev
->conn_work
);
317 void __cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
318 const u8
*req_ie
, size_t req_ie_len
,
319 const u8
*resp_ie
, size_t resp_ie_len
,
320 u16 status
, bool wextev
,
321 struct cfg80211_bss
*bss
)
323 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
325 #ifdef CONFIG_WIRELESS_EXT
326 union iwreq_data wrqu
;
329 ASSERT_WDEV_LOCK(wdev
);
331 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
334 if (wdev
->sme_state
== CFG80211_SME_CONNECTED
)
335 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), dev
,
336 bssid
, req_ie
, req_ie_len
,
337 resp_ie
, resp_ie_len
, GFP_KERNEL
);
339 nl80211_send_connect_result(wiphy_to_dev(wdev
->wiphy
), dev
,
340 bssid
, req_ie
, req_ie_len
,
341 resp_ie
, resp_ie_len
,
344 #ifdef CONFIG_WIRELESS_EXT
346 if (req_ie
&& status
== WLAN_STATUS_SUCCESS
) {
347 memset(&wrqu
, 0, sizeof(wrqu
));
348 wrqu
.data
.length
= req_ie_len
;
349 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
, req_ie
);
352 if (resp_ie
&& status
== WLAN_STATUS_SUCCESS
) {
353 memset(&wrqu
, 0, sizeof(wrqu
));
354 wrqu
.data
.length
= resp_ie_len
;
355 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
, resp_ie
);
358 memset(&wrqu
, 0, sizeof(wrqu
));
359 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
360 if (bssid
&& status
== WLAN_STATUS_SUCCESS
)
361 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
362 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
366 if (wdev
->current_bss
) {
367 cfg80211_unhold_bss(wdev
->current_bss
);
368 cfg80211_put_bss(&wdev
->current_bss
->pub
);
369 wdev
->current_bss
= NULL
;
372 if (status
== WLAN_STATUS_SUCCESS
&&
373 wdev
->sme_state
== CFG80211_SME_IDLE
)
376 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
380 wdev
->conn
->state
= CFG80211_CONN_IDLE
;
382 if (status
!= WLAN_STATUS_SUCCESS
) {
383 wdev
->sme_state
= CFG80211_SME_IDLE
;
386 kfree(wdev
->connect_keys
);
387 wdev
->connect_keys
= NULL
;
393 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
394 wdev
->ssid
, wdev
->ssid_len
,
396 WLAN_CAPABILITY_ESS
);
401 cfg80211_hold_bss(bss_from_pub(bss
));
402 wdev
->current_bss
= bss_from_pub(bss
);
404 wdev
->sme_state
= CFG80211_SME_CONNECTED
;
405 cfg80211_upload_connect_keys(wdev
);
407 country_ie
= (u8
*) ieee80211_bss_get_ie(bss
, WLAN_EID_COUNTRY
);
413 * ieee80211_bss_get_ie() ensures we can access:
414 * - country_ie + 2, the start of the country ie data, and
415 * - and country_ie[1] which is the IE length
417 regulatory_hint_11d(wdev
->wiphy
,
422 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
423 const u8
*req_ie
, size_t req_ie_len
,
424 const u8
*resp_ie
, size_t resp_ie_len
,
425 u16 status
, gfp_t gfp
)
427 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
428 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
429 struct cfg80211_event
*ev
;
432 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
436 ev
->type
= EVENT_CONNECT_RESULT
;
437 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
438 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
439 ev
->cr
.req_ie_len
= req_ie_len
;
440 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
441 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
442 ev
->cr
.resp_ie_len
= resp_ie_len
;
443 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
444 ev
->cr
.status
= status
;
446 spin_lock_irqsave(&wdev
->event_lock
, flags
);
447 list_add_tail(&ev
->list
, &wdev
->event_list
);
448 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
449 schedule_work(&rdev
->event_work
);
451 EXPORT_SYMBOL(cfg80211_connect_result
);
453 void __cfg80211_roamed(struct wireless_dev
*wdev
, const u8
*bssid
,
454 const u8
*req_ie
, size_t req_ie_len
,
455 const u8
*resp_ie
, size_t resp_ie_len
)
457 struct cfg80211_bss
*bss
;
458 #ifdef CONFIG_WIRELESS_EXT
459 union iwreq_data wrqu
;
462 ASSERT_WDEV_LOCK(wdev
);
464 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
467 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
470 /* internal error -- how did we get to CONNECTED w/o BSS? */
471 if (WARN_ON(!wdev
->current_bss
)) {
475 cfg80211_unhold_bss(wdev
->current_bss
);
476 cfg80211_put_bss(&wdev
->current_bss
->pub
);
477 wdev
->current_bss
= NULL
;
479 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
480 wdev
->ssid
, wdev
->ssid_len
,
481 WLAN_CAPABILITY_ESS
, WLAN_CAPABILITY_ESS
);
486 cfg80211_hold_bss(bss_from_pub(bss
));
487 wdev
->current_bss
= bss_from_pub(bss
);
489 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), wdev
->netdev
, bssid
,
490 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
493 #ifdef CONFIG_WIRELESS_EXT
495 memset(&wrqu
, 0, sizeof(wrqu
));
496 wrqu
.data
.length
= req_ie_len
;
497 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
502 memset(&wrqu
, 0, sizeof(wrqu
));
503 wrqu
.data
.length
= resp_ie_len
;
504 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
508 memset(&wrqu
, 0, sizeof(wrqu
));
509 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
510 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
511 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
515 void cfg80211_roamed(struct net_device
*dev
, const u8
*bssid
,
516 const u8
*req_ie
, size_t req_ie_len
,
517 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
519 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
520 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
521 struct cfg80211_event
*ev
;
524 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
528 ev
->type
= EVENT_ROAMED
;
529 memcpy(ev
->rm
.bssid
, bssid
, ETH_ALEN
);
530 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
531 ev
->rm
.req_ie_len
= req_ie_len
;
532 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
533 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
534 ev
->rm
.resp_ie_len
= resp_ie_len
;
535 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
537 spin_lock_irqsave(&wdev
->event_lock
, flags
);
538 list_add_tail(&ev
->list
, &wdev
->event_list
);
539 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
540 schedule_work(&rdev
->event_work
);
542 EXPORT_SYMBOL(cfg80211_roamed
);
544 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
545 size_t ie_len
, u16 reason
, bool from_ap
)
547 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
548 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
550 #ifdef CONFIG_WIRELESS_EXT
551 union iwreq_data wrqu
;
554 ASSERT_WDEV_LOCK(wdev
);
556 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
559 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
562 if (wdev
->current_bss
) {
563 cfg80211_unhold_bss(wdev
->current_bss
);
564 cfg80211_put_bss(&wdev
->current_bss
->pub
);
567 wdev
->current_bss
= NULL
;
568 wdev
->sme_state
= CFG80211_SME_IDLE
;
571 kfree(wdev
->conn
->ie
);
572 wdev
->conn
->ie
= NULL
;
577 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
580 * Delete all the keys ... pairwise keys can't really
581 * exist any more anyway, but default keys might.
583 if (rdev
->ops
->del_key
)
584 for (i
= 0; i
< 6; i
++)
585 rdev
->ops
->del_key(wdev
->wiphy
, dev
, i
, NULL
);
587 #ifdef CONFIG_WIRELESS_EXT
588 memset(&wrqu
, 0, sizeof(wrqu
));
589 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
590 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
594 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
595 u8
*ie
, size_t ie_len
, gfp_t gfp
)
597 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
598 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
599 struct cfg80211_event
*ev
;
602 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
606 ev
->type
= EVENT_DISCONNECTED
;
607 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
608 ev
->dc
.ie_len
= ie_len
;
609 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
610 ev
->dc
.reason
= reason
;
612 spin_lock_irqsave(&wdev
->event_lock
, flags
);
613 list_add_tail(&ev
->list
, &wdev
->event_list
);
614 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
615 schedule_work(&rdev
->event_work
);
617 EXPORT_SYMBOL(cfg80211_disconnected
);
619 int __cfg80211_connect(struct cfg80211_registered_device
*rdev
,
620 struct net_device
*dev
,
621 struct cfg80211_connect_params
*connect
,
622 struct cfg80211_cached_keys
*connkeys
)
624 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
627 ASSERT_WDEV_LOCK(wdev
);
629 if (wdev
->sme_state
!= CFG80211_SME_IDLE
)
632 if (WARN_ON(wdev
->connect_keys
)) {
633 kfree(wdev
->connect_keys
);
634 wdev
->connect_keys
= NULL
;
637 if (connkeys
&& connkeys
->def
>= 0) {
641 /* If given a WEP key we may need it for shared key auth */
642 if (connkeys
->params
[idx
].cipher
== WLAN_CIPHER_SUITE_WEP40
||
643 connkeys
->params
[idx
].cipher
== WLAN_CIPHER_SUITE_WEP104
) {
644 connect
->key_idx
= idx
;
645 connect
->key
= connkeys
->params
[idx
].key
;
646 connect
->key_len
= connkeys
->params
[idx
].key_len
;
650 if (!rdev
->ops
->connect
) {
651 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
654 if (WARN_ON(wdev
->conn
))
657 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
662 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
664 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
665 if (connect
->bssid
) {
666 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
667 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
671 wdev
->conn
->ie
= kmemdup(connect
->ie
, connect
->ie_len
,
673 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
674 if (!wdev
->conn
->ie
) {
681 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
682 wdev
->conn
->auto_auth
= true;
683 /* start with open system ... should mostly work */
684 wdev
->conn
->params
.auth_type
=
685 NL80211_AUTHTYPE_OPEN_SYSTEM
;
687 wdev
->conn
->auto_auth
= false;
690 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
691 wdev
->ssid_len
= connect
->ssid_len
;
692 wdev
->conn
->params
.ssid
= wdev
->ssid
;
693 wdev
->conn
->params
.ssid_len
= connect
->ssid_len
;
695 /* don't care about result -- but fill bssid & channel */
696 if (!wdev
->conn
->params
.bssid
|| !wdev
->conn
->params
.channel
)
697 cfg80211_get_conn_bss(wdev
);
699 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
700 wdev
->connect_keys
= connkeys
;
702 /* we're good if we have both BSSID and channel */
703 if (wdev
->conn
->params
.bssid
&& wdev
->conn
->params
.channel
) {
704 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
705 err
= cfg80211_conn_do_work(wdev
);
707 /* otherwise we'll need to scan for the AP first */
708 err
= cfg80211_conn_scan(wdev
);
710 * If we can't scan right now, then we need to scan again
711 * after the current scan finished, since the parameters
712 * changed (unless we find a good AP anyway).
716 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
722 wdev
->sme_state
= CFG80211_SME_IDLE
;
723 wdev
->connect_keys
= NULL
;
728 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
729 wdev
->connect_keys
= connkeys
;
730 err
= rdev
->ops
->connect(&rdev
->wiphy
, dev
, connect
);
732 wdev
->connect_keys
= NULL
;
733 wdev
->sme_state
= CFG80211_SME_IDLE
;
737 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
738 wdev
->ssid_len
= connect
->ssid_len
;
744 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
745 struct net_device
*dev
,
746 struct cfg80211_connect_params
*connect
,
747 struct cfg80211_cached_keys
*connkeys
)
751 wdev_lock(dev
->ieee80211_ptr
);
752 err
= __cfg80211_connect(rdev
, dev
, connect
, connkeys
);
753 wdev_unlock(dev
->ieee80211_ptr
);
758 int __cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
759 struct net_device
*dev
, u16 reason
, bool wextev
)
761 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
764 ASSERT_WDEV_LOCK(wdev
);
766 if (wdev
->sme_state
== CFG80211_SME_IDLE
)
769 kfree(wdev
->connect_keys
);
770 wdev
->connect_keys
= NULL
;
772 if (!rdev
->ops
->disconnect
) {
773 if (!rdev
->ops
->deauth
)
776 /* was it connected by userspace SME? */
778 cfg80211_mlme_down(rdev
, dev
);
782 if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
783 (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
784 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
)) {
785 wdev
->sme_state
= CFG80211_SME_IDLE
;
791 /* wdev->conn->params.bssid must be set if > SCANNING */
792 err
= __cfg80211_mlme_deauth(rdev
, dev
,
793 wdev
->conn
->params
.bssid
,
798 err
= rdev
->ops
->disconnect(&rdev
->wiphy
, dev
, reason
);
803 if (wdev
->sme_state
== CFG80211_SME_CONNECTED
)
804 __cfg80211_disconnected(dev
, NULL
, 0, 0, false);
805 else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
)
806 __cfg80211_connect_result(dev
, NULL
, NULL
, 0, NULL
, 0,
807 WLAN_STATUS_UNSPECIFIED_FAILURE
,
813 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
814 struct net_device
*dev
,
815 u16 reason
, bool wextev
)
819 wdev_lock(dev
->ieee80211_ptr
);
820 err
= __cfg80211_disconnect(rdev
, dev
, reason
, wextev
);
821 wdev_unlock(dev
->ieee80211_ptr
);
826 void cfg80211_sme_disassoc(struct net_device
*dev
, int idx
)
828 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
829 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
832 ASSERT_WDEV_LOCK(wdev
);
837 if (wdev
->conn
->state
== CFG80211_CONN_IDLE
)
841 * Ok, so the association was made by this SME -- we don't
842 * want it any more so deauthenticate too.
845 if (!wdev
->auth_bsses
[idx
])
848 memcpy(bssid
, wdev
->auth_bsses
[idx
]->pub
.bssid
, ETH_ALEN
);
849 if (__cfg80211_mlme_deauth(rdev
, dev
, bssid
,
850 NULL
, 0, WLAN_REASON_DEAUTH_LEAVING
)) {
851 /* whatever -- assume gone anyway */
852 cfg80211_unhold_bss(wdev
->auth_bsses
[idx
]);
853 cfg80211_put_bss(&wdev
->auth_bsses
[idx
]->pub
);
854 wdev
->auth_bsses
[idx
] = NULL
;