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_dev(wdev
->wiphy
);
63 struct cfg80211_scan_request
*request
;
67 ASSERT_RDEV_LOCK(rdev
);
68 ASSERT_WDEV_LOCK(wdev
);
73 if (wdev
->conn
->params
.channel
) {
76 enum ieee80211_band band
;
79 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
80 if (!wdev
->wiphy
->bands
[band
])
82 n_channels
+= wdev
->wiphy
->bands
[band
]->n_channels
;
85 request
= kzalloc(sizeof(*request
) + sizeof(request
->ssids
[0]) +
86 sizeof(request
->channels
[0]) * n_channels
,
91 if (wdev
->conn
->params
.channel
)
92 request
->channels
[0] = wdev
->conn
->params
.channel
;
95 enum ieee80211_band band
;
96 struct ieee80211_supported_band
*bands
;
97 struct ieee80211_channel
*channel
;
99 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
100 bands
= wdev
->wiphy
->bands
[band
];
103 for (j
= 0; j
< bands
->n_channels
; j
++) {
104 channel
= &bands
->channels
[j
];
105 if (channel
->flags
& IEEE80211_CHAN_DISABLED
)
107 request
->channels
[i
++] = channel
;
109 request
->rates
[band
] = (1 << bands
->n_bitrates
) - 1;
113 request
->n_channels
= n_channels
;
114 request
->ssids
= (void *)&request
->channels
[n_channels
];
115 request
->n_ssids
= 1;
117 memcpy(request
->ssids
[0].ssid
, wdev
->conn
->params
.ssid
,
118 wdev
->conn
->params
.ssid_len
);
119 request
->ssids
[0].ssid_len
= wdev
->conn
->params
.ssid_len
;
121 request
->wdev
= wdev
;
122 request
->wiphy
= &rdev
->wiphy
;
123 request
->scan_start
= jiffies
;
125 rdev
->scan_req
= request
;
127 err
= rdev_scan(rdev
, request
);
129 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
130 nl80211_send_scan_start(rdev
, wdev
);
131 dev_hold(wdev
->netdev
);
133 rdev
->scan_req
= NULL
;
139 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
)
141 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
142 struct cfg80211_connect_params
*params
;
143 struct cfg80211_assoc_request req
= {};
146 ASSERT_WDEV_LOCK(wdev
);
151 params
= &wdev
->conn
->params
;
153 switch (wdev
->conn
->state
) {
154 case CFG80211_CONN_SCANNING
:
155 /* didn't find it during scan ... */
157 case CFG80211_CONN_SCAN_AGAIN
:
158 return cfg80211_conn_scan(wdev
);
159 case CFG80211_CONN_AUTHENTICATE_NEXT
:
160 BUG_ON(!rdev
->ops
->auth
);
161 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATING
;
162 return cfg80211_mlme_auth(rdev
, wdev
->netdev
,
163 params
->channel
, params
->auth_type
,
165 params
->ssid
, params
->ssid_len
,
167 params
->key
, params
->key_len
,
168 params
->key_idx
, NULL
, 0);
169 case CFG80211_CONN_AUTH_FAILED
:
171 case CFG80211_CONN_ASSOCIATE_NEXT
:
172 BUG_ON(!rdev
->ops
->assoc
);
173 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATING
;
174 if (wdev
->conn
->prev_bssid_valid
)
175 req
.prev_bssid
= wdev
->conn
->prev_bssid
;
177 req
.ie_len
= params
->ie_len
;
178 req
.use_mfp
= params
->mfp
!= NL80211_MFP_NO
;
179 req
.crypto
= params
->crypto
;
180 req
.flags
= params
->flags
;
181 req
.ht_capa
= params
->ht_capa
;
182 req
.ht_capa_mask
= params
->ht_capa_mask
;
183 req
.vht_capa
= params
->vht_capa
;
184 req
.vht_capa_mask
= params
->vht_capa_mask
;
186 err
= cfg80211_mlme_assoc(rdev
, wdev
->netdev
, params
->channel
,
187 params
->bssid
, params
->ssid
,
188 params
->ssid_len
, &req
);
190 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
192 WLAN_REASON_DEAUTH_LEAVING
,
195 case CFG80211_CONN_ASSOC_FAILED
:
196 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
198 WLAN_REASON_DEAUTH_LEAVING
, false);
200 case CFG80211_CONN_DEAUTH
:
201 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
203 WLAN_REASON_DEAUTH_LEAVING
, false);
204 /* free directly, disconnected event already sent */
205 cfg80211_sme_free(wdev
);
212 void cfg80211_conn_work(struct work_struct
*work
)
214 struct cfg80211_registered_device
*rdev
=
215 container_of(work
, struct cfg80211_registered_device
, conn_work
);
216 struct wireless_dev
*wdev
;
217 u8 bssid_buf
[ETH_ALEN
], *bssid
= NULL
;
221 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
226 if (!netif_running(wdev
->netdev
)) {
231 wdev
->conn
->state
== CFG80211_CONN_CONNECTED
) {
235 if (wdev
->conn
->params
.bssid
) {
236 memcpy(bssid_buf
, wdev
->conn
->params
.bssid
, ETH_ALEN
);
239 if (cfg80211_conn_do_work(wdev
)) {
240 __cfg80211_connect_result(
243 WLAN_STATUS_UNSPECIFIED_FAILURE
,
245 cfg80211_sme_free(wdev
);
253 /* Returned bss is reference counted and must be cleaned up appropriately. */
254 static struct cfg80211_bss
*cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
256 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
257 struct cfg80211_bss
*bss
;
258 u16 capa
= WLAN_CAPABILITY_ESS
;
260 ASSERT_WDEV_LOCK(wdev
);
262 if (wdev
->conn
->params
.privacy
)
263 capa
|= WLAN_CAPABILITY_PRIVACY
;
265 bss
= cfg80211_get_bss(wdev
->wiphy
, wdev
->conn
->params
.channel
,
266 wdev
->conn
->params
.bssid
,
267 wdev
->conn
->params
.ssid
,
268 wdev
->conn
->params
.ssid_len
,
269 WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_PRIVACY
,
274 memcpy(wdev
->conn
->bssid
, bss
->bssid
, ETH_ALEN
);
275 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
276 wdev
->conn
->params
.channel
= bss
->channel
;
277 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
278 schedule_work(&rdev
->conn_work
);
283 static void __cfg80211_sme_scan_done(struct net_device
*dev
)
285 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
286 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
287 struct cfg80211_bss
*bss
;
289 ASSERT_WDEV_LOCK(wdev
);
294 if (wdev
->conn
->state
!= CFG80211_CONN_SCANNING
&&
295 wdev
->conn
->state
!= CFG80211_CONN_SCAN_AGAIN
)
298 bss
= cfg80211_get_conn_bss(wdev
);
300 cfg80211_put_bss(&rdev
->wiphy
, bss
);
302 schedule_work(&rdev
->conn_work
);
305 void cfg80211_sme_scan_done(struct net_device
*dev
)
307 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
310 __cfg80211_sme_scan_done(dev
);
314 void cfg80211_sme_rx_auth(struct wireless_dev
*wdev
, const u8
*buf
, size_t len
)
316 struct wiphy
*wiphy
= wdev
->wiphy
;
317 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
318 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
319 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
321 ASSERT_WDEV_LOCK(wdev
);
323 if (!wdev
->conn
|| wdev
->conn
->state
== CFG80211_CONN_CONNECTED
)
326 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
327 wdev
->conn
->auto_auth
&&
328 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
329 /* select automatically between only open, shared, leap */
330 switch (wdev
->conn
->params
.auth_type
) {
331 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
332 if (wdev
->connect_keys
)
333 wdev
->conn
->params
.auth_type
=
334 NL80211_AUTHTYPE_SHARED_KEY
;
336 wdev
->conn
->params
.auth_type
=
337 NL80211_AUTHTYPE_NETWORK_EAP
;
339 case NL80211_AUTHTYPE_SHARED_KEY
:
340 wdev
->conn
->params
.auth_type
=
341 NL80211_AUTHTYPE_NETWORK_EAP
;
345 wdev
->conn
->params
.auth_type
=
346 NL80211_AUTHTYPE_OPEN_SYSTEM
;
349 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
350 schedule_work(&rdev
->conn_work
);
351 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
352 __cfg80211_connect_result(wdev
->netdev
, mgmt
->bssid
,
354 status_code
, false, NULL
);
355 } else if (wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
356 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
357 schedule_work(&rdev
->conn_work
);
361 bool cfg80211_sme_rx_assoc_resp(struct wireless_dev
*wdev
, u16 status
)
363 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
368 if (status
== WLAN_STATUS_SUCCESS
) {
369 wdev
->conn
->state
= CFG80211_CONN_CONNECTED
;
373 if (wdev
->conn
->prev_bssid_valid
) {
375 * Some stupid APs don't accept reassoc, so we
376 * need to fall back to trying regular assoc;
377 * return true so no event is sent to userspace.
379 wdev
->conn
->prev_bssid_valid
= false;
380 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
381 schedule_work(&rdev
->conn_work
);
385 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED
;
386 schedule_work(&rdev
->conn_work
);
390 void cfg80211_sme_deauth(struct wireless_dev
*wdev
)
392 cfg80211_sme_free(wdev
);
395 void cfg80211_sme_auth_timeout(struct wireless_dev
*wdev
)
397 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
402 wdev
->conn
->state
= CFG80211_CONN_AUTH_FAILED
;
403 schedule_work(&rdev
->conn_work
);
406 void cfg80211_sme_disassoc(struct wireless_dev
*wdev
)
408 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
413 wdev
->conn
->state
= CFG80211_CONN_DEAUTH
;
414 schedule_work(&rdev
->conn_work
);
417 void cfg80211_sme_assoc_timeout(struct wireless_dev
*wdev
)
419 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
424 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED
;
425 schedule_work(&rdev
->conn_work
);
428 static int cfg80211_sme_connect(struct wireless_dev
*wdev
,
429 struct cfg80211_connect_params
*connect
,
430 const u8
*prev_bssid
)
432 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
433 struct cfg80211_bss
*bss
;
436 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
439 if (wdev
->current_bss
)
442 if (WARN_ON(wdev
->conn
))
445 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
450 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
452 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
453 if (connect
->bssid
) {
454 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
455 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
459 wdev
->conn
->ie
= kmemdup(connect
->ie
, connect
->ie_len
,
461 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
462 if (!wdev
->conn
->ie
) {
469 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
470 wdev
->conn
->auto_auth
= true;
471 /* start with open system ... should mostly work */
472 wdev
->conn
->params
.auth_type
=
473 NL80211_AUTHTYPE_OPEN_SYSTEM
;
475 wdev
->conn
->auto_auth
= false;
478 wdev
->conn
->params
.ssid
= wdev
->ssid
;
479 wdev
->conn
->params
.ssid_len
= connect
->ssid_len
;
481 /* see if we have the bss already */
482 bss
= cfg80211_get_conn_bss(wdev
);
485 memcpy(wdev
->conn
->prev_bssid
, prev_bssid
, ETH_ALEN
);
486 wdev
->conn
->prev_bssid_valid
= true;
489 /* we're good if we have a matching bss struct */
491 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
492 err
= cfg80211_conn_do_work(wdev
);
493 cfg80211_put_bss(wdev
->wiphy
, bss
);
495 /* otherwise we'll need to scan for the AP first */
496 err
= cfg80211_conn_scan(wdev
);
499 * If we can't scan right now, then we need to scan again
500 * after the current scan finished, since the parameters
501 * changed (unless we find a good AP anyway).
505 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
510 cfg80211_sme_free(wdev
);
515 static int cfg80211_sme_disconnect(struct wireless_dev
*wdev
, u16 reason
)
517 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
523 if (!rdev
->ops
->deauth
)
526 if (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
527 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
) {
532 /* wdev->conn->params.bssid must be set if > SCANNING */
533 err
= cfg80211_mlme_deauth(rdev
, wdev
->netdev
,
534 wdev
->conn
->params
.bssid
,
535 NULL
, 0, reason
, false);
537 cfg80211_sme_free(wdev
);
542 * code shared for in-device and software SME
545 static bool cfg80211_is_all_idle(void)
547 struct cfg80211_registered_device
*rdev
;
548 struct wireless_dev
*wdev
;
549 bool is_all_idle
= true;
552 * All devices must be idle as otherwise if you are actively
553 * scanning some new beacon hints could be learned and would
554 * count as new regulatory hints.
556 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
557 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
559 if (wdev
->conn
|| wdev
->current_bss
)
568 static void disconnect_work(struct work_struct
*work
)
571 if (cfg80211_is_all_idle())
572 regulatory_hint_disconnect();
576 static DECLARE_WORK(cfg80211_disconnect_work
, disconnect_work
);
580 * API calls for drivers implementing connect/disconnect and
584 /* This method must consume bss one way or another */
585 void __cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
586 const u8
*req_ie
, size_t req_ie_len
,
587 const u8
*resp_ie
, size_t resp_ie_len
,
588 u16 status
, bool wextev
,
589 struct cfg80211_bss
*bss
)
591 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
592 const u8
*country_ie
;
593 #ifdef CONFIG_CFG80211_WEXT
594 union iwreq_data wrqu
;
597 ASSERT_WDEV_LOCK(wdev
);
599 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
600 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)) {
601 cfg80211_put_bss(wdev
->wiphy
, bss
);
605 nl80211_send_connect_result(wiphy_to_dev(wdev
->wiphy
), dev
,
606 bssid
, req_ie
, req_ie_len
,
607 resp_ie
, resp_ie_len
,
610 #ifdef CONFIG_CFG80211_WEXT
612 if (req_ie
&& status
== WLAN_STATUS_SUCCESS
) {
613 memset(&wrqu
, 0, sizeof(wrqu
));
614 wrqu
.data
.length
= req_ie_len
;
615 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
, req_ie
);
618 if (resp_ie
&& status
== WLAN_STATUS_SUCCESS
) {
619 memset(&wrqu
, 0, sizeof(wrqu
));
620 wrqu
.data
.length
= resp_ie_len
;
621 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
, resp_ie
);
624 memset(&wrqu
, 0, sizeof(wrqu
));
625 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
626 if (bssid
&& status
== WLAN_STATUS_SUCCESS
) {
627 memcpy(wrqu
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
628 memcpy(wdev
->wext
.prev_bssid
, bssid
, ETH_ALEN
);
629 wdev
->wext
.prev_bssid_valid
= true;
631 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
635 if (!bss
&& (status
== WLAN_STATUS_SUCCESS
)) {
636 WARN_ON_ONCE(!wiphy_to_dev(wdev
->wiphy
)->ops
->connect
);
637 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
638 wdev
->ssid
, wdev
->ssid_len
,
640 WLAN_CAPABILITY_ESS
);
642 cfg80211_hold_bss(bss_from_pub(bss
));
645 if (wdev
->current_bss
) {
646 cfg80211_unhold_bss(wdev
->current_bss
);
647 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
648 wdev
->current_bss
= NULL
;
651 if (status
!= WLAN_STATUS_SUCCESS
) {
652 kfree(wdev
->connect_keys
);
653 wdev
->connect_keys
= NULL
;
656 cfg80211_unhold_bss(bss_from_pub(bss
));
657 cfg80211_put_bss(wdev
->wiphy
, bss
);
665 wdev
->current_bss
= bss_from_pub(bss
);
667 cfg80211_upload_connect_keys(wdev
);
670 country_ie
= ieee80211_bss_get_ie(bss
, WLAN_EID_COUNTRY
);
676 country_ie
= kmemdup(country_ie
, 2 + country_ie
[1], GFP_ATOMIC
);
683 * ieee80211_bss_get_ie() ensures we can access:
684 * - country_ie + 2, the start of the country ie data, and
685 * - and country_ie[1] which is the IE length
687 regulatory_hint_country_ie(wdev
->wiphy
, bss
->channel
->band
,
688 country_ie
+ 2, country_ie
[1]);
692 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
693 const u8
*req_ie
, size_t req_ie_len
,
694 const u8
*resp_ie
, size_t resp_ie_len
,
695 u16 status
, gfp_t gfp
)
697 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
698 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
699 struct cfg80211_event
*ev
;
702 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
706 ev
->type
= EVENT_CONNECT_RESULT
;
708 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
710 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
711 ev
->cr
.req_ie_len
= req_ie_len
;
712 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
715 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
716 ev
->cr
.resp_ie_len
= resp_ie_len
;
717 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
719 ev
->cr
.status
= status
;
721 spin_lock_irqsave(&wdev
->event_lock
, flags
);
722 list_add_tail(&ev
->list
, &wdev
->event_list
);
723 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
724 queue_work(cfg80211_wq
, &rdev
->event_work
);
726 EXPORT_SYMBOL(cfg80211_connect_result
);
728 /* Consumes bss object one way or another */
729 void __cfg80211_roamed(struct wireless_dev
*wdev
,
730 struct cfg80211_bss
*bss
,
731 const u8
*req_ie
, size_t req_ie_len
,
732 const u8
*resp_ie
, size_t resp_ie_len
)
734 #ifdef CONFIG_CFG80211_WEXT
735 union iwreq_data wrqu
;
737 ASSERT_WDEV_LOCK(wdev
);
739 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
740 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
743 if (WARN_ON(!wdev
->current_bss
))
746 cfg80211_unhold_bss(wdev
->current_bss
);
747 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
748 wdev
->current_bss
= NULL
;
750 cfg80211_hold_bss(bss_from_pub(bss
));
751 wdev
->current_bss
= bss_from_pub(bss
);
753 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), wdev
->netdev
, bss
->bssid
,
754 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
757 #ifdef CONFIG_CFG80211_WEXT
759 memset(&wrqu
, 0, sizeof(wrqu
));
760 wrqu
.data
.length
= req_ie_len
;
761 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
766 memset(&wrqu
, 0, sizeof(wrqu
));
767 wrqu
.data
.length
= resp_ie_len
;
768 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
772 memset(&wrqu
, 0, sizeof(wrqu
));
773 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
774 memcpy(wrqu
.ap_addr
.sa_data
, bss
->bssid
, ETH_ALEN
);
775 memcpy(wdev
->wext
.prev_bssid
, bss
->bssid
, ETH_ALEN
);
776 wdev
->wext
.prev_bssid_valid
= true;
777 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
782 cfg80211_put_bss(wdev
->wiphy
, bss
);
785 void cfg80211_roamed(struct net_device
*dev
,
786 struct ieee80211_channel
*channel
,
788 const u8
*req_ie
, size_t req_ie_len
,
789 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
791 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
792 struct cfg80211_bss
*bss
;
794 bss
= cfg80211_get_bss(wdev
->wiphy
, channel
, bssid
, wdev
->ssid
,
795 wdev
->ssid_len
, WLAN_CAPABILITY_ESS
,
796 WLAN_CAPABILITY_ESS
);
800 cfg80211_roamed_bss(dev
, bss
, req_ie
, req_ie_len
, resp_ie
,
803 EXPORT_SYMBOL(cfg80211_roamed
);
805 /* Consumes bss object one way or another */
806 void cfg80211_roamed_bss(struct net_device
*dev
,
807 struct cfg80211_bss
*bss
, const u8
*req_ie
,
808 size_t req_ie_len
, const u8
*resp_ie
,
809 size_t resp_ie_len
, gfp_t gfp
)
811 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
812 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
813 struct cfg80211_event
*ev
;
819 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
821 cfg80211_put_bss(wdev
->wiphy
, bss
);
825 ev
->type
= EVENT_ROAMED
;
826 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
827 ev
->rm
.req_ie_len
= req_ie_len
;
828 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
829 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
830 ev
->rm
.resp_ie_len
= resp_ie_len
;
831 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
834 spin_lock_irqsave(&wdev
->event_lock
, flags
);
835 list_add_tail(&ev
->list
, &wdev
->event_list
);
836 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
837 queue_work(cfg80211_wq
, &rdev
->event_work
);
839 EXPORT_SYMBOL(cfg80211_roamed_bss
);
841 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
842 size_t ie_len
, u16 reason
, bool from_ap
)
844 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
845 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
847 #ifdef CONFIG_CFG80211_WEXT
848 union iwreq_data wrqu
;
851 ASSERT_WDEV_LOCK(wdev
);
853 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
854 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
857 if (wdev
->current_bss
) {
858 cfg80211_unhold_bss(wdev
->current_bss
);
859 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
862 wdev
->current_bss
= NULL
;
865 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
868 * Delete all the keys ... pairwise keys can't really
869 * exist any more anyway, but default keys might.
871 if (rdev
->ops
->del_key
)
872 for (i
= 0; i
< 6; i
++)
873 rdev_del_key(rdev
, dev
, i
, false, NULL
);
875 rdev_set_qos_map(rdev
, dev
, NULL
);
877 #ifdef CONFIG_CFG80211_WEXT
878 memset(&wrqu
, 0, sizeof(wrqu
));
879 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
880 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
881 wdev
->wext
.connect
.ssid_len
= 0;
884 schedule_work(&cfg80211_disconnect_work
);
887 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
888 u8
*ie
, size_t ie_len
, gfp_t gfp
)
890 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
891 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
892 struct cfg80211_event
*ev
;
895 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
899 ev
->type
= EVENT_DISCONNECTED
;
900 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
901 ev
->dc
.ie_len
= ie_len
;
902 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
903 ev
->dc
.reason
= reason
;
905 spin_lock_irqsave(&wdev
->event_lock
, flags
);
906 list_add_tail(&ev
->list
, &wdev
->event_list
);
907 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
908 queue_work(cfg80211_wq
, &rdev
->event_work
);
910 EXPORT_SYMBOL(cfg80211_disconnected
);
913 * API calls for nl80211/wext compatibility code
915 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
916 struct net_device
*dev
,
917 struct cfg80211_connect_params
*connect
,
918 struct cfg80211_cached_keys
*connkeys
,
919 const u8
*prev_bssid
)
921 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
924 ASSERT_WDEV_LOCK(wdev
);
926 if (WARN_ON(wdev
->connect_keys
)) {
927 kfree(wdev
->connect_keys
);
928 wdev
->connect_keys
= NULL
;
931 cfg80211_oper_and_ht_capa(&connect
->ht_capa_mask
,
932 rdev
->wiphy
.ht_capa_mod_mask
);
934 if (connkeys
&& connkeys
->def
>= 0) {
939 cipher
= connkeys
->params
[idx
].cipher
;
940 /* If given a WEP key we may need it for shared key auth */
941 if (cipher
== WLAN_CIPHER_SUITE_WEP40
||
942 cipher
== WLAN_CIPHER_SUITE_WEP104
) {
943 connect
->key_idx
= idx
;
944 connect
->key
= connkeys
->params
[idx
].key
;
945 connect
->key_len
= connkeys
->params
[idx
].key_len
;
948 * If ciphers are not set (e.g. when going through
949 * iwconfig), we have to set them appropriately here.
951 if (connect
->crypto
.cipher_group
== 0)
952 connect
->crypto
.cipher_group
= cipher
;
954 if (connect
->crypto
.n_ciphers_pairwise
== 0) {
955 connect
->crypto
.n_ciphers_pairwise
= 1;
956 connect
->crypto
.ciphers_pairwise
[0] = cipher
;
961 wdev
->connect_keys
= connkeys
;
962 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
963 wdev
->ssid_len
= connect
->ssid_len
;
965 if (!rdev
->ops
->connect
)
966 err
= cfg80211_sme_connect(wdev
, connect
, prev_bssid
);
968 err
= rdev_connect(rdev
, dev
, connect
);
971 wdev
->connect_keys
= NULL
;
979 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
980 struct net_device
*dev
, u16 reason
, bool wextev
)
982 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
985 ASSERT_WDEV_LOCK(wdev
);
987 kfree(wdev
->connect_keys
);
988 wdev
->connect_keys
= NULL
;
991 err
= cfg80211_sme_disconnect(wdev
, reason
);
992 else if (!rdev
->ops
->disconnect
)
993 cfg80211_mlme_down(rdev
, dev
);
994 else if (wdev
->current_bss
)
995 err
= rdev_disconnect(rdev
, dev
, reason
);