2 * SME code for cfg80211
3 * both driver SME event handling and the SME implementation
4 * (for nl80211's connect() and wext)
6 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
7 * Copyright (C) 2009 Intel Corporation. All rights reserved.
10 #include <linux/etherdevice.h>
11 #include <linux/if_arp.h>
12 #include <linux/slab.h>
13 #include <linux/workqueue.h>
14 #include <linux/wireless.h>
15 #include <linux/export.h>
16 #include <net/iw_handler.h>
17 #include <net/cfg80211.h>
18 #include <net/rtnetlink.h>
24 * Software SME in cfg80211, using auth/assoc/deauth calls to the
25 * driver. This is is for implementing nl80211's connect/disconnect
26 * and wireless extensions (if configured.)
29 struct cfg80211_conn
{
30 struct cfg80211_connect_params params
;
31 /* these are sub-states of the _CONNECTING sme_state */
33 CFG80211_CONN_SCANNING
,
34 CFG80211_CONN_SCAN_AGAIN
,
35 CFG80211_CONN_AUTHENTICATE_NEXT
,
36 CFG80211_CONN_AUTHENTICATING
,
37 CFG80211_CONN_AUTH_FAILED
,
38 CFG80211_CONN_ASSOCIATE_NEXT
,
39 CFG80211_CONN_ASSOCIATING
,
40 CFG80211_CONN_ASSOC_FAILED
,
42 CFG80211_CONN_CONNECTED
,
44 u8 bssid
[ETH_ALEN
], prev_bssid
[ETH_ALEN
];
47 bool auto_auth
, prev_bssid_valid
;
50 static void cfg80211_sme_free(struct wireless_dev
*wdev
)
55 kfree(wdev
->conn
->ie
);
60 static int cfg80211_conn_scan(struct wireless_dev
*wdev
)
62 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
63 struct cfg80211_scan_request
*request
;
67 ASSERT_WDEV_LOCK(wdev
);
69 if (rdev
->scan_req
|| rdev
->scan_msg
)
72 if (wdev
->conn
->params
.channel
)
75 n_channels
= ieee80211_get_num_supported_channels(wdev
->wiphy
);
77 request
= kzalloc(sizeof(*request
) + sizeof(request
->ssids
[0]) +
78 sizeof(request
->channels
[0]) * n_channels
,
83 if (wdev
->conn
->params
.channel
)
84 request
->channels
[0] = wdev
->conn
->params
.channel
;
87 enum ieee80211_band band
;
88 struct ieee80211_supported_band
*bands
;
89 struct ieee80211_channel
*channel
;
91 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
92 bands
= wdev
->wiphy
->bands
[band
];
95 for (j
= 0; j
< bands
->n_channels
; j
++) {
96 channel
= &bands
->channels
[j
];
97 if (channel
->flags
& IEEE80211_CHAN_DISABLED
)
99 request
->channels
[i
++] = channel
;
101 request
->rates
[band
] = (1 << bands
->n_bitrates
) - 1;
105 request
->n_channels
= n_channels
;
106 request
->ssids
= (void *)&request
->channels
[n_channels
];
107 request
->n_ssids
= 1;
109 memcpy(request
->ssids
[0].ssid
, wdev
->conn
->params
.ssid
,
110 wdev
->conn
->params
.ssid_len
);
111 request
->ssids
[0].ssid_len
= wdev
->conn
->params
.ssid_len
;
113 request
->wdev
= wdev
;
114 request
->wiphy
= &rdev
->wiphy
;
115 request
->scan_start
= jiffies
;
117 rdev
->scan_req
= request
;
119 err
= rdev_scan(rdev
, request
);
121 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
122 nl80211_send_scan_start(rdev
, wdev
);
123 dev_hold(wdev
->netdev
);
125 rdev
->scan_req
= NULL
;
131 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
)
133 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
134 struct cfg80211_connect_params
*params
;
135 struct cfg80211_assoc_request req
= {};
138 ASSERT_WDEV_LOCK(wdev
);
143 params
= &wdev
->conn
->params
;
145 switch (wdev
->conn
->state
) {
146 case CFG80211_CONN_SCANNING
:
147 /* didn't find it during scan ... */
149 case CFG80211_CONN_SCAN_AGAIN
:
150 return cfg80211_conn_scan(wdev
);
151 case CFG80211_CONN_AUTHENTICATE_NEXT
:
152 if (WARN_ON(!rdev
->ops
->auth
))
154 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATING
;
155 return cfg80211_mlme_auth(rdev
, wdev
->netdev
,
156 params
->channel
, params
->auth_type
,
158 params
->ssid
, params
->ssid_len
,
160 params
->key
, params
->key_len
,
161 params
->key_idx
, NULL
, 0);
162 case CFG80211_CONN_AUTH_FAILED
:
164 case CFG80211_CONN_ASSOCIATE_NEXT
:
165 if (WARN_ON(!rdev
->ops
->assoc
))
167 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATING
;
168 if (wdev
->conn
->prev_bssid_valid
)
169 req
.prev_bssid
= wdev
->conn
->prev_bssid
;
171 req
.ie_len
= params
->ie_len
;
172 req
.use_mfp
= params
->mfp
!= NL80211_MFP_NO
;
173 req
.crypto
= params
->crypto
;
174 req
.flags
= params
->flags
;
175 req
.ht_capa
= params
->ht_capa
;
176 req
.ht_capa_mask
= params
->ht_capa_mask
;
177 req
.vht_capa
= params
->vht_capa
;
178 req
.vht_capa_mask
= params
->vht_capa_mask
;
180 err
= cfg80211_mlme_assoc(rdev
, wdev
->netdev
, params
->channel
,
181 params
->bssid
, params
->ssid
,
182 params
->ssid_len
, &req
);
184 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
186 WLAN_REASON_DEAUTH_LEAVING
,
189 case CFG80211_CONN_ASSOC_FAILED
:
190 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
192 WLAN_REASON_DEAUTH_LEAVING
, false);
194 case CFG80211_CONN_DEAUTH
:
195 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
197 WLAN_REASON_DEAUTH_LEAVING
, false);
198 /* free directly, disconnected event already sent */
199 cfg80211_sme_free(wdev
);
206 void cfg80211_conn_work(struct work_struct
*work
)
208 struct cfg80211_registered_device
*rdev
=
209 container_of(work
, struct cfg80211_registered_device
, conn_work
);
210 struct wireless_dev
*wdev
;
211 u8 bssid_buf
[ETH_ALEN
], *bssid
= NULL
;
215 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
220 if (!netif_running(wdev
->netdev
)) {
225 wdev
->conn
->state
== CFG80211_CONN_CONNECTED
) {
229 if (wdev
->conn
->params
.bssid
) {
230 memcpy(bssid_buf
, wdev
->conn
->params
.bssid
, ETH_ALEN
);
233 if (cfg80211_conn_do_work(wdev
)) {
234 __cfg80211_connect_result(
237 WLAN_STATUS_UNSPECIFIED_FAILURE
,
239 cfg80211_sme_free(wdev
);
247 /* Returned bss is reference counted and must be cleaned up appropriately. */
248 static struct cfg80211_bss
*cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
250 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
251 struct cfg80211_bss
*bss
;
252 u16 capa
= WLAN_CAPABILITY_ESS
;
254 ASSERT_WDEV_LOCK(wdev
);
256 if (wdev
->conn
->params
.privacy
)
257 capa
|= WLAN_CAPABILITY_PRIVACY
;
259 bss
= cfg80211_get_bss(wdev
->wiphy
, wdev
->conn
->params
.channel
,
260 wdev
->conn
->params
.bssid
,
261 wdev
->conn
->params
.ssid
,
262 wdev
->conn
->params
.ssid_len
,
263 WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_PRIVACY
,
268 memcpy(wdev
->conn
->bssid
, bss
->bssid
, ETH_ALEN
);
269 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
270 wdev
->conn
->params
.channel
= bss
->channel
;
271 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
272 schedule_work(&rdev
->conn_work
);
277 static void __cfg80211_sme_scan_done(struct net_device
*dev
)
279 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
280 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
281 struct cfg80211_bss
*bss
;
283 ASSERT_WDEV_LOCK(wdev
);
288 if (wdev
->conn
->state
!= CFG80211_CONN_SCANNING
&&
289 wdev
->conn
->state
!= CFG80211_CONN_SCAN_AGAIN
)
292 bss
= cfg80211_get_conn_bss(wdev
);
294 cfg80211_put_bss(&rdev
->wiphy
, bss
);
296 schedule_work(&rdev
->conn_work
);
299 void cfg80211_sme_scan_done(struct net_device
*dev
)
301 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
304 __cfg80211_sme_scan_done(dev
);
308 void cfg80211_sme_rx_auth(struct wireless_dev
*wdev
, const u8
*buf
, size_t len
)
310 struct wiphy
*wiphy
= wdev
->wiphy
;
311 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
312 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
313 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
315 ASSERT_WDEV_LOCK(wdev
);
317 if (!wdev
->conn
|| wdev
->conn
->state
== CFG80211_CONN_CONNECTED
)
320 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
321 wdev
->conn
->auto_auth
&&
322 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
323 /* select automatically between only open, shared, leap */
324 switch (wdev
->conn
->params
.auth_type
) {
325 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
326 if (wdev
->connect_keys
)
327 wdev
->conn
->params
.auth_type
=
328 NL80211_AUTHTYPE_SHARED_KEY
;
330 wdev
->conn
->params
.auth_type
=
331 NL80211_AUTHTYPE_NETWORK_EAP
;
333 case NL80211_AUTHTYPE_SHARED_KEY
:
334 wdev
->conn
->params
.auth_type
=
335 NL80211_AUTHTYPE_NETWORK_EAP
;
339 wdev
->conn
->params
.auth_type
=
340 NL80211_AUTHTYPE_OPEN_SYSTEM
;
343 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
344 schedule_work(&rdev
->conn_work
);
345 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
346 __cfg80211_connect_result(wdev
->netdev
, mgmt
->bssid
,
348 status_code
, false, NULL
);
349 } else if (wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
350 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
351 schedule_work(&rdev
->conn_work
);
355 bool cfg80211_sme_rx_assoc_resp(struct wireless_dev
*wdev
, u16 status
)
357 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
362 if (status
== WLAN_STATUS_SUCCESS
) {
363 wdev
->conn
->state
= CFG80211_CONN_CONNECTED
;
367 if (wdev
->conn
->prev_bssid_valid
) {
369 * Some stupid APs don't accept reassoc, so we
370 * need to fall back to trying regular assoc;
371 * return true so no event is sent to userspace.
373 wdev
->conn
->prev_bssid_valid
= false;
374 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
375 schedule_work(&rdev
->conn_work
);
379 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED
;
380 schedule_work(&rdev
->conn_work
);
384 void cfg80211_sme_deauth(struct wireless_dev
*wdev
)
386 cfg80211_sme_free(wdev
);
389 void cfg80211_sme_auth_timeout(struct wireless_dev
*wdev
)
391 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
396 wdev
->conn
->state
= CFG80211_CONN_AUTH_FAILED
;
397 schedule_work(&rdev
->conn_work
);
400 void cfg80211_sme_disassoc(struct wireless_dev
*wdev
)
402 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
407 wdev
->conn
->state
= CFG80211_CONN_DEAUTH
;
408 schedule_work(&rdev
->conn_work
);
411 void cfg80211_sme_assoc_timeout(struct wireless_dev
*wdev
)
413 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
418 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED
;
419 schedule_work(&rdev
->conn_work
);
422 static int cfg80211_sme_connect(struct wireless_dev
*wdev
,
423 struct cfg80211_connect_params
*connect
,
424 const u8
*prev_bssid
)
426 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
427 struct cfg80211_bss
*bss
;
430 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
433 if (wdev
->current_bss
)
436 if (WARN_ON(wdev
->conn
))
439 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
444 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
446 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
447 if (connect
->bssid
) {
448 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
449 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
453 wdev
->conn
->ie
= kmemdup(connect
->ie
, connect
->ie_len
,
455 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
456 if (!wdev
->conn
->ie
) {
463 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
464 wdev
->conn
->auto_auth
= true;
465 /* start with open system ... should mostly work */
466 wdev
->conn
->params
.auth_type
=
467 NL80211_AUTHTYPE_OPEN_SYSTEM
;
469 wdev
->conn
->auto_auth
= false;
472 wdev
->conn
->params
.ssid
= wdev
->ssid
;
473 wdev
->conn
->params
.ssid_len
= wdev
->ssid_len
;
475 /* see if we have the bss already */
476 bss
= cfg80211_get_conn_bss(wdev
);
479 memcpy(wdev
->conn
->prev_bssid
, prev_bssid
, ETH_ALEN
);
480 wdev
->conn
->prev_bssid_valid
= true;
483 /* we're good if we have a matching bss struct */
485 err
= cfg80211_conn_do_work(wdev
);
486 cfg80211_put_bss(wdev
->wiphy
, bss
);
488 /* otherwise we'll need to scan for the AP first */
489 err
= cfg80211_conn_scan(wdev
);
492 * If we can't scan right now, then we need to scan again
493 * after the current scan finished, since the parameters
494 * changed (unless we find a good AP anyway).
498 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
503 cfg80211_sme_free(wdev
);
508 static int cfg80211_sme_disconnect(struct wireless_dev
*wdev
, u16 reason
)
510 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
516 if (!rdev
->ops
->deauth
)
519 if (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
520 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
) {
525 /* wdev->conn->params.bssid must be set if > SCANNING */
526 err
= cfg80211_mlme_deauth(rdev
, wdev
->netdev
,
527 wdev
->conn
->params
.bssid
,
528 NULL
, 0, reason
, false);
530 cfg80211_sme_free(wdev
);
535 * code shared for in-device and software SME
538 static bool cfg80211_is_all_idle(void)
540 struct cfg80211_registered_device
*rdev
;
541 struct wireless_dev
*wdev
;
542 bool is_all_idle
= true;
545 * All devices must be idle as otherwise if you are actively
546 * scanning some new beacon hints could be learned and would
547 * count as new regulatory hints.
549 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
550 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
552 if (wdev
->conn
|| wdev
->current_bss
)
561 static void disconnect_work(struct work_struct
*work
)
564 if (cfg80211_is_all_idle())
565 regulatory_hint_disconnect();
569 static DECLARE_WORK(cfg80211_disconnect_work
, disconnect_work
);
573 * API calls for drivers implementing connect/disconnect and
577 /* This method must consume bss one way or another */
578 void __cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
579 const u8
*req_ie
, size_t req_ie_len
,
580 const u8
*resp_ie
, size_t resp_ie_len
,
581 u16 status
, bool wextev
,
582 struct cfg80211_bss
*bss
)
584 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
585 const u8
*country_ie
;
586 #ifdef CONFIG_CFG80211_WEXT
587 union iwreq_data wrqu
;
590 ASSERT_WDEV_LOCK(wdev
);
592 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
593 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)) {
594 cfg80211_put_bss(wdev
->wiphy
, bss
);
598 nl80211_send_connect_result(wiphy_to_rdev(wdev
->wiphy
), dev
,
599 bssid
, req_ie
, req_ie_len
,
600 resp_ie
, resp_ie_len
,
603 #ifdef CONFIG_CFG80211_WEXT
605 if (req_ie
&& status
== WLAN_STATUS_SUCCESS
) {
606 memset(&wrqu
, 0, sizeof(wrqu
));
607 wrqu
.data
.length
= req_ie_len
;
608 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
, req_ie
);
611 if (resp_ie
&& status
== WLAN_STATUS_SUCCESS
) {
612 memset(&wrqu
, 0, sizeof(wrqu
));
613 wrqu
.data
.length
= resp_ie_len
;
614 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
, resp_ie
);
617 memset(&wrqu
, 0, sizeof(wrqu
));
618 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
619 if (bssid
&& status
== WLAN_STATUS_SUCCESS
) {
620 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
621 memcpy(wdev
->wext
.prev_bssid
, bssid
, ETH_ALEN
);
622 wdev
->wext
.prev_bssid_valid
= true;
624 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
628 if (!bss
&& (status
== WLAN_STATUS_SUCCESS
)) {
629 WARN_ON_ONCE(!wiphy_to_rdev(wdev
->wiphy
)->ops
->connect
);
630 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
631 wdev
->ssid
, wdev
->ssid_len
,
633 WLAN_CAPABILITY_ESS
);
635 cfg80211_hold_bss(bss_from_pub(bss
));
638 if (wdev
->current_bss
) {
639 cfg80211_unhold_bss(wdev
->current_bss
);
640 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
641 wdev
->current_bss
= NULL
;
644 if (status
!= WLAN_STATUS_SUCCESS
) {
645 kfree(wdev
->connect_keys
);
646 wdev
->connect_keys
= NULL
;
649 cfg80211_unhold_bss(bss_from_pub(bss
));
650 cfg80211_put_bss(wdev
->wiphy
, bss
);
658 wdev
->current_bss
= bss_from_pub(bss
);
660 cfg80211_upload_connect_keys(wdev
);
663 country_ie
= ieee80211_bss_get_ie(bss
, WLAN_EID_COUNTRY
);
669 country_ie
= kmemdup(country_ie
, 2 + country_ie
[1], GFP_ATOMIC
);
676 * ieee80211_bss_get_ie() ensures we can access:
677 * - country_ie + 2, the start of the country ie data, and
678 * - and country_ie[1] which is the IE length
680 regulatory_hint_country_ie(wdev
->wiphy
, bss
->channel
->band
,
681 country_ie
+ 2, country_ie
[1]);
685 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
686 const u8
*req_ie
, size_t req_ie_len
,
687 const u8
*resp_ie
, size_t resp_ie_len
,
688 u16 status
, gfp_t gfp
)
690 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
691 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
692 struct cfg80211_event
*ev
;
695 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
699 ev
->type
= EVENT_CONNECT_RESULT
;
701 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
703 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
704 ev
->cr
.req_ie_len
= req_ie_len
;
705 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
708 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
709 ev
->cr
.resp_ie_len
= resp_ie_len
;
710 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
712 ev
->cr
.status
= status
;
714 spin_lock_irqsave(&wdev
->event_lock
, flags
);
715 list_add_tail(&ev
->list
, &wdev
->event_list
);
716 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
717 queue_work(cfg80211_wq
, &rdev
->event_work
);
719 EXPORT_SYMBOL(cfg80211_connect_result
);
721 /* Consumes bss object one way or another */
722 void __cfg80211_roamed(struct wireless_dev
*wdev
,
723 struct cfg80211_bss
*bss
,
724 const u8
*req_ie
, size_t req_ie_len
,
725 const u8
*resp_ie
, size_t resp_ie_len
)
727 #ifdef CONFIG_CFG80211_WEXT
728 union iwreq_data wrqu
;
730 ASSERT_WDEV_LOCK(wdev
);
732 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
733 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
736 if (WARN_ON(!wdev
->current_bss
))
739 cfg80211_unhold_bss(wdev
->current_bss
);
740 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
741 wdev
->current_bss
= NULL
;
743 cfg80211_hold_bss(bss_from_pub(bss
));
744 wdev
->current_bss
= bss_from_pub(bss
);
746 nl80211_send_roamed(wiphy_to_rdev(wdev
->wiphy
),
747 wdev
->netdev
, bss
->bssid
,
748 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
751 #ifdef CONFIG_CFG80211_WEXT
753 memset(&wrqu
, 0, sizeof(wrqu
));
754 wrqu
.data
.length
= req_ie_len
;
755 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
760 memset(&wrqu
, 0, sizeof(wrqu
));
761 wrqu
.data
.length
= resp_ie_len
;
762 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
766 memset(&wrqu
, 0, sizeof(wrqu
));
767 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
768 memcpy(wrqu
.ap_addr
.sa_data
, bss
->bssid
, ETH_ALEN
);
769 memcpy(wdev
->wext
.prev_bssid
, bss
->bssid
, ETH_ALEN
);
770 wdev
->wext
.prev_bssid_valid
= true;
771 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
776 cfg80211_put_bss(wdev
->wiphy
, bss
);
779 void cfg80211_roamed(struct net_device
*dev
,
780 struct ieee80211_channel
*channel
,
782 const u8
*req_ie
, size_t req_ie_len
,
783 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
785 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
786 struct cfg80211_bss
*bss
;
788 bss
= cfg80211_get_bss(wdev
->wiphy
, channel
, bssid
, wdev
->ssid
,
789 wdev
->ssid_len
, WLAN_CAPABILITY_ESS
,
790 WLAN_CAPABILITY_ESS
);
794 cfg80211_roamed_bss(dev
, bss
, req_ie
, req_ie_len
, resp_ie
,
797 EXPORT_SYMBOL(cfg80211_roamed
);
799 /* Consumes bss object one way or another */
800 void cfg80211_roamed_bss(struct net_device
*dev
,
801 struct cfg80211_bss
*bss
, const u8
*req_ie
,
802 size_t req_ie_len
, const u8
*resp_ie
,
803 size_t resp_ie_len
, gfp_t gfp
)
805 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
806 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
807 struct cfg80211_event
*ev
;
813 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
815 cfg80211_put_bss(wdev
->wiphy
, bss
);
819 ev
->type
= EVENT_ROAMED
;
820 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
821 ev
->rm
.req_ie_len
= req_ie_len
;
822 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
823 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
824 ev
->rm
.resp_ie_len
= resp_ie_len
;
825 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
828 spin_lock_irqsave(&wdev
->event_lock
, flags
);
829 list_add_tail(&ev
->list
, &wdev
->event_list
);
830 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
831 queue_work(cfg80211_wq
, &rdev
->event_work
);
833 EXPORT_SYMBOL(cfg80211_roamed_bss
);
835 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
836 size_t ie_len
, u16 reason
, bool from_ap
)
838 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
839 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
841 #ifdef CONFIG_CFG80211_WEXT
842 union iwreq_data wrqu
;
845 ASSERT_WDEV_LOCK(wdev
);
847 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
848 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
851 if (wdev
->current_bss
) {
852 cfg80211_unhold_bss(wdev
->current_bss
);
853 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
856 wdev
->current_bss
= NULL
;
859 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
862 * Delete all the keys ... pairwise keys can't really
863 * exist any more anyway, but default keys might.
865 if (rdev
->ops
->del_key
)
866 for (i
= 0; i
< 6; i
++)
867 rdev_del_key(rdev
, dev
, i
, false, NULL
);
869 rdev_set_qos_map(rdev
, dev
, NULL
);
871 #ifdef CONFIG_CFG80211_WEXT
872 memset(&wrqu
, 0, sizeof(wrqu
));
873 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
874 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
875 wdev
->wext
.connect
.ssid_len
= 0;
878 schedule_work(&cfg80211_disconnect_work
);
881 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
882 const u8
*ie
, size_t ie_len
, gfp_t gfp
)
884 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
885 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
886 struct cfg80211_event
*ev
;
889 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
893 ev
->type
= EVENT_DISCONNECTED
;
894 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
895 ev
->dc
.ie_len
= ie_len
;
896 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
897 ev
->dc
.reason
= reason
;
899 spin_lock_irqsave(&wdev
->event_lock
, flags
);
900 list_add_tail(&ev
->list
, &wdev
->event_list
);
901 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
902 queue_work(cfg80211_wq
, &rdev
->event_work
);
904 EXPORT_SYMBOL(cfg80211_disconnected
);
907 * API calls for nl80211/wext compatibility code
909 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
910 struct net_device
*dev
,
911 struct cfg80211_connect_params
*connect
,
912 struct cfg80211_cached_keys
*connkeys
,
913 const u8
*prev_bssid
)
915 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
918 ASSERT_WDEV_LOCK(wdev
);
920 if (WARN_ON(wdev
->connect_keys
)) {
921 kfree(wdev
->connect_keys
);
922 wdev
->connect_keys
= NULL
;
925 cfg80211_oper_and_ht_capa(&connect
->ht_capa_mask
,
926 rdev
->wiphy
.ht_capa_mod_mask
);
928 if (connkeys
&& connkeys
->def
>= 0) {
933 cipher
= connkeys
->params
[idx
].cipher
;
934 /* If given a WEP key we may need it for shared key auth */
935 if (cipher
== WLAN_CIPHER_SUITE_WEP40
||
936 cipher
== WLAN_CIPHER_SUITE_WEP104
) {
937 connect
->key_idx
= idx
;
938 connect
->key
= connkeys
->params
[idx
].key
;
939 connect
->key_len
= connkeys
->params
[idx
].key_len
;
942 * If ciphers are not set (e.g. when going through
943 * iwconfig), we have to set them appropriately here.
945 if (connect
->crypto
.cipher_group
== 0)
946 connect
->crypto
.cipher_group
= cipher
;
948 if (connect
->crypto
.n_ciphers_pairwise
== 0) {
949 connect
->crypto
.n_ciphers_pairwise
= 1;
950 connect
->crypto
.ciphers_pairwise
[0] = cipher
;
955 wdev
->connect_keys
= connkeys
;
956 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
957 wdev
->ssid_len
= connect
->ssid_len
;
959 if (!rdev
->ops
->connect
)
960 err
= cfg80211_sme_connect(wdev
, connect
, prev_bssid
);
962 err
= rdev_connect(rdev
, dev
, connect
);
965 wdev
->connect_keys
= NULL
;
973 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
974 struct net_device
*dev
, u16 reason
, bool wextev
)
976 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
979 ASSERT_WDEV_LOCK(wdev
);
981 kfree(wdev
->connect_keys
);
982 wdev
->connect_keys
= NULL
;
985 err
= cfg80211_sme_disconnect(wdev
, reason
);
986 else if (!rdev
->ops
->disconnect
)
987 cfg80211_mlme_down(rdev
, dev
);
988 else if (wdev
->current_bss
)
989 err
= rdev_disconnect(rdev
, dev
, reason
);