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 (wdev
->current_bss
) {
636 cfg80211_unhold_bss(wdev
->current_bss
);
637 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
638 wdev
->current_bss
= NULL
;
641 if (status
!= WLAN_STATUS_SUCCESS
) {
642 kfree(wdev
->connect_keys
);
643 wdev
->connect_keys
= NULL
;
646 cfg80211_unhold_bss(bss_from_pub(bss
));
647 cfg80211_put_bss(wdev
->wiphy
, bss
);
653 WARN_ON_ONCE(!wiphy_to_dev(wdev
->wiphy
)->ops
->connect
);
654 bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, bssid
,
655 wdev
->ssid
, wdev
->ssid_len
,
657 WLAN_CAPABILITY_ESS
);
660 cfg80211_hold_bss(bss_from_pub(bss
));
663 wdev
->current_bss
= bss_from_pub(bss
);
665 cfg80211_upload_connect_keys(wdev
);
668 country_ie
= ieee80211_bss_get_ie(bss
, WLAN_EID_COUNTRY
);
674 country_ie
= kmemdup(country_ie
, 2 + country_ie
[1], GFP_ATOMIC
);
681 * ieee80211_bss_get_ie() ensures we can access:
682 * - country_ie + 2, the start of the country ie data, and
683 * - and country_ie[1] which is the IE length
685 regulatory_hint_country_ie(wdev
->wiphy
, bss
->channel
->band
,
686 country_ie
+ 2, country_ie
[1]);
690 void cfg80211_connect_result(struct net_device
*dev
, const u8
*bssid
,
691 const u8
*req_ie
, size_t req_ie_len
,
692 const u8
*resp_ie
, size_t resp_ie_len
,
693 u16 status
, gfp_t gfp
)
695 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
696 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
697 struct cfg80211_event
*ev
;
700 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
704 ev
->type
= EVENT_CONNECT_RESULT
;
706 memcpy(ev
->cr
.bssid
, bssid
, ETH_ALEN
);
708 ev
->cr
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
709 ev
->cr
.req_ie_len
= req_ie_len
;
710 memcpy((void *)ev
->cr
.req_ie
, req_ie
, req_ie_len
);
713 ev
->cr
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
714 ev
->cr
.resp_ie_len
= resp_ie_len
;
715 memcpy((void *)ev
->cr
.resp_ie
, resp_ie
, resp_ie_len
);
717 ev
->cr
.status
= status
;
719 spin_lock_irqsave(&wdev
->event_lock
, flags
);
720 list_add_tail(&ev
->list
, &wdev
->event_list
);
721 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
722 queue_work(cfg80211_wq
, &rdev
->event_work
);
724 EXPORT_SYMBOL(cfg80211_connect_result
);
726 /* Consumes bss object one way or another */
727 void __cfg80211_roamed(struct wireless_dev
*wdev
,
728 struct cfg80211_bss
*bss
,
729 const u8
*req_ie
, size_t req_ie_len
,
730 const u8
*resp_ie
, size_t resp_ie_len
)
732 #ifdef CONFIG_CFG80211_WEXT
733 union iwreq_data wrqu
;
735 ASSERT_WDEV_LOCK(wdev
);
737 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
738 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
741 if (WARN_ON(!wdev
->current_bss
))
744 cfg80211_unhold_bss(wdev
->current_bss
);
745 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
746 wdev
->current_bss
= NULL
;
748 cfg80211_hold_bss(bss_from_pub(bss
));
749 wdev
->current_bss
= bss_from_pub(bss
);
751 nl80211_send_roamed(wiphy_to_dev(wdev
->wiphy
), wdev
->netdev
, bss
->bssid
,
752 req_ie
, req_ie_len
, resp_ie
, resp_ie_len
,
755 #ifdef CONFIG_CFG80211_WEXT
757 memset(&wrqu
, 0, sizeof(wrqu
));
758 wrqu
.data
.length
= req_ie_len
;
759 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
764 memset(&wrqu
, 0, sizeof(wrqu
));
765 wrqu
.data
.length
= resp_ie_len
;
766 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
770 memset(&wrqu
, 0, sizeof(wrqu
));
771 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
772 memcpy(wrqu
.ap_addr
.sa_data
, bss
->bssid
, ETH_ALEN
);
773 memcpy(wdev
->wext
.prev_bssid
, bss
->bssid
, ETH_ALEN
);
774 wdev
->wext
.prev_bssid_valid
= true;
775 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
780 cfg80211_put_bss(wdev
->wiphy
, bss
);
783 void cfg80211_roamed(struct net_device
*dev
,
784 struct ieee80211_channel
*channel
,
786 const u8
*req_ie
, size_t req_ie_len
,
787 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
789 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
790 struct cfg80211_bss
*bss
;
792 bss
= cfg80211_get_bss(wdev
->wiphy
, channel
, bssid
, wdev
->ssid
,
793 wdev
->ssid_len
, WLAN_CAPABILITY_ESS
,
794 WLAN_CAPABILITY_ESS
);
798 cfg80211_roamed_bss(dev
, bss
, req_ie
, req_ie_len
, resp_ie
,
801 EXPORT_SYMBOL(cfg80211_roamed
);
803 /* Consumes bss object one way or another */
804 void cfg80211_roamed_bss(struct net_device
*dev
,
805 struct cfg80211_bss
*bss
, const u8
*req_ie
,
806 size_t req_ie_len
, const u8
*resp_ie
,
807 size_t resp_ie_len
, gfp_t gfp
)
809 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
810 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
811 struct cfg80211_event
*ev
;
817 ev
= kzalloc(sizeof(*ev
) + req_ie_len
+ resp_ie_len
, gfp
);
819 cfg80211_put_bss(wdev
->wiphy
, bss
);
823 ev
->type
= EVENT_ROAMED
;
824 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
825 ev
->rm
.req_ie_len
= req_ie_len
;
826 memcpy((void *)ev
->rm
.req_ie
, req_ie
, req_ie_len
);
827 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + req_ie_len
;
828 ev
->rm
.resp_ie_len
= resp_ie_len
;
829 memcpy((void *)ev
->rm
.resp_ie
, resp_ie
, resp_ie_len
);
832 spin_lock_irqsave(&wdev
->event_lock
, flags
);
833 list_add_tail(&ev
->list
, &wdev
->event_list
);
834 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
835 queue_work(cfg80211_wq
, &rdev
->event_work
);
837 EXPORT_SYMBOL(cfg80211_roamed_bss
);
839 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
840 size_t ie_len
, u16 reason
, bool from_ap
)
842 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
843 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
845 #ifdef CONFIG_CFG80211_WEXT
846 union iwreq_data wrqu
;
849 ASSERT_WDEV_LOCK(wdev
);
851 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
852 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
855 if (wdev
->current_bss
) {
856 cfg80211_unhold_bss(wdev
->current_bss
);
857 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
860 wdev
->current_bss
= NULL
;
863 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
866 * Delete all the keys ... pairwise keys can't really
867 * exist any more anyway, but default keys might.
869 if (rdev
->ops
->del_key
)
870 for (i
= 0; i
< 6; i
++)
871 rdev_del_key(rdev
, dev
, i
, false, NULL
);
873 #ifdef CONFIG_CFG80211_WEXT
874 memset(&wrqu
, 0, sizeof(wrqu
));
875 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
876 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
877 wdev
->wext
.connect
.ssid_len
= 0;
880 schedule_work(&cfg80211_disconnect_work
);
883 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
884 u8
*ie
, size_t ie_len
, gfp_t gfp
)
886 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
887 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
888 struct cfg80211_event
*ev
;
891 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
895 ev
->type
= EVENT_DISCONNECTED
;
896 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
897 ev
->dc
.ie_len
= ie_len
;
898 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
899 ev
->dc
.reason
= reason
;
901 spin_lock_irqsave(&wdev
->event_lock
, flags
);
902 list_add_tail(&ev
->list
, &wdev
->event_list
);
903 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
904 queue_work(cfg80211_wq
, &rdev
->event_work
);
906 EXPORT_SYMBOL(cfg80211_disconnected
);
909 * API calls for nl80211/wext compatibility code
911 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
912 struct net_device
*dev
,
913 struct cfg80211_connect_params
*connect
,
914 struct cfg80211_cached_keys
*connkeys
,
915 const u8
*prev_bssid
)
917 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
920 ASSERT_WDEV_LOCK(wdev
);
922 if (WARN_ON(wdev
->connect_keys
)) {
923 kfree(wdev
->connect_keys
);
924 wdev
->connect_keys
= NULL
;
927 cfg80211_oper_and_ht_capa(&connect
->ht_capa_mask
,
928 rdev
->wiphy
.ht_capa_mod_mask
);
930 if (connkeys
&& connkeys
->def
>= 0) {
935 cipher
= connkeys
->params
[idx
].cipher
;
936 /* If given a WEP key we may need it for shared key auth */
937 if (cipher
== WLAN_CIPHER_SUITE_WEP40
||
938 cipher
== WLAN_CIPHER_SUITE_WEP104
) {
939 connect
->key_idx
= idx
;
940 connect
->key
= connkeys
->params
[idx
].key
;
941 connect
->key_len
= connkeys
->params
[idx
].key_len
;
944 * If ciphers are not set (e.g. when going through
945 * iwconfig), we have to set them appropriately here.
947 if (connect
->crypto
.cipher_group
== 0)
948 connect
->crypto
.cipher_group
= cipher
;
950 if (connect
->crypto
.n_ciphers_pairwise
== 0) {
951 connect
->crypto
.n_ciphers_pairwise
= 1;
952 connect
->crypto
.ciphers_pairwise
[0] = cipher
;
957 wdev
->connect_keys
= connkeys
;
958 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
959 wdev
->ssid_len
= connect
->ssid_len
;
961 if (!rdev
->ops
->connect
)
962 err
= cfg80211_sme_connect(wdev
, connect
, prev_bssid
);
964 err
= rdev_connect(rdev
, dev
, connect
);
967 wdev
->connect_keys
= NULL
;
975 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
976 struct net_device
*dev
, u16 reason
, bool wextev
)
978 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
981 ASSERT_WDEV_LOCK(wdev
);
983 kfree(wdev
->connect_keys
);
984 wdev
->connect_keys
= NULL
;
987 err
= cfg80211_sme_disconnect(wdev
, reason
);
988 else if (!rdev
->ops
->disconnect
)
989 cfg80211_mlme_down(rdev
, dev
);
990 else if (wdev
->current_bss
)
991 err
= rdev_disconnect(rdev
, dev
, reason
);