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 params
->key
, params
->key_len
,
131 case CFG80211_CONN_ASSOCIATE_NEXT
:
132 BUG_ON(!rdev
->ops
->assoc
);
133 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATING
;
135 * We could, later, implement roaming here and then actually
136 * set prev_bssid to non-NULL. But then we need to be aware
137 * that some APs don't like that -- so we'd need to retry
140 err
= __cfg80211_mlme_assoc(rdev
, wdev
->netdev
,
141 params
->channel
, params
->bssid
,
143 params
->ssid
, params
->ssid_len
,
144 params
->ie
, params
->ie_len
,
145 false, ¶ms
->crypto
);
147 __cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
149 WLAN_REASON_DEAUTH_LEAVING
);
156 void cfg80211_conn_work(struct work_struct
*work
)
158 struct cfg80211_registered_device
*rdev
=
159 container_of(work
, struct cfg80211_registered_device
, conn_work
);
160 struct wireless_dev
*wdev
;
163 cfg80211_lock_rdev(rdev
);
164 mutex_lock(&rdev
->devlist_mtx
);
166 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
168 if (!netif_running(wdev
->netdev
)) {
172 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
) {
176 if (cfg80211_conn_do_work(wdev
))
177 __cfg80211_connect_result(
179 wdev
->conn
->params
.bssid
,
181 WLAN_STATUS_UNSPECIFIED_FAILURE
,
186 mutex_unlock(&rdev
->devlist_mtx
);
187 cfg80211_unlock_rdev(rdev
);
191 static bool cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
193 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
194 struct cfg80211_bss
*bss
;
195 u16 capa
= WLAN_CAPABILITY_ESS
;
197 ASSERT_WDEV_LOCK(wdev
);
199 if (wdev
->conn
->params
.privacy
)
200 capa
|= WLAN_CAPABILITY_PRIVACY
;
202 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, wdev
->conn
->params
.bssid
,
203 wdev
->conn
->params
.ssid
,
204 wdev
->conn
->params
.ssid_len
,
205 WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_PRIVACY
,
210 memcpy(wdev
->conn
->bssid
, bss
->bssid
, ETH_ALEN
);
211 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
212 wdev
->conn
->params
.channel
= bss
->channel
;
213 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
214 schedule_work(&rdev
->conn_work
);
216 cfg80211_put_bss(bss
);
220 static void __cfg80211_sme_scan_done(struct net_device
*dev
)
222 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
223 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
225 ASSERT_WDEV_LOCK(wdev
);
227 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
233 if (wdev
->conn
->state
!= CFG80211_CONN_SCANNING
&&
234 wdev
->conn
->state
!= CFG80211_CONN_SCAN_AGAIN
)
237 if (!cfg80211_get_conn_bss(wdev
)) {
239 if (wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
)
240 schedule_work(&rdev
->conn_work
);
242 __cfg80211_connect_result(
244 wdev
->conn
->params
.bssid
,
246 WLAN_STATUS_UNSPECIFIED_FAILURE
,
251 void cfg80211_sme_scan_done(struct net_device
*dev
)
253 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
256 __cfg80211_sme_scan_done(dev
);
260 void cfg80211_sme_rx_auth(struct net_device
*dev
,
261 const u8
*buf
, size_t len
)
263 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
264 struct wiphy
*wiphy
= wdev
->wiphy
;
265 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
266 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
267 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
269 ASSERT_WDEV_LOCK(wdev
);
271 /* should only RX auth frames when connecting */
272 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
275 if (WARN_ON(!wdev
->conn
))
278 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
279 wdev
->conn
->auto_auth
&&
280 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
281 /* select automatically between only open, shared, leap */
282 switch (wdev
->conn
->params
.auth_type
) {
283 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
284 if (wdev
->connect_keys
)
285 wdev
->conn
->params
.auth_type
=
286 NL80211_AUTHTYPE_SHARED_KEY
;
288 wdev
->conn
->params
.auth_type
=
289 NL80211_AUTHTYPE_NETWORK_EAP
;
291 case NL80211_AUTHTYPE_SHARED_KEY
:
292 wdev
->conn
->params
.auth_type
=
293 NL80211_AUTHTYPE_NETWORK_EAP
;
297 wdev
->conn
->params
.auth_type
=
298 NL80211_AUTHTYPE_OPEN_SYSTEM
;
301 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
302 schedule_work(&rdev
->conn_work
);
303 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
304 __cfg80211_connect_result(dev
, mgmt
->bssid
, NULL
, 0, NULL
, 0,
306 } else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
307 wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
308 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
309 schedule_work(&rdev
->conn_work
);
313 void __cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
314 const u8
*req_ie
, size_t req_ie_len
,
315 const u8
*resp_ie
, size_t resp_ie_len
,
316 u16 status
, bool wextev
)
318 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
319 struct cfg80211_bss
*bss
;
320 #ifdef CONFIG_WIRELESS_EXT
321 union iwreq_data wrqu
;
324 ASSERT_WDEV_LOCK(wdev
);
326 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
329 if (wdev
->sme_state
== CFG80211_SME_CONNECTED
)
330 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), dev
,
331 bssid
, req_ie
, req_ie_len
,
332 resp_ie
, resp_ie_len
, GFP_KERNEL
);
334 nl80211_send_connect_result(wiphy_to_dev(wdev
->wiphy
), dev
,
335 bssid
, req_ie
, req_ie_len
,
336 resp_ie
, resp_ie_len
,
339 #ifdef CONFIG_WIRELESS_EXT
341 if (req_ie
&& status
== WLAN_STATUS_SUCCESS
) {
342 memset(&wrqu
, 0, sizeof(wrqu
));
343 wrqu
.data
.length
= req_ie_len
;
344 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
, req_ie
);
347 if (resp_ie
&& status
== WLAN_STATUS_SUCCESS
) {
348 memset(&wrqu
, 0, sizeof(wrqu
));
349 wrqu
.data
.length
= resp_ie_len
;
350 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
, resp_ie
);
353 memset(&wrqu
, 0, sizeof(wrqu
));
354 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
355 if (bssid
&& status
== WLAN_STATUS_SUCCESS
)
356 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
357 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
361 if (status
== WLAN_STATUS_SUCCESS
&&
362 wdev
->sme_state
== CFG80211_SME_IDLE
)
365 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
368 if (wdev
->current_bss
) {
369 cfg80211_unhold_bss(wdev
->current_bss
);
370 cfg80211_put_bss(&wdev
->current_bss
->pub
);
371 wdev
->current_bss
= NULL
;
375 wdev
->conn
->state
= CFG80211_CONN_IDLE
;
377 if (status
!= WLAN_STATUS_SUCCESS
) {
378 wdev
->sme_state
= CFG80211_SME_IDLE
;
381 kfree(wdev
->connect_keys
);
382 wdev
->connect_keys
= NULL
;
386 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
387 wdev
->ssid
, wdev
->ssid_len
,
389 WLAN_CAPABILITY_ESS
);
394 cfg80211_hold_bss(bss_from_pub(bss
));
395 wdev
->current_bss
= bss_from_pub(bss
);
398 wdev
->sme_state
= CFG80211_SME_CONNECTED
;
399 cfg80211_upload_connect_keys(wdev
);
402 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
403 const u8
*req_ie
, size_t req_ie_len
,
404 const u8
*resp_ie
, size_t resp_ie_len
,
405 u16 status
, gfp_t gfp
)
407 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
408 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
409 struct cfg80211_event
*ev
;
412 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
416 ev
->type
= EVENT_CONNECT_RESULT
;
417 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
418 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
419 ev
->cr
.req_ie_len
= req_ie_len
;
420 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
421 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
422 ev
->cr
.resp_ie_len
= resp_ie_len
;
423 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
424 ev
->cr
.status
= status
;
426 spin_lock_irqsave(&wdev
->event_lock
, flags
);
427 list_add_tail(&ev
->list
, &wdev
->event_list
);
428 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
429 schedule_work(&rdev
->event_work
);
431 EXPORT_SYMBOL(cfg80211_connect_result
);
433 void __cfg80211_roamed(struct wireless_dev
*wdev
, const u8
*bssid
,
434 const u8
*req_ie
, size_t req_ie_len
,
435 const u8
*resp_ie
, size_t resp_ie_len
)
437 struct cfg80211_bss
*bss
;
438 #ifdef CONFIG_WIRELESS_EXT
439 union iwreq_data wrqu
;
442 ASSERT_WDEV_LOCK(wdev
);
444 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
447 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
450 /* internal error -- how did we get to CONNECTED w/o BSS? */
451 if (WARN_ON(!wdev
->current_bss
)) {
455 cfg80211_unhold_bss(wdev
->current_bss
);
456 cfg80211_put_bss(&wdev
->current_bss
->pub
);
457 wdev
->current_bss
= NULL
;
459 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
460 wdev
->ssid
, wdev
->ssid_len
,
461 WLAN_CAPABILITY_ESS
, WLAN_CAPABILITY_ESS
);
466 cfg80211_hold_bss(bss_from_pub(bss
));
467 wdev
->current_bss
= bss_from_pub(bss
);
469 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), wdev
->netdev
, bssid
,
470 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
473 #ifdef CONFIG_WIRELESS_EXT
475 memset(&wrqu
, 0, sizeof(wrqu
));
476 wrqu
.data
.length
= req_ie_len
;
477 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
482 memset(&wrqu
, 0, sizeof(wrqu
));
483 wrqu
.data
.length
= resp_ie_len
;
484 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
488 memset(&wrqu
, 0, sizeof(wrqu
));
489 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
490 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
491 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
495 void cfg80211_roamed(struct net_device
*dev
, const u8
*bssid
,
496 const u8
*req_ie
, size_t req_ie_len
,
497 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
499 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
500 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
501 struct cfg80211_event
*ev
;
504 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
508 ev
->type
= EVENT_ROAMED
;
509 memcpy(ev
->rm
.bssid
, bssid
, ETH_ALEN
);
510 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
511 ev
->rm
.req_ie_len
= req_ie_len
;
512 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
513 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
514 ev
->rm
.resp_ie_len
= resp_ie_len
;
515 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
517 spin_lock_irqsave(&wdev
->event_lock
, flags
);
518 list_add_tail(&ev
->list
, &wdev
->event_list
);
519 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
520 schedule_work(&rdev
->event_work
);
522 EXPORT_SYMBOL(cfg80211_roamed
);
524 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
525 size_t ie_len
, u16 reason
, bool from_ap
)
527 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
528 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
530 #ifdef CONFIG_WIRELESS_EXT
531 union iwreq_data wrqu
;
534 ASSERT_WDEV_LOCK(wdev
);
536 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
539 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
542 if (wdev
->current_bss
) {
543 cfg80211_unhold_bss(wdev
->current_bss
);
544 cfg80211_put_bss(&wdev
->current_bss
->pub
);
547 wdev
->current_bss
= NULL
;
548 wdev
->sme_state
= CFG80211_SME_IDLE
;
551 kfree(wdev
->conn
->ie
);
552 wdev
->conn
->ie
= NULL
;
557 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
560 * Delete all the keys ... pairwise keys can't really
561 * exist any more anyway, but default keys might.
563 if (rdev
->ops
->del_key
)
564 for (i
= 0; i
< 6; i
++)
565 rdev
->ops
->del_key(wdev
->wiphy
, dev
, i
, NULL
);
567 #ifdef CONFIG_WIRELESS_EXT
568 memset(&wrqu
, 0, sizeof(wrqu
));
569 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
570 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
574 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
575 u8
*ie
, size_t ie_len
, gfp_t gfp
)
577 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
578 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
579 struct cfg80211_event
*ev
;
582 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
586 ev
->type
= EVENT_DISCONNECTED
;
587 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
588 ev
->dc
.ie_len
= ie_len
;
589 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
590 ev
->dc
.reason
= reason
;
592 spin_lock_irqsave(&wdev
->event_lock
, flags
);
593 list_add_tail(&ev
->list
, &wdev
->event_list
);
594 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
595 schedule_work(&rdev
->event_work
);
597 EXPORT_SYMBOL(cfg80211_disconnected
);
599 int __cfg80211_connect(struct cfg80211_registered_device
*rdev
,
600 struct net_device
*dev
,
601 struct cfg80211_connect_params
*connect
,
602 struct cfg80211_cached_keys
*connkeys
)
604 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
607 ASSERT_WDEV_LOCK(wdev
);
609 if (wdev
->sme_state
!= CFG80211_SME_IDLE
)
612 if (WARN_ON(wdev
->connect_keys
)) {
613 kfree(wdev
->connect_keys
);
614 wdev
->connect_keys
= NULL
;
617 if (connkeys
&& connkeys
->def
>= 0) {
621 /* If given a WEP key we may need it for shared key auth */
622 if (connkeys
->params
[idx
].cipher
== WLAN_CIPHER_SUITE_WEP40
||
623 connkeys
->params
[idx
].cipher
== WLAN_CIPHER_SUITE_WEP104
) {
624 connect
->key_idx
= idx
;
625 connect
->key
= connkeys
->params
[idx
].key
;
626 connect
->key_len
= connkeys
->params
[idx
].key_len
;
630 if (!rdev
->ops
->connect
) {
631 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
634 if (WARN_ON(wdev
->conn
))
637 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
642 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
644 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
645 if (connect
->bssid
) {
646 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
647 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
651 wdev
->conn
->ie
= kmemdup(connect
->ie
, connect
->ie_len
,
653 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
654 if (!wdev
->conn
->ie
) {
661 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
662 wdev
->conn
->auto_auth
= true;
663 /* start with open system ... should mostly work */
664 wdev
->conn
->params
.auth_type
=
665 NL80211_AUTHTYPE_OPEN_SYSTEM
;
667 wdev
->conn
->auto_auth
= false;
670 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
671 wdev
->ssid_len
= connect
->ssid_len
;
672 wdev
->conn
->params
.ssid
= wdev
->ssid
;
673 wdev
->conn
->params
.ssid_len
= connect
->ssid_len
;
675 /* don't care about result -- but fill bssid & channel */
676 if (!wdev
->conn
->params
.bssid
|| !wdev
->conn
->params
.channel
)
677 cfg80211_get_conn_bss(wdev
);
679 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
680 wdev
->connect_keys
= connkeys
;
682 /* we're good if we have both BSSID and channel */
683 if (wdev
->conn
->params
.bssid
&& wdev
->conn
->params
.channel
) {
684 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
685 err
= cfg80211_conn_do_work(wdev
);
687 /* otherwise we'll need to scan for the AP first */
688 err
= cfg80211_conn_scan(wdev
);
690 * If we can't scan right now, then we need to scan again
691 * after the current scan finished, since the parameters
692 * changed (unless we find a good AP anyway).
696 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
702 wdev
->sme_state
= CFG80211_SME_IDLE
;
703 wdev
->connect_keys
= NULL
;
708 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
709 wdev
->connect_keys
= connkeys
;
710 err
= rdev
->ops
->connect(&rdev
->wiphy
, dev
, connect
);
712 wdev
->connect_keys
= NULL
;
713 wdev
->sme_state
= CFG80211_SME_IDLE
;
717 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
718 wdev
->ssid_len
= connect
->ssid_len
;
724 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
725 struct net_device
*dev
,
726 struct cfg80211_connect_params
*connect
,
727 struct cfg80211_cached_keys
*connkeys
)
731 wdev_lock(dev
->ieee80211_ptr
);
732 err
= __cfg80211_connect(rdev
, dev
, connect
, connkeys
);
733 wdev_unlock(dev
->ieee80211_ptr
);
738 int __cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
739 struct net_device
*dev
, u16 reason
, bool wextev
)
741 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
744 ASSERT_WDEV_LOCK(wdev
);
746 if (wdev
->sme_state
== CFG80211_SME_IDLE
)
749 kfree(wdev
->connect_keys
);
750 wdev
->connect_keys
= NULL
;
752 if (!rdev
->ops
->disconnect
) {
753 if (!rdev
->ops
->deauth
)
756 /* was it connected by userspace SME? */
758 cfg80211_mlme_down(rdev
, dev
);
762 if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
763 (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
764 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
)) {
765 wdev
->sme_state
= CFG80211_SME_IDLE
;
771 /* wdev->conn->params.bssid must be set if > SCANNING */
772 err
= __cfg80211_mlme_deauth(rdev
, dev
,
773 wdev
->conn
->params
.bssid
,
778 err
= rdev
->ops
->disconnect(&rdev
->wiphy
, dev
, reason
);
783 if (wdev
->sme_state
== CFG80211_SME_CONNECTED
)
784 __cfg80211_disconnected(dev
, NULL
, 0, 0, false);
785 else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
)
786 __cfg80211_connect_result(dev
, NULL
, NULL
, 0, NULL
, 0,
787 WLAN_STATUS_UNSPECIFIED_FAILURE
,
793 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
794 struct net_device
*dev
,
795 u16 reason
, bool wextev
)
799 wdev_lock(dev
->ieee80211_ptr
);
800 err
= __cfg80211_disconnect(rdev
, dev
, reason
, wextev
);
801 wdev_unlock(dev
->ieee80211_ptr
);
806 void cfg80211_sme_disassoc(struct net_device
*dev
, int idx
)
808 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
809 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
812 ASSERT_WDEV_LOCK(wdev
);
817 if (wdev
->conn
->state
== CFG80211_CONN_IDLE
)
821 * Ok, so the association was made by this SME -- we don't
822 * want it any more so deauthenticate too.
825 if (!wdev
->auth_bsses
[idx
])
828 memcpy(bssid
, wdev
->auth_bsses
[idx
]->pub
.bssid
, ETH_ALEN
);
829 if (__cfg80211_mlme_deauth(rdev
, dev
, bssid
,
830 NULL
, 0, WLAN_REASON_DEAUTH_LEAVING
)) {
831 /* whatever -- assume gone anyway */
832 cfg80211_unhold_bss(wdev
->auth_bsses
[idx
]);
833 cfg80211_put_bss(&wdev
->auth_bsses
[idx
]->pub
);
834 wdev
->auth_bsses
[idx
] = NULL
;