1 // SPDX-License-Identifier: GPL-2.0
3 * SME code for cfg80211
4 * both driver SME event handling and the SME implementation
5 * (for nl80211's connect() and wext)
7 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
8 * Copyright (C) 2009 Intel Corporation. All rights reserved.
9 * Copyright 2017 Intel Deutschland GmbH
12 #include <linux/etherdevice.h>
13 #include <linux/if_arp.h>
14 #include <linux/slab.h>
15 #include <linux/workqueue.h>
16 #include <linux/wireless.h>
17 #include <linux/export.h>
18 #include <net/iw_handler.h>
19 #include <net/cfg80211.h>
20 #include <net/rtnetlink.h>
26 * Software SME in cfg80211, using auth/assoc/deauth calls to the
27 * driver. This is is for implementing nl80211's connect/disconnect
28 * and wireless extensions (if configured.)
31 struct cfg80211_conn
{
32 struct cfg80211_connect_params params
;
33 /* these are sub-states of the _CONNECTING sme_state */
35 CFG80211_CONN_SCANNING
,
36 CFG80211_CONN_SCAN_AGAIN
,
37 CFG80211_CONN_AUTHENTICATE_NEXT
,
38 CFG80211_CONN_AUTHENTICATING
,
39 CFG80211_CONN_AUTH_FAILED_TIMEOUT
,
40 CFG80211_CONN_ASSOCIATE_NEXT
,
41 CFG80211_CONN_ASSOCIATING
,
42 CFG80211_CONN_ASSOC_FAILED
,
43 CFG80211_CONN_ASSOC_FAILED_TIMEOUT
,
45 CFG80211_CONN_ABANDON
,
46 CFG80211_CONN_CONNECTED
,
48 u8 bssid
[ETH_ALEN
], prev_bssid
[ETH_ALEN
];
51 bool auto_auth
, prev_bssid_valid
;
54 static void cfg80211_sme_free(struct wireless_dev
*wdev
)
59 kfree(wdev
->conn
->ie
);
64 static int cfg80211_conn_scan(struct wireless_dev
*wdev
)
66 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
67 struct cfg80211_scan_request
*request
;
71 ASSERT_WDEV_LOCK(wdev
);
73 if (rdev
->scan_req
|| rdev
->scan_msg
)
76 if (wdev
->conn
->params
.channel
)
79 n_channels
= ieee80211_get_num_supported_channels(wdev
->wiphy
);
81 request
= kzalloc(sizeof(*request
) + sizeof(request
->ssids
[0]) +
82 sizeof(request
->channels
[0]) * n_channels
,
87 if (wdev
->conn
->params
.channel
) {
88 enum nl80211_band band
= wdev
->conn
->params
.channel
->band
;
89 struct ieee80211_supported_band
*sband
=
90 wdev
->wiphy
->bands
[band
];
96 request
->channels
[0] = wdev
->conn
->params
.channel
;
97 request
->rates
[band
] = (1 << sband
->n_bitrates
) - 1;
100 enum nl80211_band band
;
101 struct ieee80211_supported_band
*bands
;
102 struct ieee80211_channel
*channel
;
104 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
105 bands
= wdev
->wiphy
->bands
[band
];
108 for (j
= 0; j
< bands
->n_channels
; j
++) {
109 channel
= &bands
->channels
[j
];
110 if (channel
->flags
& IEEE80211_CHAN_DISABLED
)
112 request
->channels
[i
++] = channel
;
114 request
->rates
[band
] = (1 << bands
->n_bitrates
) - 1;
118 request
->n_channels
= n_channels
;
119 request
->ssids
= (void *)&request
->channels
[n_channels
];
120 request
->n_ssids
= 1;
122 memcpy(request
->ssids
[0].ssid
, wdev
->conn
->params
.ssid
,
123 wdev
->conn
->params
.ssid_len
);
124 request
->ssids
[0].ssid_len
= wdev
->conn
->params
.ssid_len
;
126 eth_broadcast_addr(request
->bssid
);
128 request
->wdev
= wdev
;
129 request
->wiphy
= &rdev
->wiphy
;
130 request
->scan_start
= jiffies
;
132 rdev
->scan_req
= request
;
134 err
= rdev_scan(rdev
, request
);
136 wdev
->conn
->state
= CFG80211_CONN_SCANNING
;
137 nl80211_send_scan_start(rdev
, wdev
);
138 dev_hold(wdev
->netdev
);
140 rdev
->scan_req
= NULL
;
146 static int cfg80211_conn_do_work(struct wireless_dev
*wdev
,
147 enum nl80211_timeout_reason
*treason
)
149 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
150 struct cfg80211_connect_params
*params
;
151 struct cfg80211_assoc_request req
= {};
154 ASSERT_WDEV_LOCK(wdev
);
159 params
= &wdev
->conn
->params
;
161 switch (wdev
->conn
->state
) {
162 case CFG80211_CONN_SCANNING
:
163 /* didn't find it during scan ... */
165 case CFG80211_CONN_SCAN_AGAIN
:
166 return cfg80211_conn_scan(wdev
);
167 case CFG80211_CONN_AUTHENTICATE_NEXT
:
168 if (WARN_ON(!rdev
->ops
->auth
))
170 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATING
;
171 return cfg80211_mlme_auth(rdev
, wdev
->netdev
,
172 params
->channel
, params
->auth_type
,
174 params
->ssid
, params
->ssid_len
,
176 params
->key
, params
->key_len
,
177 params
->key_idx
, NULL
, 0);
178 case CFG80211_CONN_AUTH_FAILED_TIMEOUT
:
179 *treason
= NL80211_TIMEOUT_AUTH
;
181 case CFG80211_CONN_ASSOCIATE_NEXT
:
182 if (WARN_ON(!rdev
->ops
->assoc
))
184 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATING
;
185 if (wdev
->conn
->prev_bssid_valid
)
186 req
.prev_bssid
= wdev
->conn
->prev_bssid
;
188 req
.ie_len
= params
->ie_len
;
189 req
.use_mfp
= params
->mfp
!= NL80211_MFP_NO
;
190 req
.crypto
= params
->crypto
;
191 req
.flags
= params
->flags
;
192 req
.ht_capa
= params
->ht_capa
;
193 req
.ht_capa_mask
= params
->ht_capa_mask
;
194 req
.vht_capa
= params
->vht_capa
;
195 req
.vht_capa_mask
= params
->vht_capa_mask
;
197 err
= cfg80211_mlme_assoc(rdev
, wdev
->netdev
, params
->channel
,
198 params
->bssid
, params
->ssid
,
199 params
->ssid_len
, &req
);
201 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
203 WLAN_REASON_DEAUTH_LEAVING
,
206 case CFG80211_CONN_ASSOC_FAILED_TIMEOUT
:
207 *treason
= NL80211_TIMEOUT_ASSOC
;
209 case CFG80211_CONN_ASSOC_FAILED
:
210 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
212 WLAN_REASON_DEAUTH_LEAVING
, false);
214 case CFG80211_CONN_DEAUTH
:
215 cfg80211_mlme_deauth(rdev
, wdev
->netdev
, params
->bssid
,
217 WLAN_REASON_DEAUTH_LEAVING
, false);
219 case CFG80211_CONN_ABANDON
:
220 /* free directly, disconnected event already sent */
221 cfg80211_sme_free(wdev
);
228 void cfg80211_conn_work(struct work_struct
*work
)
230 struct cfg80211_registered_device
*rdev
=
231 container_of(work
, struct cfg80211_registered_device
, conn_work
);
232 struct wireless_dev
*wdev
;
233 u8 bssid_buf
[ETH_ALEN
], *bssid
= NULL
;
234 enum nl80211_timeout_reason treason
;
238 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
243 if (!netif_running(wdev
->netdev
)) {
248 wdev
->conn
->state
== CFG80211_CONN_CONNECTED
) {
252 if (wdev
->conn
->params
.bssid
) {
253 memcpy(bssid_buf
, wdev
->conn
->params
.bssid
, ETH_ALEN
);
256 treason
= NL80211_TIMEOUT_UNSPECIFIED
;
257 if (cfg80211_conn_do_work(wdev
, &treason
)) {
258 struct cfg80211_connect_resp_params cr
;
260 memset(&cr
, 0, sizeof(cr
));
263 cr
.timeout_reason
= treason
;
264 __cfg80211_connect_result(wdev
->netdev
, &cr
, false);
272 /* Returned bss is reference counted and must be cleaned up appropriately. */
273 static struct cfg80211_bss
*cfg80211_get_conn_bss(struct wireless_dev
*wdev
)
275 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
276 struct cfg80211_bss
*bss
;
278 ASSERT_WDEV_LOCK(wdev
);
280 bss
= cfg80211_get_bss(wdev
->wiphy
, wdev
->conn
->params
.channel
,
281 wdev
->conn
->params
.bssid
,
282 wdev
->conn
->params
.ssid
,
283 wdev
->conn
->params
.ssid_len
,
285 IEEE80211_PRIVACY(wdev
->conn
->params
.privacy
));
289 memcpy(wdev
->conn
->bssid
, bss
->bssid
, ETH_ALEN
);
290 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
291 wdev
->conn
->params
.channel
= bss
->channel
;
292 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
293 schedule_work(&rdev
->conn_work
);
298 static void __cfg80211_sme_scan_done(struct net_device
*dev
)
300 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
301 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
302 struct cfg80211_bss
*bss
;
304 ASSERT_WDEV_LOCK(wdev
);
309 if (wdev
->conn
->state
!= CFG80211_CONN_SCANNING
&&
310 wdev
->conn
->state
!= CFG80211_CONN_SCAN_AGAIN
)
313 bss
= cfg80211_get_conn_bss(wdev
);
315 cfg80211_put_bss(&rdev
->wiphy
, bss
);
317 schedule_work(&rdev
->conn_work
);
320 void cfg80211_sme_scan_done(struct net_device
*dev
)
322 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
325 __cfg80211_sme_scan_done(dev
);
329 void cfg80211_sme_rx_auth(struct wireless_dev
*wdev
, const u8
*buf
, size_t len
)
331 struct wiphy
*wiphy
= wdev
->wiphy
;
332 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
333 struct ieee80211_mgmt
*mgmt
= (struct ieee80211_mgmt
*)buf
;
334 u16 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
336 ASSERT_WDEV_LOCK(wdev
);
338 if (!wdev
->conn
|| wdev
->conn
->state
== CFG80211_CONN_CONNECTED
)
341 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
&&
342 wdev
->conn
->auto_auth
&&
343 wdev
->conn
->params
.auth_type
!= NL80211_AUTHTYPE_NETWORK_EAP
) {
344 /* select automatically between only open, shared, leap */
345 switch (wdev
->conn
->params
.auth_type
) {
346 case NL80211_AUTHTYPE_OPEN_SYSTEM
:
347 if (wdev
->connect_keys
)
348 wdev
->conn
->params
.auth_type
=
349 NL80211_AUTHTYPE_SHARED_KEY
;
351 wdev
->conn
->params
.auth_type
=
352 NL80211_AUTHTYPE_NETWORK_EAP
;
354 case NL80211_AUTHTYPE_SHARED_KEY
:
355 wdev
->conn
->params
.auth_type
=
356 NL80211_AUTHTYPE_NETWORK_EAP
;
360 wdev
->conn
->params
.auth_type
=
361 NL80211_AUTHTYPE_OPEN_SYSTEM
;
364 wdev
->conn
->state
= CFG80211_CONN_AUTHENTICATE_NEXT
;
365 schedule_work(&rdev
->conn_work
);
366 } else if (status_code
!= WLAN_STATUS_SUCCESS
) {
367 struct cfg80211_connect_resp_params cr
;
369 memset(&cr
, 0, sizeof(cr
));
370 cr
.status
= status_code
;
371 cr
.bssid
= mgmt
->bssid
;
372 cr
.timeout_reason
= NL80211_TIMEOUT_UNSPECIFIED
;
373 __cfg80211_connect_result(wdev
->netdev
, &cr
, false);
374 } else if (wdev
->conn
->state
== CFG80211_CONN_AUTHENTICATING
) {
375 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
376 schedule_work(&rdev
->conn_work
);
380 bool cfg80211_sme_rx_assoc_resp(struct wireless_dev
*wdev
, u16 status
)
382 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
387 if (status
== WLAN_STATUS_SUCCESS
) {
388 wdev
->conn
->state
= CFG80211_CONN_CONNECTED
;
392 if (wdev
->conn
->prev_bssid_valid
) {
394 * Some stupid APs don't accept reassoc, so we
395 * need to fall back to trying regular assoc;
396 * return true so no event is sent to userspace.
398 wdev
->conn
->prev_bssid_valid
= false;
399 wdev
->conn
->state
= CFG80211_CONN_ASSOCIATE_NEXT
;
400 schedule_work(&rdev
->conn_work
);
404 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED
;
405 schedule_work(&rdev
->conn_work
);
409 void cfg80211_sme_deauth(struct wireless_dev
*wdev
)
411 cfg80211_sme_free(wdev
);
414 void cfg80211_sme_auth_timeout(struct wireless_dev
*wdev
)
416 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
421 wdev
->conn
->state
= CFG80211_CONN_AUTH_FAILED_TIMEOUT
;
422 schedule_work(&rdev
->conn_work
);
425 void cfg80211_sme_disassoc(struct wireless_dev
*wdev
)
427 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
432 wdev
->conn
->state
= CFG80211_CONN_DEAUTH
;
433 schedule_work(&rdev
->conn_work
);
436 void cfg80211_sme_assoc_timeout(struct wireless_dev
*wdev
)
438 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
443 wdev
->conn
->state
= CFG80211_CONN_ASSOC_FAILED_TIMEOUT
;
444 schedule_work(&rdev
->conn_work
);
447 void cfg80211_sme_abandon_assoc(struct wireless_dev
*wdev
)
449 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
454 wdev
->conn
->state
= CFG80211_CONN_ABANDON
;
455 schedule_work(&rdev
->conn_work
);
458 static int cfg80211_sme_get_conn_ies(struct wireless_dev
*wdev
,
459 const u8
*ies
, size_t ies_len
,
460 const u8
**out_ies
, size_t *out_ies_len
)
462 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
466 if (!rdev
->wiphy
.extended_capabilities_len
||
467 (ies
&& cfg80211_find_ie(WLAN_EID_EXT_CAPABILITY
, ies
, ies_len
))) {
468 *out_ies
= kmemdup(ies
, ies_len
, GFP_KERNEL
);
471 *out_ies_len
= ies_len
;
475 buf
= kmalloc(ies_len
+ rdev
->wiphy
.extended_capabilities_len
+ 2,
481 static const u8 before_extcapa
[] = {
482 /* not listing IEs expected to be created by driver */
485 WLAN_EID_RRM_ENABLED_CAPABILITIES
,
486 WLAN_EID_MOBILITY_DOMAIN
,
487 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
488 WLAN_EID_BSS_COEX_2040
,
491 offs
= ieee80211_ie_split(ies
, ies_len
, before_extcapa
,
492 ARRAY_SIZE(before_extcapa
), 0);
493 memcpy(buf
, ies
, offs
);
494 /* leave a whole for extended capabilities IE */
495 memcpy(buf
+ offs
+ rdev
->wiphy
.extended_capabilities_len
+ 2,
496 ies
+ offs
, ies_len
- offs
);
501 /* place extended capabilities IE (with only driver capabilities) */
502 buf
[offs
] = WLAN_EID_EXT_CAPABILITY
;
503 buf
[offs
+ 1] = rdev
->wiphy
.extended_capabilities_len
;
504 memcpy(buf
+ offs
+ 2,
505 rdev
->wiphy
.extended_capabilities
,
506 rdev
->wiphy
.extended_capabilities_len
);
509 *out_ies_len
= ies_len
+ rdev
->wiphy
.extended_capabilities_len
+ 2;
514 static int cfg80211_sme_connect(struct wireless_dev
*wdev
,
515 struct cfg80211_connect_params
*connect
,
516 const u8
*prev_bssid
)
518 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
519 struct cfg80211_bss
*bss
;
522 if (!rdev
->ops
->auth
|| !rdev
->ops
->assoc
)
525 if (wdev
->current_bss
) {
526 cfg80211_unhold_bss(wdev
->current_bss
);
527 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
528 wdev
->current_bss
= NULL
;
530 cfg80211_sme_free(wdev
);
533 if (WARN_ON(wdev
->conn
))
536 wdev
->conn
= kzalloc(sizeof(*wdev
->conn
), GFP_KERNEL
);
541 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
543 memcpy(&wdev
->conn
->params
, connect
, sizeof(*connect
));
544 if (connect
->bssid
) {
545 wdev
->conn
->params
.bssid
= wdev
->conn
->bssid
;
546 memcpy(wdev
->conn
->bssid
, connect
->bssid
, ETH_ALEN
);
549 if (cfg80211_sme_get_conn_ies(wdev
, connect
->ie
, connect
->ie_len
,
551 &wdev
->conn
->params
.ie_len
)) {
556 wdev
->conn
->params
.ie
= wdev
->conn
->ie
;
558 if (connect
->auth_type
== NL80211_AUTHTYPE_AUTOMATIC
) {
559 wdev
->conn
->auto_auth
= true;
560 /* start with open system ... should mostly work */
561 wdev
->conn
->params
.auth_type
=
562 NL80211_AUTHTYPE_OPEN_SYSTEM
;
564 wdev
->conn
->auto_auth
= false;
567 wdev
->conn
->params
.ssid
= wdev
->ssid
;
568 wdev
->conn
->params
.ssid_len
= wdev
->ssid_len
;
570 /* see if we have the bss already */
571 bss
= cfg80211_get_conn_bss(wdev
);
574 memcpy(wdev
->conn
->prev_bssid
, prev_bssid
, ETH_ALEN
);
575 wdev
->conn
->prev_bssid_valid
= true;
578 /* we're good if we have a matching bss struct */
580 enum nl80211_timeout_reason treason
;
582 err
= cfg80211_conn_do_work(wdev
, &treason
);
583 cfg80211_put_bss(wdev
->wiphy
, bss
);
585 /* otherwise we'll need to scan for the AP first */
586 err
= cfg80211_conn_scan(wdev
);
589 * If we can't scan right now, then we need to scan again
590 * after the current scan finished, since the parameters
591 * changed (unless we find a good AP anyway).
595 wdev
->conn
->state
= CFG80211_CONN_SCAN_AGAIN
;
600 cfg80211_sme_free(wdev
);
605 static int cfg80211_sme_disconnect(struct wireless_dev
*wdev
, u16 reason
)
607 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
613 if (!rdev
->ops
->deauth
)
616 if (wdev
->conn
->state
== CFG80211_CONN_SCANNING
||
617 wdev
->conn
->state
== CFG80211_CONN_SCAN_AGAIN
) {
622 /* wdev->conn->params.bssid must be set if > SCANNING */
623 err
= cfg80211_mlme_deauth(rdev
, wdev
->netdev
,
624 wdev
->conn
->params
.bssid
,
625 NULL
, 0, reason
, false);
627 cfg80211_sme_free(wdev
);
632 * code shared for in-device and software SME
635 static bool cfg80211_is_all_idle(void)
637 struct cfg80211_registered_device
*rdev
;
638 struct wireless_dev
*wdev
;
639 bool is_all_idle
= true;
642 * All devices must be idle as otherwise if you are actively
643 * scanning some new beacon hints could be learned and would
644 * count as new regulatory hints.
645 * Also if there is any other active beaconing interface we
646 * need not issue a disconnect hint and reset any info such
647 * as chan dfs state, etc.
649 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
650 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
652 if (wdev
->conn
|| wdev
->current_bss
||
653 cfg80211_beaconing_iface_active(wdev
))
662 static void disconnect_work(struct work_struct
*work
)
665 if (cfg80211_is_all_idle())
666 regulatory_hint_disconnect();
670 DECLARE_WORK(cfg80211_disconnect_work
, disconnect_work
);
674 * API calls for drivers implementing connect/disconnect and
678 /* This method must consume bss one way or another */
679 void __cfg80211_connect_result(struct net_device
*dev
,
680 struct cfg80211_connect_resp_params
*cr
,
683 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
684 const u8
*country_ie
;
685 #ifdef CONFIG_CFG80211_WEXT
686 union iwreq_data wrqu
;
689 ASSERT_WDEV_LOCK(wdev
);
691 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
692 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)) {
693 cfg80211_put_bss(wdev
->wiphy
, cr
->bss
);
697 nl80211_send_connect_result(wiphy_to_rdev(wdev
->wiphy
), dev
, cr
,
700 #ifdef CONFIG_CFG80211_WEXT
702 if (cr
->req_ie
&& cr
->status
== WLAN_STATUS_SUCCESS
) {
703 memset(&wrqu
, 0, sizeof(wrqu
));
704 wrqu
.data
.length
= cr
->req_ie_len
;
705 wireless_send_event(dev
, IWEVASSOCREQIE
, &wrqu
,
709 if (cr
->resp_ie
&& cr
->status
== WLAN_STATUS_SUCCESS
) {
710 memset(&wrqu
, 0, sizeof(wrqu
));
711 wrqu
.data
.length
= cr
->resp_ie_len
;
712 wireless_send_event(dev
, IWEVASSOCRESPIE
, &wrqu
,
716 memset(&wrqu
, 0, sizeof(wrqu
));
717 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
718 if (cr
->bssid
&& cr
->status
== WLAN_STATUS_SUCCESS
) {
719 memcpy(wrqu
.ap_addr
.sa_data
, cr
->bssid
, ETH_ALEN
);
720 memcpy(wdev
->wext
.prev_bssid
, cr
->bssid
, ETH_ALEN
);
721 wdev
->wext
.prev_bssid_valid
= true;
723 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
727 if (!cr
->bss
&& (cr
->status
== WLAN_STATUS_SUCCESS
)) {
728 WARN_ON_ONCE(!wiphy_to_rdev(wdev
->wiphy
)->ops
->connect
);
729 cr
->bss
= cfg80211_get_bss(wdev
->wiphy
, NULL
, cr
->bssid
,
730 wdev
->ssid
, wdev
->ssid_len
,
732 IEEE80211_PRIVACY_ANY
);
734 cfg80211_hold_bss(bss_from_pub(cr
->bss
));
737 if (wdev
->current_bss
) {
738 cfg80211_unhold_bss(wdev
->current_bss
);
739 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
740 wdev
->current_bss
= NULL
;
743 if (cr
->status
!= WLAN_STATUS_SUCCESS
) {
744 kzfree(wdev
->connect_keys
);
745 wdev
->connect_keys
= NULL
;
747 wdev
->conn_owner_nlportid
= 0;
749 cfg80211_unhold_bss(bss_from_pub(cr
->bss
));
750 cfg80211_put_bss(wdev
->wiphy
, cr
->bss
);
752 cfg80211_sme_free(wdev
);
756 if (WARN_ON(!cr
->bss
))
759 wdev
->current_bss
= bss_from_pub(cr
->bss
);
761 if (!(wdev
->wiphy
->flags
& WIPHY_FLAG_HAS_STATIC_WEP
))
762 cfg80211_upload_connect_keys(wdev
);
765 country_ie
= ieee80211_bss_get_ie(cr
->bss
, WLAN_EID_COUNTRY
);
771 country_ie
= kmemdup(country_ie
, 2 + country_ie
[1], GFP_ATOMIC
);
778 * ieee80211_bss_get_ie() ensures we can access:
779 * - country_ie + 2, the start of the country ie data, and
780 * - and country_ie[1] which is the IE length
782 regulatory_hint_country_ie(wdev
->wiphy
, cr
->bss
->channel
->band
,
783 country_ie
+ 2, country_ie
[1]);
787 /* Consumes bss object one way or another */
788 void cfg80211_connect_done(struct net_device
*dev
,
789 struct cfg80211_connect_resp_params
*params
,
792 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
793 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
794 struct cfg80211_event
*ev
;
799 /* Make sure the bss entry provided by the driver is valid. */
800 struct cfg80211_internal_bss
*ibss
= bss_from_pub(params
->bss
);
802 if (WARN_ON(list_empty(&ibss
->list
))) {
803 cfg80211_put_bss(wdev
->wiphy
, params
->bss
);
808 ev
= kzalloc(sizeof(*ev
) + (params
->bssid
? ETH_ALEN
: 0) +
809 params
->req_ie_len
+ params
->resp_ie_len
+
810 params
->fils_kek_len
+ params
->pmk_len
+
811 (params
->pmkid
? WLAN_PMKID_LEN
: 0), gfp
);
813 cfg80211_put_bss(wdev
->wiphy
, params
->bss
);
817 ev
->type
= EVENT_CONNECT_RESULT
;
818 next
= ((u8
*)ev
) + sizeof(*ev
);
821 memcpy((void *)ev
->cr
.bssid
, params
->bssid
, ETH_ALEN
);
824 if (params
->req_ie_len
) {
825 ev
->cr
.req_ie
= next
;
826 ev
->cr
.req_ie_len
= params
->req_ie_len
;
827 memcpy((void *)ev
->cr
.req_ie
, params
->req_ie
,
829 next
+= params
->req_ie_len
;
831 if (params
->resp_ie_len
) {
832 ev
->cr
.resp_ie
= next
;
833 ev
->cr
.resp_ie_len
= params
->resp_ie_len
;
834 memcpy((void *)ev
->cr
.resp_ie
, params
->resp_ie
,
835 params
->resp_ie_len
);
836 next
+= params
->resp_ie_len
;
838 if (params
->fils_kek_len
) {
839 ev
->cr
.fils_kek
= next
;
840 ev
->cr
.fils_kek_len
= params
->fils_kek_len
;
841 memcpy((void *)ev
->cr
.fils_kek
, params
->fils_kek
,
842 params
->fils_kek_len
);
843 next
+= params
->fils_kek_len
;
845 if (params
->pmk_len
) {
847 ev
->cr
.pmk_len
= params
->pmk_len
;
848 memcpy((void *)ev
->cr
.pmk
, params
->pmk
, params
->pmk_len
);
849 next
+= params
->pmk_len
;
853 memcpy((void *)ev
->cr
.pmkid
, params
->pmkid
, WLAN_PMKID_LEN
);
854 next
+= WLAN_PMKID_LEN
;
856 ev
->cr
.update_erp_next_seq_num
= params
->update_erp_next_seq_num
;
857 if (params
->update_erp_next_seq_num
)
858 ev
->cr
.fils_erp_next_seq_num
= params
->fils_erp_next_seq_num
;
860 cfg80211_hold_bss(bss_from_pub(params
->bss
));
861 ev
->cr
.bss
= params
->bss
;
862 ev
->cr
.status
= params
->status
;
863 ev
->cr
.timeout_reason
= params
->timeout_reason
;
865 spin_lock_irqsave(&wdev
->event_lock
, flags
);
866 list_add_tail(&ev
->list
, &wdev
->event_list
);
867 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
868 queue_work(cfg80211_wq
, &rdev
->event_work
);
870 EXPORT_SYMBOL(cfg80211_connect_done
);
872 /* Consumes bss object one way or another */
873 void __cfg80211_roamed(struct wireless_dev
*wdev
,
874 struct cfg80211_roam_info
*info
)
876 #ifdef CONFIG_CFG80211_WEXT
877 union iwreq_data wrqu
;
879 ASSERT_WDEV_LOCK(wdev
);
881 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
882 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
885 if (WARN_ON(!wdev
->current_bss
))
888 cfg80211_unhold_bss(wdev
->current_bss
);
889 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
890 wdev
->current_bss
= NULL
;
892 if (WARN_ON(!info
->bss
))
895 cfg80211_hold_bss(bss_from_pub(info
->bss
));
896 wdev
->current_bss
= bss_from_pub(info
->bss
);
898 nl80211_send_roamed(wiphy_to_rdev(wdev
->wiphy
),
899 wdev
->netdev
, info
, GFP_KERNEL
);
901 #ifdef CONFIG_CFG80211_WEXT
903 memset(&wrqu
, 0, sizeof(wrqu
));
904 wrqu
.data
.length
= info
->req_ie_len
;
905 wireless_send_event(wdev
->netdev
, IWEVASSOCREQIE
,
906 &wrqu
, info
->req_ie
);
910 memset(&wrqu
, 0, sizeof(wrqu
));
911 wrqu
.data
.length
= info
->resp_ie_len
;
912 wireless_send_event(wdev
->netdev
, IWEVASSOCRESPIE
,
913 &wrqu
, info
->resp_ie
);
916 memset(&wrqu
, 0, sizeof(wrqu
));
917 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
918 memcpy(wrqu
.ap_addr
.sa_data
, info
->bss
->bssid
, ETH_ALEN
);
919 memcpy(wdev
->wext
.prev_bssid
, info
->bss
->bssid
, ETH_ALEN
);
920 wdev
->wext
.prev_bssid_valid
= true;
921 wireless_send_event(wdev
->netdev
, SIOCGIWAP
, &wrqu
, NULL
);
926 cfg80211_put_bss(wdev
->wiphy
, info
->bss
);
929 /* Consumes info->bss object one way or another */
930 void cfg80211_roamed(struct net_device
*dev
, struct cfg80211_roam_info
*info
,
933 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
934 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
935 struct cfg80211_event
*ev
;
939 info
->bss
= cfg80211_get_bss(wdev
->wiphy
, info
->channel
,
940 info
->bssid
, wdev
->ssid
,
943 IEEE80211_PRIVACY_ANY
);
946 if (WARN_ON(!info
->bss
))
949 ev
= kzalloc(sizeof(*ev
) + info
->req_ie_len
+ info
->resp_ie_len
, gfp
);
951 cfg80211_put_bss(wdev
->wiphy
, info
->bss
);
955 ev
->type
= EVENT_ROAMED
;
956 ev
->rm
.req_ie
= ((u8
*)ev
) + sizeof(*ev
);
957 ev
->rm
.req_ie_len
= info
->req_ie_len
;
958 memcpy((void *)ev
->rm
.req_ie
, info
->req_ie
, info
->req_ie_len
);
959 ev
->rm
.resp_ie
= ((u8
*)ev
) + sizeof(*ev
) + info
->req_ie_len
;
960 ev
->rm
.resp_ie_len
= info
->resp_ie_len
;
961 memcpy((void *)ev
->rm
.resp_ie
, info
->resp_ie
, info
->resp_ie_len
);
962 ev
->rm
.bss
= info
->bss
;
964 spin_lock_irqsave(&wdev
->event_lock
, flags
);
965 list_add_tail(&ev
->list
, &wdev
->event_list
);
966 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
967 queue_work(cfg80211_wq
, &rdev
->event_work
);
969 EXPORT_SYMBOL(cfg80211_roamed
);
971 void __cfg80211_port_authorized(struct wireless_dev
*wdev
, const u8
*bssid
)
973 ASSERT_WDEV_LOCK(wdev
);
975 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
))
978 if (WARN_ON(!wdev
->current_bss
) ||
979 WARN_ON(!ether_addr_equal(wdev
->current_bss
->pub
.bssid
, bssid
)))
982 nl80211_send_port_authorized(wiphy_to_rdev(wdev
->wiphy
), wdev
->netdev
,
986 void cfg80211_port_authorized(struct net_device
*dev
, const u8
*bssid
,
989 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
990 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
991 struct cfg80211_event
*ev
;
997 ev
= kzalloc(sizeof(*ev
), gfp
);
1001 ev
->type
= EVENT_PORT_AUTHORIZED
;
1002 memcpy(ev
->pa
.bssid
, bssid
, ETH_ALEN
);
1005 * Use the wdev event list so that if there are pending
1006 * connected/roamed events, they will be reported first.
1008 spin_lock_irqsave(&wdev
->event_lock
, flags
);
1009 list_add_tail(&ev
->list
, &wdev
->event_list
);
1010 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
1011 queue_work(cfg80211_wq
, &rdev
->event_work
);
1013 EXPORT_SYMBOL(cfg80211_port_authorized
);
1015 void __cfg80211_disconnected(struct net_device
*dev
, const u8
*ie
,
1016 size_t ie_len
, u16 reason
, bool from_ap
)
1018 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1019 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
1021 #ifdef CONFIG_CFG80211_WEXT
1022 union iwreq_data wrqu
;
1025 ASSERT_WDEV_LOCK(wdev
);
1027 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
1028 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
))
1031 if (wdev
->current_bss
) {
1032 cfg80211_unhold_bss(wdev
->current_bss
);
1033 cfg80211_put_bss(wdev
->wiphy
, &wdev
->current_bss
->pub
);
1036 wdev
->current_bss
= NULL
;
1038 wdev
->conn_owner_nlportid
= 0;
1039 kzfree(wdev
->connect_keys
);
1040 wdev
->connect_keys
= NULL
;
1042 nl80211_send_disconnected(rdev
, dev
, reason
, ie
, ie_len
, from_ap
);
1044 /* stop critical protocol if supported */
1045 if (rdev
->ops
->crit_proto_stop
&& rdev
->crit_proto_nlportid
) {
1046 rdev
->crit_proto_nlportid
= 0;
1047 rdev_crit_proto_stop(rdev
, wdev
);
1051 * Delete all the keys ... pairwise keys can't really
1052 * exist any more anyway, but default keys might.
1054 if (rdev
->ops
->del_key
)
1055 for (i
= 0; i
< 6; i
++)
1056 rdev_del_key(rdev
, dev
, i
, false, NULL
);
1058 rdev_set_qos_map(rdev
, dev
, NULL
);
1060 #ifdef CONFIG_CFG80211_WEXT
1061 memset(&wrqu
, 0, sizeof(wrqu
));
1062 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1063 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
1064 wdev
->wext
.connect
.ssid_len
= 0;
1067 schedule_work(&cfg80211_disconnect_work
);
1070 void cfg80211_disconnected(struct net_device
*dev
, u16 reason
,
1071 const u8
*ie
, size_t ie_len
,
1072 bool locally_generated
, gfp_t gfp
)
1074 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1075 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
1076 struct cfg80211_event
*ev
;
1077 unsigned long flags
;
1079 ev
= kzalloc(sizeof(*ev
) + ie_len
, gfp
);
1083 ev
->type
= EVENT_DISCONNECTED
;
1084 ev
->dc
.ie
= ((u8
*)ev
) + sizeof(*ev
);
1085 ev
->dc
.ie_len
= ie_len
;
1086 memcpy((void *)ev
->dc
.ie
, ie
, ie_len
);
1087 ev
->dc
.reason
= reason
;
1088 ev
->dc
.locally_generated
= locally_generated
;
1090 spin_lock_irqsave(&wdev
->event_lock
, flags
);
1091 list_add_tail(&ev
->list
, &wdev
->event_list
);
1092 spin_unlock_irqrestore(&wdev
->event_lock
, flags
);
1093 queue_work(cfg80211_wq
, &rdev
->event_work
);
1095 EXPORT_SYMBOL(cfg80211_disconnected
);
1098 * API calls for nl80211/wext compatibility code
1100 int cfg80211_connect(struct cfg80211_registered_device
*rdev
,
1101 struct net_device
*dev
,
1102 struct cfg80211_connect_params
*connect
,
1103 struct cfg80211_cached_keys
*connkeys
,
1104 const u8
*prev_bssid
)
1106 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1109 ASSERT_WDEV_LOCK(wdev
);
1112 * If we have an ssid_len, we're trying to connect or are
1113 * already connected, so reject a new SSID unless it's the
1114 * same (which is the case for re-association.)
1116 if (wdev
->ssid_len
&&
1117 (wdev
->ssid_len
!= connect
->ssid_len
||
1118 memcmp(wdev
->ssid
, connect
->ssid
, wdev
->ssid_len
)))
1122 * If connected, reject (re-)association unless prev_bssid
1123 * matches the current BSSID.
1125 if (wdev
->current_bss
) {
1128 if (!ether_addr_equal(prev_bssid
, wdev
->current_bss
->pub
.bssid
))
1133 * Reject if we're in the process of connecting with WEP,
1134 * this case isn't very interesting and trying to handle
1135 * it would make the code much more complex.
1137 if (wdev
->connect_keys
)
1138 return -EINPROGRESS
;
1140 cfg80211_oper_and_ht_capa(&connect
->ht_capa_mask
,
1141 rdev
->wiphy
.ht_capa_mod_mask
);
1143 if (connkeys
&& connkeys
->def
>= 0) {
1147 idx
= connkeys
->def
;
1148 cipher
= connkeys
->params
[idx
].cipher
;
1149 /* If given a WEP key we may need it for shared key auth */
1150 if (cipher
== WLAN_CIPHER_SUITE_WEP40
||
1151 cipher
== WLAN_CIPHER_SUITE_WEP104
) {
1152 connect
->key_idx
= idx
;
1153 connect
->key
= connkeys
->params
[idx
].key
;
1154 connect
->key_len
= connkeys
->params
[idx
].key_len
;
1157 * If ciphers are not set (e.g. when going through
1158 * iwconfig), we have to set them appropriately here.
1160 if (connect
->crypto
.cipher_group
== 0)
1161 connect
->crypto
.cipher_group
= cipher
;
1163 if (connect
->crypto
.n_ciphers_pairwise
== 0) {
1164 connect
->crypto
.n_ciphers_pairwise
= 1;
1165 connect
->crypto
.ciphers_pairwise
[0] = cipher
;
1169 connect
->crypto
.wep_keys
= connkeys
->params
;
1170 connect
->crypto
.wep_tx_key
= connkeys
->def
;
1172 if (WARN_ON(connkeys
))
1176 wdev
->connect_keys
= connkeys
;
1177 memcpy(wdev
->ssid
, connect
->ssid
, connect
->ssid_len
);
1178 wdev
->ssid_len
= connect
->ssid_len
;
1180 wdev
->conn_bss_type
= connect
->pbss
? IEEE80211_BSS_TYPE_PBSS
:
1181 IEEE80211_BSS_TYPE_ESS
;
1183 if (!rdev
->ops
->connect
)
1184 err
= cfg80211_sme_connect(wdev
, connect
, prev_bssid
);
1186 err
= rdev_connect(rdev
, dev
, connect
);
1189 wdev
->connect_keys
= NULL
;
1191 * This could be reassoc getting refused, don't clear
1192 * ssid_len in that case.
1194 if (!wdev
->current_bss
)
1202 int cfg80211_disconnect(struct cfg80211_registered_device
*rdev
,
1203 struct net_device
*dev
, u16 reason
, bool wextev
)
1205 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1208 ASSERT_WDEV_LOCK(wdev
);
1210 kzfree(wdev
->connect_keys
);
1211 wdev
->connect_keys
= NULL
;
1213 wdev
->conn_owner_nlportid
= 0;
1216 err
= cfg80211_sme_disconnect(wdev
, reason
);
1217 else if (!rdev
->ops
->disconnect
)
1218 cfg80211_mlme_down(rdev
, dev
);
1219 else if (wdev
->ssid_len
)
1220 err
= rdev_disconnect(rdev
, dev
, reason
);
1223 * Clear ssid_len unless we actually were fully connected,
1224 * in which case cfg80211_disconnected() will take care of
1227 if (!wdev
->current_bss
)
1234 * Used to clean up after the connection / connection attempt owner socket
1237 void cfg80211_autodisconnect_wk(struct work_struct
*work
)
1239 struct wireless_dev
*wdev
=
1240 container_of(work
, struct wireless_dev
, disconnect_wk
);
1241 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
1245 if (wdev
->conn_owner_nlportid
) {
1247 * Use disconnect_bssid if still connecting and ops->disconnect
1248 * not implemented. Otherwise we can use cfg80211_disconnect.
1250 if (rdev
->ops
->disconnect
|| wdev
->current_bss
)
1251 cfg80211_disconnect(rdev
, wdev
->netdev
,
1252 WLAN_REASON_DEAUTH_LEAVING
, true);
1254 cfg80211_mlme_deauth(rdev
, wdev
->netdev
,
1255 wdev
->disconnect_bssid
, NULL
, 0,
1256 WLAN_REASON_DEAUTH_LEAVING
, false);