ibss.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Some IBSS support code for cfg80211.
  4. *
  5. * Copyright 2009 Johannes Berg <[email protected]>
  6. * Copyright (C) 2020-2022 Intel Corporation
  7. */
  8. #include <linux/etherdevice.h>
  9. #include <linux/if_arp.h>
  10. #include <linux/slab.h>
  11. #include <linux/export.h>
  12. #include <net/cfg80211.h>
  13. #include "wext-compat.h"
  14. #include "nl80211.h"
  15. #include "rdev-ops.h"
  16. void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
  17. struct ieee80211_channel *channel)
  18. {
  19. struct wireless_dev *wdev = dev->ieee80211_ptr;
  20. struct cfg80211_bss *bss;
  21. #ifdef CONFIG_CFG80211_WEXT
  22. union iwreq_data wrqu;
  23. #endif
  24. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  25. return;
  26. if (!wdev->u.ibss.ssid_len)
  27. return;
  28. bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, NULL, 0,
  29. IEEE80211_BSS_TYPE_IBSS, IEEE80211_PRIVACY_ANY);
  30. if (WARN_ON(!bss))
  31. return;
  32. if (wdev->u.ibss.current_bss) {
  33. cfg80211_unhold_bss(wdev->u.ibss.current_bss);
  34. cfg80211_put_bss(wdev->wiphy, &wdev->u.ibss.current_bss->pub);
  35. }
  36. cfg80211_hold_bss(bss_from_pub(bss));
  37. wdev->u.ibss.current_bss = bss_from_pub(bss);
  38. if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))
  39. cfg80211_upload_connect_keys(wdev);
  40. nl80211_send_ibss_bssid(wiphy_to_rdev(wdev->wiphy), dev, bssid,
  41. GFP_KERNEL);
  42. #ifdef CONFIG_CFG80211_WEXT
  43. memset(&wrqu, 0, sizeof(wrqu));
  44. memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
  45. wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
  46. #endif
  47. }
  48. void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
  49. struct ieee80211_channel *channel, gfp_t gfp)
  50. {
  51. struct wireless_dev *wdev = dev->ieee80211_ptr;
  52. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  53. struct cfg80211_event *ev;
  54. unsigned long flags;
  55. trace_cfg80211_ibss_joined(dev, bssid, channel);
  56. if (WARN_ON(!channel))
  57. return;
  58. ev = kzalloc(sizeof(*ev), gfp);
  59. if (!ev)
  60. return;
  61. ev->type = EVENT_IBSS_JOINED;
  62. memcpy(ev->ij.bssid, bssid, ETH_ALEN);
  63. ev->ij.channel = channel;
  64. spin_lock_irqsave(&wdev->event_lock, flags);
  65. list_add_tail(&ev->list, &wdev->event_list);
  66. spin_unlock_irqrestore(&wdev->event_lock, flags);
  67. queue_work(cfg80211_wq, &rdev->event_work);
  68. }
  69. EXPORT_SYMBOL(cfg80211_ibss_joined);
  70. int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
  71. struct net_device *dev,
  72. struct cfg80211_ibss_params *params,
  73. struct cfg80211_cached_keys *connkeys)
  74. {
  75. struct wireless_dev *wdev = dev->ieee80211_ptr;
  76. int err;
  77. lockdep_assert_held(&rdev->wiphy.mtx);
  78. ASSERT_WDEV_LOCK(wdev);
  79. if (wdev->u.ibss.ssid_len)
  80. return -EALREADY;
  81. if (!params->basic_rates) {
  82. /*
  83. * If no rates were explicitly configured,
  84. * use the mandatory rate set for 11b or
  85. * 11a for maximum compatibility.
  86. */
  87. struct ieee80211_supported_band *sband;
  88. enum nl80211_band band;
  89. u32 flag;
  90. int j;
  91. band = params->chandef.chan->band;
  92. if (band == NL80211_BAND_5GHZ ||
  93. band == NL80211_BAND_6GHZ)
  94. flag = IEEE80211_RATE_MANDATORY_A;
  95. else
  96. flag = IEEE80211_RATE_MANDATORY_B;
  97. sband = rdev->wiphy.bands[band];
  98. for (j = 0; j < sband->n_bitrates; j++) {
  99. if (sband->bitrates[j].flags & flag)
  100. params->basic_rates |= BIT(j);
  101. }
  102. }
  103. if (WARN_ON(connkeys && connkeys->def < 0))
  104. return -EINVAL;
  105. if (WARN_ON(wdev->connect_keys))
  106. kfree_sensitive(wdev->connect_keys);
  107. wdev->connect_keys = connkeys;
  108. wdev->u.ibss.chandef = params->chandef;
  109. if (connkeys) {
  110. params->wep_keys = connkeys->params;
  111. params->wep_tx_key = connkeys->def;
  112. }
  113. #ifdef CONFIG_CFG80211_WEXT
  114. wdev->wext.ibss.chandef = params->chandef;
  115. #endif
  116. err = rdev_join_ibss(rdev, dev, params);
  117. if (err) {
  118. wdev->connect_keys = NULL;
  119. return err;
  120. }
  121. memcpy(wdev->u.ibss.ssid, params->ssid, params->ssid_len);
  122. wdev->u.ibss.ssid_len = params->ssid_len;
  123. return 0;
  124. }
  125. static void __cfg80211_clear_ibss(struct net_device *dev, bool nowext)
  126. {
  127. struct wireless_dev *wdev = dev->ieee80211_ptr;
  128. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  129. int i;
  130. ASSERT_WDEV_LOCK(wdev);
  131. kfree_sensitive(wdev->connect_keys);
  132. wdev->connect_keys = NULL;
  133. rdev_set_qos_map(rdev, dev, NULL);
  134. /*
  135. * Delete all the keys ... pairwise keys can't really
  136. * exist any more anyway, but default keys might.
  137. */
  138. if (rdev->ops->del_key)
  139. for (i = 0; i < 6; i++)
  140. rdev_del_key(rdev, dev, -1, i, false, NULL);
  141. if (wdev->u.ibss.current_bss) {
  142. cfg80211_unhold_bss(wdev->u.ibss.current_bss);
  143. cfg80211_put_bss(wdev->wiphy, &wdev->u.ibss.current_bss->pub);
  144. }
  145. wdev->u.ibss.current_bss = NULL;
  146. wdev->u.ibss.ssid_len = 0;
  147. memset(&wdev->u.ibss.chandef, 0, sizeof(wdev->u.ibss.chandef));
  148. #ifdef CONFIG_CFG80211_WEXT
  149. if (!nowext)
  150. wdev->wext.ibss.ssid_len = 0;
  151. #endif
  152. cfg80211_sched_dfs_chan_update(rdev);
  153. }
  154. void cfg80211_clear_ibss(struct net_device *dev, bool nowext)
  155. {
  156. struct wireless_dev *wdev = dev->ieee80211_ptr;
  157. wdev_lock(wdev);
  158. __cfg80211_clear_ibss(dev, nowext);
  159. wdev_unlock(wdev);
  160. }
  161. int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
  162. struct net_device *dev, bool nowext)
  163. {
  164. struct wireless_dev *wdev = dev->ieee80211_ptr;
  165. int err;
  166. ASSERT_WDEV_LOCK(wdev);
  167. if (!wdev->u.ibss.ssid_len)
  168. return -ENOLINK;
  169. err = rdev_leave_ibss(rdev, dev);
  170. if (err)
  171. return err;
  172. wdev->conn_owner_nlportid = 0;
  173. __cfg80211_clear_ibss(dev, nowext);
  174. return 0;
  175. }
  176. int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
  177. struct net_device *dev, bool nowext)
  178. {
  179. struct wireless_dev *wdev = dev->ieee80211_ptr;
  180. int err;
  181. wdev_lock(wdev);
  182. err = __cfg80211_leave_ibss(rdev, dev, nowext);
  183. wdev_unlock(wdev);
  184. return err;
  185. }
  186. #ifdef CONFIG_CFG80211_WEXT
  187. int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
  188. struct wireless_dev *wdev)
  189. {
  190. struct cfg80211_cached_keys *ck = NULL;
  191. enum nl80211_band band;
  192. int i, err;
  193. ASSERT_WDEV_LOCK(wdev);
  194. if (!wdev->wext.ibss.beacon_interval)
  195. wdev->wext.ibss.beacon_interval = 100;
  196. /* try to find an IBSS channel if none requested ... */
  197. if (!wdev->wext.ibss.chandef.chan) {
  198. struct ieee80211_channel *new_chan = NULL;
  199. for (band = 0; band < NUM_NL80211_BANDS; band++) {
  200. struct ieee80211_supported_band *sband;
  201. struct ieee80211_channel *chan;
  202. sband = rdev->wiphy.bands[band];
  203. if (!sband)
  204. continue;
  205. for (i = 0; i < sband->n_channels; i++) {
  206. chan = &sband->channels[i];
  207. if (chan->flags & IEEE80211_CHAN_NO_IR)
  208. continue;
  209. if (chan->flags & IEEE80211_CHAN_DISABLED)
  210. continue;
  211. new_chan = chan;
  212. break;
  213. }
  214. if (new_chan)
  215. break;
  216. }
  217. if (!new_chan)
  218. return -EINVAL;
  219. cfg80211_chandef_create(&wdev->wext.ibss.chandef, new_chan,
  220. NL80211_CHAN_NO_HT);
  221. }
  222. /* don't join -- SSID is not there */
  223. if (!wdev->wext.ibss.ssid_len)
  224. return 0;
  225. if (!netif_running(wdev->netdev))
  226. return 0;
  227. if (wdev->wext.keys)
  228. wdev->wext.keys->def = wdev->wext.default_key;
  229. wdev->wext.ibss.privacy = wdev->wext.default_key != -1;
  230. if (wdev->wext.keys && wdev->wext.keys->def != -1) {
  231. ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
  232. if (!ck)
  233. return -ENOMEM;
  234. for (i = 0; i < CFG80211_MAX_WEP_KEYS; i++)
  235. ck->params[i].key = ck->data[i];
  236. }
  237. err = __cfg80211_join_ibss(rdev, wdev->netdev,
  238. &wdev->wext.ibss, ck);
  239. if (err)
  240. kfree(ck);
  241. return err;
  242. }
  243. int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
  244. struct iw_request_info *info,
  245. struct iw_freq *wextfreq, char *extra)
  246. {
  247. struct wireless_dev *wdev = dev->ieee80211_ptr;
  248. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  249. struct ieee80211_channel *chan = NULL;
  250. int err, freq;
  251. /* call only for ibss! */
  252. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  253. return -EINVAL;
  254. if (!rdev->ops->join_ibss)
  255. return -EOPNOTSUPP;
  256. freq = cfg80211_wext_freq(wextfreq);
  257. if (freq < 0)
  258. return freq;
  259. if (freq) {
  260. chan = ieee80211_get_channel(wdev->wiphy, freq);
  261. if (!chan)
  262. return -EINVAL;
  263. if (chan->flags & IEEE80211_CHAN_NO_IR ||
  264. chan->flags & IEEE80211_CHAN_DISABLED)
  265. return -EINVAL;
  266. }
  267. if (wdev->wext.ibss.chandef.chan == chan)
  268. return 0;
  269. wdev_lock(wdev);
  270. err = 0;
  271. if (wdev->u.ibss.ssid_len)
  272. err = __cfg80211_leave_ibss(rdev, dev, true);
  273. wdev_unlock(wdev);
  274. if (err)
  275. return err;
  276. if (chan) {
  277. cfg80211_chandef_create(&wdev->wext.ibss.chandef, chan,
  278. NL80211_CHAN_NO_HT);
  279. wdev->wext.ibss.channel_fixed = true;
  280. } else {
  281. /* cfg80211_ibss_wext_join will pick one if needed */
  282. wdev->wext.ibss.channel_fixed = false;
  283. }
  284. wdev_lock(wdev);
  285. err = cfg80211_ibss_wext_join(rdev, wdev);
  286. wdev_unlock(wdev);
  287. return err;
  288. }
  289. int cfg80211_ibss_wext_giwfreq(struct net_device *dev,
  290. struct iw_request_info *info,
  291. struct iw_freq *freq, char *extra)
  292. {
  293. struct wireless_dev *wdev = dev->ieee80211_ptr;
  294. struct ieee80211_channel *chan = NULL;
  295. /* call only for ibss! */
  296. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  297. return -EINVAL;
  298. wdev_lock(wdev);
  299. if (wdev->u.ibss.current_bss)
  300. chan = wdev->u.ibss.current_bss->pub.channel;
  301. else if (wdev->wext.ibss.chandef.chan)
  302. chan = wdev->wext.ibss.chandef.chan;
  303. wdev_unlock(wdev);
  304. if (chan) {
  305. freq->m = chan->center_freq;
  306. freq->e = 6;
  307. return 0;
  308. }
  309. /* no channel if not joining */
  310. return -EINVAL;
  311. }
  312. int cfg80211_ibss_wext_siwessid(struct net_device *dev,
  313. struct iw_request_info *info,
  314. struct iw_point *data, char *ssid)
  315. {
  316. struct wireless_dev *wdev = dev->ieee80211_ptr;
  317. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  318. size_t len = data->length;
  319. int err;
  320. /* call only for ibss! */
  321. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  322. return -EINVAL;
  323. if (!rdev->ops->join_ibss)
  324. return -EOPNOTSUPP;
  325. wdev_lock(wdev);
  326. err = 0;
  327. if (wdev->u.ibss.ssid_len)
  328. err = __cfg80211_leave_ibss(rdev, dev, true);
  329. wdev_unlock(wdev);
  330. if (err)
  331. return err;
  332. /* iwconfig uses nul termination in SSID.. */
  333. if (len > 0 && ssid[len - 1] == '\0')
  334. len--;
  335. memcpy(wdev->u.ibss.ssid, ssid, len);
  336. wdev->wext.ibss.ssid = wdev->u.ibss.ssid;
  337. wdev->wext.ibss.ssid_len = len;
  338. wdev_lock(wdev);
  339. err = cfg80211_ibss_wext_join(rdev, wdev);
  340. wdev_unlock(wdev);
  341. return err;
  342. }
  343. int cfg80211_ibss_wext_giwessid(struct net_device *dev,
  344. struct iw_request_info *info,
  345. struct iw_point *data, char *ssid)
  346. {
  347. struct wireless_dev *wdev = dev->ieee80211_ptr;
  348. /* call only for ibss! */
  349. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  350. return -EINVAL;
  351. data->flags = 0;
  352. wdev_lock(wdev);
  353. if (wdev->u.ibss.ssid_len) {
  354. data->flags = 1;
  355. data->length = wdev->u.ibss.ssid_len;
  356. memcpy(ssid, wdev->u.ibss.ssid, data->length);
  357. } else if (wdev->wext.ibss.ssid && wdev->wext.ibss.ssid_len) {
  358. data->flags = 1;
  359. data->length = wdev->wext.ibss.ssid_len;
  360. memcpy(ssid, wdev->wext.ibss.ssid, data->length);
  361. }
  362. wdev_unlock(wdev);
  363. return 0;
  364. }
  365. int cfg80211_ibss_wext_siwap(struct net_device *dev,
  366. struct iw_request_info *info,
  367. struct sockaddr *ap_addr, char *extra)
  368. {
  369. struct wireless_dev *wdev = dev->ieee80211_ptr;
  370. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  371. u8 *bssid = ap_addr->sa_data;
  372. int err;
  373. /* call only for ibss! */
  374. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  375. return -EINVAL;
  376. if (!rdev->ops->join_ibss)
  377. return -EOPNOTSUPP;
  378. if (ap_addr->sa_family != ARPHRD_ETHER)
  379. return -EINVAL;
  380. /* automatic mode */
  381. if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
  382. bssid = NULL;
  383. if (bssid && !is_valid_ether_addr(bssid))
  384. return -EINVAL;
  385. /* both automatic */
  386. if (!bssid && !wdev->wext.ibss.bssid)
  387. return 0;
  388. /* fixed already - and no change */
  389. if (wdev->wext.ibss.bssid && bssid &&
  390. ether_addr_equal(bssid, wdev->wext.ibss.bssid))
  391. return 0;
  392. wdev_lock(wdev);
  393. err = 0;
  394. if (wdev->u.ibss.ssid_len)
  395. err = __cfg80211_leave_ibss(rdev, dev, true);
  396. wdev_unlock(wdev);
  397. if (err)
  398. return err;
  399. if (bssid) {
  400. memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
  401. wdev->wext.ibss.bssid = wdev->wext.bssid;
  402. } else
  403. wdev->wext.ibss.bssid = NULL;
  404. wdev_lock(wdev);
  405. err = cfg80211_ibss_wext_join(rdev, wdev);
  406. wdev_unlock(wdev);
  407. return err;
  408. }
  409. int cfg80211_ibss_wext_giwap(struct net_device *dev,
  410. struct iw_request_info *info,
  411. struct sockaddr *ap_addr, char *extra)
  412. {
  413. struct wireless_dev *wdev = dev->ieee80211_ptr;
  414. /* call only for ibss! */
  415. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
  416. return -EINVAL;
  417. ap_addr->sa_family = ARPHRD_ETHER;
  418. wdev_lock(wdev);
  419. if (wdev->u.ibss.current_bss)
  420. memcpy(ap_addr->sa_data, wdev->u.ibss.current_bss->pub.bssid,
  421. ETH_ALEN);
  422. else if (wdev->wext.ibss.bssid)
  423. memcpy(ap_addr->sa_data, wdev->wext.ibss.bssid, ETH_ALEN);
  424. else
  425. eth_zero_addr(ap_addr->sa_data);
  426. wdev_unlock(wdev);
  427. return 0;
  428. }
  429. #endif