sme.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973
  1. /*
  2. * SME code for cfg80211
  3. * both driver SME event handling and the SME implementation
  4. * (for nl80211's connect() and wext)
  5. *
  6. * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
  7. * Copyright (C) 2009 Intel Corporation. All rights reserved.
  8. */
  9. #include <linux/etherdevice.h>
  10. #include <linux/if_arp.h>
  11. #include <linux/slab.h>
  12. #include <linux/workqueue.h>
  13. #include <linux/wireless.h>
  14. #include <linux/export.h>
  15. #include <net/iw_handler.h>
  16. #include <net/cfg80211.h>
  17. #include <net/rtnetlink.h>
  18. #include "nl80211.h"
  19. #include "reg.h"
  20. #include "rdev-ops.h"
  21. /*
  22. * Software SME in cfg80211, using auth/assoc/deauth calls to the
  23. * driver. This is is for implementing nl80211's connect/disconnect
  24. * and wireless extensions (if configured.)
  25. */
  26. struct cfg80211_conn {
  27. struct cfg80211_connect_params params;
  28. /* these are sub-states of the _CONNECTING sme_state */
  29. enum {
  30. CFG80211_CONN_SCANNING,
  31. CFG80211_CONN_SCAN_AGAIN,
  32. CFG80211_CONN_AUTHENTICATE_NEXT,
  33. CFG80211_CONN_AUTHENTICATING,
  34. CFG80211_CONN_ASSOCIATE_NEXT,
  35. CFG80211_CONN_ASSOCIATING,
  36. CFG80211_CONN_DEAUTH,
  37. CFG80211_CONN_CONNECTED,
  38. } state;
  39. u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
  40. u8 *ie;
  41. size_t ie_len;
  42. bool auto_auth, prev_bssid_valid;
  43. };
  44. static void cfg80211_sme_free(struct wireless_dev *wdev)
  45. {
  46. if (!wdev->conn)
  47. return;
  48. kfree(wdev->conn->ie);
  49. kfree(wdev->conn);
  50. wdev->conn = NULL;
  51. }
  52. static int cfg80211_conn_scan(struct wireless_dev *wdev)
  53. {
  54. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  55. struct cfg80211_scan_request *request;
  56. int n_channels, err;
  57. ASSERT_RTNL();
  58. ASSERT_RDEV_LOCK(rdev);
  59. ASSERT_WDEV_LOCK(wdev);
  60. if (rdev->scan_req)
  61. return -EBUSY;
  62. if (wdev->conn->params.channel) {
  63. n_channels = 1;
  64. } else {
  65. enum ieee80211_band band;
  66. n_channels = 0;
  67. for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
  68. if (!wdev->wiphy->bands[band])
  69. continue;
  70. n_channels += wdev->wiphy->bands[band]->n_channels;
  71. }
  72. }
  73. request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
  74. sizeof(request->channels[0]) * n_channels,
  75. GFP_KERNEL);
  76. if (!request)
  77. return -ENOMEM;
  78. if (wdev->conn->params.channel)
  79. request->channels[0] = wdev->conn->params.channel;
  80. else {
  81. int i = 0, j;
  82. enum ieee80211_band band;
  83. struct ieee80211_supported_band *bands;
  84. struct ieee80211_channel *channel;
  85. for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
  86. bands = wdev->wiphy->bands[band];
  87. if (!bands)
  88. continue;
  89. for (j = 0; j < bands->n_channels; j++) {
  90. channel = &bands->channels[j];
  91. if (channel->flags & IEEE80211_CHAN_DISABLED)
  92. continue;
  93. request->channels[i++] = channel;
  94. }
  95. request->rates[band] = (1 << bands->n_bitrates) - 1;
  96. }
  97. n_channels = i;
  98. }
  99. request->n_channels = n_channels;
  100. request->ssids = (void *)&request->channels[n_channels];
  101. request->n_ssids = 1;
  102. memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
  103. wdev->conn->params.ssid_len);
  104. request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
  105. request->wdev = wdev;
  106. request->wiphy = &rdev->wiphy;
  107. request->scan_start = jiffies;
  108. rdev->scan_req = request;
  109. err = rdev_scan(rdev, request);
  110. if (!err) {
  111. wdev->conn->state = CFG80211_CONN_SCANNING;
  112. nl80211_send_scan_start(rdev, wdev);
  113. dev_hold(wdev->netdev);
  114. } else {
  115. rdev->scan_req = NULL;
  116. kfree(request);
  117. }
  118. return err;
  119. }
  120. static int cfg80211_conn_do_work(struct wireless_dev *wdev)
  121. {
  122. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  123. struct cfg80211_connect_params *params;
  124. struct cfg80211_assoc_request req = {};
  125. int err;
  126. ASSERT_WDEV_LOCK(wdev);
  127. if (!wdev->conn)
  128. return 0;
  129. params = &wdev->conn->params;
  130. switch (wdev->conn->state) {
  131. case CFG80211_CONN_SCANNING:
  132. /* didn't find it during scan ... */
  133. return -ENOENT;
  134. case CFG80211_CONN_SCAN_AGAIN:
  135. return cfg80211_conn_scan(wdev);
  136. case CFG80211_CONN_AUTHENTICATE_NEXT:
  137. BUG_ON(!rdev->ops->auth);
  138. wdev->conn->state = CFG80211_CONN_AUTHENTICATING;
  139. return cfg80211_mlme_auth(rdev, wdev->netdev,
  140. params->channel, params->auth_type,
  141. params->bssid,
  142. params->ssid, params->ssid_len,
  143. NULL, 0,
  144. params->key, params->key_len,
  145. params->key_idx, NULL, 0);
  146. case CFG80211_CONN_ASSOCIATE_NEXT:
  147. BUG_ON(!rdev->ops->assoc);
  148. wdev->conn->state = CFG80211_CONN_ASSOCIATING;
  149. if (wdev->conn->prev_bssid_valid)
  150. req.prev_bssid = wdev->conn->prev_bssid;
  151. req.ie = params->ie;
  152. req.ie_len = params->ie_len;
  153. req.use_mfp = params->mfp != NL80211_MFP_NO;
  154. req.crypto = params->crypto;
  155. req.flags = params->flags;
  156. req.ht_capa = params->ht_capa;
  157. req.ht_capa_mask = params->ht_capa_mask;
  158. req.vht_capa = params->vht_capa;
  159. req.vht_capa_mask = params->vht_capa_mask;
  160. err = cfg80211_mlme_assoc(rdev, wdev->netdev, params->channel,
  161. params->bssid, params->ssid,
  162. params->ssid_len, &req);
  163. if (err)
  164. cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
  165. NULL, 0,
  166. WLAN_REASON_DEAUTH_LEAVING,
  167. false);
  168. return err;
  169. case CFG80211_CONN_DEAUTH:
  170. cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
  171. NULL, 0,
  172. WLAN_REASON_DEAUTH_LEAVING, false);
  173. return 0;
  174. default:
  175. return 0;
  176. }
  177. }
  178. void cfg80211_conn_work(struct work_struct *work)
  179. {
  180. struct cfg80211_registered_device *rdev =
  181. container_of(work, struct cfg80211_registered_device, conn_work);
  182. struct wireless_dev *wdev;
  183. u8 bssid_buf[ETH_ALEN], *bssid = NULL;
  184. rtnl_lock();
  185. list_for_each_entry(wdev, &rdev->wdev_list, list) {
  186. if (!wdev->netdev)
  187. continue;
  188. wdev_lock(wdev);
  189. if (!netif_running(wdev->netdev)) {
  190. wdev_unlock(wdev);
  191. continue;
  192. }
  193. if (!wdev->conn ||
  194. wdev->conn->state == CFG80211_CONN_CONNECTED) {
  195. wdev_unlock(wdev);
  196. continue;
  197. }
  198. if (wdev->conn->params.bssid) {
  199. memcpy(bssid_buf, wdev->conn->params.bssid, ETH_ALEN);
  200. bssid = bssid_buf;
  201. }
  202. if (cfg80211_conn_do_work(wdev)) {
  203. __cfg80211_connect_result(
  204. wdev->netdev, bssid,
  205. NULL, 0, NULL, 0,
  206. WLAN_STATUS_UNSPECIFIED_FAILURE,
  207. false, NULL);
  208. cfg80211_sme_free(wdev);
  209. }
  210. wdev_unlock(wdev);
  211. }
  212. rtnl_unlock();
  213. }
  214. /* Returned bss is reference counted and must be cleaned up appropriately. */
  215. static struct cfg80211_bss *cfg80211_get_conn_bss(struct wireless_dev *wdev)
  216. {
  217. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  218. struct cfg80211_bss *bss;
  219. u16 capa = WLAN_CAPABILITY_ESS;
  220. ASSERT_WDEV_LOCK(wdev);
  221. if (wdev->conn->params.privacy)
  222. capa |= WLAN_CAPABILITY_PRIVACY;
  223. bss = cfg80211_get_bss(wdev->wiphy, wdev->conn->params.channel,
  224. wdev->conn->params.bssid,
  225. wdev->conn->params.ssid,
  226. wdev->conn->params.ssid_len,
  227. WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_PRIVACY,
  228. capa);
  229. if (!bss)
  230. return NULL;
  231. memcpy(wdev->conn->bssid, bss->bssid, ETH_ALEN);
  232. wdev->conn->params.bssid = wdev->conn->bssid;
  233. wdev->conn->params.channel = bss->channel;
  234. wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
  235. schedule_work(&rdev->conn_work);
  236. return bss;
  237. }
  238. static void __cfg80211_sme_scan_done(struct net_device *dev)
  239. {
  240. struct wireless_dev *wdev = dev->ieee80211_ptr;
  241. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  242. struct cfg80211_bss *bss;
  243. ASSERT_WDEV_LOCK(wdev);
  244. if (!wdev->conn)
  245. return;
  246. if (wdev->conn->state != CFG80211_CONN_SCANNING &&
  247. wdev->conn->state != CFG80211_CONN_SCAN_AGAIN)
  248. return;
  249. bss = cfg80211_get_conn_bss(wdev);
  250. if (bss)
  251. cfg80211_put_bss(&rdev->wiphy, bss);
  252. else
  253. schedule_work(&rdev->conn_work);
  254. }
  255. void cfg80211_sme_scan_done(struct net_device *dev)
  256. {
  257. struct wireless_dev *wdev = dev->ieee80211_ptr;
  258. wdev_lock(wdev);
  259. __cfg80211_sme_scan_done(dev);
  260. wdev_unlock(wdev);
  261. }
  262. void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len)
  263. {
  264. struct wiphy *wiphy = wdev->wiphy;
  265. struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
  266. struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
  267. u16 status_code = le16_to_cpu(mgmt->u.auth.status_code);
  268. ASSERT_WDEV_LOCK(wdev);
  269. if (!wdev->conn || wdev->conn->state == CFG80211_CONN_CONNECTED)
  270. return;
  271. if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
  272. wdev->conn->auto_auth &&
  273. wdev->conn->params.auth_type != NL80211_AUTHTYPE_NETWORK_EAP) {
  274. /* select automatically between only open, shared, leap */
  275. switch (wdev->conn->params.auth_type) {
  276. case NL80211_AUTHTYPE_OPEN_SYSTEM:
  277. if (wdev->connect_keys)
  278. wdev->conn->params.auth_type =
  279. NL80211_AUTHTYPE_SHARED_KEY;
  280. else
  281. wdev->conn->params.auth_type =
  282. NL80211_AUTHTYPE_NETWORK_EAP;
  283. break;
  284. case NL80211_AUTHTYPE_SHARED_KEY:
  285. wdev->conn->params.auth_type =
  286. NL80211_AUTHTYPE_NETWORK_EAP;
  287. break;
  288. default:
  289. /* huh? */
  290. wdev->conn->params.auth_type =
  291. NL80211_AUTHTYPE_OPEN_SYSTEM;
  292. break;
  293. }
  294. wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
  295. schedule_work(&rdev->conn_work);
  296. } else if (status_code != WLAN_STATUS_SUCCESS) {
  297. __cfg80211_connect_result(wdev->netdev, mgmt->bssid,
  298. NULL, 0, NULL, 0,
  299. status_code, false, NULL);
  300. } else if (wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
  301. wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
  302. schedule_work(&rdev->conn_work);
  303. }
  304. }
  305. bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status)
  306. {
  307. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  308. if (!wdev->conn)
  309. return false;
  310. if (status == WLAN_STATUS_SUCCESS) {
  311. wdev->conn->state = CFG80211_CONN_CONNECTED;
  312. return false;
  313. }
  314. if (wdev->conn->prev_bssid_valid) {
  315. /*
  316. * Some stupid APs don't accept reassoc, so we
  317. * need to fall back to trying regular assoc;
  318. * return true so no event is sent to userspace.
  319. */
  320. wdev->conn->prev_bssid_valid = false;
  321. wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
  322. schedule_work(&rdev->conn_work);
  323. return true;
  324. }
  325. wdev->conn->state = CFG80211_CONN_DEAUTH;
  326. schedule_work(&rdev->conn_work);
  327. return false;
  328. }
  329. void cfg80211_sme_deauth(struct wireless_dev *wdev)
  330. {
  331. cfg80211_sme_free(wdev);
  332. }
  333. void cfg80211_sme_auth_timeout(struct wireless_dev *wdev)
  334. {
  335. cfg80211_sme_free(wdev);
  336. }
  337. void cfg80211_sme_disassoc(struct wireless_dev *wdev)
  338. {
  339. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  340. if (!wdev->conn)
  341. return;
  342. wdev->conn->state = CFG80211_CONN_DEAUTH;
  343. schedule_work(&rdev->conn_work);
  344. }
  345. void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev)
  346. {
  347. cfg80211_sme_disassoc(wdev);
  348. }
  349. static int cfg80211_sme_connect(struct wireless_dev *wdev,
  350. struct cfg80211_connect_params *connect,
  351. const u8 *prev_bssid)
  352. {
  353. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  354. struct cfg80211_bss *bss;
  355. int err;
  356. if (!rdev->ops->auth || !rdev->ops->assoc)
  357. return -EOPNOTSUPP;
  358. if (wdev->current_bss)
  359. return -EALREADY;
  360. if (WARN_ON(wdev->conn))
  361. return -EINPROGRESS;
  362. wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
  363. if (!wdev->conn)
  364. return -ENOMEM;
  365. /*
  366. * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
  367. */
  368. memcpy(&wdev->conn->params, connect, sizeof(*connect));
  369. if (connect->bssid) {
  370. wdev->conn->params.bssid = wdev->conn->bssid;
  371. memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
  372. }
  373. if (connect->ie) {
  374. wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
  375. GFP_KERNEL);
  376. wdev->conn->params.ie = wdev->conn->ie;
  377. if (!wdev->conn->ie) {
  378. kfree(wdev->conn);
  379. wdev->conn = NULL;
  380. return -ENOMEM;
  381. }
  382. }
  383. if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
  384. wdev->conn->auto_auth = true;
  385. /* start with open system ... should mostly work */
  386. wdev->conn->params.auth_type =
  387. NL80211_AUTHTYPE_OPEN_SYSTEM;
  388. } else {
  389. wdev->conn->auto_auth = false;
  390. }
  391. wdev->conn->params.ssid = wdev->ssid;
  392. wdev->conn->params.ssid_len = connect->ssid_len;
  393. /* see if we have the bss already */
  394. bss = cfg80211_get_conn_bss(wdev);
  395. if (prev_bssid) {
  396. memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
  397. wdev->conn->prev_bssid_valid = true;
  398. }
  399. /* we're good if we have a matching bss struct */
  400. if (bss) {
  401. wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
  402. err = cfg80211_conn_do_work(wdev);
  403. cfg80211_put_bss(wdev->wiphy, bss);
  404. } else {
  405. /* otherwise we'll need to scan for the AP first */
  406. err = cfg80211_conn_scan(wdev);
  407. /*
  408. * If we can't scan right now, then we need to scan again
  409. * after the current scan finished, since the parameters
  410. * changed (unless we find a good AP anyway).
  411. */
  412. if (err == -EBUSY) {
  413. err = 0;
  414. wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
  415. }
  416. }
  417. if (err)
  418. cfg80211_sme_free(wdev);
  419. return err;
  420. }
  421. static int cfg80211_sme_disconnect(struct wireless_dev *wdev, u16 reason)
  422. {
  423. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  424. int err;
  425. if (!wdev->conn)
  426. return 0;
  427. if (!rdev->ops->deauth)
  428. return -EOPNOTSUPP;
  429. if (wdev->conn->state == CFG80211_CONN_SCANNING ||
  430. wdev->conn->state == CFG80211_CONN_SCAN_AGAIN) {
  431. err = 0;
  432. goto out;
  433. }
  434. /* wdev->conn->params.bssid must be set if > SCANNING */
  435. err = cfg80211_mlme_deauth(rdev, wdev->netdev,
  436. wdev->conn->params.bssid,
  437. NULL, 0, reason, false);
  438. out:
  439. cfg80211_sme_free(wdev);
  440. return err;
  441. }
  442. /*
  443. * code shared for in-device and software SME
  444. */
  445. static bool cfg80211_is_all_idle(void)
  446. {
  447. struct cfg80211_registered_device *rdev;
  448. struct wireless_dev *wdev;
  449. bool is_all_idle = true;
  450. /*
  451. * All devices must be idle as otherwise if you are actively
  452. * scanning some new beacon hints could be learned and would
  453. * count as new regulatory hints.
  454. */
  455. list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
  456. list_for_each_entry(wdev, &rdev->wdev_list, list) {
  457. wdev_lock(wdev);
  458. if (wdev->conn || wdev->current_bss)
  459. is_all_idle = false;
  460. wdev_unlock(wdev);
  461. }
  462. }
  463. return is_all_idle;
  464. }
  465. static void disconnect_work(struct work_struct *work)
  466. {
  467. rtnl_lock();
  468. if (cfg80211_is_all_idle())
  469. regulatory_hint_disconnect();
  470. rtnl_unlock();
  471. }
  472. static DECLARE_WORK(cfg80211_disconnect_work, disconnect_work);
  473. /*
  474. * API calls for drivers implementing connect/disconnect and
  475. * SME event handling
  476. */
  477. /* This method must consume bss one way or another */
  478. void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
  479. const u8 *req_ie, size_t req_ie_len,
  480. const u8 *resp_ie, size_t resp_ie_len,
  481. u16 status, bool wextev,
  482. struct cfg80211_bss *bss)
  483. {
  484. struct wireless_dev *wdev = dev->ieee80211_ptr;
  485. const u8 *country_ie;
  486. #ifdef CONFIG_CFG80211_WEXT
  487. union iwreq_data wrqu;
  488. #endif
  489. ASSERT_WDEV_LOCK(wdev);
  490. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  491. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)) {
  492. cfg80211_put_bss(wdev->wiphy, bss);
  493. return;
  494. }
  495. nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev,
  496. bssid, req_ie, req_ie_len,
  497. resp_ie, resp_ie_len,
  498. status, GFP_KERNEL);
  499. #ifdef CONFIG_CFG80211_WEXT
  500. if (wextev) {
  501. if (req_ie && status == WLAN_STATUS_SUCCESS) {
  502. memset(&wrqu, 0, sizeof(wrqu));
  503. wrqu.data.length = req_ie_len;
  504. wireless_send_event(dev, IWEVASSOCREQIE, &wrqu, req_ie);
  505. }
  506. if (resp_ie && status == WLAN_STATUS_SUCCESS) {
  507. memset(&wrqu, 0, sizeof(wrqu));
  508. wrqu.data.length = resp_ie_len;
  509. wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
  510. }
  511. memset(&wrqu, 0, sizeof(wrqu));
  512. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  513. if (bssid && status == WLAN_STATUS_SUCCESS) {
  514. memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
  515. memcpy(wdev->wext.prev_bssid, bssid, ETH_ALEN);
  516. wdev->wext.prev_bssid_valid = true;
  517. }
  518. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  519. }
  520. #endif
  521. if (wdev->current_bss) {
  522. cfg80211_unhold_bss(wdev->current_bss);
  523. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  524. wdev->current_bss = NULL;
  525. }
  526. if (status != WLAN_STATUS_SUCCESS) {
  527. kfree(wdev->connect_keys);
  528. wdev->connect_keys = NULL;
  529. wdev->ssid_len = 0;
  530. if (bss) {
  531. cfg80211_unhold_bss(bss_from_pub(bss));
  532. cfg80211_put_bss(wdev->wiphy, bss);
  533. }
  534. return;
  535. }
  536. if (!bss) {
  537. WARN_ON_ONCE(!wiphy_to_dev(wdev->wiphy)->ops->connect);
  538. bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
  539. wdev->ssid, wdev->ssid_len,
  540. WLAN_CAPABILITY_ESS,
  541. WLAN_CAPABILITY_ESS);
  542. if (WARN_ON(!bss))
  543. return;
  544. cfg80211_hold_bss(bss_from_pub(bss));
  545. }
  546. wdev->current_bss = bss_from_pub(bss);
  547. cfg80211_upload_connect_keys(wdev);
  548. rcu_read_lock();
  549. country_ie = ieee80211_bss_get_ie(bss, WLAN_EID_COUNTRY);
  550. if (!country_ie) {
  551. rcu_read_unlock();
  552. return;
  553. }
  554. country_ie = kmemdup(country_ie, 2 + country_ie[1], GFP_ATOMIC);
  555. rcu_read_unlock();
  556. if (!country_ie)
  557. return;
  558. /*
  559. * ieee80211_bss_get_ie() ensures we can access:
  560. * - country_ie + 2, the start of the country ie data, and
  561. * - and country_ie[1] which is the IE length
  562. */
  563. regulatory_hint_11d(wdev->wiphy, bss->channel->band,
  564. country_ie + 2, country_ie[1]);
  565. kfree(country_ie);
  566. }
  567. void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
  568. const u8 *req_ie, size_t req_ie_len,
  569. const u8 *resp_ie, size_t resp_ie_len,
  570. u16 status, gfp_t gfp)
  571. {
  572. struct wireless_dev *wdev = dev->ieee80211_ptr;
  573. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  574. struct cfg80211_event *ev;
  575. unsigned long flags;
  576. ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
  577. if (!ev)
  578. return;
  579. ev->type = EVENT_CONNECT_RESULT;
  580. if (bssid)
  581. memcpy(ev->cr.bssid, bssid, ETH_ALEN);
  582. if (req_ie_len) {
  583. ev->cr.req_ie = ((u8 *)ev) + sizeof(*ev);
  584. ev->cr.req_ie_len = req_ie_len;
  585. memcpy((void *)ev->cr.req_ie, req_ie, req_ie_len);
  586. }
  587. if (resp_ie_len) {
  588. ev->cr.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
  589. ev->cr.resp_ie_len = resp_ie_len;
  590. memcpy((void *)ev->cr.resp_ie, resp_ie, resp_ie_len);
  591. }
  592. ev->cr.status = status;
  593. spin_lock_irqsave(&wdev->event_lock, flags);
  594. list_add_tail(&ev->list, &wdev->event_list);
  595. spin_unlock_irqrestore(&wdev->event_lock, flags);
  596. queue_work(cfg80211_wq, &rdev->event_work);
  597. }
  598. EXPORT_SYMBOL(cfg80211_connect_result);
  599. /* Consumes bss object one way or another */
  600. void __cfg80211_roamed(struct wireless_dev *wdev,
  601. struct cfg80211_bss *bss,
  602. const u8 *req_ie, size_t req_ie_len,
  603. const u8 *resp_ie, size_t resp_ie_len)
  604. {
  605. #ifdef CONFIG_CFG80211_WEXT
  606. union iwreq_data wrqu;
  607. #endif
  608. ASSERT_WDEV_LOCK(wdev);
  609. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  610. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  611. goto out;
  612. if (WARN_ON(!wdev->current_bss))
  613. goto out;
  614. cfg80211_unhold_bss(wdev->current_bss);
  615. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  616. wdev->current_bss = NULL;
  617. cfg80211_hold_bss(bss_from_pub(bss));
  618. wdev->current_bss = bss_from_pub(bss);
  619. nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), wdev->netdev, bss->bssid,
  620. req_ie, req_ie_len, resp_ie, resp_ie_len,
  621. GFP_KERNEL);
  622. #ifdef CONFIG_CFG80211_WEXT
  623. if (req_ie) {
  624. memset(&wrqu, 0, sizeof(wrqu));
  625. wrqu.data.length = req_ie_len;
  626. wireless_send_event(wdev->netdev, IWEVASSOCREQIE,
  627. &wrqu, req_ie);
  628. }
  629. if (resp_ie) {
  630. memset(&wrqu, 0, sizeof(wrqu));
  631. wrqu.data.length = resp_ie_len;
  632. wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
  633. &wrqu, resp_ie);
  634. }
  635. memset(&wrqu, 0, sizeof(wrqu));
  636. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  637. memcpy(wrqu.ap_addr.sa_data, bss->bssid, ETH_ALEN);
  638. memcpy(wdev->wext.prev_bssid, bss->bssid, ETH_ALEN);
  639. wdev->wext.prev_bssid_valid = true;
  640. wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
  641. #endif
  642. return;
  643. out:
  644. cfg80211_put_bss(wdev->wiphy, bss);
  645. }
  646. void cfg80211_roamed(struct net_device *dev,
  647. struct ieee80211_channel *channel,
  648. const u8 *bssid,
  649. const u8 *req_ie, size_t req_ie_len,
  650. const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
  651. {
  652. struct wireless_dev *wdev = dev->ieee80211_ptr;
  653. struct cfg80211_bss *bss;
  654. bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, wdev->ssid,
  655. wdev->ssid_len, WLAN_CAPABILITY_ESS,
  656. WLAN_CAPABILITY_ESS);
  657. if (WARN_ON(!bss))
  658. return;
  659. cfg80211_roamed_bss(dev, bss, req_ie, req_ie_len, resp_ie,
  660. resp_ie_len, gfp);
  661. }
  662. EXPORT_SYMBOL(cfg80211_roamed);
  663. /* Consumes bss object one way or another */
  664. void cfg80211_roamed_bss(struct net_device *dev,
  665. struct cfg80211_bss *bss, const u8 *req_ie,
  666. size_t req_ie_len, const u8 *resp_ie,
  667. size_t resp_ie_len, gfp_t gfp)
  668. {
  669. struct wireless_dev *wdev = dev->ieee80211_ptr;
  670. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  671. struct cfg80211_event *ev;
  672. unsigned long flags;
  673. if (WARN_ON(!bss))
  674. return;
  675. ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
  676. if (!ev) {
  677. cfg80211_put_bss(wdev->wiphy, bss);
  678. return;
  679. }
  680. ev->type = EVENT_ROAMED;
  681. ev->rm.req_ie = ((u8 *)ev) + sizeof(*ev);
  682. ev->rm.req_ie_len = req_ie_len;
  683. memcpy((void *)ev->rm.req_ie, req_ie, req_ie_len);
  684. ev->rm.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
  685. ev->rm.resp_ie_len = resp_ie_len;
  686. memcpy((void *)ev->rm.resp_ie, resp_ie, resp_ie_len);
  687. ev->rm.bss = bss;
  688. spin_lock_irqsave(&wdev->event_lock, flags);
  689. list_add_tail(&ev->list, &wdev->event_list);
  690. spin_unlock_irqrestore(&wdev->event_lock, flags);
  691. queue_work(cfg80211_wq, &rdev->event_work);
  692. }
  693. EXPORT_SYMBOL(cfg80211_roamed_bss);
  694. void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
  695. size_t ie_len, u16 reason, bool from_ap)
  696. {
  697. struct wireless_dev *wdev = dev->ieee80211_ptr;
  698. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  699. int i;
  700. #ifdef CONFIG_CFG80211_WEXT
  701. union iwreq_data wrqu;
  702. #endif
  703. ASSERT_WDEV_LOCK(wdev);
  704. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  705. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  706. return;
  707. if (wdev->current_bss) {
  708. cfg80211_unhold_bss(wdev->current_bss);
  709. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  710. }
  711. wdev->current_bss = NULL;
  712. wdev->ssid_len = 0;
  713. nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
  714. /*
  715. * Delete all the keys ... pairwise keys can't really
  716. * exist any more anyway, but default keys might.
  717. */
  718. if (rdev->ops->del_key)
  719. for (i = 0; i < 6; i++)
  720. rdev_del_key(rdev, dev, i, false, NULL);
  721. #ifdef CONFIG_CFG80211_WEXT
  722. memset(&wrqu, 0, sizeof(wrqu));
  723. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  724. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  725. wdev->wext.connect.ssid_len = 0;
  726. #endif
  727. schedule_work(&cfg80211_disconnect_work);
  728. }
  729. void cfg80211_disconnected(struct net_device *dev, u16 reason,
  730. u8 *ie, size_t ie_len, gfp_t gfp)
  731. {
  732. struct wireless_dev *wdev = dev->ieee80211_ptr;
  733. struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  734. struct cfg80211_event *ev;
  735. unsigned long flags;
  736. ev = kzalloc(sizeof(*ev) + ie_len, gfp);
  737. if (!ev)
  738. return;
  739. ev->type = EVENT_DISCONNECTED;
  740. ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
  741. ev->dc.ie_len = ie_len;
  742. memcpy((void *)ev->dc.ie, ie, ie_len);
  743. ev->dc.reason = reason;
  744. spin_lock_irqsave(&wdev->event_lock, flags);
  745. list_add_tail(&ev->list, &wdev->event_list);
  746. spin_unlock_irqrestore(&wdev->event_lock, flags);
  747. queue_work(cfg80211_wq, &rdev->event_work);
  748. }
  749. EXPORT_SYMBOL(cfg80211_disconnected);
  750. /*
  751. * API calls for nl80211/wext compatibility code
  752. */
  753. int cfg80211_connect(struct cfg80211_registered_device *rdev,
  754. struct net_device *dev,
  755. struct cfg80211_connect_params *connect,
  756. struct cfg80211_cached_keys *connkeys,
  757. const u8 *prev_bssid)
  758. {
  759. struct wireless_dev *wdev = dev->ieee80211_ptr;
  760. int err;
  761. ASSERT_WDEV_LOCK(wdev);
  762. if (WARN_ON(wdev->connect_keys)) {
  763. kfree(wdev->connect_keys);
  764. wdev->connect_keys = NULL;
  765. }
  766. cfg80211_oper_and_ht_capa(&connect->ht_capa_mask,
  767. rdev->wiphy.ht_capa_mod_mask);
  768. if (connkeys && connkeys->def >= 0) {
  769. int idx;
  770. u32 cipher;
  771. idx = connkeys->def;
  772. cipher = connkeys->params[idx].cipher;
  773. /* If given a WEP key we may need it for shared key auth */
  774. if (cipher == WLAN_CIPHER_SUITE_WEP40 ||
  775. cipher == WLAN_CIPHER_SUITE_WEP104) {
  776. connect->key_idx = idx;
  777. connect->key = connkeys->params[idx].key;
  778. connect->key_len = connkeys->params[idx].key_len;
  779. /*
  780. * If ciphers are not set (e.g. when going through
  781. * iwconfig), we have to set them appropriately here.
  782. */
  783. if (connect->crypto.cipher_group == 0)
  784. connect->crypto.cipher_group = cipher;
  785. if (connect->crypto.n_ciphers_pairwise == 0) {
  786. connect->crypto.n_ciphers_pairwise = 1;
  787. connect->crypto.ciphers_pairwise[0] = cipher;
  788. }
  789. }
  790. }
  791. wdev->connect_keys = connkeys;
  792. memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
  793. wdev->ssid_len = connect->ssid_len;
  794. if (!rdev->ops->connect)
  795. err = cfg80211_sme_connect(wdev, connect, prev_bssid);
  796. else
  797. err = rdev_connect(rdev, dev, connect);
  798. if (err) {
  799. wdev->connect_keys = NULL;
  800. wdev->ssid_len = 0;
  801. return err;
  802. }
  803. return 0;
  804. }
  805. int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
  806. struct net_device *dev, u16 reason, bool wextev)
  807. {
  808. struct wireless_dev *wdev = dev->ieee80211_ptr;
  809. int err;
  810. ASSERT_WDEV_LOCK(wdev);
  811. kfree(wdev->connect_keys);
  812. wdev->connect_keys = NULL;
  813. if (wdev->conn) {
  814. err = cfg80211_sme_disconnect(wdev, reason);
  815. } else if (!rdev->ops->disconnect) {
  816. cfg80211_mlme_down(rdev, dev);
  817. err = 0;
  818. } else {
  819. err = rdev_disconnect(rdev, dev, reason);
  820. }
  821. return err;
  822. }