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
,
30 u8 bssid
[ETH_ALEN
], prev_bssid
[ETH_ALEN
];
33 bool auto_auth
, prev_bssid_valid
;
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 if (wdev
->conn
->params
.channel
)
69 request
->channels
[0] = wdev
->conn
->params
.channel
;
72 enum ieee80211_band band
;
74 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
75 if (!wdev
->wiphy
->bands
[band
])
77 for (j
= 0; j
< wdev
->wiphy
->bands
[band
]->n_channels
;
79 request
->channels
[i
] =
80 &wdev
->wiphy
->bands
[band
]->channels
[j
];
83 request
->n_channels
= n_channels
;
84 request
->ssids
= (void *)&request
->channels
[n_channels
];
87 memcpy(request
->ssids
[0].ssid
, wdev
->conn
->params
.ssid
,
88 wdev
->conn
->params
.ssid_len
);
89 request
->ssids
[0].ssid_len
= wdev
->conn
->params
.ssid_len
;
91 request
->dev
= wdev
->netdev
;
92 request
->wiphy
= &rdev
->wiphy
;
94 rdev
->scan_req
= request
;
96 err
= rdev
->ops
->scan(wdev
->wiphy
, wdev
->netdev
, request
);
98 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
99 nl80211_send_scan_start(rdev
, wdev
->netdev
);
100 dev_hold(wdev
->netdev
);
102 rdev
->scan_req
= NULL
;
108 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
)
110 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
111 struct cfg80211_connect_params
*params
;
112 const u8
*prev_bssid
= NULL
;
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
;
138 if (wdev
->conn
->prev_bssid_valid
)
139 prev_bssid
= wdev
->conn
->prev_bssid
;
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
;
255 mutex_lock(&wiphy_to_dev(wdev
->wiphy
)->devlist_mtx
);
257 __cfg80211_sme_scan_done(dev
);
259 mutex_unlock(&wiphy_to_dev(wdev
->wiphy
)->devlist_mtx
);
262 void cfg80211_sme_rx_auth(struct net_device
*dev
,
263 const u8
*buf
, size_t len
)
265 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
266 struct wiphy
*wiphy
= wdev
->wiphy
;
267 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
268 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
269 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
271 ASSERT_WDEV_LOCK(wdev
);
273 /* should only RX auth frames when connecting */
274 if (wdev
->sme_state
!= CFG80211_SME_CONNECTING
)
277 if (WARN_ON(!wdev
->conn
))
280 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
281 wdev
->conn
->auto_auth
&&
282 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
283 /* select automatically between only open, shared, leap */
284 switch (wdev
->conn
->params
.auth_type
) {
285 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
286 if (wdev
->connect_keys
)
287 wdev
->conn
->params
.auth_type
=
288 NL80211_AUTHTYPE_SHARED_KEY
;
290 wdev
->conn
->params
.auth_type
=
291 NL80211_AUTHTYPE_NETWORK_EAP
;
293 case NL80211_AUTHTYPE_SHARED_KEY
:
294 wdev
->conn
->params
.auth_type
=
295 NL80211_AUTHTYPE_NETWORK_EAP
;
299 wdev
->conn
->params
.auth_type
=
300 NL80211_AUTHTYPE_OPEN_SYSTEM
;
303 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
304 schedule_work(&rdev
->conn_work
);
305 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
306 __cfg80211_connect_result(dev
, mgmt
->bssid
, NULL
, 0, NULL
, 0,
307 status_code
, false, NULL
);
308 } else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
309 wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
310 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
311 schedule_work(&rdev
->conn_work
);
315 bool cfg80211_sme_failed_reassoc(struct wireless_dev
*wdev
)
317 struct wiphy
*wiphy
= wdev
->wiphy
;
318 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
320 if (WARN_ON(!wdev
->conn
))
323 if (!wdev
->conn
->prev_bssid_valid
)
327 * Some stupid APs don't accept reassoc, so we
328 * need to fall back to trying regular assoc.
330 wdev
->conn
->prev_bssid_valid
= false;
331 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
332 schedule_work(&rdev
->conn_work
);
337 void __cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
338 const u8
*req_ie
, size_t req_ie_len
,
339 const u8
*resp_ie
, size_t resp_ie_len
,
340 u16 status
, bool wextev
,
341 struct cfg80211_bss
*bss
)
343 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
345 #ifdef CONFIG_WIRELESS_EXT
346 union iwreq_data wrqu
;
349 ASSERT_WDEV_LOCK(wdev
);
351 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
354 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTING
))
357 nl80211_send_connect_result(wiphy_to_dev(wdev
->wiphy
), dev
,
358 bssid
, req_ie
, req_ie_len
,
359 resp_ie
, resp_ie_len
,
362 #ifdef CONFIG_WIRELESS_EXT
364 if (req_ie
&& status
== WLAN_STATUS_SUCCESS
) {
365 memset(&wrqu
, 0, sizeof(wrqu
));
366 wrqu
.data
.length
= req_ie_len
;
367 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
, req_ie
);
370 if (resp_ie
&& status
== WLAN_STATUS_SUCCESS
) {
371 memset(&wrqu
, 0, sizeof(wrqu
));
372 wrqu
.data
.length
= resp_ie_len
;
373 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
, resp_ie
);
376 memset(&wrqu
, 0, sizeof(wrqu
));
377 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
378 if (bssid
&& status
== WLAN_STATUS_SUCCESS
) {
379 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
380 memcpy(wdev
->wext
.prev_bssid
, bssid
, ETH_ALEN
);
381 wdev
->wext
.prev_bssid_valid
= true;
383 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
387 if (wdev
->current_bss
) {
388 cfg80211_unhold_bss(wdev
->current_bss
);
389 cfg80211_put_bss(&wdev
->current_bss
->pub
);
390 wdev
->current_bss
= NULL
;
394 wdev
->conn
->state
= CFG80211_CONN_IDLE
;
396 if (status
!= WLAN_STATUS_SUCCESS
) {
397 wdev
->sme_state
= CFG80211_SME_IDLE
;
400 kfree(wdev
->connect_keys
);
401 wdev
->connect_keys
= NULL
;
407 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
408 wdev
->ssid
, wdev
->ssid_len
,
410 WLAN_CAPABILITY_ESS
);
415 cfg80211_hold_bss(bss_from_pub(bss
));
416 wdev
->current_bss
= bss_from_pub(bss
);
418 wdev
->sme_state
= CFG80211_SME_CONNECTED
;
419 cfg80211_upload_connect_keys(wdev
);
421 country_ie
= (u8
*) ieee80211_bss_get_ie(bss
, WLAN_EID_COUNTRY
);
427 * ieee80211_bss_get_ie() ensures we can access:
428 * - country_ie + 2, the start of the country ie data, and
429 * - and country_ie[1] which is the IE length
431 regulatory_hint_11d(wdev
->wiphy
,
436 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
437 const u8
*req_ie
, size_t req_ie_len
,
438 const u8
*resp_ie
, size_t resp_ie_len
,
439 u16 status
, gfp_t gfp
)
441 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
442 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
443 struct cfg80211_event
*ev
;
446 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
450 ev
->type
= EVENT_CONNECT_RESULT
;
451 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
452 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
453 ev
->cr
.req_ie_len
= req_ie_len
;
454 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
455 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
456 ev
->cr
.resp_ie_len
= resp_ie_len
;
457 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
458 ev
->cr
.status
= status
;
460 spin_lock_irqsave(&wdev
->event_lock
, flags
);
461 list_add_tail(&ev
->list
, &wdev
->event_list
);
462 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
463 schedule_work(&rdev
->event_work
);
465 EXPORT_SYMBOL(cfg80211_connect_result
);
467 void __cfg80211_roamed(struct wireless_dev
*wdev
, const u8
*bssid
,
468 const u8
*req_ie
, size_t req_ie_len
,
469 const u8
*resp_ie
, size_t resp_ie_len
)
471 struct cfg80211_bss
*bss
;
472 #ifdef CONFIG_WIRELESS_EXT
473 union iwreq_data wrqu
;
476 ASSERT_WDEV_LOCK(wdev
);
478 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
481 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
484 /* internal error -- how did we get to CONNECTED w/o BSS? */
485 if (WARN_ON(!wdev
->current_bss
)) {
489 cfg80211_unhold_bss(wdev
->current_bss
);
490 cfg80211_put_bss(&wdev
->current_bss
->pub
);
491 wdev
->current_bss
= NULL
;
493 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
494 wdev
->ssid
, wdev
->ssid_len
,
495 WLAN_CAPABILITY_ESS
, WLAN_CAPABILITY_ESS
);
500 cfg80211_hold_bss(bss_from_pub(bss
));
501 wdev
->current_bss
= bss_from_pub(bss
);
503 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), wdev
->netdev
, bssid
,
504 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
507 #ifdef CONFIG_WIRELESS_EXT
509 memset(&wrqu
, 0, sizeof(wrqu
));
510 wrqu
.data
.length
= req_ie_len
;
511 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
516 memset(&wrqu
, 0, sizeof(wrqu
));
517 wrqu
.data
.length
= resp_ie_len
;
518 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
522 memset(&wrqu
, 0, sizeof(wrqu
));
523 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
524 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
525 memcpy(wdev
->wext
.prev_bssid
, bssid
, ETH_ALEN
);
526 wdev
->wext
.prev_bssid_valid
= true;
527 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
531 void cfg80211_roamed(struct net_device
*dev
, const u8
*bssid
,
532 const u8
*req_ie
, size_t req_ie_len
,
533 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
535 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
536 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
537 struct cfg80211_event
*ev
;
540 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
544 ev
->type
= EVENT_ROAMED
;
545 memcpy(ev
->rm
.bssid
, bssid
, ETH_ALEN
);
546 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
547 ev
->rm
.req_ie_len
= req_ie_len
;
548 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
549 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
550 ev
->rm
.resp_ie_len
= resp_ie_len
;
551 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
553 spin_lock_irqsave(&wdev
->event_lock
, flags
);
554 list_add_tail(&ev
->list
, &wdev
->event_list
);
555 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
556 schedule_work(&rdev
->event_work
);
558 EXPORT_SYMBOL(cfg80211_roamed
);
560 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
561 size_t ie_len
, u16 reason
, bool from_ap
)
563 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
564 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
566 #ifdef CONFIG_WIRELESS_EXT
567 union iwreq_data wrqu
;
570 ASSERT_WDEV_LOCK(wdev
);
572 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
575 if (WARN_ON(wdev
->sme_state
!= CFG80211_SME_CONNECTED
))
578 if (wdev
->current_bss
) {
579 cfg80211_unhold_bss(wdev
->current_bss
);
580 cfg80211_put_bss(&wdev
->current_bss
->pub
);
583 wdev
->current_bss
= NULL
;
584 wdev
->sme_state
= CFG80211_SME_IDLE
;
591 kfree(wdev
->conn
->ie
);
592 wdev
->conn
->ie
= NULL
;
597 * If this disconnect was due to a disassoc, we
598 * we might still have an auth BSS around. For
599 * the userspace SME that's currently expected,
600 * but for the kernel SME (nl80211 CONNECT or
601 * wireless extensions) we want to clear up all
604 for (i
= 0; i
< MAX_AUTH_BSSES
; i
++) {
605 if (!wdev
->auth_bsses
[i
])
607 bssid
= wdev
->auth_bsses
[i
]->pub
.bssid
;
608 ret
= __cfg80211_mlme_deauth(rdev
, dev
, bssid
, NULL
, 0,
609 WLAN_REASON_DEAUTH_LEAVING
);
610 WARN(ret
, "deauth failed: %d\n", ret
);
614 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
617 * Delete all the keys ... pairwise keys can't really
618 * exist any more anyway, but default keys might.
620 if (rdev
->ops
->del_key
)
621 for (i
= 0; i
< 6; i
++)
622 rdev
->ops
->del_key(wdev
->wiphy
, dev
, i
, NULL
);
624 #ifdef CONFIG_WIRELESS_EXT
625 memset(&wrqu
, 0, sizeof(wrqu
));
626 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
627 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
631 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
632 u8
*ie
, size_t ie_len
, gfp_t gfp
)
634 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
635 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
636 struct cfg80211_event
*ev
;
639 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
643 ev
->type
= EVENT_DISCONNECTED
;
644 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
645 ev
->dc
.ie_len
= ie_len
;
646 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
647 ev
->dc
.reason
= reason
;
649 spin_lock_irqsave(&wdev
->event_lock
, flags
);
650 list_add_tail(&ev
->list
, &wdev
->event_list
);
651 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
652 schedule_work(&rdev
->event_work
);
654 EXPORT_SYMBOL(cfg80211_disconnected
);
656 int __cfg80211_connect(struct cfg80211_registered_device
*rdev
,
657 struct net_device
*dev
,
658 struct cfg80211_connect_params
*connect
,
659 struct cfg80211_cached_keys
*connkeys
,
660 const u8
*prev_bssid
)
662 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
663 struct ieee80211_channel
*chan
;
666 ASSERT_WDEV_LOCK(wdev
);
668 if (wdev
->sme_state
!= CFG80211_SME_IDLE
)
671 chan
= rdev_fixed_channel(rdev
, wdev
);
672 if (chan
&& chan
!= connect
->channel
)
675 if (WARN_ON(wdev
->connect_keys
)) {
676 kfree(wdev
->connect_keys
);
677 wdev
->connect_keys
= NULL
;
680 if (connkeys
&& connkeys
->def
>= 0) {
685 cipher
= connkeys
->params
[idx
].cipher
;
686 /* If given a WEP key we may need it for shared key auth */
687 if (cipher
== WLAN_CIPHER_SUITE_WEP40
||
688 cipher
== WLAN_CIPHER_SUITE_WEP104
) {
689 connect
->key_idx
= idx
;
690 connect
->key
= connkeys
->params
[idx
].key
;
691 connect
->key_len
= connkeys
->params
[idx
].key_len
;
694 * If ciphers are not set (e.g. when going through
695 * iwconfig), we have to set them appropriately here.
697 if (connect
->crypto
.cipher_group
== 0)
698 connect
->crypto
.cipher_group
= cipher
;
700 if (connect
->crypto
.n_ciphers_pairwise
== 0) {
701 connect
->crypto
.n_ciphers_pairwise
= 1;
702 connect
->crypto
.ciphers_pairwise
[0] = cipher
;
707 if (!rdev
->ops
->connect
) {
708 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
711 if (WARN_ON(wdev
->conn
))
714 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
719 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
721 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
722 if (connect
->bssid
) {
723 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
724 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
728 wdev
->conn
->ie
= kmemdup(connect
->ie
, connect
->ie_len
,
730 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
731 if (!wdev
->conn
->ie
) {
738 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
739 wdev
->conn
->auto_auth
= true;
740 /* start with open system ... should mostly work */
741 wdev
->conn
->params
.auth_type
=
742 NL80211_AUTHTYPE_OPEN_SYSTEM
;
744 wdev
->conn
->auto_auth
= false;
747 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
748 wdev
->ssid_len
= connect
->ssid_len
;
749 wdev
->conn
->params
.ssid
= wdev
->ssid
;
750 wdev
->conn
->params
.ssid_len
= connect
->ssid_len
;
752 /* don't care about result -- but fill bssid & channel */
753 if (!wdev
->conn
->params
.bssid
|| !wdev
->conn
->params
.channel
)
754 cfg80211_get_conn_bss(wdev
);
756 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
757 wdev
->connect_keys
= connkeys
;
760 memcpy(wdev
->conn
->prev_bssid
, prev_bssid
, ETH_ALEN
);
761 wdev
->conn
->prev_bssid_valid
= true;
764 /* we're good if we have both BSSID and channel */
765 if (wdev
->conn
->params
.bssid
&& wdev
->conn
->params
.channel
) {
766 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
767 err
= cfg80211_conn_do_work(wdev
);
769 /* otherwise we'll need to scan for the AP first */
770 err
= cfg80211_conn_scan(wdev
);
772 * If we can't scan right now, then we need to scan again
773 * after the current scan finished, since the parameters
774 * changed (unless we find a good AP anyway).
778 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
784 wdev
->sme_state
= CFG80211_SME_IDLE
;
785 wdev
->connect_keys
= NULL
;
791 wdev
->sme_state
= CFG80211_SME_CONNECTING
;
792 wdev
->connect_keys
= connkeys
;
793 err
= rdev
->ops
->connect(&rdev
->wiphy
, dev
, connect
);
795 wdev
->connect_keys
= NULL
;
796 wdev
->sme_state
= CFG80211_SME_IDLE
;
800 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
801 wdev
->ssid_len
= connect
->ssid_len
;
807 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
808 struct net_device
*dev
,
809 struct cfg80211_connect_params
*connect
,
810 struct cfg80211_cached_keys
*connkeys
)
814 mutex_lock(&rdev
->devlist_mtx
);
815 wdev_lock(dev
->ieee80211_ptr
);
816 err
= __cfg80211_connect(rdev
, dev
, connect
, connkeys
, NULL
);
817 wdev_unlock(dev
->ieee80211_ptr
);
818 mutex_unlock(&rdev
->devlist_mtx
);
823 int __cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
824 struct net_device
*dev
, u16 reason
, bool wextev
)
826 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
829 ASSERT_WDEV_LOCK(wdev
);
831 if (wdev
->sme_state
== CFG80211_SME_IDLE
)
834 kfree(wdev
->connect_keys
);
835 wdev
->connect_keys
= NULL
;
837 if (!rdev
->ops
->disconnect
) {
838 if (!rdev
->ops
->deauth
)
841 /* was it connected by userspace SME? */
843 cfg80211_mlme_down(rdev
, dev
);
847 if (wdev
->sme_state
== CFG80211_SME_CONNECTING
&&
848 (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
849 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
)) {
850 wdev
->sme_state
= CFG80211_SME_IDLE
;
857 /* wdev->conn->params.bssid must be set if > SCANNING */
858 err
= __cfg80211_mlme_deauth(rdev
, dev
,
859 wdev
->conn
->params
.bssid
,
864 err
= rdev
->ops
->disconnect(&rdev
->wiphy
, dev
, reason
);
869 if (wdev
->sme_state
== CFG80211_SME_CONNECTED
)
870 __cfg80211_disconnected(dev
, NULL
, 0, 0, false);
871 else if (wdev
->sme_state
== CFG80211_SME_CONNECTING
)
872 __cfg80211_connect_result(dev
, NULL
, NULL
, 0, NULL
, 0,
873 WLAN_STATUS_UNSPECIFIED_FAILURE
,
879 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
880 struct net_device
*dev
,
881 u16 reason
, bool wextev
)
885 wdev_lock(dev
->ieee80211_ptr
);
886 err
= __cfg80211_disconnect(rdev
, dev
, reason
, wextev
);
887 wdev_unlock(dev
->ieee80211_ptr
);
892 void cfg80211_sme_disassoc(struct net_device
*dev
, int idx
)
894 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
895 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
898 ASSERT_WDEV_LOCK(wdev
);
903 if (wdev
->conn
->state
== CFG80211_CONN_IDLE
)
907 * Ok, so the association was made by this SME -- we don't
908 * want it any more so deauthenticate too.
911 if (!wdev
->auth_bsses
[idx
])
914 memcpy(bssid
, wdev
->auth_bsses
[idx
]->pub
.bssid
, ETH_ALEN
);
915 if (__cfg80211_mlme_deauth(rdev
, dev
, bssid
,
916 NULL
, 0, WLAN_REASON_DEAUTH_LEAVING
)) {
917 /* whatever -- assume gone anyway */
918 cfg80211_unhold_bss(wdev
->auth_bsses
[idx
]);
919 cfg80211_put_bss(&wdev
->auth_bsses
[idx
]->pub
);
920 wdev
->auth_bsses
[idx
] = NULL
;