sme.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355
  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, 2020 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 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. fallthrough;
  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. fallthrough;
  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 (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. wdev->unprot_beacon_reported = 0;
  591. nl80211_send_connect_result(wiphy_to_rdev(wdev->wiphy), dev, cr,
  592. GFP_KERNEL);
  593. #ifdef CONFIG_CFG80211_WEXT
  594. if (wextev) {
  595. if (cr->req_ie && cr->status == WLAN_STATUS_SUCCESS) {
  596. memset(&wrqu, 0, sizeof(wrqu));
  597. wrqu.data.length = cr->req_ie_len;
  598. wireless_send_event(dev, IWEVASSOCREQIE, &wrqu,
  599. cr->req_ie);
  600. }
  601. if (cr->resp_ie && cr->status == WLAN_STATUS_SUCCESS) {
  602. memset(&wrqu, 0, sizeof(wrqu));
  603. wrqu.data.length = cr->resp_ie_len;
  604. wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu,
  605. cr->resp_ie);
  606. }
  607. memset(&wrqu, 0, sizeof(wrqu));
  608. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  609. if (cr->bssid && cr->status == WLAN_STATUS_SUCCESS) {
  610. memcpy(wrqu.ap_addr.sa_data, cr->bssid, ETH_ALEN);
  611. memcpy(wdev->wext.prev_bssid, cr->bssid, ETH_ALEN);
  612. wdev->wext.prev_bssid_valid = true;
  613. }
  614. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  615. }
  616. #endif
  617. if (!cr->bss && (cr->status == WLAN_STATUS_SUCCESS)) {
  618. WARN_ON_ONCE(!wiphy_to_rdev(wdev->wiphy)->ops->connect);
  619. cr->bss = cfg80211_get_bss(wdev->wiphy, NULL, cr->bssid,
  620. wdev->ssid, wdev->ssid_len,
  621. wdev->conn_bss_type,
  622. IEEE80211_PRIVACY_ANY);
  623. if (cr->bss)
  624. cfg80211_hold_bss(bss_from_pub(cr->bss));
  625. }
  626. if (wdev->current_bss) {
  627. cfg80211_unhold_bss(wdev->current_bss);
  628. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  629. wdev->current_bss = NULL;
  630. }
  631. if (cr->status != WLAN_STATUS_SUCCESS) {
  632. kfree_sensitive(wdev->connect_keys);
  633. wdev->connect_keys = NULL;
  634. wdev->ssid_len = 0;
  635. wdev->conn_owner_nlportid = 0;
  636. if (cr->bss) {
  637. cfg80211_unhold_bss(bss_from_pub(cr->bss));
  638. cfg80211_put_bss(wdev->wiphy, cr->bss);
  639. }
  640. cfg80211_sme_free(wdev);
  641. return;
  642. }
  643. if (WARN_ON(!cr->bss))
  644. return;
  645. wdev->current_bss = bss_from_pub(cr->bss);
  646. if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))
  647. cfg80211_upload_connect_keys(wdev);
  648. rcu_read_lock();
  649. country_ie = ieee80211_bss_get_ie(cr->bss, WLAN_EID_COUNTRY);
  650. if (!country_ie) {
  651. rcu_read_unlock();
  652. return;
  653. }
  654. country_ie = kmemdup(country_ie, 2 + country_ie[1], GFP_ATOMIC);
  655. rcu_read_unlock();
  656. if (!country_ie)
  657. return;
  658. /*
  659. * ieee80211_bss_get_ie() ensures we can access:
  660. * - country_ie + 2, the start of the country ie data, and
  661. * - and country_ie[1] which is the IE length
  662. */
  663. regulatory_hint_country_ie(wdev->wiphy, cr->bss->channel->band,
  664. country_ie + 2, country_ie[1]);
  665. kfree(country_ie);
  666. }
  667. /* Consumes bss object one way or another */
  668. void cfg80211_connect_done(struct net_device *dev,
  669. struct cfg80211_connect_resp_params *params,
  670. gfp_t gfp)
  671. {
  672. struct wireless_dev *wdev = dev->ieee80211_ptr;
  673. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  674. struct cfg80211_event *ev;
  675. unsigned long flags;
  676. u8 *next;
  677. if (params->bss) {
  678. struct cfg80211_internal_bss *ibss = bss_from_pub(params->bss);
  679. if (list_empty(&ibss->list)) {
  680. struct cfg80211_bss *found = NULL, *tmp = params->bss;
  681. found = cfg80211_get_bss(wdev->wiphy, NULL,
  682. params->bss->bssid,
  683. wdev->ssid, wdev->ssid_len,
  684. wdev->conn_bss_type,
  685. IEEE80211_PRIVACY_ANY);
  686. if (found) {
  687. /* The same BSS is already updated so use it
  688. * instead, as it has latest info.
  689. */
  690. params->bss = found;
  691. } else {
  692. /* Update with BSS provided by driver, it will
  693. * be freshly added and ref cnted, we can free
  694. * the old one.
  695. *
  696. * signal_valid can be false, as we are not
  697. * expecting the BSS to be found.
  698. *
  699. * keep the old timestamp to avoid confusion
  700. */
  701. cfg80211_bss_update(rdev, ibss, false,
  702. ibss->ts);
  703. }
  704. cfg80211_put_bss(wdev->wiphy, tmp);
  705. }
  706. }
  707. ev = kzalloc(sizeof(*ev) + (params->bssid ? ETH_ALEN : 0) +
  708. params->req_ie_len + params->resp_ie_len +
  709. params->fils.kek_len + params->fils.pmk_len +
  710. (params->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
  711. if (!ev) {
  712. cfg80211_put_bss(wdev->wiphy, params->bss);
  713. return;
  714. }
  715. ev->type = EVENT_CONNECT_RESULT;
  716. next = ((u8 *)ev) + sizeof(*ev);
  717. if (params->bssid) {
  718. ev->cr.bssid = next;
  719. memcpy((void *)ev->cr.bssid, params->bssid, ETH_ALEN);
  720. next += ETH_ALEN;
  721. }
  722. if (params->req_ie_len) {
  723. ev->cr.req_ie = next;
  724. ev->cr.req_ie_len = params->req_ie_len;
  725. memcpy((void *)ev->cr.req_ie, params->req_ie,
  726. params->req_ie_len);
  727. next += params->req_ie_len;
  728. }
  729. if (params->resp_ie_len) {
  730. ev->cr.resp_ie = next;
  731. ev->cr.resp_ie_len = params->resp_ie_len;
  732. memcpy((void *)ev->cr.resp_ie, params->resp_ie,
  733. params->resp_ie_len);
  734. next += params->resp_ie_len;
  735. }
  736. if (params->fils.kek_len) {
  737. ev->cr.fils.kek = next;
  738. ev->cr.fils.kek_len = params->fils.kek_len;
  739. memcpy((void *)ev->cr.fils.kek, params->fils.kek,
  740. params->fils.kek_len);
  741. next += params->fils.kek_len;
  742. }
  743. if (params->fils.pmk_len) {
  744. ev->cr.fils.pmk = next;
  745. ev->cr.fils.pmk_len = params->fils.pmk_len;
  746. memcpy((void *)ev->cr.fils.pmk, params->fils.pmk,
  747. params->fils.pmk_len);
  748. next += params->fils.pmk_len;
  749. }
  750. if (params->fils.pmkid) {
  751. ev->cr.fils.pmkid = next;
  752. memcpy((void *)ev->cr.fils.pmkid, params->fils.pmkid,
  753. WLAN_PMKID_LEN);
  754. next += WLAN_PMKID_LEN;
  755. }
  756. ev->cr.fils.update_erp_next_seq_num = params->fils.update_erp_next_seq_num;
  757. if (params->fils.update_erp_next_seq_num)
  758. ev->cr.fils.erp_next_seq_num = params->fils.erp_next_seq_num;
  759. if (params->bss)
  760. cfg80211_hold_bss(bss_from_pub(params->bss));
  761. ev->cr.bss = params->bss;
  762. ev->cr.status = params->status;
  763. ev->cr.timeout_reason = params->timeout_reason;
  764. spin_lock_irqsave(&wdev->event_lock, flags);
  765. list_add_tail(&ev->list, &wdev->event_list);
  766. spin_unlock_irqrestore(&wdev->event_lock, flags);
  767. queue_work(cfg80211_wq, &rdev->event_work);
  768. }
  769. EXPORT_SYMBOL(cfg80211_connect_done);
  770. /* Consumes bss object one way or another */
  771. void __cfg80211_roamed(struct wireless_dev *wdev,
  772. struct cfg80211_roam_info *info)
  773. {
  774. #ifdef CONFIG_CFG80211_WEXT
  775. union iwreq_data wrqu;
  776. #endif
  777. ASSERT_WDEV_LOCK(wdev);
  778. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  779. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  780. goto out;
  781. if (WARN_ON(!wdev->current_bss))
  782. goto out;
  783. cfg80211_unhold_bss(wdev->current_bss);
  784. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  785. wdev->current_bss = NULL;
  786. if (WARN_ON(!info->bss))
  787. return;
  788. cfg80211_hold_bss(bss_from_pub(info->bss));
  789. wdev->current_bss = bss_from_pub(info->bss);
  790. wdev->unprot_beacon_reported = 0;
  791. nl80211_send_roamed(wiphy_to_rdev(wdev->wiphy),
  792. wdev->netdev, info, GFP_KERNEL);
  793. #ifdef CONFIG_CFG80211_WEXT
  794. if (info->req_ie) {
  795. memset(&wrqu, 0, sizeof(wrqu));
  796. wrqu.data.length = info->req_ie_len;
  797. wireless_send_event(wdev->netdev, IWEVASSOCREQIE,
  798. &wrqu, info->req_ie);
  799. }
  800. if (info->resp_ie) {
  801. memset(&wrqu, 0, sizeof(wrqu));
  802. wrqu.data.length = info->resp_ie_len;
  803. wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
  804. &wrqu, info->resp_ie);
  805. }
  806. memset(&wrqu, 0, sizeof(wrqu));
  807. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  808. memcpy(wrqu.ap_addr.sa_data, info->bss->bssid, ETH_ALEN);
  809. memcpy(wdev->wext.prev_bssid, info->bss->bssid, ETH_ALEN);
  810. wdev->wext.prev_bssid_valid = true;
  811. wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
  812. #endif
  813. return;
  814. out:
  815. cfg80211_put_bss(wdev->wiphy, info->bss);
  816. }
  817. /* Consumes info->bss object one way or another */
  818. void cfg80211_roamed(struct net_device *dev, struct cfg80211_roam_info *info,
  819. gfp_t gfp)
  820. {
  821. struct wireless_dev *wdev = dev->ieee80211_ptr;
  822. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  823. struct cfg80211_event *ev;
  824. unsigned long flags;
  825. u8 *next;
  826. if (!info->bss) {
  827. info->bss = cfg80211_get_bss(wdev->wiphy, info->channel,
  828. info->bssid, wdev->ssid,
  829. wdev->ssid_len,
  830. wdev->conn_bss_type,
  831. IEEE80211_PRIVACY_ANY);
  832. }
  833. if (WARN_ON(!info->bss))
  834. return;
  835. ev = kzalloc(sizeof(*ev) + info->req_ie_len + info->resp_ie_len +
  836. info->fils.kek_len + info->fils.pmk_len +
  837. (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
  838. if (!ev) {
  839. cfg80211_put_bss(wdev->wiphy, info->bss);
  840. return;
  841. }
  842. ev->type = EVENT_ROAMED;
  843. next = ((u8 *)ev) + sizeof(*ev);
  844. if (info->req_ie_len) {
  845. ev->rm.req_ie = next;
  846. ev->rm.req_ie_len = info->req_ie_len;
  847. memcpy((void *)ev->rm.req_ie, info->req_ie, info->req_ie_len);
  848. next += info->req_ie_len;
  849. }
  850. if (info->resp_ie_len) {
  851. ev->rm.resp_ie = next;
  852. ev->rm.resp_ie_len = info->resp_ie_len;
  853. memcpy((void *)ev->rm.resp_ie, info->resp_ie,
  854. info->resp_ie_len);
  855. next += info->resp_ie_len;
  856. }
  857. if (info->fils.kek_len) {
  858. ev->rm.fils.kek = next;
  859. ev->rm.fils.kek_len = info->fils.kek_len;
  860. memcpy((void *)ev->rm.fils.kek, info->fils.kek,
  861. info->fils.kek_len);
  862. next += info->fils.kek_len;
  863. }
  864. if (info->fils.pmk_len) {
  865. ev->rm.fils.pmk = next;
  866. ev->rm.fils.pmk_len = info->fils.pmk_len;
  867. memcpy((void *)ev->rm.fils.pmk, info->fils.pmk,
  868. info->fils.pmk_len);
  869. next += info->fils.pmk_len;
  870. }
  871. if (info->fils.pmkid) {
  872. ev->rm.fils.pmkid = next;
  873. memcpy((void *)ev->rm.fils.pmkid, info->fils.pmkid,
  874. WLAN_PMKID_LEN);
  875. next += WLAN_PMKID_LEN;
  876. }
  877. ev->rm.fils.update_erp_next_seq_num = info->fils.update_erp_next_seq_num;
  878. if (info->fils.update_erp_next_seq_num)
  879. ev->rm.fils.erp_next_seq_num = info->fils.erp_next_seq_num;
  880. ev->rm.bss = info->bss;
  881. spin_lock_irqsave(&wdev->event_lock, flags);
  882. list_add_tail(&ev->list, &wdev->event_list);
  883. spin_unlock_irqrestore(&wdev->event_lock, flags);
  884. queue_work(cfg80211_wq, &rdev->event_work);
  885. }
  886. EXPORT_SYMBOL(cfg80211_roamed);
  887. void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid)
  888. {
  889. ASSERT_WDEV_LOCK(wdev);
  890. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
  891. return;
  892. if (WARN_ON(!wdev->current_bss) ||
  893. WARN_ON(!ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))
  894. return;
  895. nl80211_send_port_authorized(wiphy_to_rdev(wdev->wiphy), wdev->netdev,
  896. bssid);
  897. }
  898. void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
  899. gfp_t gfp)
  900. {
  901. struct wireless_dev *wdev = dev->ieee80211_ptr;
  902. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  903. struct cfg80211_event *ev;
  904. unsigned long flags;
  905. if (WARN_ON(!bssid))
  906. return;
  907. ev = kzalloc(sizeof(*ev), gfp);
  908. if (!ev)
  909. return;
  910. ev->type = EVENT_PORT_AUTHORIZED;
  911. memcpy(ev->pa.bssid, bssid, ETH_ALEN);
  912. /*
  913. * Use the wdev event list so that if there are pending
  914. * connected/roamed events, they will be reported first.
  915. */
  916. spin_lock_irqsave(&wdev->event_lock, flags);
  917. list_add_tail(&ev->list, &wdev->event_list);
  918. spin_unlock_irqrestore(&wdev->event_lock, flags);
  919. queue_work(cfg80211_wq, &rdev->event_work);
  920. }
  921. EXPORT_SYMBOL(cfg80211_port_authorized);
  922. void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
  923. size_t ie_len, u16 reason, bool from_ap)
  924. {
  925. struct wireless_dev *wdev = dev->ieee80211_ptr;
  926. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  927. int i;
  928. #ifdef CONFIG_CFG80211_WEXT
  929. union iwreq_data wrqu;
  930. #endif
  931. ASSERT_WDEV_LOCK(wdev);
  932. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
  933. wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
  934. return;
  935. if (wdev->current_bss) {
  936. cfg80211_unhold_bss(wdev->current_bss);
  937. cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
  938. }
  939. wdev->current_bss = NULL;
  940. wdev->ssid_len = 0;
  941. wdev->conn_owner_nlportid = 0;
  942. kfree_sensitive(wdev->connect_keys);
  943. wdev->connect_keys = NULL;
  944. nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
  945. /* stop critical protocol if supported */
  946. if (rdev->ops->crit_proto_stop && rdev->crit_proto_nlportid) {
  947. rdev->crit_proto_nlportid = 0;
  948. rdev_crit_proto_stop(rdev, wdev);
  949. }
  950. /*
  951. * Delete all the keys ... pairwise keys can't really
  952. * exist any more anyway, but default keys might.
  953. */
  954. if (rdev->ops->del_key) {
  955. int max_key_idx = 5;
  956. if (wiphy_ext_feature_isset(
  957. wdev->wiphy,
  958. NL80211_EXT_FEATURE_BEACON_PROTECTION) ||
  959. wiphy_ext_feature_isset(
  960. wdev->wiphy,
  961. NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT))
  962. max_key_idx = 7;
  963. for (i = 0; i <= max_key_idx; i++)
  964. rdev_del_key(rdev, dev, i, false, NULL);
  965. }
  966. rdev_set_qos_map(rdev, dev, NULL);
  967. #ifdef CONFIG_CFG80211_WEXT
  968. memset(&wrqu, 0, sizeof(wrqu));
  969. wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  970. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  971. wdev->wext.connect.ssid_len = 0;
  972. #endif
  973. schedule_work(&cfg80211_disconnect_work);
  974. }
  975. void cfg80211_disconnected(struct net_device *dev, u16 reason,
  976. const u8 *ie, size_t ie_len,
  977. bool locally_generated, gfp_t gfp)
  978. {
  979. struct wireless_dev *wdev = dev->ieee80211_ptr;
  980. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  981. struct cfg80211_event *ev;
  982. unsigned long flags;
  983. ev = kzalloc(sizeof(*ev) + ie_len, gfp);
  984. if (!ev)
  985. return;
  986. ev->type = EVENT_DISCONNECTED;
  987. ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
  988. ev->dc.ie_len = ie_len;
  989. memcpy((void *)ev->dc.ie, ie, ie_len);
  990. ev->dc.reason = reason;
  991. ev->dc.locally_generated = locally_generated;
  992. spin_lock_irqsave(&wdev->event_lock, flags);
  993. list_add_tail(&ev->list, &wdev->event_list);
  994. spin_unlock_irqrestore(&wdev->event_lock, flags);
  995. queue_work(cfg80211_wq, &rdev->event_work);
  996. }
  997. EXPORT_SYMBOL(cfg80211_disconnected);
  998. /*
  999. * API calls for nl80211/wext compatibility code
  1000. */
  1001. int cfg80211_connect(struct cfg80211_registered_device *rdev,
  1002. struct net_device *dev,
  1003. struct cfg80211_connect_params *connect,
  1004. struct cfg80211_cached_keys *connkeys,
  1005. const u8 *prev_bssid)
  1006. {
  1007. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1008. int err;
  1009. ASSERT_WDEV_LOCK(wdev);
  1010. /*
  1011. * If we have an ssid_len, we're trying to connect or are
  1012. * already connected, so reject a new SSID unless it's the
  1013. * same (which is the case for re-association.)
  1014. */
  1015. if (wdev->ssid_len &&
  1016. (wdev->ssid_len != connect->ssid_len ||
  1017. memcmp(wdev->ssid, connect->ssid, wdev->ssid_len)))
  1018. return -EALREADY;
  1019. /*
  1020. * If connected, reject (re-)association unless prev_bssid
  1021. * matches the current BSSID.
  1022. */
  1023. if (wdev->current_bss) {
  1024. if (!prev_bssid)
  1025. return -EALREADY;
  1026. if (!ether_addr_equal(prev_bssid, wdev->current_bss->pub.bssid))
  1027. return -ENOTCONN;
  1028. }
  1029. /*
  1030. * Reject if we're in the process of connecting with WEP,
  1031. * this case isn't very interesting and trying to handle
  1032. * it would make the code much more complex.
  1033. */
  1034. if (wdev->connect_keys)
  1035. return -EINPROGRESS;
  1036. cfg80211_oper_and_ht_capa(&connect->ht_capa_mask,
  1037. rdev->wiphy.ht_capa_mod_mask);
  1038. cfg80211_oper_and_vht_capa(&connect->vht_capa_mask,
  1039. rdev->wiphy.vht_capa_mod_mask);
  1040. if (connkeys && connkeys->def >= 0) {
  1041. int idx;
  1042. u32 cipher;
  1043. idx = connkeys->def;
  1044. cipher = connkeys->params[idx].cipher;
  1045. /* If given a WEP key we may need it for shared key auth */
  1046. if (cipher == WLAN_CIPHER_SUITE_WEP40 ||
  1047. cipher == WLAN_CIPHER_SUITE_WEP104) {
  1048. connect->key_idx = idx;
  1049. connect->key = connkeys->params[idx].key;
  1050. connect->key_len = connkeys->params[idx].key_len;
  1051. /*
  1052. * If ciphers are not set (e.g. when going through
  1053. * iwconfig), we have to set them appropriately here.
  1054. */
  1055. if (connect->crypto.cipher_group == 0)
  1056. connect->crypto.cipher_group = cipher;
  1057. if (connect->crypto.n_ciphers_pairwise == 0) {
  1058. connect->crypto.n_ciphers_pairwise = 1;
  1059. connect->crypto.ciphers_pairwise[0] = cipher;
  1060. }
  1061. }
  1062. connect->crypto.wep_keys = connkeys->params;
  1063. connect->crypto.wep_tx_key = connkeys->def;
  1064. } else {
  1065. if (WARN_ON(connkeys))
  1066. return -EINVAL;
  1067. }
  1068. wdev->connect_keys = connkeys;
  1069. memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
  1070. wdev->ssid_len = connect->ssid_len;
  1071. wdev->conn_bss_type = connect->pbss ? IEEE80211_BSS_TYPE_PBSS :
  1072. IEEE80211_BSS_TYPE_ESS;
  1073. if (!rdev->ops->connect)
  1074. err = cfg80211_sme_connect(wdev, connect, prev_bssid);
  1075. else
  1076. err = rdev_connect(rdev, dev, connect);
  1077. if (err) {
  1078. wdev->connect_keys = NULL;
  1079. /*
  1080. * This could be reassoc getting refused, don't clear
  1081. * ssid_len in that case.
  1082. */
  1083. if (!wdev->current_bss)
  1084. wdev->ssid_len = 0;
  1085. return err;
  1086. }
  1087. return 0;
  1088. }
  1089. int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
  1090. struct net_device *dev, u16 reason, bool wextev)
  1091. {
  1092. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1093. int err = 0;
  1094. ASSERT_WDEV_LOCK(wdev);
  1095. kfree_sensitive(wdev->connect_keys);
  1096. wdev->connect_keys = NULL;
  1097. wdev->conn_owner_nlportid = 0;
  1098. if (wdev->conn)
  1099. err = cfg80211_sme_disconnect(wdev, reason);
  1100. else if (!rdev->ops->disconnect)
  1101. cfg80211_mlme_down(rdev, dev);
  1102. else if (wdev->ssid_len)
  1103. err = rdev_disconnect(rdev, dev, reason);
  1104. /*
  1105. * Clear ssid_len unless we actually were fully connected,
  1106. * in which case cfg80211_disconnected() will take care of
  1107. * this later.
  1108. */
  1109. if (!wdev->current_bss)
  1110. wdev->ssid_len = 0;
  1111. return err;
  1112. }
  1113. /*
  1114. * Used to clean up after the connection / connection attempt owner socket
  1115. * disconnects
  1116. */
  1117. void cfg80211_autodisconnect_wk(struct work_struct *work)
  1118. {
  1119. struct wireless_dev *wdev =
  1120. container_of(work, struct wireless_dev, disconnect_wk);
  1121. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  1122. wdev_lock(wdev);
  1123. if (wdev->conn_owner_nlportid) {
  1124. switch (wdev->iftype) {
  1125. case NL80211_IFTYPE_ADHOC:
  1126. __cfg80211_leave_ibss(rdev, wdev->netdev, false);
  1127. break;
  1128. case NL80211_IFTYPE_AP:
  1129. case NL80211_IFTYPE_P2P_GO:
  1130. __cfg80211_stop_ap(rdev, wdev->netdev, false);
  1131. break;
  1132. case NL80211_IFTYPE_MESH_POINT:
  1133. __cfg80211_leave_mesh(rdev, wdev->netdev);
  1134. break;
  1135. case NL80211_IFTYPE_STATION:
  1136. case NL80211_IFTYPE_P2P_CLIENT:
  1137. /*
  1138. * Use disconnect_bssid if still connecting and
  1139. * ops->disconnect not implemented. Otherwise we can
  1140. * use cfg80211_disconnect.
  1141. */
  1142. if (rdev->ops->disconnect || wdev->current_bss)
  1143. cfg80211_disconnect(rdev, wdev->netdev,
  1144. WLAN_REASON_DEAUTH_LEAVING,
  1145. true);
  1146. else
  1147. cfg80211_mlme_deauth(rdev, wdev->netdev,
  1148. wdev->disconnect_bssid,
  1149. NULL, 0,
  1150. WLAN_REASON_DEAUTH_LEAVING,
  1151. false);
  1152. break;
  1153. default:
  1154. break;
  1155. }
  1156. }
  1157. wdev_unlock(wdev);
  1158. }