/net/wireless/sme.c

http://github.com/mirrors/linux · C · 1350 lines · 1024 code · 197 blank · 129 comment · 184 complexity · fdc4a76d727cdd8d627480f53fd2be61 MD5 · raw file

  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * SME code for cfg80211
  4. * both driver SME event handling and the SME implementation
  5. * (for nl80211's connect() and wext)
  6. *
  7. * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
  8. * Copyright (C) 2009 Intel Corporation. All rights reserved.
  9. * Copyright 2017 Intel Deutschland GmbH
  10. */
  11. #include <linux/etherdevice.h>
  12. #include <linux/if_arp.h>
  13. #include <linux/slab.h>
  14. #include <linux/workqueue.h>
  15. #include <linux/wireless.h>
  16. #include <linux/export.h>
  17. #include <net/iw_handler.h>
  18. #include <net/cfg80211.h>
  19. #include <net/rtnetlink.h>
  20. #include "nl80211.h"
  21. #include "reg.h"
  22. #include "rdev-ops.h"
  23. /*
  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.)
  27. */
  28. struct cfg80211_conn {
  29. struct cfg80211_connect_params params;
  30. /* these are sub-states of the _CONNECTING sme_state */
  31. enum {
  32. CFG80211_CONN_SCANNING,
  33. CFG80211_CONN_SCAN_AGAIN,
  34. CFG80211_CONN_AUTHENTICATE_NEXT,
  35. CFG80211_CONN_AUTHENTICATING,
  36. CFG80211_CONN_AUTH_FAILED_TIMEOUT,
  37. CFG80211_CONN_ASSOCIATE_NEXT,
  38. CFG80211_CONN_ASSOCIATING,
  39. CFG80211_CONN_ASSOC_FAILED,
  40. CFG80211_CONN_ASSOC_FAILED_TIMEOUT,
  41. CFG80211_CONN_DEAUTH,
  42. CFG80211_CONN_ABANDON,
  43. CFG80211_CONN_CONNECTED,
  44. } state;
  45. u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
  46. const u8 *ie;
  47. size_t ie_len;
  48. bool auto_auth, prev_bssid_valid;
  49. };
  50. static void cfg80211_sme_free(struct wireless_dev *wdev)
  51. {
  52. if (!wdev->conn)
  53. return;
  54. kfree(wdev->conn->ie);
  55. kfree(wdev->conn);
  56. wdev->conn = NULL;
  57. }
  58. static int cfg80211_conn_scan(struct wireless_dev *wdev)
  59. {
  60. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  61. struct cfg80211_scan_request *request;
  62. int n_channels, err;
  63. ASSERT_RTNL();
  64. ASSERT_WDEV_LOCK(wdev);
  65. if (rdev->scan_req || rdev->scan_msg)
  66. return -EBUSY;
  67. if (wdev->conn->params.channel)
  68. n_channels = 1;
  69. else
  70. n_channels = ieee80211_get_num_supported_channels(wdev->wiphy);
  71. request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
  72. sizeof(request->channels[0]) * n_channels,
  73. GFP_KERNEL);
  74. if (!request)
  75. return -ENOMEM;
  76. if (wdev->conn->params.channel) {
  77. enum nl80211_band band = wdev->conn->params.channel->band;
  78. struct ieee80211_supported_band *sband =
  79. wdev->wiphy->bands[band];
  80. if (!sband) {
  81. kfree(request);
  82. return -EINVAL;
  83. }
  84. request->channels[0] = wdev->conn->params.channel;
  85. request->rates[band] = (1 << sband->n_bitrates) - 1;
  86. } else {
  87. int i = 0, j;
  88. enum nl80211_band band;
  89. struct ieee80211_supported_band *bands;
  90. struct ieee80211_channel *channel;
  91. for (band = 0; band < NUM_NL80211_BANDS; band++) {
  92. bands = wdev->wiphy->bands[band];
  93. if (!bands)
  94. continue;
  95. for (j = 0; j < bands->n_channels; j++) {
  96. channel = &bands->channels[j];
  97. if (channel->flags & IEEE80211_CHAN_DISABLED)
  98. continue;
  99. request->channels[i++] = channel;
  100. }
  101. request->rates[band] = (1 << bands->n_bitrates) - 1;
  102. }
  103. n_channels = i;
  104. }
  105. request->n_channels = n_channels;
  106. request->ssids = (void *)&request->channels[n_channels];
  107. request->n_ssids = 1;
  108. memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
  109. wdev->conn->params.ssid_len);
  110. request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
  111. eth_broadcast_addr(request->bssid);
  112. request->wdev = wdev;
  113. request->wiphy = &rdev->wiphy;
  114. request->scan_start = jiffies;
  115. rdev->scan_req = request;
  116. err = rdev_scan(rdev, request);
  117. if (!err) {
  118. wdev->conn->state = CFG80211_CONN_SCANNING;
  119. nl80211_send_scan_start(rdev, wdev);
  120. dev_hold(wdev->netdev);
  121. } else {
  122. rdev->scan_req = NULL;
  123. kfree(request);
  124. }
  125. return err;
  126. }
  127. static int cfg80211_conn_do_work(struct wireless_dev *wdev,
  128. enum nl80211_timeout_reason *treason)
  129. {
  130. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  131. struct cfg80211_connect_params *params;
  132. struct cfg80211_assoc_request req = {};
  133. int err;
  134. ASSERT_WDEV_LOCK(wdev);
  135. if (!wdev->conn)
  136. return 0;
  137. params = &wdev->conn->params;
  138. switch (wdev->conn->state) {
  139. case CFG80211_CONN_SCANNING:
  140. /* didn't find it during scan ... */
  141. return -ENOENT;
  142. case CFG80211_CONN_SCAN_AGAIN:
  143. return cfg80211_conn_scan(wdev);
  144. case CFG80211_CONN_AUTHENTICATE_NEXT:
  145. if (WARN_ON(!rdev->ops->auth))
  146. return -EOPNOTSUPP;
  147. wdev->conn->state = CFG80211_CONN_AUTHENTICATING;
  148. return cfg80211_mlme_auth(rdev, wdev->netdev,
  149. params->channel, params->auth_type,
  150. params->bssid,
  151. params->ssid, params->ssid_len,
  152. NULL, 0,
  153. params->key, params->key_len,
  154. params->key_idx, NULL, 0);
  155. case CFG80211_CONN_AUTH_FAILED_TIMEOUT:
  156. *treason = NL80211_TIMEOUT_AUTH;
  157. return -ENOTCONN;
  158. case CFG80211_CONN_ASSOCIATE_NEXT:
  159. if (WARN_ON(!rdev->ops->assoc))
  160. return -EOPNOTSUPP;
  161. wdev->conn->state = CFG80211_CONN_ASSOCIATING;
  162. if (wdev->conn->prev_bssid_valid)
  163. req.prev_bssid = wdev->conn->prev_bssid;
  164. req.ie = params->ie;
  165. req.ie_len = params->ie_len;
  166. req.use_mfp = params->mfp != NL80211_MFP_NO;
  167. req.crypto = params->crypto;
  168. req.flags = params->flags;
  169. req.ht_capa = params->ht_capa;
  170. req.ht_capa_mask = params->ht_capa_mask;
  171. req.vht_capa = params->vht_capa;
  172. req.vht_capa_mask = params->vht_capa_mask;
  173. err = cfg80211_mlme_assoc(rdev, wdev->netdev, params->channel,
  174. params->bssid, params->ssid,
  175. params->ssid_len, &req);
  176. if (err)
  177. cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
  178. NULL, 0,
  179. WLAN_REASON_DEAUTH_LEAVING,
  180. false);
  181. return err;
  182. case CFG80211_CONN_ASSOC_FAILED_TIMEOUT:
  183. *treason = NL80211_TIMEOUT_ASSOC;
  184. /* fall through */
  185. case CFG80211_CONN_ASSOC_FAILED:
  186. cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
  187. NULL, 0,
  188. WLAN_REASON_DEAUTH_LEAVING, false);
  189. return -ENOTCONN;
  190. case CFG80211_CONN_DEAUTH:
  191. cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
  192. NULL, 0,
  193. WLAN_REASON_DEAUTH_LEAVING, false);
  194. /* fall through */
  195. case CFG80211_CONN_ABANDON:
  196. /* free directly, disconnected event already sent */
  197. cfg80211_sme_free(wdev);
  198. return 0;
  199. default:
  200. return 0;
  201. }
  202. }
  203. void cfg80211_conn_work(struct work_struct *work)
  204. {
  205. struct cfg80211_registered_device *rdev =
  206. container_of(work, struct cfg80211_registered_device, conn_work);
  207. struct wireless_dev *wdev;
  208. u8 bssid_buf[ETH_ALEN], *bssid = NULL;
  209. enum nl80211_timeout_reason treason;
  210. rtnl_lock();
  211. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  212. if (!wdev->netdev)
  213. continue;
  214. wdev_lock(wdev);
  215. if (!netif_running(wdev->netdev)) {
  216. wdev_unlock(wdev);
  217. continue;
  218. }
  219. if (!wdev->conn ||
  220. wdev->conn->state == CFG80211_CONN_CONNECTED) {
  221. wdev_unlock(wdev);
  222. continue;
  223. }
  224. if (wdev->conn->params.bssid) {
  225. memcpy(bssid_buf, wdev->conn->params.bssid, ETH_ALEN);
  226. bssid = bssid_buf;
  227. }
  228. treason = NL80211_TIMEOUT_UNSPECIFIED;
  229. if (cfg80211_conn_do_work(wdev, &treason)) {
  230. struct cfg80211_connect_resp_params cr;
  231. memset(&cr, 0, sizeof(cr));
  232. cr.status = -1;
  233. cr.bssid = bssid;
  234. cr.timeout_reason = treason;
  235. __cfg80211_connect_result(wdev->netdev, &cr, false);
  236. }
  237. wdev_unlock(wdev);
  238. }
  239. rtnl_unlock();
  240. }
  241. /* Returned bss is reference counted and must be cleaned up appropriately. */
  242. static struct cfg80211_bss *cfg80211_get_conn_bss(struct wireless_dev *wdev)
  243. {
  244. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  245. struct cfg80211_bss *bss;
  246. ASSERT_WDEV_LOCK(wdev);
  247. bss = cfg80211_get_bss(wdev->wiphy, wdev->conn->params.channel,
  248. wdev->conn->params.bssid,
  249. wdev->conn->params.ssid,
  250. wdev->conn->params.ssid_len,
  251. wdev->conn_bss_type,
  252. IEEE80211_PRIVACY(wdev->conn->params.privacy));
  253. if (!bss)
  254. return NULL;
  255. memcpy(wdev->conn->bssid, bss->bssid, ETH_ALEN);
  256. wdev->conn->params.bssid = wdev->conn->bssid;
  257. wdev->conn->params.channel = bss->channel;
  258. wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
  259. schedule_work(&rdev->conn_work);
  260. return bss;
  261. }
  262. static void __cfg80211_sme_scan_done(struct net_device *dev)
  263. {
  264. struct wireless_dev *wdev = dev->ieee80211_ptr;
  265. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  266. struct cfg80211_bss *bss;
  267. ASSERT_WDEV_LOCK(wdev);
  268. if (!wdev->conn)
  269. return;
  270. if (wdev->conn->state != CFG80211_CONN_SCANNING &&
  271. wdev->conn->state != CFG80211_CONN_SCAN_AGAIN)
  272. return;
  273. bss = cfg80211_get_conn_bss(wdev);
  274. if (bss)
  275. cfg80211_put_bss(&rdev->wiphy, bss);
  276. else
  277. schedule_work(&rdev->conn_work);
  278. }
  279. void cfg80211_sme_scan_done(struct net_device *dev)
  280. {
  281. struct wireless_dev *wdev = dev->ieee80211_ptr;
  282. wdev_lock(wdev);
  283. __cfg80211_sme_scan_done(dev);
  284. wdev_unlock(wdev);
  285. }
  286. void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len)
  287. {
  288. struct wiphy *wiphy = wdev->wiphy;
  289. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  290. struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
  291. u16 status_code = le16_to_cpu(mgmt->u.auth.status_code);
  292. ASSERT_WDEV_LOCK(wdev);
  293. if (!wdev->conn || wdev->conn->state == CFG80211_CONN_CONNECTED)
  294. return;
  295. if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
  296. wdev->conn->auto_auth &&
  297. wdev->conn->params.auth_type != NL80211_AUTHTYPE_NETWORK_EAP) {
  298. /* select automatically between only open, shared, leap */
  299. switch (wdev->conn->params.auth_type) {
  300. case NL80211_AUTHTYPE_OPEN_SYSTEM:
  301. if (wdev->connect_keys)
  302. wdev->conn->params.auth_type =
  303. NL80211_AUTHTYPE_SHARED_KEY;
  304. else
  305. wdev->conn->params.auth_type =
  306. NL80211_AUTHTYPE_NETWORK_EAP;
  307. break;
  308. case NL80211_AUTHTYPE_SHARED_KEY:
  309. wdev->conn->params.auth_type =
  310. NL80211_AUTHTYPE_NETWORK_EAP;
  311. break;
  312. default:
  313. /* huh? */
  314. wdev->conn->params.auth_type =
  315. NL80211_AUTHTYPE_OPEN_SYSTEM;
  316. break;
  317. }
  318. wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
  319. schedule_work(&rdev->conn_work);
  320. } else if (status_code != WLAN_STATUS_SUCCESS) {
  321. struct cfg80211_connect_resp_params cr;
  322. memset(&cr, 0, sizeof(cr));
  323. cr.status = status_code;
  324. cr.bssid = mgmt->bssid;
  325. cr.timeout_reason = NL80211_TIMEOUT_UNSPECIFIED;
  326. __cfg80211_connect_result(wdev->netdev, &cr, false);
  327. } else if (wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
  328. wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
  329. schedule_work(&rdev->conn_work);
  330. }
  331. }
  332. bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status)
  333. {
  334. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  335. if (!wdev->conn)
  336. return false;
  337. if (status == WLAN_STATUS_SUCCESS) {
  338. wdev->conn->state = CFG80211_CONN_CONNECTED;
  339. return false;
  340. }
  341. if (wdev->conn->prev_bssid_valid) {
  342. /*
  343. * Some stupid APs don't accept reassoc, so we
  344. * need to fall back to trying regular assoc;
  345. * return true so no event is sent to userspace.
  346. */
  347. wdev->conn->prev_bssid_valid = false;
  348. wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
  349. schedule_work(&rdev->conn_work);
  350. return true;
  351. }
  352. wdev->conn->state = CFG80211_CONN_ASSOC_FAILED;
  353. schedule_work(&rdev->conn_work);
  354. return false;
  355. }
  356. void cfg80211_sme_deauth(struct wireless_dev *wdev)
  357. {
  358. cfg80211_sme_free(wdev);
  359. }
  360. void cfg80211_sme_auth_timeout(struct wireless_dev *wdev)
  361. {
  362. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  363. if (!wdev->conn)
  364. return;
  365. wdev->conn->state = CFG80211_CONN_AUTH_FAILED_TIMEOUT;
  366. schedule_work(&rdev->conn_work);
  367. }
  368. void cfg80211_sme_disassoc(struct wireless_dev *wdev)
  369. {
  370. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  371. if (!wdev->conn)
  372. return;
  373. wdev->conn->state = CFG80211_CONN_DEAUTH;
  374. schedule_work(&rdev->conn_work);
  375. }
  376. void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev)
  377. {
  378. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  379. if (!wdev->conn)
  380. return;
  381. wdev->conn->state = CFG80211_CONN_ASSOC_FAILED_TIMEOUT;
  382. schedule_work(&rdev->conn_work);
  383. }
  384. void cfg80211_sme_abandon_assoc(struct wireless_dev *wdev)
  385. {
  386. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  387. if (!wdev->conn)
  388. return;
  389. wdev->conn->state = CFG80211_CONN_ABANDON;
  390. schedule_work(&rdev->conn_work);
  391. }
  392. static int cfg80211_sme_get_conn_ies(struct wireless_dev *wdev,
  393. const u8 *ies, size_t ies_len,
  394. const u8 **out_ies, size_t *out_ies_len)
  395. {
  396. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  397. u8 *buf;
  398. size_t offs;
  399. if (!rdev->wiphy.extended_capabilities_len ||
  400. (ies && cfg80211_find_ie(WLAN_EID_EXT_CAPABILITY, ies, ies_len))) {
  401. *out_ies = kmemdup(ies, ies_len, GFP_KERNEL);
  402. if (!*out_ies)
  403. return -ENOMEM;
  404. *out_ies_len = ies_len;
  405. return 0;
  406. }
  407. buf = kmalloc(ies_len + rdev->wiphy.extended_capabilities_len + 2,
  408. GFP_KERNEL);
  409. if (!buf)
  410. return -ENOMEM;
  411. if (ies_len) {
  412. static const u8 before_extcapa[] = {
  413. /* not listing IEs expected to be created by driver */
  414. WLAN_EID_RSN,
  415. WLAN_EID_QOS_CAPA,
  416. WLAN_EID_RRM_ENABLED_CAPABILITIES,
  417. WLAN_EID_MOBILITY_DOMAIN,
  418. WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
  419. WLAN_EID_BSS_COEX_2040,
  420. };
  421. offs = ieee80211_ie_split(ies, ies_len, before_extcapa,
  422. ARRAY_SIZE(before_extcapa), 0);
  423. memcpy(buf, ies, offs);
  424. /* leave a whole for extended capabilities IE */
  425. memcpy(buf + offs + rdev->wiphy.extended_capabilities_len + 2,
  426. ies + offs, ies_len - offs);
  427. } else {
  428. offs = 0;
  429. }
  430. /* place extended capabilities IE (with only driver capabilities) */
  431. buf[offs] = WLAN_EID_EXT_CAPABILITY;
  432. buf[offs + 1] = rdev->wiphy.extended_capabilities_len;
  433. memcpy(buf + offs + 2,
  434. rdev->wiphy.extended_capabilities,
  435. rdev->wiphy.extended_capabilities_len);
  436. *out_ies = buf;
  437. *out_ies_len = ies_len + rdev->wiphy.extended_capabilities_len + 2;
  438. return 0;
  439. }
  440. static int cfg80211_sme_connect(struct wireless_dev *wdev,
  441. struct cfg80211_connect_params *connect,
  442. const u8 *prev_bssid)
  443. {
  444. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  445. struct cfg80211_bss *bss;
  446. int err;
  447. if (!rdev->ops->auth || !rdev->ops->assoc)
  448. return -EOPNOTSUPP;
  449. if (wdev->current_bss) {
  450. cfg80211_unhold_bss(wdev->current_bss);
  451. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  452. wdev->current_bss = NULL;
  453. cfg80211_sme_free(wdev);
  454. }
  455. if (WARN_ON(wdev->conn))
  456. return -EINPROGRESS;
  457. wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
  458. if (!wdev->conn)
  459. return -ENOMEM;
  460. /*
  461. * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
  462. */
  463. memcpy(&wdev->conn->params, connect, sizeof(*connect));
  464. if (connect->bssid) {
  465. wdev->conn->params.bssid = wdev->conn->bssid;
  466. memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
  467. }
  468. if (cfg80211_sme_get_conn_ies(wdev, connect->ie, connect->ie_len,
  469. &wdev->conn->ie,
  470. &wdev->conn->params.ie_len)) {
  471. kfree(wdev->conn);
  472. wdev->conn = NULL;
  473. return -ENOMEM;
  474. }
  475. wdev->conn->params.ie = wdev->conn->ie;
  476. if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
  477. wdev->conn->auto_auth = true;
  478. /* start with open system ... should mostly work */
  479. wdev->conn->params.auth_type =
  480. NL80211_AUTHTYPE_OPEN_SYSTEM;
  481. } else {
  482. wdev->conn->auto_auth = false;
  483. }
  484. wdev->conn->params.ssid = wdev->ssid;
  485. wdev->conn->params.ssid_len = wdev->ssid_len;
  486. /* see if we have the bss already */
  487. bss = cfg80211_get_conn_bss(wdev);
  488. if (prev_bssid) {
  489. memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
  490. wdev->conn->prev_bssid_valid = true;
  491. }
  492. /* we're good if we have a matching bss struct */
  493. if (bss) {
  494. enum nl80211_timeout_reason treason;
  495. err = cfg80211_conn_do_work(wdev, &treason);
  496. cfg80211_put_bss(wdev->wiphy, bss);
  497. } else {
  498. /* otherwise we'll need to scan for the AP first */
  499. err = cfg80211_conn_scan(wdev);
  500. /*
  501. * If we can't scan right now, then we need to scan again
  502. * after the current scan finished, since the parameters
  503. * changed (unless we find a good AP anyway).
  504. */
  505. if (err == -EBUSY) {
  506. err = 0;
  507. wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
  508. }
  509. }
  510. if (err)
  511. cfg80211_sme_free(wdev);
  512. return err;
  513. }
  514. static int cfg80211_sme_disconnect(struct wireless_dev *wdev, u16 reason)
  515. {
  516. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  517. int err;
  518. if (!wdev->conn)
  519. return 0;
  520. if (!rdev->ops->deauth)
  521. return -EOPNOTSUPP;
  522. if (wdev->conn->state == CFG80211_CONN_SCANNING ||
  523. wdev->conn->state == CFG80211_CONN_SCAN_AGAIN) {
  524. err = 0;
  525. goto out;
  526. }
  527. /* wdev->conn->params.bssid must be set if > SCANNING */
  528. err = cfg80211_mlme_deauth(rdev, wdev->netdev,
  529. wdev->conn->params.bssid,
  530. NULL, 0, reason, false);
  531. out:
  532. cfg80211_sme_free(wdev);
  533. return err;
  534. }
  535. /*
  536. * code shared for in-device and software SME
  537. */
  538. static bool cfg80211_is_all_idle(void)
  539. {
  540. struct cfg80211_registered_device *rdev;
  541. struct wireless_dev *wdev;
  542. bool is_all_idle = true;
  543. /*
  544. * All devices must be idle as otherwise if you are actively
  545. * scanning some new beacon hints could be learned and would
  546. * count as new regulatory hints.
  547. * Also if there is any other active beaconing interface we
  548. * need not issue a disconnect hint and reset any info such
  549. * as chan dfs state, etc.
  550. */
  551. list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
  552. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  553. wdev_lock(wdev);
  554. if (wdev->conn || wdev->current_bss ||
  555. cfg80211_beaconing_iface_active(wdev))
  556. is_all_idle = false;
  557. wdev_unlock(wdev);
  558. }
  559. }
  560. return is_all_idle;
  561. }
  562. static void disconnect_work(struct work_struct *work)
  563. {
  564. rtnl_lock();
  565. if (cfg80211_is_all_idle())
  566. regulatory_hint_disconnect();
  567. rtnl_unlock();
  568. }
  569. DECLARE_WORK(cfg80211_disconnect_work, disconnect_work);
  570. /*
  571. * API calls for drivers implementing connect/disconnect and
  572. * SME event handling
  573. */
  574. /* This method must consume bss one way or another */
  575. void __cfg80211_connect_result(struct net_device *dev,
  576. struct cfg80211_connect_resp_params *cr,
  577. bool wextev)
  578. {
  579. struct wireless_dev *wdev = dev->ieee80211_ptr;
  580. const u8 *country_ie;
  581. #ifdef CONFIG_CFG80211_WEXT
  582. union iwreq_data wrqu;
  583. #endif
  584. ASSERT_WDEV_LOCK(wdev);
  585. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  586. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)) {
  587. cfg80211_put_bss(wdev->wiphy, cr->bss);
  588. return;
  589. }
  590. nl80211_send_connect_result(wiphy_to_rdev(wdev->wiphy), dev, cr,
  591. GFP_KERNEL);
  592. #ifdef CONFIG_CFG80211_WEXT
  593. if (wextev) {
  594. if (cr->req_ie && cr->status == WLAN_STATUS_SUCCESS) {
  595. memset(&wrqu, 0, sizeof(wrqu));
  596. wrqu.data.length = cr->req_ie_len;
  597. wireless_send_event(dev, IWEVASSOCREQIE, &wrqu,
  598. cr->req_ie);
  599. }
  600. if (cr->resp_ie && cr->status == WLAN_STATUS_SUCCESS) {
  601. memset(&wrqu, 0, sizeof(wrqu));
  602. wrqu.data.length = cr->resp_ie_len;
  603. wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu,
  604. cr->resp_ie);
  605. }
  606. memset(&wrqu, 0, sizeof(wrqu));
  607. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  608. if (cr->bssid && cr->status == WLAN_STATUS_SUCCESS) {
  609. memcpy(wrqu.ap_addr.sa_data, cr->bssid, ETH_ALEN);
  610. memcpy(wdev->wext.prev_bssid, cr->bssid, ETH_ALEN);
  611. wdev->wext.prev_bssid_valid = true;
  612. }
  613. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  614. }
  615. #endif
  616. if (!cr->bss && (cr->status == WLAN_STATUS_SUCCESS)) {
  617. WARN_ON_ONCE(!wiphy_to_rdev(wdev->wiphy)->ops->connect);
  618. cr->bss = cfg80211_get_bss(wdev->wiphy, NULL, cr->bssid,
  619. wdev->ssid, wdev->ssid_len,
  620. wdev->conn_bss_type,
  621. IEEE80211_PRIVACY_ANY);
  622. if (cr->bss)
  623. cfg80211_hold_bss(bss_from_pub(cr->bss));
  624. }
  625. if (wdev->current_bss) {
  626. cfg80211_unhold_bss(wdev->current_bss);
  627. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  628. wdev->current_bss = NULL;
  629. }
  630. if (cr->status != WLAN_STATUS_SUCCESS) {
  631. kzfree(wdev->connect_keys);
  632. wdev->connect_keys = NULL;
  633. wdev->ssid_len = 0;
  634. wdev->conn_owner_nlportid = 0;
  635. if (cr->bss) {
  636. cfg80211_unhold_bss(bss_from_pub(cr->bss));
  637. cfg80211_put_bss(wdev->wiphy, cr->bss);
  638. }
  639. cfg80211_sme_free(wdev);
  640. return;
  641. }
  642. if (WARN_ON(!cr->bss))
  643. return;
  644. wdev->current_bss = bss_from_pub(cr->bss);
  645. if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))
  646. cfg80211_upload_connect_keys(wdev);
  647. rcu_read_lock();
  648. country_ie = ieee80211_bss_get_ie(cr->bss, WLAN_EID_COUNTRY);
  649. if (!country_ie) {
  650. rcu_read_unlock();
  651. return;
  652. }
  653. country_ie = kmemdup(country_ie, 2 + country_ie[1], GFP_ATOMIC);
  654. rcu_read_unlock();
  655. if (!country_ie)
  656. return;
  657. /*
  658. * ieee80211_bss_get_ie() ensures we can access:
  659. * - country_ie + 2, the start of the country ie data, and
  660. * - and country_ie[1] which is the IE length
  661. */
  662. regulatory_hint_country_ie(wdev->wiphy, cr->bss->channel->band,
  663. country_ie + 2, country_ie[1]);
  664. kfree(country_ie);
  665. }
  666. /* Consumes bss object one way or another */
  667. void cfg80211_connect_done(struct net_device *dev,
  668. struct cfg80211_connect_resp_params *params,
  669. gfp_t gfp)
  670. {
  671. struct wireless_dev *wdev = dev->ieee80211_ptr;
  672. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  673. struct cfg80211_event *ev;
  674. unsigned long flags;
  675. u8 *next;
  676. if (params->bss) {
  677. struct cfg80211_internal_bss *ibss = bss_from_pub(params->bss);
  678. if (list_empty(&ibss->list)) {
  679. struct cfg80211_bss *found = NULL, *tmp = params->bss;
  680. found = cfg80211_get_bss(wdev->wiphy, NULL,
  681. params->bss->bssid,
  682. wdev->ssid, wdev->ssid_len,
  683. wdev->conn_bss_type,
  684. IEEE80211_PRIVACY_ANY);
  685. if (found) {
  686. /* The same BSS is already updated so use it
  687. * instead, as it has latest info.
  688. */
  689. params->bss = found;
  690. } else {
  691. /* Update with BSS provided by driver, it will
  692. * be freshly added and ref cnted, we can free
  693. * the old one.
  694. *
  695. * signal_valid can be false, as we are not
  696. * expecting the BSS to be found.
  697. *
  698. * keep the old timestamp to avoid confusion
  699. */
  700. cfg80211_bss_update(rdev, ibss, false,
  701. ibss->ts);
  702. }
  703. cfg80211_put_bss(wdev->wiphy, tmp);
  704. }
  705. }
  706. ev = kzalloc(sizeof(*ev) + (params->bssid ? ETH_ALEN : 0) +
  707. params->req_ie_len + params->resp_ie_len +
  708. params->fils.kek_len + params->fils.pmk_len +
  709. (params->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
  710. if (!ev) {
  711. cfg80211_put_bss(wdev->wiphy, params->bss);
  712. return;
  713. }
  714. ev->type = EVENT_CONNECT_RESULT;
  715. next = ((u8 *)ev) + sizeof(*ev);
  716. if (params->bssid) {
  717. ev->cr.bssid = next;
  718. memcpy((void *)ev->cr.bssid, params->bssid, ETH_ALEN);
  719. next += ETH_ALEN;
  720. }
  721. if (params->req_ie_len) {
  722. ev->cr.req_ie = next;
  723. ev->cr.req_ie_len = params->req_ie_len;
  724. memcpy((void *)ev->cr.req_ie, params->req_ie,
  725. params->req_ie_len);
  726. next += params->req_ie_len;
  727. }
  728. if (params->resp_ie_len) {
  729. ev->cr.resp_ie = next;
  730. ev->cr.resp_ie_len = params->resp_ie_len;
  731. memcpy((void *)ev->cr.resp_ie, params->resp_ie,
  732. params->resp_ie_len);
  733. next += params->resp_ie_len;
  734. }
  735. if (params->fils.kek_len) {
  736. ev->cr.fils.kek = next;
  737. ev->cr.fils.kek_len = params->fils.kek_len;
  738. memcpy((void *)ev->cr.fils.kek, params->fils.kek,
  739. params->fils.kek_len);
  740. next += params->fils.kek_len;
  741. }
  742. if (params->fils.pmk_len) {
  743. ev->cr.fils.pmk = next;
  744. ev->cr.fils.pmk_len = params->fils.pmk_len;
  745. memcpy((void *)ev->cr.fils.pmk, params->fils.pmk,
  746. params->fils.pmk_len);
  747. next += params->fils.pmk_len;
  748. }
  749. if (params->fils.pmkid) {
  750. ev->cr.fils.pmkid = next;
  751. memcpy((void *)ev->cr.fils.pmkid, params->fils.pmkid,
  752. WLAN_PMKID_LEN);
  753. next += WLAN_PMKID_LEN;
  754. }
  755. ev->cr.fils.update_erp_next_seq_num = params->fils.update_erp_next_seq_num;
  756. if (params->fils.update_erp_next_seq_num)
  757. ev->cr.fils.erp_next_seq_num = params->fils.erp_next_seq_num;
  758. if (params->bss)
  759. cfg80211_hold_bss(bss_from_pub(params->bss));
  760. ev->cr.bss = params->bss;
  761. ev->cr.status = params->status;
  762. ev->cr.timeout_reason = params->timeout_reason;
  763. spin_lock_irqsave(&wdev->event_lock, flags);
  764. list_add_tail(&ev->list, &wdev->event_list);
  765. spin_unlock_irqrestore(&wdev->event_lock, flags);
  766. queue_work(cfg80211_wq, &rdev->event_work);
  767. }
  768. EXPORT_SYMBOL(cfg80211_connect_done);
  769. /* Consumes bss object one way or another */
  770. void __cfg80211_roamed(struct wireless_dev *wdev,
  771. struct cfg80211_roam_info *info)
  772. {
  773. #ifdef CONFIG_CFG80211_WEXT
  774. union iwreq_data wrqu;
  775. #endif
  776. ASSERT_WDEV_LOCK(wdev);
  777. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  778. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  779. goto out;
  780. if (WARN_ON(!wdev->current_bss))
  781. goto out;
  782. cfg80211_unhold_bss(wdev->current_bss);
  783. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  784. wdev->current_bss = NULL;
  785. if (WARN_ON(!info->bss))
  786. return;
  787. cfg80211_hold_bss(bss_from_pub(info->bss));
  788. wdev->current_bss = bss_from_pub(info->bss);
  789. nl80211_send_roamed(wiphy_to_rdev(wdev->wiphy),
  790. wdev->netdev, info, GFP_KERNEL);
  791. #ifdef CONFIG_CFG80211_WEXT
  792. if (info->req_ie) {
  793. memset(&wrqu, 0, sizeof(wrqu));
  794. wrqu.data.length = info->req_ie_len;
  795. wireless_send_event(wdev->netdev, IWEVASSOCREQIE,
  796. &wrqu, info->req_ie);
  797. }
  798. if (info->resp_ie) {
  799. memset(&wrqu, 0, sizeof(wrqu));
  800. wrqu.data.length = info->resp_ie_len;
  801. wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
  802. &wrqu, info->resp_ie);
  803. }
  804. memset(&wrqu, 0, sizeof(wrqu));
  805. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  806. memcpy(wrqu.ap_addr.sa_data, info->bss->bssid, ETH_ALEN);
  807. memcpy(wdev->wext.prev_bssid, info->bss->bssid, ETH_ALEN);
  808. wdev->wext.prev_bssid_valid = true;
  809. wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
  810. #endif
  811. return;
  812. out:
  813. cfg80211_put_bss(wdev->wiphy, info->bss);
  814. }
  815. /* Consumes info->bss object one way or another */
  816. void cfg80211_roamed(struct net_device *dev, struct cfg80211_roam_info *info,
  817. gfp_t gfp)
  818. {
  819. struct wireless_dev *wdev = dev->ieee80211_ptr;
  820. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  821. struct cfg80211_event *ev;
  822. unsigned long flags;
  823. u8 *next;
  824. if (!info->bss) {
  825. info->bss = cfg80211_get_bss(wdev->wiphy, info->channel,
  826. info->bssid, wdev->ssid,
  827. wdev->ssid_len,
  828. wdev->conn_bss_type,
  829. IEEE80211_PRIVACY_ANY);
  830. }
  831. if (WARN_ON(!info->bss))
  832. return;
  833. ev = kzalloc(sizeof(*ev) + info->req_ie_len + info->resp_ie_len +
  834. info->fils.kek_len + info->fils.pmk_len +
  835. (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
  836. if (!ev) {
  837. cfg80211_put_bss(wdev->wiphy, info->bss);
  838. return;
  839. }
  840. ev->type = EVENT_ROAMED;
  841. next = ((u8 *)ev) + sizeof(*ev);
  842. if (info->req_ie_len) {
  843. ev->rm.req_ie = next;
  844. ev->rm.req_ie_len = info->req_ie_len;
  845. memcpy((void *)ev->rm.req_ie, info->req_ie, info->req_ie_len);
  846. next += info->req_ie_len;
  847. }
  848. if (info->resp_ie_len) {
  849. ev->rm.resp_ie = next;
  850. ev->rm.resp_ie_len = info->resp_ie_len;
  851. memcpy((void *)ev->rm.resp_ie, info->resp_ie,
  852. info->resp_ie_len);
  853. next += info->resp_ie_len;
  854. }
  855. if (info->fils.kek_len) {
  856. ev->rm.fils.kek = next;
  857. ev->rm.fils.kek_len = info->fils.kek_len;
  858. memcpy((void *)ev->rm.fils.kek, info->fils.kek,
  859. info->fils.kek_len);
  860. next += info->fils.kek_len;
  861. }
  862. if (info->fils.pmk_len) {
  863. ev->rm.fils.pmk = next;
  864. ev->rm.fils.pmk_len = info->fils.pmk_len;
  865. memcpy((void *)ev->rm.fils.pmk, info->fils.pmk,
  866. info->fils.pmk_len);
  867. next += info->fils.pmk_len;
  868. }
  869. if (info->fils.pmkid) {
  870. ev->rm.fils.pmkid = next;
  871. memcpy((void *)ev->rm.fils.pmkid, info->fils.pmkid,
  872. WLAN_PMKID_LEN);
  873. next += WLAN_PMKID_LEN;
  874. }
  875. ev->rm.fils.update_erp_next_seq_num = info->fils.update_erp_next_seq_num;
  876. if (info->fils.update_erp_next_seq_num)
  877. ev->rm.fils.erp_next_seq_num = info->fils.erp_next_seq_num;
  878. ev->rm.bss = info->bss;
  879. spin_lock_irqsave(&wdev->event_lock, flags);
  880. list_add_tail(&ev->list, &wdev->event_list);
  881. spin_unlock_irqrestore(&wdev->event_lock, flags);
  882. queue_work(cfg80211_wq, &rdev->event_work);
  883. }
  884. EXPORT_SYMBOL(cfg80211_roamed);
  885. void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid)
  886. {
  887. ASSERT_WDEV_LOCK(wdev);
  888. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
  889. return;
  890. if (WARN_ON(!wdev->current_bss) ||
  891. WARN_ON(!ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))
  892. return;
  893. nl80211_send_port_authorized(wiphy_to_rdev(wdev->wiphy), wdev->netdev,
  894. bssid);
  895. }
  896. void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
  897. gfp_t gfp)
  898. {
  899. struct wireless_dev *wdev = dev->ieee80211_ptr;
  900. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  901. struct cfg80211_event *ev;
  902. unsigned long flags;
  903. if (WARN_ON(!bssid))
  904. return;
  905. ev = kzalloc(sizeof(*ev), gfp);
  906. if (!ev)
  907. return;
  908. ev->type = EVENT_PORT_AUTHORIZED;
  909. memcpy(ev->pa.bssid, bssid, ETH_ALEN);
  910. /*
  911. * Use the wdev event list so that if there are pending
  912. * connected/roamed events, they will be reported first.
  913. */
  914. spin_lock_irqsave(&wdev->event_lock, flags);
  915. list_add_tail(&ev->list, &wdev->event_list);
  916. spin_unlock_irqrestore(&wdev->event_lock, flags);
  917. queue_work(cfg80211_wq, &rdev->event_work);
  918. }
  919. EXPORT_SYMBOL(cfg80211_port_authorized);
  920. void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
  921. size_t ie_len, u16 reason, bool from_ap)
  922. {
  923. struct wireless_dev *wdev = dev->ieee80211_ptr;
  924. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  925. int i;
  926. #ifdef CONFIG_CFG80211_WEXT
  927. union iwreq_data wrqu;
  928. #endif
  929. ASSERT_WDEV_LOCK(wdev);
  930. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  931. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  932. return;
  933. if (wdev->current_bss) {
  934. cfg80211_unhold_bss(wdev->current_bss);
  935. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  936. }
  937. wdev->current_bss = NULL;
  938. wdev->ssid_len = 0;
  939. wdev->conn_owner_nlportid = 0;
  940. kzfree(wdev->connect_keys);
  941. wdev->connect_keys = NULL;
  942. nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
  943. /* stop critical protocol if supported */
  944. if (rdev->ops->crit_proto_stop && rdev->crit_proto_nlportid) {
  945. rdev->crit_proto_nlportid = 0;
  946. rdev_crit_proto_stop(rdev, wdev);
  947. }
  948. /*
  949. * Delete all the keys ... pairwise keys can't really
  950. * exist any more anyway, but default keys might.
  951. */
  952. if (rdev->ops->del_key) {
  953. int max_key_idx = 5;
  954. if (wiphy_ext_feature_isset(
  955. wdev->wiphy,
  956. NL80211_EXT_FEATURE_BEACON_PROTECTION))
  957. max_key_idx = 7;
  958. for (i = 0; i <= max_key_idx; i++)
  959. rdev_del_key(rdev, dev, i, false, NULL);
  960. }
  961. rdev_set_qos_map(rdev, dev, NULL);
  962. #ifdef CONFIG_CFG80211_WEXT
  963. memset(&wrqu, 0, sizeof(wrqu));
  964. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  965. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  966. wdev->wext.connect.ssid_len = 0;
  967. #endif
  968. schedule_work(&cfg80211_disconnect_work);
  969. }
  970. void cfg80211_disconnected(struct net_device *dev, u16 reason,
  971. const u8 *ie, size_t ie_len,
  972. bool locally_generated, gfp_t gfp)
  973. {
  974. struct wireless_dev *wdev = dev->ieee80211_ptr;
  975. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  976. struct cfg80211_event *ev;
  977. unsigned long flags;
  978. ev = kzalloc(sizeof(*ev) + ie_len, gfp);
  979. if (!ev)
  980. return;
  981. ev->type = EVENT_DISCONNECTED;
  982. ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
  983. ev->dc.ie_len = ie_len;
  984. memcpy((void *)ev->dc.ie, ie, ie_len);
  985. ev->dc.reason = reason;
  986. ev->dc.locally_generated = locally_generated;
  987. spin_lock_irqsave(&wdev->event_lock, flags);
  988. list_add_tail(&ev->list, &wdev->event_list);
  989. spin_unlock_irqrestore(&wdev->event_lock, flags);
  990. queue_work(cfg80211_wq, &rdev->event_work);
  991. }
  992. EXPORT_SYMBOL(cfg80211_disconnected);
  993. /*
  994. * API calls for nl80211/wext compatibility code
  995. */
  996. int cfg80211_connect(struct cfg80211_registered_device *rdev,
  997. struct net_device *dev,
  998. struct cfg80211_connect_params *connect,
  999. struct cfg80211_cached_keys *connkeys,
  1000. const u8 *prev_bssid)
  1001. {
  1002. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1003. int err;
  1004. ASSERT_WDEV_LOCK(wdev);
  1005. /*
  1006. * If we have an ssid_len, we're trying to connect or are
  1007. * already connected, so reject a new SSID unless it's the
  1008. * same (which is the case for re-association.)
  1009. */
  1010. if (wdev->ssid_len &&
  1011. (wdev->ssid_len != connect->ssid_len ||
  1012. memcmp(wdev->ssid, connect->ssid, wdev->ssid_len)))
  1013. return -EALREADY;
  1014. /*
  1015. * If connected, reject (re-)association unless prev_bssid
  1016. * matches the current BSSID.
  1017. */
  1018. if (wdev->current_bss) {
  1019. if (!prev_bssid)
  1020. return -EALREADY;
  1021. if (!ether_addr_equal(prev_bssid, wdev->current_bss->pub.bssid))
  1022. return -ENOTCONN;
  1023. }
  1024. /*
  1025. * Reject if we're in the process of connecting with WEP,
  1026. * this case isn't very interesting and trying to handle
  1027. * it would make the code much more complex.
  1028. */
  1029. if (wdev->connect_keys)
  1030. return -EINPROGRESS;
  1031. cfg80211_oper_and_ht_capa(&connect->ht_capa_mask,
  1032. rdev->wiphy.ht_capa_mod_mask);
  1033. cfg80211_oper_and_vht_capa(&connect->vht_capa_mask,
  1034. rdev->wiphy.vht_capa_mod_mask);
  1035. if (connkeys && connkeys->def >= 0) {
  1036. int idx;
  1037. u32 cipher;
  1038. idx = connkeys->def;
  1039. cipher = connkeys->params[idx].cipher;
  1040. /* If given a WEP key we may need it for shared key auth */
  1041. if (cipher == WLAN_CIPHER_SUITE_WEP40 ||
  1042. cipher == WLAN_CIPHER_SUITE_WEP104) {
  1043. connect->key_idx = idx;
  1044. connect->key = connkeys->params[idx].key;
  1045. connect->key_len = connkeys->params[idx].key_len;
  1046. /*
  1047. * If ciphers are not set (e.g. when going through
  1048. * iwconfig), we have to set them appropriately here.
  1049. */
  1050. if (connect->crypto.cipher_group == 0)
  1051. connect->crypto.cipher_group = cipher;
  1052. if (connect->crypto.n_ciphers_pairwise == 0) {
  1053. connect->crypto.n_ciphers_pairwise = 1;
  1054. connect->crypto.ciphers_pairwise[0] = cipher;
  1055. }
  1056. }
  1057. connect->crypto.wep_keys = connkeys->params;
  1058. connect->crypto.wep_tx_key = connkeys->def;
  1059. } else {
  1060. if (WARN_ON(connkeys))
  1061. return -EINVAL;
  1062. }
  1063. wdev->connect_keys = connkeys;
  1064. memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
  1065. wdev->ssid_len = connect->ssid_len;
  1066. wdev->conn_bss_type = connect->pbss ? IEEE80211_BSS_TYPE_PBSS :
  1067. IEEE80211_BSS_TYPE_ESS;
  1068. if (!rdev->ops->connect)
  1069. err = cfg80211_sme_connect(wdev, connect, prev_bssid);
  1070. else
  1071. err = rdev_connect(rdev, dev, connect);
  1072. if (err) {
  1073. wdev->connect_keys = NULL;
  1074. /*
  1075. * This could be reassoc getting refused, don't clear
  1076. * ssid_len in that case.
  1077. */
  1078. if (!wdev->current_bss)
  1079. wdev->ssid_len = 0;
  1080. return err;
  1081. }
  1082. return 0;
  1083. }
  1084. int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
  1085. struct net_device *dev, u16 reason, bool wextev)
  1086. {
  1087. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1088. int err = 0;
  1089. ASSERT_WDEV_LOCK(wdev);
  1090. kzfree(wdev->connect_keys);
  1091. wdev->connect_keys = NULL;
  1092. wdev->conn_owner_nlportid = 0;
  1093. if (wdev->conn)
  1094. err = cfg80211_sme_disconnect(wdev, reason);
  1095. else if (!rdev->ops->disconnect)
  1096. cfg80211_mlme_down(rdev, dev);
  1097. else if (wdev->ssid_len)
  1098. err = rdev_disconnect(rdev, dev, reason);
  1099. /*
  1100. * Clear ssid_len unless we actually were fully connected,
  1101. * in which case cfg80211_disconnected() will take care of
  1102. * this later.
  1103. */
  1104. if (!wdev->current_bss)
  1105. wdev->ssid_len = 0;
  1106. return err;
  1107. }
  1108. /*
  1109. * Used to clean up after the connection / connection attempt owner socket
  1110. * disconnects
  1111. */
  1112. void cfg80211_autodisconnect_wk(struct work_struct *work)
  1113. {
  1114. struct wireless_dev *wdev =
  1115. container_of(work, struct wireless_dev, disconnect_wk);
  1116. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  1117. wdev_lock(wdev);
  1118. if (wdev->conn_owner_nlportid) {
  1119. switch (wdev->iftype) {
  1120. case NL80211_IFTYPE_ADHOC:
  1121. __cfg80211_leave_ibss(rdev, wdev->netdev, false);
  1122. break;
  1123. case NL80211_IFTYPE_AP:
  1124. case NL80211_IFTYPE_P2P_GO:
  1125. __cfg80211_stop_ap(rdev, wdev->netdev, false);
  1126. break;
  1127. case NL80211_IFTYPE_MESH_POINT:
  1128. __cfg80211_leave_mesh(rdev, wdev->netdev);
  1129. break;
  1130. case NL80211_IFTYPE_STATION:
  1131. case NL80211_IFTYPE_P2P_CLIENT:
  1132. /*
  1133. * Use disconnect_bssid if still connecting and
  1134. * ops->disconnect not implemented. Otherwise we can
  1135. * use cfg80211_disconnect.
  1136. */
  1137. if (rdev->ops->disconnect || wdev->current_bss)
  1138. cfg80211_disconnect(rdev, wdev->netdev,
  1139. WLAN_REASON_DEAUTH_LEAVING,
  1140. true);
  1141. else
  1142. cfg80211_mlme_deauth(rdev, wdev->netdev,
  1143. wdev->disconnect_bssid,
  1144. NULL, 0,
  1145. WLAN_REASON_DEAUTH_LEAVING,
  1146. false);
  1147. break;
  1148. default:
  1149. break;
  1150. }
  1151. }
  1152. wdev_unlock(wdev);
  1153. }