]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/wireless/nl80211.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UBUNTU: Ubuntu-4.15.0-96.97
[mirror_ubuntu-bionic-kernel.git] / net / wireless / nl80211.c
CommitLineData
55682965
JB		 1/*
2 * This is the new netlink-based wireless configuration interface.
3 *
026331c4 4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
2740f0cf 5 * Copyright 2013-2014 Intel Mobile Communications GmbH
66cd794e 6 * Copyright 2015-2017 Intel Deutschland GmbH
55682965
JB		 7 */
8
9#include <linux/if.h>
10#include <linux/module.h>
11#include <linux/err.h>
5a0e3ad6 12#include <linux/slab.h>
55682965
JB		 13#include <linux/list.h>
14#include <linux/if_ether.h>
15#include <linux/ieee80211.h>
16#include <linux/nl80211.h>
17#include <linux/rtnetlink.h>
18#include <linux/netlink.h>
c7cb043b 19#include <linux/nospec.h>
2a519311 20#include <linux/etherdevice.h>
463d0183 21#include <net/net_namespace.h>
55682965
JB		 22#include <net/genetlink.h>
23#include <net/cfg80211.h>
463d0183 24#include <net/sock.h>
2a0e047e 25#include <net/inet_connection_sock.h>
55682965
JB		 26#include "core.h"
27#include "nl80211.h"
b2e1b302 28#include "reg.h"
e35e4d28 29#include "rdev-ops.h"
55682965 30
5fb628e9
JM		 31static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
32 struct genl_info *info,
33 struct cfg80211_crypto_settings *settings,
34 int cipher_limit);
35
55682965 36/* the netlink family */
489111e5 37static struct genl_family nl80211_fam;
55682965 38
2a94fe48
JB		 39/* multicast groups */
40enum nl80211_multicast_groups {
41 NL80211_MCGRP_CONFIG,
42 NL80211_MCGRP_SCAN,
43 NL80211_MCGRP_REGULATORY,
44 NL80211_MCGRP_MLME,
567ffc35 45 NL80211_MCGRP_VENDOR,
50bcd31d 46 NL80211_MCGRP_NAN,
2a94fe48
JB		 47 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
48};
49
50static const struct genl_multicast_group nl80211_mcgrps[] = {
71b836ec
JB		 51 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
52 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
53 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
54 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
55 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
50bcd31d 56 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN },
2a94fe48 57#ifdef CONFIG_NL80211_TESTMODE
71b836ec 58 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
2a94fe48
JB		 59#endif
60};
61
89a54e48
JB		 62/* returns ERR_PTR values */
63static struct wireless_dev *
64__cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
55682965 65{
89a54e48
JB		 66 struct cfg80211_registered_device *rdev;
67 struct wireless_dev *result = NULL;
68 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
69 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
70 u64 wdev_id;
71 int wiphy_idx = -1;
72 int ifidx = -1;
55682965 73
5fe231e8 74 ASSERT_RTNL();
55682965 75
89a54e48
JB		 76 if (!have_ifidx && !have_wdev_id)
77 return ERR_PTR(-EINVAL);
55682965 78
89a54e48
JB		 79 if (have_ifidx)
80 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
81 if (have_wdev_id) {
82 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
83 wiphy_idx = wdev_id >> 32;
55682965
JB		 84 }
85
89a54e48
JB		 86 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
87 struct wireless_dev *wdev;
88
89 if (wiphy_net(&rdev->wiphy) != netns)
90 continue;
91
92 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
93 continue;
94
53873f13 95 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
89a54e48
JB		 96 if (have_ifidx && wdev->netdev &&
97 wdev->netdev->ifindex == ifidx) {
98 result = wdev;
99 break;
100 }
101 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
102 result = wdev;
103 break;
104 }
105 }
89a54e48
JB		 106
107 if (result)
108 break;
109 }
110
111 if (result)
112 return result;
113 return ERR_PTR(-ENODEV);
55682965
JB		 114}
115
a9455408 116static struct cfg80211_registered_device *
878d9ec7 117__cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
a9455408 118{
7fee4778
JB		 119 struct cfg80211_registered_device *rdev = NULL, *tmp;
120 struct net_device *netdev;
a9455408 121
5fe231e8 122 ASSERT_RTNL();
a9455408 123
878d9ec7 124 if (!attrs[NL80211_ATTR_WIPHY] &&
89a54e48
JB		 125 !attrs[NL80211_ATTR_IFINDEX] &&
126 !attrs[NL80211_ATTR_WDEV])
7fee4778
JB		 127 return ERR_PTR(-EINVAL);
128
878d9ec7 129 if (attrs[NL80211_ATTR_WIPHY])
7fee4778 130 rdev = cfg80211_rdev_by_wiphy_idx(
878d9ec7 131 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
a9455408 132
89a54e48
JB		 133 if (attrs[NL80211_ATTR_WDEV]) {
134 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
135 struct wireless_dev *wdev;
136 bool found = false;
137
138 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
139 if (tmp) {
140 /* make sure wdev exists */
53873f13 141 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
89a54e48
JB		 142 if (wdev->identifier != (u32)wdev_id)
143 continue;
144 found = true;
145 break;
146 }
89a54e48
JB		 147
148 if (!found)
149 tmp = NULL;
150
151 if (rdev && tmp != rdev)
152 return ERR_PTR(-EINVAL);
153 rdev = tmp;
154 }
155 }
156
878d9ec7
JB		 157 if (attrs[NL80211_ATTR_IFINDEX]) {
158 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
7a087e74 159
7f2b8562 160 netdev = __dev_get_by_index(netns, ifindex);
7fee4778
JB		 161 if (netdev) {
162 if (netdev->ieee80211_ptr)
f26cbf40
ZG		 163 tmp = wiphy_to_rdev(
164 netdev->ieee80211_ptr->wiphy);
7fee4778
JB		 165 else
166 tmp = NULL;
167
7fee4778
JB		 168 /* not wireless device -- return error */
169 if (!tmp)
170 return ERR_PTR(-EINVAL);
171
172 /* mismatch -- return error */
173 if (rdev && tmp != rdev)
174 return ERR_PTR(-EINVAL);
175
176 rdev = tmp;
a9455408 177 }
a9455408 178 }
a9455408 179
4f7eff10
JB		 180 if (!rdev)
181 return ERR_PTR(-ENODEV);
a9455408 182
4f7eff10
JB		 183 if (netns != wiphy_net(&rdev->wiphy))
184 return ERR_PTR(-ENODEV);
185
186 return rdev;
a9455408
JB		 187}
188
189/*
190 * This function returns a pointer to the driver
191 * that the genl_info item that is passed refers to.
a9455408
JB		 192 *
193 * The result of this can be a PTR_ERR and hence must
194 * be checked with IS_ERR() for errors.
195 */
196static struct cfg80211_registered_device *
4f7eff10 197cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
a9455408 198{
5fe231e8 199 return __cfg80211_rdev_from_attrs(netns, info->attrs);
a9455408
JB		 200}
201
ffd30d74
JB		 202static int validate_beacon_head(const struct nlattr *attr,
203 struct netlink_ext_ack *extack)
204{
205 const u8 *data = nla_data(attr);
206 unsigned int len = nla_len(attr);
207 const struct element *elem;
208 const struct ieee80211_mgmt *mgmt = (void *)data;
209 unsigned int fixedlen = offsetof(struct ieee80211_mgmt,
210 u.beacon.variable);
211
212 if (len < fixedlen)
213 goto err;
214
215 if (ieee80211_hdrlen(mgmt->frame_control) !=
216 offsetof(struct ieee80211_mgmt, u.beacon))
217 goto err;
218
219 data += fixedlen;
220 len -= fixedlen;
221
222 for_each_element(elem, data, len) {
223 /* nothing */
224 }
225
226 if (for_each_element_completed(elem, data, len))
227 return 0;
228
229err:
230 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head");
231 return -EINVAL;
232}
233
55682965 234/* policy for the attributes */
8cd4d456 235static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
55682965
JB		 236 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
237 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
079e24ed 238 .len = 20-1 },
31888487 239 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
3d9d1d66 240
72bdcf34 241 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
094d05dc 242 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
3d9d1d66
JB		 243 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
244 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
245 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
246
b9a5f8ca
JM		 247 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
248 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
249 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
250 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
81077e82 251 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
3057dbfd 252 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
55682965
JB		 253
254 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
255 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
256 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
41ade00f 257
e007b857
EP		 258 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
259 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
41ade00f 260
b9454e83 261 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
41ade00f
JB		 262 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
263 .len = WLAN_MAX_KEY_LEN },
264 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
265 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
266 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
81962267 267 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
e31b8213 268 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
ed1b6cc7
JB		 269
270 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
271 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
272 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
273 .len = IEEE80211_MAX_DATA_LEN },
274 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
275 .len = IEEE80211_MAX_DATA_LEN },
5727ef1b
JB		 276 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
277 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
278 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
279 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
280 .len = NL80211_MAX_SUPP_RATES },
2ec600d6 281 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
5727ef1b 282 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
0a9542ee 283 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
2ec600d6 284 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
a4f606ea 285 .len = IEEE80211_MAX_MESH_ID_LEN },
24b51b48
MT		 286 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_BINARY,
287 .len = ETH_ALEN },
9f1ba906 288
b2e1b302
LR		 289 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
290 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
291
9f1ba906
JM		 292 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
293 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
294 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
90c97a04
JM		 295 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
296 .len = NL80211_MAX_SUPP_RATES },
50b12f59 297 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
36aedc90 298
24bdd9f4 299 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
15d5dda6 300 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
93da9cc1 301
6c739419 302 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
9aed3cc1
JM		 303
304 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
305 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
306 .len = IEEE80211_MAX_DATA_LEN },
2a519311
JB		 307 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
308 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
636a5d36
JM		 309
310 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
311 .len = IEEE80211_MAX_SSID_LEN },
312 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
313 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
04a773ad 314 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
1965c853 315 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
dc6382ce 316 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
eccb8e8f
JB		 317 [NL80211_ATTR_STA_FLAGS2] = {
318 .len = sizeof(struct nl80211_sta_flag_update),
319 },
3f77316c 320 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
c0692b8f
JB		 321 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
322 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
b23aa676
SO		 323 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
324 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
325 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
463d0183 326 [NL80211_ATTR_PID] = { .type = NLA_U32 },
8b787643 327 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
9361df14 328 [NL80211_ATTR_PMKID] = { .len = WLAN_PMKID_LEN },
9588bbd5
JM		 329 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
330 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
13ae75b1 331 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
026331c4
JM		 332 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
333 .len = IEEE80211_MAX_DATA_LEN },
334 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
ffb9eb3d 335 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
d6dc1a38 336 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
d5cdfacb 337 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
fd8aaaf3 338 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
98d2ff8b
JO		 339 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
340 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
2e161f78 341 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
afe0cbf8
BR		 342 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
343 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
885a46d0 344 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
f7ca38df 345 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
dbd2fd65 346 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
ff1b6e69 347 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
9c3990aa 348 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
bbe6ad6d 349 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
e5497d76 350 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
34850ab2 351 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
32e9de84 352 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
9946ecfb
JM		 353 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
354 .len = IEEE80211_MAX_DATA_LEN },
355 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
356 .len = IEEE80211_MAX_DATA_LEN },
f4b34b55 357 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
a1f1c21c 358 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
e9f935e3 359 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
109086ce
AN		 360 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
361 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
362 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
363 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
364 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
31fa97c5 365 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
e247bd90 366 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
00f740e1
AN		 367 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
368 .len = IEEE80211_MAX_DATA_LEN },
8b60b078 369 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
7e7c8926
BG		 370 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
371 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
372 .len = NL80211_HT_CAPABILITY_LEN
373 },
1d9d9213 374 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
1b658f11 375 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
4486ea98 376 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
89a54e48 377 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
57b5ce07 378 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
11b6b5a4 379 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
f461be3e 380 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
ed473771 381 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
53cabad7
JB		 382 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
383 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
8feb69c7 384 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] = {. type = NLA_U32 },
77765eaf
VT		 385 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
386 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
9d62a986
JM		 387 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
388 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
3713b4e3 389 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
ee2aca34
JB		 390 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
391 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
392 .len = NL80211_VHT_CAPABILITY_LEN,
393 },
355199e0
JM		 394 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
395 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
396 .len = IEEE80211_MAX_DATA_LEN },
5e4b6f56 397 [NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
16ef1fe2
SW		 398 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
399 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
400 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
9a774c78
AO		 401 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
402 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
c01fc9ad
SD		 403 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
404 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
5336fa88 405 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
60f4a7b1 406 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
ad7e718c
JB		 407 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
408 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
409 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
fa9ffc74
KP		 410 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
411 .len = IEEE80211_QOS_MAP_LEN_MAX },
1df4a510
JM		 412 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
413 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
df942e7b 414 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
18e5ca65 415 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
34d22ce2 416 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
bab5ab7d 417 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
960d01ac
JB		 418 [NL80211_ATTR_TSID] = { .type = NLA_U8 },
419 [NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
420 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
18998c38 421 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
ad2b26ab 422 [NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
1bdd716c 423 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
4b681c82 424 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
9c748934 425 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
05050753 426 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
34d50519 427 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
38de03d2 428 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
17b94247 429 [NL80211_ATTR_STA_SUPPORT_P2P_PS] = { .type = NLA_U8 },
c6e6a0c8
AE		 430 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
431 .len = VHT_MUMIMO_GROUPS_DATA_LEN
432 },
433 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = { .len = ETH_ALEN },
cb3b7d87 434 [NL80211_ATTR_NAN_MASTER_PREF] = { .type = NLA_U8 },
8585989d 435 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
a442b761 436 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
348bd456
JM		 437 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
438 .len = FILS_MAX_KEK_LEN },
439 [NL80211_ATTR_FILS_NONCES] = { .len = 2 * FILS_NONCE_LEN },
ce0ce13a 440 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
2fa436b3 441 [NL80211_ATTR_BSSID] = { .len = ETH_ALEN },
bf95ecdb 442 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
443 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
444 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
445 },
3093ebbe 446 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
a3caf744
VK		 447 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
448 .len = FILS_ERP_MAX_USERNAME_LEN },
449 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
450 .len = FILS_ERP_MAX_REALM_LEN },
451 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
452 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
453 .len = FILS_ERP_MAX_RRK_LEN },
454 [NL80211_ATTR_FILS_CACHE_ID] = { .len = 2 },
455 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
ca986ad9 456 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
55682965
JB		 457};
458
e31b8213 459/* policy for the key attributes */
b54452b0 460static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
fffd0934 461 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 462 [NL80211_KEY_IDX] = { .type = NLA_U8 },
463 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
81962267 464 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
b9454e83
JB		 465 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
466 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
e31b8213 467 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
dbd2fd65
JB		 468 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
469};
470
471/* policy for the key default flags */
472static const struct nla_policy
473nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
474 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
475 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
b9454e83
JB		 476};
477
f83ace3b 478#ifdef CONFIG_PM
ff1b6e69
JB		 479/* policy for WoWLAN attributes */
480static const struct nla_policy
481nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
482 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
483 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
484 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
485 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
77dbbb13
JB		 486 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
487 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
488 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
489 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
2a0e047e 490 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
8cd4d456 491 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
2a0e047e
JB		 492};
493
494static const struct nla_policy
495nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
496 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
497 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
498 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
499 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
500 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
501 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
502 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
503 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
504 },
505 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
506 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
507 },
508 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
509 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
510 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
ff1b6e69 511};
f83ace3b 512#endif /* CONFIG_PM */
ff1b6e69 513
be29b99a
AK		 514/* policy for coalesce rule attributes */
515static const struct nla_policy
516nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
517 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
518 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
519 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
520};
521
e5497d76
JB		 522/* policy for GTK rekey offload attributes */
523static const struct nla_policy
524nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
525 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
526 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
527 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
528};
529
a1f1c21c
LC		 530static const struct nla_policy
531nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
4a4ab0d7 532 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
a1f1c21c 533 .len = IEEE80211_MAX_SSID_LEN },
3007e352 534 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = { .len = ETH_ALEN },
88e920b4 535 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
a1f1c21c
LC		 536};
537
3b06d277
AS		 538static const struct nla_policy
539nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
540 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
541 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
542};
543
38de03d2
AS		 544static const struct nla_policy
545nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
546 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
547 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
548 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
549 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
550 },
551};
552
a442b761
AB		 553/* policy for NAN function attributes */
554static const struct nla_policy
555nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
556 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
0a27844c 557 [NL80211_NAN_FUNC_SERVICE_ID] = {
a442b761
AB		 558 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
559 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
560 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
561 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
562 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
563 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
564 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { .len = ETH_ALEN },
565 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
566 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
567 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
568 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
569 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
570 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
571 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
572 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
573 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
574};
575
576/* policy for Service Response Filter attributes */
577static const struct nla_policy
578nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
579 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
580 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
581 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
582 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
583 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
584};
585
ad670233
PX		 586/* policy for packet pattern attributes */
587static const struct nla_policy
588nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
589 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
590 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
591 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
592};
593
97990a06
JB		 594static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
595 struct netlink_callback *cb,
596 struct cfg80211_registered_device **rdev,
597 struct wireless_dev **wdev)
a043897a 598{
97990a06 599 int err;
a043897a 600
97990a06
JB		 601 if (!cb->args[0]) {
602 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da 603 genl_family_attrbuf(&nl80211_fam),
fceb6435 604 nl80211_fam.maxattr, nl80211_policy, NULL);
97990a06 605 if (err)
ea90e0dc 606 return err;
67748893 607
c90c39da
JB		 608 *wdev = __cfg80211_wdev_from_attrs(
609 sock_net(skb->sk),
610 genl_family_attrbuf(&nl80211_fam));
ea90e0dc
JB		 611 if (IS_ERR(*wdev))
612 return PTR_ERR(*wdev);
f26cbf40 613 *rdev = wiphy_to_rdev((*wdev)->wiphy);
c319d50b
JB		 614 /* 0 is the first index - add 1 to parse only once */
615 cb->args[0] = (*rdev)->wiphy_idx + 1;
97990a06
JB		 616 cb->args[1] = (*wdev)->identifier;
617 } else {
c319d50b
JB		 618 /* subtract the 1 again here */
619 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
97990a06 620 struct wireless_dev *tmp;
67748893 621
ea90e0dc
JB		 622 if (!wiphy)
623 return -ENODEV;
f26cbf40 624 *rdev = wiphy_to_rdev(wiphy);
97990a06 625 *wdev = NULL;
67748893 626
53873f13 627 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
97990a06
JB		 628 if (tmp->identifier == cb->args[1]) {
629 *wdev = tmp;
630 break;
631 }
632 }
67748893 633
ea90e0dc
JB		 634 if (!*wdev)
635 return -ENODEV;
67748893
JB		 636 }
637
67748893 638 return 0;
67748893
JB		 639}
640
f4a11bb0
JB		 641/* IE validation */
642static bool is_valid_ie_attr(const struct nlattr *attr)
643{
644 const u8 *pos;
645 int len;
646
647 if (!attr)
648 return true;
649
650 pos = nla_data(attr);
651 len = nla_len(attr);
652
653 while (len) {
654 u8 elemlen;
655
656 if (len < 2)
657 return false;
658 len -= 2;
659
660 elemlen = pos[1];
661 if (elemlen > len)
662 return false;
663
664 len -= elemlen;
665 pos += 2 + elemlen;
666 }
667
668 return true;
669}
670
55682965 671/* message building helper */
15e47304 672static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
55682965
JB		 673 int flags, u8 cmd)
674{
675 /* since there is no private header just add the generic one */
15e47304 676 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
55682965
JB		 677}
678
5dab3b8a 679static int nl80211_msg_put_channel(struct sk_buff *msg,
cdc89b97
JB		 680 struct ieee80211_channel *chan,
681 bool large)
5dab3b8a 682{
ea077c1c
RL		 683 /* Some channels must be completely excluded from the
684 * list to protect old user-space tools from breaking
685 */
686 if (!large && chan->flags &
687 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
688 return 0;
689
9360ffd1
DM		 690 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
691 chan->center_freq))
692 goto nla_put_failure;
5dab3b8a 693
9360ffd1
DM		 694 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
695 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
696 goto nla_put_failure;
8fe02e16
LR		 697 if (chan->flags & IEEE80211_CHAN_NO_IR) {
698 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
699 goto nla_put_failure;
700 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
701 goto nla_put_failure;
702 }
cdc89b97
JB		 703 if (chan->flags & IEEE80211_CHAN_RADAR) {
704 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
705 goto nla_put_failure;
706 if (large) {
707 u32 time;
708
709 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
710
711 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
712 chan->dfs_state))
713 goto nla_put_failure;
714 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
715 time))
716 goto nla_put_failure;
089027e5
JD		 717 if (nla_put_u32(msg,
718 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
719 chan->dfs_cac_ms))
720 goto nla_put_failure;
cdc89b97
JB		 721 }
722 }
5dab3b8a 723
fe1abafd
JB		 724 if (large) {
725 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
726 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
727 goto nla_put_failure;
728 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
729 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
730 goto nla_put_failure;
731 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
732 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
733 goto nla_put_failure;
734 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
735 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
736 goto nla_put_failure;
570dbde1
DS		 737 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
738 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
739 goto nla_put_failure;
06f207fc
AN		 740 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
741 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
570dbde1 742 goto nla_put_failure;
ea077c1c
RL		 743 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
744 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
745 goto nla_put_failure;
746 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
747 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
748 goto nla_put_failure;
fe1abafd
JB		 749 }
750
9360ffd1
DM		 751 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
752 DBM_TO_MBM(chan->max_power)))
753 goto nla_put_failure;
5dab3b8a
LR		 754
755 return 0;
756
757 nla_put_failure:
758 return -ENOBUFS;
759}
760
55682965
JB		 761/* netlink command implementations */
762
b9454e83
JB		 763struct key_parse {
764 struct key_params p;
765 int idx;
e31b8213 766 int type;
b9454e83 767 bool def, defmgmt;
dbd2fd65 768 bool def_uni, def_multi;
b9454e83
JB		 769};
770
771static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
772{
773 struct nlattr *tb[NL80211_KEY_MAX + 1];
774 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
fceb6435 775 nl80211_key_policy, NULL);
b9454e83
JB		 776 if (err)
777 return err;
778
779 k->def = !!tb[NL80211_KEY_DEFAULT];
780 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
781
dbd2fd65
JB		 782 if (k->def) {
783 k->def_uni = true;
784 k->def_multi = true;
785 }
786 if (k->defmgmt)
787 k->def_multi = true;
788
b9454e83
JB		 789 if (tb[NL80211_KEY_IDX])
790 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
791
792 if (tb[NL80211_KEY_DATA]) {
793 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
794 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
795 }
796
797 if (tb[NL80211_KEY_SEQ]) {
798 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
799 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
800 }
801
802 if (tb[NL80211_KEY_CIPHER])
803 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
804
e31b8213
JB		 805 if (tb[NL80211_KEY_TYPE]) {
806 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
807 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
808 return -EINVAL;
809 }
810
dbd2fd65
JB		 811 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
812 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
7a087e74 813
2da8f419
JB		 814 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
815 tb[NL80211_KEY_DEFAULT_TYPES],
fceb6435 816 nl80211_key_default_policy, NULL);
dbd2fd65
JB		 817 if (err)
818 return err;
819
820 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
821 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
822 }
823
b9454e83
JB		 824 return 0;
825}
826
827static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
828{
829 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
830 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
831 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
832 }
833
834 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
835 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
836 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
837 }
838
839 if (info->attrs[NL80211_ATTR_KEY_IDX])
840 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
841
842 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
843 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
844
845 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
846 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
847
dbd2fd65
JB		 848 if (k->def) {
849 k->def_uni = true;
850 k->def_multi = true;
851 }
852 if (k->defmgmt)
853 k->def_multi = true;
854
e31b8213
JB		 855 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
856 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
857 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
858 return -EINVAL;
859 }
860
dbd2fd65
JB		 861 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
862 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
fceb6435
JB		 863 int err = nla_parse_nested(kdt,
864 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
865 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
fe52145f
JB		 866 nl80211_key_default_policy,
867 info->extack);
dbd2fd65
JB		 868 if (err)
869 return err;
870
871 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
872 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
873 }
874
b9454e83
JB		 875 return 0;
876}
877
878static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
879{
880 int err;
881
882 memset(k, 0, sizeof(*k));
883 k->idx = -1;
e31b8213 884 k->type = -1;
b9454e83
JB		 885
886 if (info->attrs[NL80211_ATTR_KEY])
887 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
888 else
889 err = nl80211_parse_key_old(info, k);
890
891 if (err)
892 return err;
893
894 if (k->def && k->defmgmt)
895 return -EINVAL;
896
dbd2fd65
JB		 897 if (k->defmgmt) {
898 if (k->def_uni || !k->def_multi)
899 return -EINVAL;
900 }
901
b9454e83
JB		 902 if (k->idx != -1) {
903 if (k->defmgmt) {
904 if (k->idx < 4 || k->idx > 5)
905 return -EINVAL;
906 } else if (k->def) {
907 if (k->idx < 0 || k->idx > 3)
908 return -EINVAL;
909 } else {
910 if (k->idx < 0 || k->idx > 5)
911 return -EINVAL;
912 }
913 }
914
915 return 0;
916}
917
fffd0934
JB		 918static struct cfg80211_cached_keys *
919nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
de7044ee 920 struct nlattr *keys, bool *no_ht)
fffd0934
JB		 921{
922 struct key_parse parse;
923 struct nlattr *key;
924 struct cfg80211_cached_keys *result;
925 int rem, err, def = 0;
f1c1f17a
JB		 926 bool have_key = false;
927
928 nla_for_each_nested(key, keys, rem) {
929 have_key = true;
930 break;
931 }
932
933 if (!have_key)
934 return NULL;
fffd0934
JB		 935
936 result = kzalloc(sizeof(*result), GFP_KERNEL);
937 if (!result)
938 return ERR_PTR(-ENOMEM);
939
940 result->def = -1;
fffd0934
JB		 941
942 nla_for_each_nested(key, keys, rem) {
943 memset(&parse, 0, sizeof(parse));
944 parse.idx = -1;
945
946 err = nl80211_parse_key_new(key, &parse);
947 if (err)
948 goto error;
949 err = -EINVAL;
950 if (!parse.p.key)
951 goto error;
42ee231c 952 if (parse.idx < 0 || parse.idx > 3)
fffd0934
JB		 953 goto error;
954 if (parse.def) {
955 if (def)
956 goto error;
957 def = 1;
958 result->def = parse.idx;
dbd2fd65
JB		 959 if (!parse.def_uni || !parse.def_multi)
960 goto error;
fffd0934
JB		 961 } else if (parse.defmgmt)
962 goto error;
963 err = cfg80211_validate_key_settings(rdev, &parse.p,
e31b8213 964 parse.idx, false, NULL);
fffd0934
JB		 965 if (err)
966 goto error;
386b1f27
JB		 967 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
968 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
969 err = -EINVAL;
970 goto error;
971 }
fffd0934
JB		 972 result->params[parse.idx].cipher = parse.p.cipher;
973 result->params[parse.idx].key_len = parse.p.key_len;
974 result->params[parse.idx].key = result->data[parse.idx];
975 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
de7044ee 976
386b1f27
JB		 977 /* must be WEP key if we got here */
978 if (no_ht)
979 *no_ht = true;
fffd0934
JB		 980 }
981
f1c1f17a
JB		 982 if (result->def < 0) {
983 err = -EINVAL;
984 goto error;
985 }
986
fffd0934
JB		 987 return result;
988 error:
989 kfree(result);
990 return ERR_PTR(err);
991}
992
993static int nl80211_key_allowed(struct wireless_dev *wdev)
994{
995 ASSERT_WDEV_LOCK(wdev);
996
fffd0934
JB		 997 switch (wdev->iftype) {
998 case NL80211_IFTYPE_AP:
999 case NL80211_IFTYPE_AP_VLAN:
074ac8df 1000 case NL80211_IFTYPE_P2P_GO:
ff973af7 1001 case NL80211_IFTYPE_MESH_POINT:
fffd0934
JB		 1002 break;
1003 case NL80211_IFTYPE_ADHOC:
fffd0934 1004 case NL80211_IFTYPE_STATION:
074ac8df 1005 case NL80211_IFTYPE_P2P_CLIENT:
ceca7b71 1006 if (!wdev->current_bss)
fffd0934
JB		 1007 return -ENOLINK;
1008 break;
de4fcbad 1009 case NL80211_IFTYPE_UNSPECIFIED:
6e0bd6c3 1010 case NL80211_IFTYPE_OCB:
de4fcbad 1011 case NL80211_IFTYPE_MONITOR:
cb3b7d87 1012 case NL80211_IFTYPE_NAN:
de4fcbad
JB		 1013 case NL80211_IFTYPE_P2P_DEVICE:
1014 case NL80211_IFTYPE_WDS:
1015 case NUM_NL80211_IFTYPES:
fffd0934
JB		 1016 return -EINVAL;
1017 }
1018
1019 return 0;
1020}
1021
664834de
JM		 1022static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1023 struct nlattr *tb)
1024{
1025 struct ieee80211_channel *chan;
1026
1027 if (tb == NULL)
1028 return NULL;
1029 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
1030 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1031 return NULL;
1032 return chan;
1033}
1034
7527a782
JB		 1035static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1036{
1037 struct nlattr *nl_modes = nla_nest_start(msg, attr);
1038 int i;
1039
1040 if (!nl_modes)
1041 goto nla_put_failure;
1042
1043 i = 0;
1044 while (ifmodes) {
9360ffd1
DM		 1045 if ((ifmodes & 1) && nla_put_flag(msg, i))
1046 goto nla_put_failure;
7527a782
JB		 1047 ifmodes >>= 1;
1048 i++;
1049 }
1050
1051 nla_nest_end(msg, nl_modes);
1052 return 0;
1053
1054nla_put_failure:
1055 return -ENOBUFS;
1056}
1057
1058static int nl80211_put_iface_combinations(struct wiphy *wiphy,
cdc89b97
JB		 1059 struct sk_buff *msg,
1060 bool large)
7527a782
JB		 1061{
1062 struct nlattr *nl_combis;
1063 int i, j;
1064
1065 nl_combis = nla_nest_start(msg,
1066 NL80211_ATTR_INTERFACE_COMBINATIONS);
1067 if (!nl_combis)
1068 goto nla_put_failure;
1069
1070 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1071 const struct ieee80211_iface_combination *c;
1072 struct nlattr *nl_combi, *nl_limits;
1073
1074 c = &wiphy->iface_combinations[i];
1075
1076 nl_combi = nla_nest_start(msg, i + 1);
1077 if (!nl_combi)
1078 goto nla_put_failure;
1079
1080 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
1081 if (!nl_limits)
1082 goto nla_put_failure;
1083
1084 for (j = 0; j < c->n_limits; j++) {
1085 struct nlattr *nl_limit;
1086
1087 nl_limit = nla_nest_start(msg, j + 1);
1088 if (!nl_limit)
1089 goto nla_put_failure;
9360ffd1
DM		 1090 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1091 c->limits[j].max))
1092 goto nla_put_failure;
7527a782
JB		 1093 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1094 c->limits[j].types))
1095 goto nla_put_failure;
1096 nla_nest_end(msg, nl_limit);
1097 }
1098
1099 nla_nest_end(msg, nl_limits);
1100
9360ffd1
DM		 1101 if (c->beacon_int_infra_match &&
1102 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1103 goto nla_put_failure;
1104 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1105 c->num_different_channels) ||
1106 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1107 c->max_interfaces))
1108 goto nla_put_failure;
cdc89b97 1109 if (large &&
8c48b50a
FF		 1110 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1111 c->radar_detect_widths) ||
1112 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1113 c->radar_detect_regions)))
cdc89b97 1114 goto nla_put_failure;
0c317a02
PK		 1115 if (c->beacon_int_min_gcd &&
1116 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1117 c->beacon_int_min_gcd))
1118 goto nla_put_failure;
7527a782
JB		 1119
1120 nla_nest_end(msg, nl_combi);
1121 }
1122
1123 nla_nest_end(msg, nl_combis);
1124
1125 return 0;
1126nla_put_failure:
1127 return -ENOBUFS;
1128}
1129
3713b4e3 1130#ifdef CONFIG_PM
b56cf720
JB		 1131static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1132 struct sk_buff *msg)
1133{
964dc9e2 1134 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
b56cf720
JB		 1135 struct nlattr *nl_tcp;
1136
1137 if (!tcp)
1138 return 0;
1139
1140 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1141 if (!nl_tcp)
1142 return -ENOBUFS;
1143
1144 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1145 tcp->data_payload_max))
1146 return -ENOBUFS;
1147
1148 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1149 tcp->data_payload_max))
1150 return -ENOBUFS;
1151
1152 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1153 return -ENOBUFS;
1154
1155 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1156 sizeof(*tcp->tok), tcp->tok))
1157 return -ENOBUFS;
1158
1159 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1160 tcp->data_interval_max))
1161 return -ENOBUFS;
1162
1163 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1164 tcp->wake_payload_max))
1165 return -ENOBUFS;
1166
1167 nla_nest_end(msg, nl_tcp);
1168 return 0;
1169}
1170
3713b4e3 1171static int nl80211_send_wowlan(struct sk_buff *msg,
1b8ec87a 1172 struct cfg80211_registered_device *rdev,
b56cf720 1173 bool large)
55682965 1174{
3713b4e3 1175 struct nlattr *nl_wowlan;
55682965 1176
1b8ec87a 1177 if (!rdev->wiphy.wowlan)
3713b4e3 1178 return 0;
55682965 1179
3713b4e3
JB		 1180 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1181 if (!nl_wowlan)
1182 return -ENOBUFS;
9360ffd1 1183
1b8ec87a 1184 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
3713b4e3 1185 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1b8ec87a 1186 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
3713b4e3 1187 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1b8ec87a 1188 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
3713b4e3 1189 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1b8ec87a 1190 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
3713b4e3 1191 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1b8ec87a 1192 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
3713b4e3 1193 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1b8ec87a 1194 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
3713b4e3 1195 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1b8ec87a 1196 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
3713b4e3 1197 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1b8ec87a 1198 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
3713b4e3
JB		 1199 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1200 return -ENOBUFS;
9360ffd1 1201
1b8ec87a 1202 if (rdev->wiphy.wowlan->n_patterns) {
50ac6607 1203 struct nl80211_pattern_support pat = {
1b8ec87a
ZG		 1204 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1205 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1206 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1207 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
3713b4e3 1208 };
9360ffd1 1209
3713b4e3
JB		 1210 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1211 sizeof(pat), &pat))
1212 return -ENOBUFS;
1213 }
9360ffd1 1214
75453ccb
LC		 1215 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1216 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1217 rdev->wiphy.wowlan->max_nd_match_sets))
1218 return -ENOBUFS;
1219
1b8ec87a 1220 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
b56cf720
JB		 1221 return -ENOBUFS;
1222
3713b4e3 1223 nla_nest_end(msg, nl_wowlan);
9360ffd1 1224
3713b4e3
JB		 1225 return 0;
1226}
1227#endif
9360ffd1 1228
be29b99a 1229static int nl80211_send_coalesce(struct sk_buff *msg,
1b8ec87a 1230 struct cfg80211_registered_device *rdev)
be29b99a
AK		 1231{
1232 struct nl80211_coalesce_rule_support rule;
1233
1b8ec87a 1234 if (!rdev->wiphy.coalesce)
be29b99a
AK		 1235 return 0;
1236
1b8ec87a
ZG		 1237 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1238 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1239 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1240 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1241 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1242 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
be29b99a
AK		 1243
1244 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1245 return -ENOBUFS;
1246
1247 return 0;
1248}
1249
3713b4e3
JB		 1250static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1251 struct ieee80211_supported_band *sband)
1252{
1253 struct nlattr *nl_rates, *nl_rate;
1254 struct ieee80211_rate *rate;
1255 int i;
87bbbe22 1256
3713b4e3
JB		 1257 /* add HT info */
1258 if (sband->ht_cap.ht_supported &&
1259 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1260 sizeof(sband->ht_cap.mcs),
1261 &sband->ht_cap.mcs) ||
1262 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1263 sband->ht_cap.cap) ||
1264 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1265 sband->ht_cap.ampdu_factor) ||
1266 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1267 sband->ht_cap.ampdu_density)))
1268 return -ENOBUFS;
afe0cbf8 1269
3713b4e3
JB		 1270 /* add VHT info */
1271 if (sband->vht_cap.vht_supported &&
1272 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1273 sizeof(sband->vht_cap.vht_mcs),
1274 &sband->vht_cap.vht_mcs) ||
1275 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1276 sband->vht_cap.cap)))
1277 return -ENOBUFS;
f59ac048 1278
3713b4e3
JB		 1279 /* add bitrates */
1280 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1281 if (!nl_rates)
1282 return -ENOBUFS;
ee688b00 1283
3713b4e3
JB		 1284 for (i = 0; i < sband->n_bitrates; i++) {
1285 nl_rate = nla_nest_start(msg, i);
1286 if (!nl_rate)
1287 return -ENOBUFS;
ee688b00 1288
3713b4e3
JB		 1289 rate = &sband->bitrates[i];
1290 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1291 rate->bitrate))
1292 return -ENOBUFS;
1293 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1294 nla_put_flag(msg,
1295 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1296 return -ENOBUFS;
ee688b00 1297
3713b4e3
JB		 1298 nla_nest_end(msg, nl_rate);
1299 }
d51626df 1300
3713b4e3 1301 nla_nest_end(msg, nl_rates);
bf0c111e 1302
3713b4e3
JB		 1303 return 0;
1304}
ee688b00 1305
3713b4e3
JB		 1306static int
1307nl80211_send_mgmt_stypes(struct sk_buff *msg,
1308 const struct ieee80211_txrx_stypes *mgmt_stypes)
1309{
1310 u16 stypes;
1311 struct nlattr *nl_ftypes, *nl_ifs;
1312 enum nl80211_iftype ift;
1313 int i;
ee688b00 1314
3713b4e3
JB		 1315 if (!mgmt_stypes)
1316 return 0;
5dab3b8a 1317
3713b4e3
JB		 1318 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1319 if (!nl_ifs)
1320 return -ENOBUFS;
e2f367f2 1321
3713b4e3
JB		 1322 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1323 nl_ftypes = nla_nest_start(msg, ift);
1324 if (!nl_ftypes)
1325 return -ENOBUFS;
1326 i = 0;
1327 stypes = mgmt_stypes[ift].tx;
1328 while (stypes) {
1329 if ((stypes & 1) &&
1330 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1331 (i << 4) | IEEE80211_FTYPE_MGMT))
1332 return -ENOBUFS;
1333 stypes >>= 1;
1334 i++;
ee688b00 1335 }
3713b4e3
JB		 1336 nla_nest_end(msg, nl_ftypes);
1337 }
ee688b00 1338
3713b4e3 1339 nla_nest_end(msg, nl_ifs);
ee688b00 1340
3713b4e3
JB		 1341 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1342 if (!nl_ifs)
1343 return -ENOBUFS;
ee688b00 1344
3713b4e3
JB		 1345 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1346 nl_ftypes = nla_nest_start(msg, ift);
1347 if (!nl_ftypes)
1348 return -ENOBUFS;
1349 i = 0;
1350 stypes = mgmt_stypes[ift].rx;
1351 while (stypes) {
1352 if ((stypes & 1) &&
1353 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1354 (i << 4) | IEEE80211_FTYPE_MGMT))
1355 return -ENOBUFS;
1356 stypes >>= 1;
1357 i++;
1358 }
1359 nla_nest_end(msg, nl_ftypes);
1360 }
1361 nla_nest_end(msg, nl_ifs);
ee688b00 1362
3713b4e3
JB		 1363 return 0;
1364}
ee688b00 1365
1794899e
JB		 1366#define CMD(op, n) \
1367 do { \
1368 if (rdev->ops->op) { \
1369 i++; \
1370 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1371 goto nla_put_failure; \
1372 } \
1373 } while (0)
1374
1375static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1376 struct sk_buff *msg)
1377{
1378 int i = 0;
1379
1380 /*
1381 * do *NOT* add anything into this function, new things need to be
1382 * advertised only to new versions of userspace that can deal with
1383 * the split (and they can't possibly care about new features...
1384 */
1385 CMD(add_virtual_intf, NEW_INTERFACE);
1386 CMD(change_virtual_intf, SET_INTERFACE);
1387 CMD(add_key, NEW_KEY);
1388 CMD(start_ap, START_AP);
1389 CMD(add_station, NEW_STATION);
1390 CMD(add_mpath, NEW_MPATH);
1391 CMD(update_mesh_config, SET_MESH_CONFIG);
1392 CMD(change_bss, SET_BSS);
1393 CMD(auth, AUTHENTICATE);
1394 CMD(assoc, ASSOCIATE);
1395 CMD(deauth, DEAUTHENTICATE);
1396 CMD(disassoc, DISASSOCIATE);
1397 CMD(join_ibss, JOIN_IBSS);
1398 CMD(join_mesh, JOIN_MESH);
1399 CMD(set_pmksa, SET_PMKSA);
1400 CMD(del_pmksa, DEL_PMKSA);
1401 CMD(flush_pmksa, FLUSH_PMKSA);
1402 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1403 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1404 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1405 CMD(mgmt_tx, FRAME);
1406 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1407 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1408 i++;
1409 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1410 goto nla_put_failure;
1411 }
1412 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1413 rdev->ops->join_mesh) {
1414 i++;
1415 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1416 goto nla_put_failure;
1417 }
1418 CMD(set_wds_peer, SET_WDS_PEER);
1419 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1420 CMD(tdls_mgmt, TDLS_MGMT);
1421 CMD(tdls_oper, TDLS_OPER);
1422 }
ca986ad9 1423 if (rdev->wiphy.max_sched_scan_reqs)
1794899e
JB		 1424 CMD(sched_scan_start, START_SCHED_SCAN);
1425 CMD(probe_client, PROBE_CLIENT);
1426 CMD(set_noack_map, SET_NOACK_MAP);
1427 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1428 i++;
1429 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1430 goto nla_put_failure;
1431 }
1432 CMD(start_p2p_device, START_P2P_DEVICE);
1433 CMD(set_mcast_rate, SET_MCAST_RATE);
1434#ifdef CONFIG_NL80211_TESTMODE
1435 CMD(testmode_cmd, TESTMODE);
1436#endif
1437
1438 if (rdev->ops->connect || rdev->ops->auth) {
1439 i++;
1440 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1441 goto nla_put_failure;
1442 }
1443
1444 if (rdev->ops->disconnect || rdev->ops->deauth) {
1445 i++;
1446 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1447 goto nla_put_failure;
1448 }
1449
1450 return i;
1451 nla_put_failure:
1452 return -ENOBUFS;
1453}
1454
86e8cf98
JB		 1455struct nl80211_dump_wiphy_state {
1456 s64 filter_wiphy;
1457 long start;
019ae3a9 1458 long split_start, band_start, chan_start, capa_start;
86e8cf98
JB		 1459 bool split;
1460};
1461
1b8ec87a 1462static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
3bb20556 1463 enum nl80211_commands cmd,
3713b4e3 1464 struct sk_buff *msg, u32 portid, u32 seq,
86e8cf98 1465 int flags, struct nl80211_dump_wiphy_state *state)
3713b4e3
JB		 1466{
1467 void *hdr;
1468 struct nlattr *nl_bands, *nl_band;
1469 struct nlattr *nl_freqs, *nl_freq;
1470 struct nlattr *nl_cmds;
57fbcce3 1471 enum nl80211_band band;
3713b4e3
JB		 1472 struct ieee80211_channel *chan;
1473 int i;
1474 const struct ieee80211_txrx_stypes *mgmt_stypes =
1b8ec87a 1475 rdev->wiphy.mgmt_stypes;
fe1abafd 1476 u32 features;
ee688b00 1477
3bb20556 1478 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3713b4e3
JB		 1479 if (!hdr)
1480 return -ENOBUFS;
ee688b00 1481
86e8cf98
JB		 1482 if (WARN_ON(!state))
1483 return -EINVAL;
ee688b00 1484
1b8ec87a 1485 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3713b4e3 1486 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1b8ec87a 1487 wiphy_name(&rdev->wiphy)) ||
3713b4e3
JB		 1488 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1489 cfg80211_rdev_list_generation))
8fdc621d
JB		 1490 goto nla_put_failure;
1491
3bb20556
JB		 1492 if (cmd != NL80211_CMD_NEW_WIPHY)
1493 goto finish;
1494
86e8cf98 1495 switch (state->split_start) {
3713b4e3
JB		 1496 case 0:
1497 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1b8ec87a 1498 rdev->wiphy.retry_short) ||
3713b4e3 1499 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1b8ec87a 1500 rdev->wiphy.retry_long) ||
3713b4e3 1501 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1b8ec87a 1502 rdev->wiphy.frag_threshold) ||
3713b4e3 1503 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1b8ec87a 1504 rdev->wiphy.rts_threshold) ||
3713b4e3 1505 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1b8ec87a 1506 rdev->wiphy.coverage_class) ||
3713b4e3 1507 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1b8ec87a 1508 rdev->wiphy.max_scan_ssids) ||
3713b4e3 1509 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1b8ec87a 1510 rdev->wiphy.max_sched_scan_ssids) ||
3713b4e3 1511 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1b8ec87a 1512 rdev->wiphy.max_scan_ie_len) ||
3713b4e3 1513 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1b8ec87a 1514 rdev->wiphy.max_sched_scan_ie_len) ||
3713b4e3 1515 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
3b06d277
AS		 1516 rdev->wiphy.max_match_sets) ||
1517 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1518 rdev->wiphy.max_sched_scan_plans) ||
1519 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1520 rdev->wiphy.max_sched_scan_plan_interval) ||
1521 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1522 rdev->wiphy.max_sched_scan_plan_iterations))
9360ffd1 1523 goto nla_put_failure;
3713b4e3 1524
1b8ec87a 1525 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
3713b4e3 1526 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
aa430da4 1527 goto nla_put_failure;
1b8ec87a 1528 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
3713b4e3
JB		 1529 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1530 goto nla_put_failure;
1b8ec87a 1531 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3713b4e3
JB		 1532 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1533 goto nla_put_failure;
1b8ec87a 1534 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
3713b4e3
JB		 1535 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1536 goto nla_put_failure;
1b8ec87a 1537 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
3713b4e3
JB		 1538 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1539 goto nla_put_failure;
1b8ec87a 1540 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
3713b4e3 1541 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
9360ffd1 1542 goto nla_put_failure;
86e8cf98
JB		 1543 state->split_start++;
1544 if (state->split)
3713b4e3
JB		 1545 break;
1546 case 1:
1547 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1b8ec87a
ZG		 1548 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1549 rdev->wiphy.cipher_suites))
3713b4e3 1550 goto nla_put_failure;
4745fc09 1551
3713b4e3 1552 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1b8ec87a 1553 rdev->wiphy.max_num_pmkids))
3713b4e3 1554 goto nla_put_failure;
b23aa676 1555
1b8ec87a 1556 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
3713b4e3 1557 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
9360ffd1 1558 goto nla_put_failure;
b23aa676 1559
3713b4e3 1560 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1b8ec87a 1561 rdev->wiphy.available_antennas_tx) ||
3713b4e3 1562 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1b8ec87a 1563 rdev->wiphy.available_antennas_rx))
9360ffd1 1564 goto nla_put_failure;
b23aa676 1565
1b8ec87a 1566 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
3713b4e3 1567 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1b8ec87a 1568 rdev->wiphy.probe_resp_offload))
3713b4e3 1569 goto nla_put_failure;
8fdc621d 1570
1b8ec87a
ZG		 1571 if ((rdev->wiphy.available_antennas_tx ||
1572 rdev->wiphy.available_antennas_rx) &&
1573 rdev->ops->get_antenna) {
3713b4e3
JB		 1574 u32 tx_ant = 0, rx_ant = 0;
1575 int res;
7a087e74 1576
1b8ec87a 1577 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
3713b4e3
JB		 1578 if (!res) {
1579 if (nla_put_u32(msg,
1580 NL80211_ATTR_WIPHY_ANTENNA_TX,
1581 tx_ant) ||
1582 nla_put_u32(msg,
1583 NL80211_ATTR_WIPHY_ANTENNA_RX,
1584 rx_ant))
1585 goto nla_put_failure;
1586 }
1587 }
a293911d 1588
86e8cf98
JB		 1589 state->split_start++;
1590 if (state->split)
3713b4e3
JB		 1591 break;
1592 case 2:
1593 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1b8ec87a 1594 rdev->wiphy.interface_modes))
3713b4e3 1595 goto nla_put_failure;
86e8cf98
JB		 1596 state->split_start++;
1597 if (state->split)
3713b4e3
JB		 1598 break;
1599 case 3:
1600 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1601 if (!nl_bands)
1602 goto nla_put_failure;
f7ca38df 1603
86e8cf98 1604 for (band = state->band_start;
57fbcce3 1605 band < NUM_NL80211_BANDS; band++) {
3713b4e3 1606 struct ieee80211_supported_band *sband;
2e161f78 1607
1b8ec87a 1608 sband = rdev->wiphy.bands[band];
2e161f78 1609
3713b4e3
JB		 1610 if (!sband)
1611 continue;
1612
1613 nl_band = nla_nest_start(msg, band);
1614 if (!nl_band)
2e161f78 1615 goto nla_put_failure;
3713b4e3 1616
86e8cf98 1617 switch (state->chan_start) {
3713b4e3
JB		 1618 case 0:
1619 if (nl80211_send_band_rateinfo(msg, sband))
9360ffd1 1620 goto nla_put_failure;
86e8cf98
JB		 1621 state->chan_start++;
1622 if (state->split)
3713b4e3
JB		 1623 break;
1624 default:
1625 /* add frequencies */
1626 nl_freqs = nla_nest_start(
1627 msg, NL80211_BAND_ATTR_FREQS);
1628 if (!nl_freqs)
1629 goto nla_put_failure;
1630
86e8cf98 1631 for (i = state->chan_start - 1;
3713b4e3
JB		 1632 i < sband->n_channels;
1633 i++) {
1634 nl_freq = nla_nest_start(msg, i);
1635 if (!nl_freq)
1636 goto nla_put_failure;
1637
1638 chan = &sband->channels[i];
1639
86e8cf98
JB		 1640 if (nl80211_msg_put_channel(
1641 msg, chan,
1642 state->split))
3713b4e3
JB		 1643 goto nla_put_failure;
1644
1645 nla_nest_end(msg, nl_freq);
86e8cf98 1646 if (state->split)
3713b4e3
JB		 1647 break;
1648 }
1649 if (i < sband->n_channels)
86e8cf98 1650 state->chan_start = i + 2;
3713b4e3 1651 else
86e8cf98 1652 state->chan_start = 0;
3713b4e3
JB		 1653 nla_nest_end(msg, nl_freqs);
1654 }
1655
1656 nla_nest_end(msg, nl_band);
1657
86e8cf98 1658 if (state->split) {
3713b4e3 1659 /* start again here */
86e8cf98 1660 if (state->chan_start)
3713b4e3
JB		 1661 band--;
1662 break;
2e161f78 1663 }
2e161f78 1664 }
3713b4e3 1665 nla_nest_end(msg, nl_bands);
2e161f78 1666
57fbcce3 1667 if (band < NUM_NL80211_BANDS)
86e8cf98 1668 state->band_start = band + 1;
3713b4e3 1669 else
86e8cf98 1670 state->band_start = 0;
74b70a4e 1671
3713b4e3 1672 /* if bands & channels are done, continue outside */
86e8cf98
JB		 1673 if (state->band_start == 0 && state->chan_start == 0)
1674 state->split_start++;
1675 if (state->split)
3713b4e3
JB		 1676 break;
1677 case 4:
1678 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1679 if (!nl_cmds)
2e161f78
JB		 1680 goto nla_put_failure;
1681
1794899e
JB		 1682 i = nl80211_add_commands_unsplit(rdev, msg);
1683 if (i < 0)
1684 goto nla_put_failure;
86e8cf98 1685 if (state->split) {
5de17984
AS		 1686 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1687 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1b8ec87a 1688 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
16ef1fe2 1689 CMD(channel_switch, CHANNEL_SWITCH);
02df00eb 1690 CMD(set_qos_map, SET_QOS_MAP);
723e73ac
JB		 1691 if (rdev->wiphy.features &
1692 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
960d01ac 1693 CMD(add_tx_ts, ADD_TX_TS);
ce0ce13a 1694 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
088e8df8 1695 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
5de17984 1696 }
3713b4e3 1697#undef CMD
ff1b6e69 1698
3713b4e3 1699 nla_nest_end(msg, nl_cmds);
86e8cf98
JB		 1700 state->split_start++;
1701 if (state->split)
3713b4e3
JB		 1702 break;
1703 case 5:
1b8ec87a
ZG		 1704 if (rdev->ops->remain_on_channel &&
1705 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
3713b4e3
JB		 1706 nla_put_u32(msg,
1707 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1b8ec87a 1708 rdev->wiphy.max_remain_on_channel_duration))
3713b4e3
JB		 1709 goto nla_put_failure;
1710
1b8ec87a 1711 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
3713b4e3
JB		 1712 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1713 goto nla_put_failure;
1714
1715 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1716 goto nla_put_failure;
86e8cf98
JB		 1717 state->split_start++;
1718 if (state->split)
3713b4e3
JB		 1719 break;
1720 case 6:
1721#ifdef CONFIG_PM
1b8ec87a 1722 if (nl80211_send_wowlan(msg, rdev, state->split))
3713b4e3 1723 goto nla_put_failure;
86e8cf98
JB		 1724 state->split_start++;
1725 if (state->split)
3713b4e3
JB		 1726 break;
1727#else
86e8cf98 1728 state->split_start++;
dfb89c56 1729#endif
3713b4e3
JB		 1730 case 7:
1731 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1b8ec87a 1732 rdev->wiphy.software_iftypes))
3713b4e3 1733 goto nla_put_failure;
ff1b6e69 1734
1b8ec87a 1735 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
86e8cf98 1736 state->split))
3713b4e3 1737 goto nla_put_failure;
7527a782 1738
86e8cf98
JB		 1739 state->split_start++;
1740 if (state->split)
3713b4e3
JB		 1741 break;
1742 case 8:
1b8ec87a 1743 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
3713b4e3 1744 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1b8ec87a 1745 rdev->wiphy.ap_sme_capa))
3713b4e3 1746 goto nla_put_failure;
7527a782 1747
1b8ec87a 1748 features = rdev->wiphy.features;
fe1abafd
JB		 1749 /*
1750 * We can only add the per-channel limit information if the
1751 * dump is split, otherwise it makes it too big. Therefore
1752 * only advertise it in that case.
1753 */
86e8cf98 1754 if (state->split)
fe1abafd
JB		 1755 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1756 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
3713b4e3 1757 goto nla_put_failure;
562a7480 1758
1b8ec87a 1759 if (rdev->wiphy.ht_capa_mod_mask &&
3713b4e3 1760 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1b8ec87a
ZG		 1761 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1762 rdev->wiphy.ht_capa_mod_mask))
3713b4e3 1763 goto nla_put_failure;
1f074bd8 1764
1b8ec87a
ZG		 1765 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1766 rdev->wiphy.max_acl_mac_addrs &&
3713b4e3 1767 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1b8ec87a 1768 rdev->wiphy.max_acl_mac_addrs))
3713b4e3 1769 goto nla_put_failure;
7e7c8926 1770
3713b4e3
JB		 1771 /*
1772 * Any information below this point is only available to
1773 * applications that can deal with it being split. This
1774 * helps ensure that newly added capabilities don't break
1775 * older tools by overrunning their buffers.
1776 *
1777 * We still increment split_start so that in the split
1778 * case we'll continue with more data in the next round,
1779 * but break unconditionally so unsplit data stops here.
1780 */
86e8cf98 1781 state->split_start++;
3713b4e3
JB		 1782 break;
1783 case 9:
1b8ec87a 1784 if (rdev->wiphy.extended_capabilities &&
fe1abafd 1785 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1b8ec87a
ZG		 1786 rdev->wiphy.extended_capabilities_len,
1787 rdev->wiphy.extended_capabilities) ||
fe1abafd 1788 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1b8ec87a
ZG		 1789 rdev->wiphy.extended_capabilities_len,
1790 rdev->wiphy.extended_capabilities_mask)))
fe1abafd 1791 goto nla_put_failure;
a50df0c4 1792
1b8ec87a 1793 if (rdev->wiphy.vht_capa_mod_mask &&
ee2aca34 1794 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1b8ec87a
ZG		 1795 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1796 rdev->wiphy.vht_capa_mod_mask))
ee2aca34
JB		 1797 goto nla_put_failure;
1798
be29b99a
AK		 1799 state->split_start++;
1800 break;
1801 case 10:
1b8ec87a 1802 if (nl80211_send_coalesce(msg, rdev))
be29b99a
AK		 1803 goto nla_put_failure;
1804
1b8ec87a 1805 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
01e0daa4
FF		 1806 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1807 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1808 goto nla_put_failure;
b43504cf 1809
1b8ec87a 1810 if (rdev->wiphy.max_ap_assoc_sta &&
b43504cf 1811 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1b8ec87a 1812 rdev->wiphy.max_ap_assoc_sta))
b43504cf
JM		 1813 goto nla_put_failure;
1814
ad7e718c
JB		 1815 state->split_start++;
1816 break;
1817 case 11:
1b8ec87a 1818 if (rdev->wiphy.n_vendor_commands) {
567ffc35
JB		 1819 const struct nl80211_vendor_cmd_info *info;
1820 struct nlattr *nested;
1821
1822 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1823 if (!nested)
1824 goto nla_put_failure;
1825
1b8ec87a
ZG		 1826 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1827 info = &rdev->wiphy.vendor_commands[i].info;
567ffc35
JB		 1828 if (nla_put(msg, i + 1, sizeof(*info), info))
1829 goto nla_put_failure;
1830 }
1831 nla_nest_end(msg, nested);
1832 }
1833
1b8ec87a 1834 if (rdev->wiphy.n_vendor_events) {
567ffc35
JB		 1835 const struct nl80211_vendor_cmd_info *info;
1836 struct nlattr *nested;
ad7e718c 1837
567ffc35
JB		 1838 nested = nla_nest_start(msg,
1839 NL80211_ATTR_VENDOR_EVENTS);
1840 if (!nested)
ad7e718c 1841 goto nla_put_failure;
567ffc35 1842
1b8ec87a
ZG		 1843 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1844 info = &rdev->wiphy.vendor_events[i];
567ffc35
JB		 1845 if (nla_put(msg, i + 1, sizeof(*info), info))
1846 goto nla_put_failure;
1847 }
1848 nla_nest_end(msg, nested);
1849 }
9a774c78
AO		 1850 state->split_start++;
1851 break;
1852 case 12:
1853 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1854 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1855 rdev->wiphy.max_num_csa_counters))
1856 goto nla_put_failure;
01e0daa4 1857
1bdd716c
AN		 1858 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
1859 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
1860 goto nla_put_failure;
1861
ca986ad9
AVS		 1862 if (rdev->wiphy.max_sched_scan_reqs &&
1863 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
1864 rdev->wiphy.max_sched_scan_reqs))
1865 goto nla_put_failure;
1866
d75bb06b
GKS		 1867 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
1868 sizeof(rdev->wiphy.ext_features),
1869 rdev->wiphy.ext_features))
1870 goto nla_put_failure;
1871
38de03d2
AS		 1872 if (rdev->wiphy.bss_select_support) {
1873 struct nlattr *nested;
1874 u32 bss_select_support = rdev->wiphy.bss_select_support;
1875
1876 nested = nla_nest_start(msg, NL80211_ATTR_BSS_SELECT);
1877 if (!nested)
1878 goto nla_put_failure;
1879
1880 i = 0;
1881 while (bss_select_support) {
1882 if ((bss_select_support & 1) &&
1883 nla_put_flag(msg, i))
1884 goto nla_put_failure;
1885 i++;
1886 bss_select_support >>= 1;
1887 }
1888 nla_nest_end(msg, nested);
1889 }
1890
019ae3a9
KV		 1891 state->split_start++;
1892 break;
1893 case 13:
1894 if (rdev->wiphy.num_iftype_ext_capab &&
1895 rdev->wiphy.iftype_ext_capab) {
1896 struct nlattr *nested_ext_capab, *nested;
1897
1898 nested = nla_nest_start(msg,
1899 NL80211_ATTR_IFTYPE_EXT_CAPA);
1900 if (!nested)
1901 goto nla_put_failure;
1902
1903 for (i = state->capa_start;
1904 i < rdev->wiphy.num_iftype_ext_capab; i++) {
1905 const struct wiphy_iftype_ext_capab *capab;
1906
1907 capab = &rdev->wiphy.iftype_ext_capab[i];
1908
1909 nested_ext_capab = nla_nest_start(msg, i);
1910 if (!nested_ext_capab ||
1911 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
1912 capab->iftype) ||
1913 nla_put(msg, NL80211_ATTR_EXT_CAPA,
1914 capab->extended_capabilities_len,
1915 capab->extended_capabilities) ||
1916 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1917 capab->extended_capabilities_len,
1918 capab->extended_capabilities_mask))
1919 goto nla_put_failure;
1920
1921 nla_nest_end(msg, nested_ext_capab);
1922 if (state->split)
1923 break;
1924 }
1925 nla_nest_end(msg, nested);
1926 if (i < rdev->wiphy.num_iftype_ext_capab) {
1927 state->capa_start = i + 1;
1928 break;
1929 }
1930 }
1931
8585989d
LC		 1932 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
1933 rdev->wiphy.nan_supported_bands))
1934 goto nla_put_failure;
1935
3713b4e3 1936 /* done */
86e8cf98 1937 state->split_start = 0;
3713b4e3
JB		 1938 break;
1939 }
3bb20556 1940 finish:
053c095a
JB		 1941 genlmsg_end(msg, hdr);
1942 return 0;
55682965
JB		 1943
1944 nla_put_failure:
bc3ed28c
TG		 1945 genlmsg_cancel(msg, hdr);
1946 return -EMSGSIZE;
55682965
JB		 1947}
1948
86e8cf98
JB		 1949static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
1950 struct netlink_callback *cb,
1951 struct nl80211_dump_wiphy_state *state)
1952{
c90c39da 1953 struct nlattr **tb = genl_family_attrbuf(&nl80211_fam);
fceb6435
JB		 1954 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb,
1955 nl80211_fam.maxattr, nl80211_policy, NULL);
86e8cf98
JB		 1956 /* ignore parse errors for backward compatibility */
1957 if (ret)
1958 return 0;
1959
1960 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1961 if (tb[NL80211_ATTR_WIPHY])
1962 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1963 if (tb[NL80211_ATTR_WDEV])
1964 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1965 if (tb[NL80211_ATTR_IFINDEX]) {
1966 struct net_device *netdev;
1967 struct cfg80211_registered_device *rdev;
1968 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1969
7f2b8562 1970 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
86e8cf98
JB		 1971 if (!netdev)
1972 return -ENODEV;
1973 if (netdev->ieee80211_ptr) {
f26cbf40 1974 rdev = wiphy_to_rdev(
86e8cf98
JB		 1975 netdev->ieee80211_ptr->wiphy);
1976 state->filter_wiphy = rdev->wiphy_idx;
1977 }
86e8cf98
JB		 1978 }
1979
1980 return 0;
1981}
1982
55682965
JB		 1983static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1984{
645e77de 1985 int idx = 0, ret;
86e8cf98 1986 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
1b8ec87a 1987 struct cfg80211_registered_device *rdev;
3a5a423b 1988
5fe231e8 1989 rtnl_lock();
86e8cf98
JB		 1990 if (!state) {
1991 state = kzalloc(sizeof(*state), GFP_KERNEL);
57ed5cd6
JL		 1992 if (!state) {
1993 rtnl_unlock();
86e8cf98 1994 return -ENOMEM;
3713b4e3 1995 }
86e8cf98
JB		 1996 state->filter_wiphy = -1;
1997 ret = nl80211_dump_wiphy_parse(skb, cb, state);
1998 if (ret) {
1999 kfree(state);
2000 rtnl_unlock();
2001 return ret;
3713b4e3 2002 }
86e8cf98 2003 cb->args[0] = (long)state;
3713b4e3
JB		 2004 }
2005
1b8ec87a
ZG		 2006 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2007 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2008 continue;
86e8cf98 2009 if (++idx <= state->start)
55682965 2010 continue;
86e8cf98 2011 if (state->filter_wiphy != -1 &&
1b8ec87a 2012 state->filter_wiphy != rdev->wiphy_idx)
3713b4e3
JB		 2013 continue;
2014 /* attempt to fit multiple wiphy data chunks into the skb */
2015 do {
3bb20556
JB		 2016 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
2017 skb,
3713b4e3
JB		 2018 NETLINK_CB(cb->skb).portid,
2019 cb->nlh->nlmsg_seq,
86e8cf98 2020 NLM_F_MULTI, state);
3713b4e3
JB		 2021 if (ret < 0) {
2022 /*
2023 * If sending the wiphy data didn't fit (ENOBUFS
2024 * or EMSGSIZE returned), this SKB is still
2025 * empty (so it's not too big because another
2026 * wiphy dataset is already in the skb) and
2027 * we've not tried to adjust the dump allocation
2028 * yet ... then adjust the alloc size to be
2029 * bigger, and return 1 but with the empty skb.
2030 * This results in an empty message being RX'ed
2031 * in userspace, but that is ignored.
2032 *
2033 * We can then retry with the larger buffer.
2034 */
2035 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
f12cb289 2036 !skb->len && !state->split &&
3713b4e3
JB		 2037 cb->min_dump_alloc < 4096) {
2038 cb->min_dump_alloc = 4096;
f12cb289 2039 state->split_start = 0;
d98cae64 2040 rtnl_unlock();
3713b4e3
JB		 2041 return 1;
2042 }
2043 idx--;
2044 break;
645e77de 2045 }
86e8cf98 2046 } while (state->split_start > 0);
3713b4e3 2047 break;
55682965 2048 }
5fe231e8 2049 rtnl_unlock();
55682965 2050
86e8cf98 2051 state->start = idx;
55682965
JB		 2052
2053 return skb->len;
2054}
2055
86e8cf98
JB		 2056static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2057{
2058 kfree((void *)cb->args[0]);
2059 return 0;
2060}
2061
55682965
JB		 2062static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2063{
2064 struct sk_buff *msg;
1b8ec87a 2065 struct cfg80211_registered_device *rdev = info->user_ptr[0];
86e8cf98 2066 struct nl80211_dump_wiphy_state state = {};
55682965 2067
645e77de 2068 msg = nlmsg_new(4096, GFP_KERNEL);
55682965 2069 if (!msg)
4c476991 2070 return -ENOMEM;
55682965 2071
3bb20556
JB		 2072 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2073 info->snd_portid, info->snd_seq, 0,
86e8cf98 2074 &state) < 0) {
4c476991
JB		 2075 nlmsg_free(msg);
2076 return -ENOBUFS;
2077 }
55682965 2078
134e6375 2079 return genlmsg_reply(msg, info);
55682965
JB		 2080}
2081
31888487
JM		 2082static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2083 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2084 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2085 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2086 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2087 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2088};
2089
2090static int parse_txq_params(struct nlattr *tb[],
2091 struct ieee80211_txq_params *txq_params)
2092{
c7cb043b
DW		 2093 u8 ac;
2094
a3304b0a 2095 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
31888487
JM		 2096 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2097 !tb[NL80211_TXQ_ATTR_AIFS])
2098 return -EINVAL;
2099
c7cb043b 2100 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
31888487
JM		 2101 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2102 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2103 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2104 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2105
c7cb043b 2106 if (ac >= NL80211_NUM_ACS)
a3304b0a 2107 return -EINVAL;
c7cb043b 2108 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
31888487
JM		 2109 return 0;
2110}
2111
f444de05
JB		 2112static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2113{
2114 /*
cc1d2806
JB		 2115 * You can only set the channel explicitly for WDS interfaces,
2116 * all others have their channel managed via their respective
2117 * "establish a connection" command (connect, join, ...)
2118 *
2119 * For AP/GO and mesh mode, the channel can be set with the
2120 * channel userspace API, but is only stored and passed to the
2121 * low-level driver when the AP starts or the mesh is joined.
2122 * This is for backward compatibility, userspace can also give
2123 * the channel in the start-ap or join-mesh commands instead.
f444de05
JB		 2124 *
2125 * Monitors are special as they are normally slaved to
e8c9bd5b
JB		 2126 * whatever else is going on, so they have their own special
2127 * operation to set the monitor channel if possible.
f444de05
JB		 2128 */
2129 return !wdev ||
2130 wdev->iftype == NL80211_IFTYPE_AP ||
f444de05 2131 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
074ac8df
JB		 2132 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2133 wdev->iftype == NL80211_IFTYPE_P2P_GO;
f444de05
JB		 2134}
2135
683b6d3b
JB		 2136static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2137 struct genl_info *info,
2138 struct cfg80211_chan_def *chandef)
2139{
dbeca2ea 2140 u32 control_freq;
683b6d3b
JB		 2141
2142 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
2143 return -EINVAL;
2144
2145 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
2146
2e85f3b1
JB		 2147 memset(chandef, 0, sizeof(*chandef));
2148
683b6d3b 2149 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
3d9d1d66
JB		 2150 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2151 chandef->center_freq1 = control_freq;
2152 chandef->center_freq2 = 0;
683b6d3b
JB		 2153
2154 /* Primary channel not allowed */
2155 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
2156 return -EINVAL;
2157
3d9d1d66
JB		 2158 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2159 enum nl80211_channel_type chantype;
2160
2161 chantype = nla_get_u32(
2162 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2163
2164 switch (chantype) {
2165 case NL80211_CHAN_NO_HT:
2166 case NL80211_CHAN_HT20:
2167 case NL80211_CHAN_HT40PLUS:
2168 case NL80211_CHAN_HT40MINUS:
2169 cfg80211_chandef_create(chandef, chandef->chan,
2170 chantype);
ffa4629e
TM		 2171 /* user input for center_freq is incorrect */
2172 if (info->attrs[NL80211_ATTR_CENTER_FREQ1] &&
2173 chandef->center_freq1 != nla_get_u32(
2174 info->attrs[NL80211_ATTR_CENTER_FREQ1]))
2175 return -EINVAL;
2176 /* center_freq2 must be zero */
2177 if (info->attrs[NL80211_ATTR_CENTER_FREQ2] &&
2178 nla_get_u32(info->attrs[NL80211_ATTR_CENTER_FREQ2]))
2179 return -EINVAL;
3d9d1d66
JB		 2180 break;
2181 default:
2182 return -EINVAL;
2183 }
2184 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2185 chandef->width =
2186 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2187 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
2188 chandef->center_freq1 =
2189 nla_get_u32(
2190 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
2191 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
2192 chandef->center_freq2 =
2193 nla_get_u32(
2194 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
2195 }
2196
9f5e8f6e 2197 if (!cfg80211_chandef_valid(chandef))
3d9d1d66
JB		 2198 return -EINVAL;
2199
9f5e8f6e
JB		 2200 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2201 IEEE80211_CHAN_DISABLED))
3d9d1d66
JB		 2202 return -EINVAL;
2203
2f301ab2
SW		 2204 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2205 chandef->width == NL80211_CHAN_WIDTH_10) &&
2206 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ))
2207 return -EINVAL;
2208
683b6d3b
JB		 2209 return 0;
2210}
2211
f444de05 2212static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
e16821bc 2213 struct net_device *dev,
f444de05
JB		 2214 struct genl_info *info)
2215{
683b6d3b 2216 struct cfg80211_chan_def chandef;
f444de05 2217 int result;
e8c9bd5b 2218 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
e16821bc 2219 struct wireless_dev *wdev = NULL;
e8c9bd5b 2220
e16821bc
JM		 2221 if (dev)
2222 wdev = dev->ieee80211_ptr;
f444de05
JB		 2223 if (!nl80211_can_set_dev_channel(wdev))
2224 return -EOPNOTSUPP;
e16821bc
JM		 2225 if (wdev)
2226 iftype = wdev->iftype;
f444de05 2227
683b6d3b
JB		 2228 result = nl80211_parse_chandef(rdev, info, &chandef);
2229 if (result)
2230 return result;
f444de05 2231
e8c9bd5b 2232 switch (iftype) {
aa430da4
JB		 2233 case NL80211_IFTYPE_AP:
2234 case NL80211_IFTYPE_P2P_GO:
923b352f
AN		 2235 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2236 iftype)) {
aa430da4
JB		 2237 result = -EINVAL;
2238 break;
2239 }
e16821bc
JM		 2240 if (wdev->beacon_interval) {
2241 if (!dev || !rdev->ops->set_ap_chanwidth ||
2242 !(rdev->wiphy.features &
2243 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2244 result = -EBUSY;
2245 break;
2246 }
2247
2248 /* Only allow dynamic channel width changes */
2249 if (chandef.chan != wdev->preset_chandef.chan) {
2250 result = -EBUSY;
2251 break;
2252 }
2253 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2254 if (result)
2255 break;
2256 }
683b6d3b 2257 wdev->preset_chandef = chandef;
aa430da4
JB		 2258 result = 0;
2259 break;
cc1d2806 2260 case NL80211_IFTYPE_MESH_POINT:
683b6d3b 2261 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
cc1d2806 2262 break;
e8c9bd5b 2263 case NL80211_IFTYPE_MONITOR:
683b6d3b 2264 result = cfg80211_set_monitor_channel(rdev, &chandef);
e8c9bd5b 2265 break;
aa430da4 2266 default:
e8c9bd5b 2267 result = -EINVAL;
f444de05 2268 }
f444de05
JB		 2269
2270 return result;
2271}
2272
2273static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2274{
4c476991
JB		 2275 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2276 struct net_device *netdev = info->user_ptr[1];
f444de05 2277
e16821bc 2278 return __nl80211_set_channel(rdev, netdev, info);
f444de05
JB		 2279}
2280
e8347eba
BJ		 2281static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2282{
43b19952
JB		 2283 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2284 struct net_device *dev = info->user_ptr[1];
2285 struct wireless_dev *wdev = dev->ieee80211_ptr;
388ac775 2286 const u8 *bssid;
e8347eba
BJ		 2287
2288 if (!info->attrs[NL80211_ATTR_MAC])
2289 return -EINVAL;
2290
43b19952
JB		 2291 if (netif_running(dev))
2292 return -EBUSY;
e8347eba 2293
43b19952
JB		 2294 if (!rdev->ops->set_wds_peer)
2295 return -EOPNOTSUPP;
e8347eba 2296
43b19952
JB		 2297 if (wdev->iftype != NL80211_IFTYPE_WDS)
2298 return -EOPNOTSUPP;
e8347eba
BJ		 2299
2300 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
e35e4d28 2301 return rdev_set_wds_peer(rdev, dev, bssid);
e8347eba
BJ		 2302}
2303
55682965
JB		 2304static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2305{
2306 struct cfg80211_registered_device *rdev;
f444de05
JB		 2307 struct net_device *netdev = NULL;
2308 struct wireless_dev *wdev;
a1e567c8 2309 int result = 0, rem_txq_params = 0;
31888487 2310 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 2311 u32 changed;
2312 u8 retry_short = 0, retry_long = 0;
2313 u32 frag_threshold = 0, rts_threshold = 0;
81077e82 2314 u8 coverage_class = 0;
55682965 2315
5fe231e8
JB		 2316 ASSERT_RTNL();
2317
f444de05
JB		 2318 /*
2319 * Try to find the wiphy and netdev. Normally this
2320 * function shouldn't need the netdev, but this is
2321 * done for backward compatibility -- previously
2322 * setting the channel was done per wiphy, but now
2323 * it is per netdev. Previous userland like hostapd
2324 * also passed a netdev to set_wiphy, so that it is
2325 * possible to let that go to the right netdev!
2326 */
4bbf4d56 2327
f444de05
JB		 2328 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2329 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2330
7f2b8562 2331 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
5fe231e8 2332 if (netdev && netdev->ieee80211_ptr)
f26cbf40 2333 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
5fe231e8 2334 else
f444de05 2335 netdev = NULL;
4bbf4d56
JB		 2336 }
2337
f444de05 2338 if (!netdev) {
878d9ec7
JB		 2339 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2340 info->attrs);
5fe231e8 2341 if (IS_ERR(rdev))
4c476991 2342 return PTR_ERR(rdev);
f444de05
JB		 2343 wdev = NULL;
2344 netdev = NULL;
2345 result = 0;
71fe96bf 2346 } else
f444de05 2347 wdev = netdev->ieee80211_ptr;
f444de05
JB		 2348
2349 /*
2350 * end workaround code, by now the rdev is available
2351 * and locked, and wdev may or may not be NULL.
2352 */
4bbf4d56
JB		 2353
2354 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 2355 result = cfg80211_dev_rename(
2356 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56 2357
4bbf4d56 2358 if (result)
7f2b8562 2359 return result;
31888487
JM		 2360
2361 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2362 struct ieee80211_txq_params txq_params;
2363 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2364
7f2b8562
YX		 2365 if (!rdev->ops->set_txq_params)
2366 return -EOPNOTSUPP;
31888487 2367
7f2b8562
YX		 2368 if (!netdev)
2369 return -EINVAL;
f70f01c2 2370
133a3ff2 2371 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7f2b8562
YX		 2372 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2373 return -EINVAL;
133a3ff2 2374
7f2b8562
YX		 2375 if (!netif_running(netdev))
2376 return -ENETDOWN;
2b5f8b0b 2377
31888487
JM		 2378 nla_for_each_nested(nl_txq_params,
2379 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2380 rem_txq_params) {
bfe2c7b1
JB		 2381 result = nla_parse_nested(tb, NL80211_TXQ_ATTR_MAX,
2382 nl_txq_params,
fe52145f
JB		 2383 txq_params_policy,
2384 info->extack);
ae811e21
JB		 2385 if (result)
2386 return result;
31888487
JM		 2387 result = parse_txq_params(tb, &txq_params);
2388 if (result)
7f2b8562 2389 return result;
31888487 2390
e35e4d28
HG		 2391 result = rdev_set_txq_params(rdev, netdev,
2392 &txq_params);
31888487 2393 if (result)
7f2b8562 2394 return result;
31888487
JM		 2395 }
2396 }
55682965 2397
72bdcf34 2398 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
e16821bc
JM		 2399 result = __nl80211_set_channel(
2400 rdev,
2401 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2402 info);
72bdcf34 2403 if (result)
7f2b8562 2404 return result;
72bdcf34
JM		 2405 }
2406
98d2ff8b 2407 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
c8442118 2408 struct wireless_dev *txp_wdev = wdev;
98d2ff8b
JO		 2409 enum nl80211_tx_power_setting type;
2410 int idx, mbm = 0;
2411
c8442118
JB		 2412 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2413 txp_wdev = NULL;
2414
7f2b8562
YX		 2415 if (!rdev->ops->set_tx_power)
2416 return -EOPNOTSUPP;
98d2ff8b
JO		 2417
2418 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2419 type = nla_get_u32(info->attrs[idx]);
2420
2421 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
7f2b8562
YX		 2422 (type != NL80211_TX_POWER_AUTOMATIC))
2423 return -EINVAL;
98d2ff8b
JO		 2424
2425 if (type != NL80211_TX_POWER_AUTOMATIC) {
2426 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2427 mbm = nla_get_u32(info->attrs[idx]);
2428 }
2429
c8442118 2430 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
98d2ff8b 2431 if (result)
7f2b8562 2432 return result;
98d2ff8b
JO		 2433 }
2434
afe0cbf8
BR		 2435 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2436 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2437 u32 tx_ant, rx_ant;
7a087e74 2438
7f531e03
BR		 2439 if ((!rdev->wiphy.available_antennas_tx &&
2440 !rdev->wiphy.available_antennas_rx) ||
7f2b8562
YX		 2441 !rdev->ops->set_antenna)
2442 return -EOPNOTSUPP;
afe0cbf8
BR		 2443
2444 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2445 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2446
a7ffac95 2447 /* reject antenna configurations which don't match the
7f531e03
BR		 2448 * available antenna masks, except for the "all" mask */
2449 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
7f2b8562
YX		 2450 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2451 return -EINVAL;
a7ffac95 2452
7f531e03
BR		 2453 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2454 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
a7ffac95 2455
e35e4d28 2456 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
afe0cbf8 2457 if (result)
7f2b8562 2458 return result;
afe0cbf8
BR		 2459 }
2460
b9a5f8ca
JM		 2461 changed = 0;
2462
2463 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2464 retry_short = nla_get_u8(
2465 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
7f2b8562
YX		 2466 if (retry_short == 0)
2467 return -EINVAL;
2468
b9a5f8ca
JM		 2469 changed |= WIPHY_PARAM_RETRY_SHORT;
2470 }
2471
2472 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2473 retry_long = nla_get_u8(
2474 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
7f2b8562
YX		 2475 if (retry_long == 0)
2476 return -EINVAL;
2477
b9a5f8ca
JM		 2478 changed |= WIPHY_PARAM_RETRY_LONG;
2479 }
2480
2481 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2482 frag_threshold = nla_get_u32(
2483 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
7f2b8562
YX		 2484 if (frag_threshold < 256)
2485 return -EINVAL;
2486
b9a5f8ca
JM		 2487 if (frag_threshold != (u32) -1) {
2488 /*
2489 * Fragments (apart from the last one) are required to
2490 * have even length. Make the fragmentation code
2491 * simpler by stripping LSB should someone try to use
2492 * odd threshold value.
2493 */
2494 frag_threshold &= ~0x1;
2495 }
2496 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2497 }
2498
2499 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2500 rts_threshold = nla_get_u32(
2501 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2502 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2503 }
2504
81077e82 2505 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3057dbfd
LB		 2506 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2507 return -EINVAL;
2508
81077e82
LT		 2509 coverage_class = nla_get_u8(
2510 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2511 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2512 }
2513
3057dbfd
LB		 2514 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2515 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2516 return -EOPNOTSUPP;
2517
2518 changed |= WIPHY_PARAM_DYN_ACK;
81077e82
LT		 2519 }
2520
b9a5f8ca
JM		 2521 if (changed) {
2522 u8 old_retry_short, old_retry_long;
2523 u32 old_frag_threshold, old_rts_threshold;
81077e82 2524 u8 old_coverage_class;
b9a5f8ca 2525
7f2b8562
YX		 2526 if (!rdev->ops->set_wiphy_params)
2527 return -EOPNOTSUPP;
b9a5f8ca
JM		 2528
2529 old_retry_short = rdev->wiphy.retry_short;
2530 old_retry_long = rdev->wiphy.retry_long;
2531 old_frag_threshold = rdev->wiphy.frag_threshold;
2532 old_rts_threshold = rdev->wiphy.rts_threshold;
81077e82 2533 old_coverage_class = rdev->wiphy.coverage_class;
b9a5f8ca
JM		 2534
2535 if (changed & WIPHY_PARAM_RETRY_SHORT)
2536 rdev->wiphy.retry_short = retry_short;
2537 if (changed & WIPHY_PARAM_RETRY_LONG)
2538 rdev->wiphy.retry_long = retry_long;
2539 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2540 rdev->wiphy.frag_threshold = frag_threshold;
2541 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2542 rdev->wiphy.rts_threshold = rts_threshold;
81077e82
LT		 2543 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2544 rdev->wiphy.coverage_class = coverage_class;
b9a5f8ca 2545
e35e4d28 2546 result = rdev_set_wiphy_params(rdev, changed);
b9a5f8ca
JM		 2547 if (result) {
2548 rdev->wiphy.retry_short = old_retry_short;
2549 rdev->wiphy.retry_long = old_retry_long;
2550 rdev->wiphy.frag_threshold = old_frag_threshold;
2551 rdev->wiphy.rts_threshold = old_rts_threshold;
81077e82 2552 rdev->wiphy.coverage_class = old_coverage_class;
9189ee31 2553 return result;
b9a5f8ca
JM		 2554 }
2555 }
7f2b8562 2556 return 0;
55682965
JB		 2557}
2558
71bbc994
JB		 2559static inline u64 wdev_id(struct wireless_dev *wdev)
2560{
2561 return (u64)wdev->identifier |
f26cbf40 2562 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
71bbc994 2563}
55682965 2564
683b6d3b 2565static int nl80211_send_chandef(struct sk_buff *msg,
d2859df5 2566 const struct cfg80211_chan_def *chandef)
683b6d3b 2567{
601555cd
JB		 2568 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2569 return -EINVAL;
3d9d1d66 2570
683b6d3b
JB		 2571 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2572 chandef->chan->center_freq))
2573 return -ENOBUFS;
3d9d1d66
JB		 2574 switch (chandef->width) {
2575 case NL80211_CHAN_WIDTH_20_NOHT:
2576 case NL80211_CHAN_WIDTH_20:
2577 case NL80211_CHAN_WIDTH_40:
2578 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2579 cfg80211_get_chandef_type(chandef)))
2580 return -ENOBUFS;
2581 break;
2582 default:
2583 break;
2584 }
2585 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2586 return -ENOBUFS;
2587 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2588 return -ENOBUFS;
2589 if (chandef->center_freq2 &&
2590 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
683b6d3b
JB		 2591 return -ENOBUFS;
2592 return 0;
2593}
2594
15e47304 2595static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
d726405a 2596 struct cfg80211_registered_device *rdev,
8f894be2 2597 struct wireless_dev *wdev, bool removal)
55682965 2598{
72fb2abc 2599 struct net_device *dev = wdev->netdev;
8f894be2 2600 u8 cmd = NL80211_CMD_NEW_INTERFACE;
55682965
JB		 2601 void *hdr;
2602
8f894be2
TB		 2603 if (removal)
2604 cmd = NL80211_CMD_DEL_INTERFACE;
2605
2606 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
55682965
JB		 2607 if (!hdr)
2608 return -1;
2609
72fb2abc
JB		 2610 if (dev &&
2611 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
98104fde 2612 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
72fb2abc
JB		 2613 goto nla_put_failure;
2614
2615 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2616 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2dad624e
ND		 2617 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
2618 NL80211_ATTR_PAD) ||
98104fde 2619 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
9360ffd1
DM		 2620 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2621 rdev->devlist_generation ^
2622 (cfg80211_rdev_list_generation << 2)))
2623 goto nla_put_failure;
f5ea9120 2624
5b7ccaf3 2625 if (rdev->ops->get_channel) {
683b6d3b 2626 int ret;
2e85f3b1 2627 struct cfg80211_chan_def chandef = {};
683b6d3b
JB		 2628
2629 ret = rdev_get_channel(rdev, wdev, &chandef);
2630 if (ret == 0) {
2631 if (nl80211_send_chandef(msg, &chandef))
2632 goto nla_put_failure;
2633 }
d91df0e3
PF		 2634 }
2635
d55d0d59
RM		 2636 if (rdev->ops->get_tx_power) {
2637 int dbm, ret;
2638
2639 ret = rdev_get_tx_power(rdev, wdev, &dbm);
2640 if (ret == 0 &&
2641 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
2642 DBM_TO_MBM(dbm)))
2643 goto nla_put_failure;
2644 }
2645
44905265
JB		 2646 wdev_lock(wdev);
2647 switch (wdev->iftype) {
2648 case NL80211_IFTYPE_AP:
2649 if (wdev->ssid_len &&
2650 nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
4564b187 2651 goto nla_put_failure_locked;
44905265
JB		 2652 break;
2653 case NL80211_IFTYPE_STATION:
2654 case NL80211_IFTYPE_P2P_CLIENT:
2655 case NL80211_IFTYPE_ADHOC: {
2656 const u8 *ssid_ie;
2657 if (!wdev->current_bss)
2658 break;
7a94b8c2 2659 rcu_read_lock();
44905265
JB		 2660 ssid_ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
2661 WLAN_EID_SSID);
7a94b8c2
DB		 2662 if (ssid_ie &&
2663 nla_put(msg, NL80211_ATTR_SSID, ssid_ie[1], ssid_ie + 2))
2664 goto nla_put_failure_rcu_locked;
2665 rcu_read_unlock();
44905265
JB		 2666 break;
2667 }
2668 default:
2669 /* nothing */
2670 break;
b84e7a05 2671 }
44905265 2672 wdev_unlock(wdev);
b84e7a05 2673
053c095a
JB		 2674 genlmsg_end(msg, hdr);
2675 return 0;
55682965 2676
7a94b8c2
DB		 2677 nla_put_failure_rcu_locked:
2678 rcu_read_unlock();
4564b187
JB		 2679 nla_put_failure_locked:
2680 wdev_unlock(wdev);
55682965 2681 nla_put_failure:
bc3ed28c
TG		 2682 genlmsg_cancel(msg, hdr);
2683 return -EMSGSIZE;
55682965
JB		 2684}
2685
2686static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2687{
2688 int wp_idx = 0;
2689 int if_idx = 0;
2690 int wp_start = cb->args[0];
2691 int if_start = cb->args[1];
b7fb44da 2692 int filter_wiphy = -1;
f5ea9120 2693 struct cfg80211_registered_device *rdev;
55682965 2694 struct wireless_dev *wdev;
ea90e0dc 2695 int ret;
55682965 2696
5fe231e8 2697 rtnl_lock();
b7fb44da
DK		 2698 if (!cb->args[2]) {
2699 struct nl80211_dump_wiphy_state state = {
2700 .filter_wiphy = -1,
2701 };
b7fb44da
DK		 2702
2703 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
2704 if (ret)
ea90e0dc 2705 goto out_unlock;
b7fb44da
DK		 2706
2707 filter_wiphy = state.filter_wiphy;
2708
2709 /*
2710 * if filtering, set cb->args[2] to +1 since 0 is the default
2711 * value needed to determine that parsing is necessary.
2712 */
2713 if (filter_wiphy >= 0)
2714 cb->args[2] = filter_wiphy + 1;
2715 else
2716 cb->args[2] = -1;
2717 } else if (cb->args[2] > 0) {
2718 filter_wiphy = cb->args[2] - 1;
2719 }
2720
f5ea9120
JB		 2721 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2722 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2723 continue;
bba95fef
JB		 2724 if (wp_idx < wp_start) {
2725 wp_idx++;
55682965 2726 continue;
bba95fef 2727 }
b7fb44da
DK		 2728
2729 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
2730 continue;
2731
55682965
JB		 2732 if_idx = 0;
2733
53873f13 2734 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
bba95fef
JB		 2735 if (if_idx < if_start) {
2736 if_idx++;
55682965 2737 continue;
bba95fef 2738 }
15e47304 2739 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
55682965 2740 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8f894be2 2741 rdev, wdev, false) < 0) {
bba95fef
JB		 2742 goto out;
2743 }
2744 if_idx++;
55682965 2745 }
bba95fef
JB		 2746
2747 wp_idx++;
55682965 2748 }
bba95fef 2749 out:
55682965
JB		 2750 cb->args[0] = wp_idx;
2751 cb->args[1] = if_idx;
2752
ea90e0dc
JB		 2753 ret = skb->len;
2754 out_unlock:
2755 rtnl_unlock();
2756
2757 return ret;
55682965
JB		 2758}
2759
2760static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2761{
2762 struct sk_buff *msg;
1b8ec87a 2763 struct cfg80211_registered_device *rdev = info->user_ptr[0];
72fb2abc 2764 struct wireless_dev *wdev = info->user_ptr[1];
55682965 2765
fd2120ca 2766 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965 2767 if (!msg)
4c476991 2768 return -ENOMEM;
55682965 2769
15e47304 2770 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2771 rdev, wdev, false) < 0) {
4c476991
JB		 2772 nlmsg_free(msg);
2773 return -ENOBUFS;
2774 }
55682965 2775
134e6375 2776 return genlmsg_reply(msg, info);
55682965
JB		 2777}
2778
66f7ac50
MW		 2779static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2780 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2781 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2782 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2783 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2784 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
e057d3c3 2785 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
66f7ac50
MW		 2786};
2787
2788static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2789{
2790 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2791 int flag;
2792
2793 *mntrflags = 0;
2794
2795 if (!nla)
2796 return -EINVAL;
2797
fceb6435
JB		 2798 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX, nla,
2799 mntr_flags_policy, NULL))
66f7ac50
MW		 2800 return -EINVAL;
2801
2802 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2803 if (flags[flag])
2804 *mntrflags |= (1<<flag);
2805
818a986e
JB		 2806 *mntrflags |= MONITOR_FLAG_CHANGED;
2807
66f7ac50
MW		 2808 return 0;
2809}
2810
1db77596
JB		 2811static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
2812 enum nl80211_iftype type,
2813 struct genl_info *info,
2814 struct vif_params *params)
2815{
2816 bool change = false;
2817 int err;
2818
2819 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2820 if (type != NL80211_IFTYPE_MONITOR)
2821 return -EINVAL;
2822
2823 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2824 &params->flags);
2825 if (err)
2826 return err;
2827
2828 change = true;
2829 }
2830
2831 if (params->flags & MONITOR_FLAG_ACTIVE &&
2832 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2833 return -EOPNOTSUPP;
2834
2835 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
2836 const u8 *mumimo_groups;
2837 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2838
2839 if (type != NL80211_IFTYPE_MONITOR)
2840 return -EINVAL;
2841
2842 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2843 return -EOPNOTSUPP;
2844
2845 mumimo_groups =
2846 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
2847
2848 /* bits 0 and 63 are reserved and must be zero */
4954601f
JB		 2849 if ((mumimo_groups[0] & BIT(0)) ||
2850 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
1db77596
JB		 2851 return -EINVAL;
2852
2853 params->vht_mumimo_groups = mumimo_groups;
2854 change = true;
2855 }
2856
2857 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
2858 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2859
2860 if (type != NL80211_IFTYPE_MONITOR)
2861 return -EINVAL;
2862
2863 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2864 return -EOPNOTSUPP;
2865
2866 params->vht_mumimo_follow_addr =
2867 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
2868 change = true;
2869 }
2870
2871 return change ? 1 : 0;
2872}
2873
9bc383de 2874static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
ad4bb6f8
JB		 2875 struct net_device *netdev, u8 use_4addr,
2876 enum nl80211_iftype iftype)
9bc383de 2877{
ad4bb6f8 2878 if (!use_4addr) {
f350a0a8 2879 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
ad4bb6f8 2880 return -EBUSY;
9bc383de 2881 return 0;
ad4bb6f8 2882 }
9bc383de
JB		 2883
2884 switch (iftype) {
2885 case NL80211_IFTYPE_AP_VLAN:
2886 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2887 return 0;
2888 break;
2889 case NL80211_IFTYPE_STATION:
2890 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2891 return 0;
2892 break;
2893 default:
2894 break;
2895 }
2896
2897 return -EOPNOTSUPP;
2898}
2899
55682965
JB		 2900static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2901{
4c476991 2902 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2903 struct vif_params params;
e36d56b6 2904 int err;
04a773ad 2905 enum nl80211_iftype otype, ntype;
4c476991 2906 struct net_device *dev = info->user_ptr[1];
ac7f9cfa 2907 bool change = false;
55682965 2908
2ec600d6
LCC		 2909 memset(&params, 0, sizeof(params));
2910
04a773ad 2911 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 2912
723b038d 2913 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 2914 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 2915 if (otype != ntype)
ac7f9cfa 2916 change = true;
4c476991
JB		 2917 if (ntype > NL80211_IFTYPE_MAX)
2918 return -EINVAL;
723b038d
JB		 2919 }
2920
92ffe055 2921 if (info->attrs[NL80211_ATTR_MESH_ID]) {
29cbe68c
JB		 2922 struct wireless_dev *wdev = dev->ieee80211_ptr;
2923
4c476991
JB		 2924 if (ntype != NL80211_IFTYPE_MESH_POINT)
2925 return -EINVAL;
29cbe68c
JB		 2926 if (netif_running(dev))
2927 return -EBUSY;
2928
2929 wdev_lock(wdev);
2930 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2931 IEEE80211_MAX_MESH_ID_LEN);
2932 wdev->mesh_id_up_len =
2933 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2934 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2935 wdev->mesh_id_up_len);
2936 wdev_unlock(wdev);
2ec600d6
LCC		 2937 }
2938
8b787643
FF		 2939 if (info->attrs[NL80211_ATTR_4ADDR]) {
2940 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2941 change = true;
ad4bb6f8 2942 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
9bc383de 2943 if (err)
4c476991 2944 return err;
8b787643
FF		 2945 } else {
2946 params.use_4addr = -1;
2947 }
2948
1db77596
JB		 2949 err = nl80211_parse_mon_options(rdev, ntype, info, &params);
2950 if (err < 0)
2951 return err;
2952 if (err > 0)
c6e6a0c8 2953 change = true;
e057d3c3 2954
ac7f9cfa 2955 if (change)
818a986e 2956 err = cfg80211_change_iface(rdev, dev, ntype, &params);
ac7f9cfa
JB		 2957 else
2958 err = 0;
60719ffd 2959
9bc383de
JB		 2960 if (!err && params.use_4addr != -1)
2961 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2962
55682965
JB		 2963 return err;
2964}
2965
2966static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2967{
4c476991 2968 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2969 struct vif_params params;
84efbb84 2970 struct wireless_dev *wdev;
896ff063 2971 struct sk_buff *msg;
55682965
JB		 2972 int err;
2973 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2974
78f22b6a
JB		 2975 /* to avoid failing a new interface creation due to pending removal */
2976 cfg80211_destroy_ifaces(rdev);
2977
2ec600d6
LCC		 2978 memset(&params, 0, sizeof(params));
2979
55682965
JB		 2980 if (!info->attrs[NL80211_ATTR_IFNAME])
2981 return -EINVAL;
2982
2983 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2984 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2985 if (type > NL80211_IFTYPE_MAX)
2986 return -EINVAL;
2987 }
2988
5378c941 2989 if (!rdev->ops->add_virtual_intf)
4c476991 2990 return -EOPNOTSUPP;
55682965 2991
cb3b7d87 2992 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
e8f479b1
BG		 2993 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2994 info->attrs[NL80211_ATTR_MAC]) {
1c18f145
AS		 2995 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2996 ETH_ALEN);
2997 if (!is_valid_ether_addr(params.macaddr))
2998 return -EADDRNOTAVAIL;
2999 }
3000
9bc383de 3001 if (info->attrs[NL80211_ATTR_4ADDR]) {
8b787643 3002 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
ad4bb6f8 3003 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
9bc383de 3004 if (err)
4c476991 3005 return err;
9bc383de 3006 }
8b787643 3007
f160a6fe 3008 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
5378c941
MP		 3009 return -EOPNOTSUPP;
3010
1db77596
JB		 3011 err = nl80211_parse_mon_options(rdev, type, info, &params);
3012 if (err < 0)
3013 return err;
e057d3c3 3014
a18c7192
JB		 3015 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3016 if (!msg)
3017 return -ENOMEM;
3018
e35e4d28
HG		 3019 wdev = rdev_add_virtual_intf(rdev,
3020 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
818a986e 3021 NET_NAME_USER, type, &params);
d687cbb7
RM		 3022 if (WARN_ON(!wdev)) {
3023 nlmsg_free(msg);
3024 return -EPROTO;
3025 } else if (IS_ERR(wdev)) {
1c90f9d4 3026 nlmsg_free(msg);
84efbb84 3027 return PTR_ERR(wdev);
1c90f9d4 3028 }
2ec600d6 3029
18e5ca65 3030 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
78f22b6a
JB		 3031 wdev->owner_nlportid = info->snd_portid;
3032
98104fde
JB		 3033 switch (type) {
3034 case NL80211_IFTYPE_MESH_POINT:
3035 if (!info->attrs[NL80211_ATTR_MESH_ID])
3036 break;
29cbe68c
JB		 3037 wdev_lock(wdev);
3038 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3039 IEEE80211_MAX_MESH_ID_LEN);
3040 wdev->mesh_id_up_len =
3041 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3042 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3043 wdev->mesh_id_up_len);
3044 wdev_unlock(wdev);
98104fde 3045 break;
cb3b7d87 3046 case NL80211_IFTYPE_NAN:
98104fde
JB		 3047 case NL80211_IFTYPE_P2P_DEVICE:
3048 /*
cb3b7d87 3049 * P2P Device and NAN do not have a netdev, so don't go
98104fde
JB		 3050 * through the netdev notifier and must be added here
3051 */
3052 mutex_init(&wdev->mtx);
3053 INIT_LIST_HEAD(&wdev->event_list);
3054 spin_lock_init(&wdev->event_lock);
3055 INIT_LIST_HEAD(&wdev->mgmt_registrations);
3056 spin_lock_init(&wdev->mgmt_registrations_lock);
3057
98104fde 3058 wdev->identifier = ++rdev->wdev_id;
53873f13 3059 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
98104fde 3060 rdev->devlist_generation++;
98104fde
JB		 3061 break;
3062 default:
3063 break;
29cbe68c
JB		 3064 }
3065
15e47304 3066 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 3067 rdev, wdev, false) < 0) {
1c90f9d4
JB		 3068 nlmsg_free(msg);
3069 return -ENOBUFS;
3070 }
3071
896ff063
DK		 3072 /*
3073 * For wdevs which have no associated netdev object (e.g. of type
3074 * NL80211_IFTYPE_P2P_DEVICE), emit the NEW_INTERFACE event here.
3075 * For all other types, the event will be generated from the
3076 * netdev notifier
3077 */
3078 if (!wdev->netdev)
3079 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
8f894be2 3080
1c90f9d4 3081 return genlmsg_reply(msg, info);
55682965
JB		 3082}
3083
3084static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3085{
4c476991 3086 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84efbb84 3087 struct wireless_dev *wdev = info->user_ptr[1];
55682965 3088
4c476991
JB		 3089 if (!rdev->ops->del_virtual_intf)
3090 return -EOPNOTSUPP;
55682965 3091
84efbb84
JB		 3092 /*
3093 * If we remove a wireless device without a netdev then clear
3094 * user_ptr[1] so that nl80211_post_doit won't dereference it
3095 * to check if it needs to do dev_put(). Otherwise it crashes
3096 * since the wdev has been freed, unlike with a netdev where
3097 * we need the dev_put() for the netdev to really be freed.
3098 */
3099 if (!wdev->netdev)
3100 info->user_ptr[1] = NULL;
3101
7f8ed01e 3102 return rdev_del_virtual_intf(rdev, wdev);
55682965
JB		 3103}
3104
1d9d9213
SW		 3105static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3106{
3107 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3108 struct net_device *dev = info->user_ptr[1];
3109 u16 noack_map;
3110
3111 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3112 return -EINVAL;
3113
3114 if (!rdev->ops->set_noack_map)
3115 return -EOPNOTSUPP;
3116
3117 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3118
e35e4d28 3119 return rdev_set_noack_map(rdev, dev, noack_map);
1d9d9213
SW		 3120}
3121
41ade00f
JB		 3122struct get_key_cookie {
3123 struct sk_buff *msg;
3124 int error;
b9454e83 3125 int idx;
41ade00f
JB		 3126};
3127
3128static void get_key_callback(void *c, struct key_params *params)
3129{
b9454e83 3130 struct nlattr *key;
41ade00f
JB		 3131 struct get_key_cookie *cookie = c;
3132
9360ffd1
DM		 3133 if ((params->key &&
3134 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3135 params->key_len, params->key)) ||
3136 (params->seq &&
3137 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3138 params->seq_len, params->seq)) ||
3139 (params->cipher &&
3140 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3141 params->cipher)))
3142 goto nla_put_failure;
41ade00f 3143
b9454e83
JB		 3144 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
3145 if (!key)
3146 goto nla_put_failure;
3147
9360ffd1
DM		 3148 if ((params->key &&
3149 nla_put(cookie->msg, NL80211_KEY_DATA,
3150 params->key_len, params->key)) ||
3151 (params->seq &&
3152 nla_put(cookie->msg, NL80211_KEY_SEQ,
3153 params->seq_len, params->seq)) ||
3154 (params->cipher &&
3155 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3156 params->cipher)))
3157 goto nla_put_failure;
b9454e83 3158
1fa22f56 3159 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
9360ffd1 3160 goto nla_put_failure;
b9454e83
JB		 3161
3162 nla_nest_end(cookie->msg, key);
3163
41ade00f
JB		 3164 return;
3165 nla_put_failure:
3166 cookie->error = 1;
3167}
3168
3169static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3170{
4c476991 3171 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3172 int err;
4c476991 3173 struct net_device *dev = info->user_ptr[1];
41ade00f 3174 u8 key_idx = 0;
e31b8213
JB		 3175 const u8 *mac_addr = NULL;
3176 bool pairwise;
41ade00f
JB		 3177 struct get_key_cookie cookie = {
3178 .error = 0,
3179 };
3180 void *hdr;
3181 struct sk_buff *msg;
3182
3183 if (info->attrs[NL80211_ATTR_KEY_IDX])
3184 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3185
3cfcf6ac 3186 if (key_idx > 5)
41ade00f
JB		 3187 return -EINVAL;
3188
3189 if (info->attrs[NL80211_ATTR_MAC])
3190 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3191
e31b8213
JB		 3192 pairwise = !!mac_addr;
3193 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3194 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
7a087e74 3195
e31b8213
JB		 3196 if (kt >= NUM_NL80211_KEYTYPES)
3197 return -EINVAL;
3198 if (kt != NL80211_KEYTYPE_GROUP &&
3199 kt != NL80211_KEYTYPE_PAIRWISE)
3200 return -EINVAL;
3201 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3202 }
3203
4c476991
JB		 3204 if (!rdev->ops->get_key)
3205 return -EOPNOTSUPP;
41ade00f 3206
0fa7b391
JB		 3207 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3208 return -ENOENT;
3209
fd2120ca 3210 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 3211 if (!msg)
3212 return -ENOMEM;
41ade00f 3213
15e47304 3214 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
41ade00f 3215 NL80211_CMD_NEW_KEY);
cb35fba3 3216 if (!hdr)
9fe271af 3217 goto nla_put_failure;
41ade00f
JB		 3218
3219 cookie.msg = msg;
b9454e83 3220 cookie.idx = key_idx;
41ade00f 3221
9360ffd1
DM		 3222 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3223 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3224 goto nla_put_failure;
3225 if (mac_addr &&
3226 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3227 goto nla_put_failure;
41ade00f 3228
e35e4d28
HG		 3229 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3230 get_key_callback);
41ade00f
JB		 3231
3232 if (err)
6c95e2a2 3233 goto free_msg;
41ade00f
JB		 3234
3235 if (cookie.error)
3236 goto nla_put_failure;
3237
3238 genlmsg_end(msg, hdr);
4c476991 3239 return genlmsg_reply(msg, info);
41ade00f
JB		 3240
3241 nla_put_failure:
3242 err = -ENOBUFS;
6c95e2a2 3243 free_msg:
41ade00f 3244 nlmsg_free(msg);
41ade00f
JB		 3245 return err;
3246}
3247
3248static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3249{
4c476991 3250 struct cfg80211_registered_device *rdev = info->user_ptr[0];
b9454e83 3251 struct key_parse key;
41ade00f 3252 int err;
4c476991 3253 struct net_device *dev = info->user_ptr[1];
41ade00f 3254
b9454e83
JB		 3255 err = nl80211_parse_key(info, &key);
3256 if (err)
3257 return err;
41ade00f 3258
b9454e83 3259 if (key.idx < 0)
41ade00f
JB		 3260 return -EINVAL;
3261
b9454e83
JB		 3262 /* only support setting default key */
3263 if (!key.def && !key.defmgmt)
41ade00f
JB		 3264 return -EINVAL;
3265
dbd2fd65 3266 wdev_lock(dev->ieee80211_ptr);
3cfcf6ac 3267
dbd2fd65
JB		 3268 if (key.def) {
3269 if (!rdev->ops->set_default_key) {
3270 err = -EOPNOTSUPP;
3271 goto out;
3272 }
41ade00f 3273
dbd2fd65
JB		 3274 err = nl80211_key_allowed(dev->ieee80211_ptr);
3275 if (err)
3276 goto out;
3277
e35e4d28 3278 err = rdev_set_default_key(rdev, dev, key.idx,
dbd2fd65
JB		 3279 key.def_uni, key.def_multi);
3280
3281 if (err)
3282 goto out;
fffd0934 3283
3d23e349 3284#ifdef CONFIG_CFG80211_WEXT
dbd2fd65
JB		 3285 dev->ieee80211_ptr->wext.default_key = key.idx;
3286#endif
3287 } else {
3288 if (key.def_uni || !key.def_multi) {
3289 err = -EINVAL;
3290 goto out;
3291 }
3292
3293 if (!rdev->ops->set_default_mgmt_key) {
3294 err = -EOPNOTSUPP;
3295 goto out;
3296 }
3297
3298 err = nl80211_key_allowed(dev->ieee80211_ptr);
3299 if (err)
3300 goto out;
3301
e35e4d28 3302 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
dbd2fd65
JB		 3303 if (err)
3304 goto out;
3305
3306#ifdef CONFIG_CFG80211_WEXT
3307 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126 3308#endif
dbd2fd65
JB		 3309 }
3310
3311 out:
fffd0934 3312 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3313
41ade00f
JB		 3314 return err;
3315}
3316
3317static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3318{
4c476991 3319 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fffd0934 3320 int err;
4c476991 3321 struct net_device *dev = info->user_ptr[1];
b9454e83 3322 struct key_parse key;
e31b8213 3323 const u8 *mac_addr = NULL;
41ade00f 3324
b9454e83
JB		 3325 err = nl80211_parse_key(info, &key);
3326 if (err)
3327 return err;
41ade00f 3328
b9454e83 3329 if (!key.p.key)
41ade00f
JB		 3330 return -EINVAL;
3331
41ade00f
JB		 3332 if (info->attrs[NL80211_ATTR_MAC])
3333 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3334
e31b8213
JB		 3335 if (key.type == -1) {
3336 if (mac_addr)
3337 key.type = NL80211_KEYTYPE_PAIRWISE;
3338 else
3339 key.type = NL80211_KEYTYPE_GROUP;
3340 }
3341
3342 /* for now */
3343 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3344 key.type != NL80211_KEYTYPE_GROUP)
3345 return -EINVAL;
3346
4c476991
JB		 3347 if (!rdev->ops->add_key)
3348 return -EOPNOTSUPP;
25e47c18 3349
e31b8213
JB		 3350 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3351 key.type == NL80211_KEYTYPE_PAIRWISE,
3352 mac_addr))
4c476991 3353 return -EINVAL;
41ade00f 3354
fffd0934
JB		 3355 wdev_lock(dev->ieee80211_ptr);
3356 err = nl80211_key_allowed(dev->ieee80211_ptr);
3357 if (!err)
e35e4d28
HG		 3358 err = rdev_add_key(rdev, dev, key.idx,
3359 key.type == NL80211_KEYTYPE_PAIRWISE,
3360 mac_addr, &key.p);
fffd0934 3361 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3362
41ade00f
JB		 3363 return err;
3364}
3365
3366static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3367{
4c476991 3368 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3369 int err;
4c476991 3370 struct net_device *dev = info->user_ptr[1];
41ade00f 3371 u8 *mac_addr = NULL;
b9454e83 3372 struct key_parse key;
41ade00f 3373
b9454e83
JB		 3374 err = nl80211_parse_key(info, &key);
3375 if (err)
3376 return err;
41ade00f
JB		 3377
3378 if (info->attrs[NL80211_ATTR_MAC])
3379 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3380
e31b8213
JB		 3381 if (key.type == -1) {
3382 if (mac_addr)
3383 key.type = NL80211_KEYTYPE_PAIRWISE;
3384 else
3385 key.type = NL80211_KEYTYPE_GROUP;
3386 }
3387
3388 /* for now */
3389 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3390 key.type != NL80211_KEYTYPE_GROUP)
3391 return -EINVAL;
3392
4c476991
JB		 3393 if (!rdev->ops->del_key)
3394 return -EOPNOTSUPP;
41ade00f 3395
fffd0934
JB		 3396 wdev_lock(dev->ieee80211_ptr);
3397 err = nl80211_key_allowed(dev->ieee80211_ptr);
e31b8213 3398
0fa7b391 3399 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
e31b8213
JB		 3400 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3401 err = -ENOENT;
3402
fffd0934 3403 if (!err)
e35e4d28
HG		 3404 err = rdev_del_key(rdev, dev, key.idx,
3405 key.type == NL80211_KEYTYPE_PAIRWISE,
3406 mac_addr);
41ade00f 3407
3d23e349 3408#ifdef CONFIG_CFG80211_WEXT
08645126 3409 if (!err) {
b9454e83 3410 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 3411 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 3412 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 3413 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3414 }
3415#endif
fffd0934 3416 wdev_unlock(dev->ieee80211_ptr);
08645126 3417
41ade00f
JB		 3418 return err;
3419}
3420
77765eaf
VT		 3421/* This function returns an error or the number of nested attributes */
3422static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3423{
3424 struct nlattr *attr;
3425 int n_entries = 0, tmp;
3426
3427 nla_for_each_nested(attr, nl_attr, tmp) {
3428 if (nla_len(attr) != ETH_ALEN)
3429 return -EINVAL;
3430
3431 n_entries++;
3432 }
3433
3434 return n_entries;
3435}
3436
3437/*
3438 * This function parses ACL information and allocates memory for ACL data.
3439 * On successful return, the calling function is responsible to free the
3440 * ACL buffer returned by this function.
3441 */
3442static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3443 struct genl_info *info)
3444{
3445 enum nl80211_acl_policy acl_policy;
3446 struct nlattr *attr;
3447 struct cfg80211_acl_data *acl;
3448 int i = 0, n_entries, tmp;
3449
3450 if (!wiphy->max_acl_mac_addrs)
3451 return ERR_PTR(-EOPNOTSUPP);
3452
3453 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3454 return ERR_PTR(-EINVAL);
3455
3456 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3457 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3458 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3459 return ERR_PTR(-EINVAL);
3460
3461 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3462 return ERR_PTR(-EINVAL);
3463
3464 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3465 if (n_entries < 0)
3466 return ERR_PTR(n_entries);
3467
3468 if (n_entries > wiphy->max_acl_mac_addrs)
3469 return ERR_PTR(-ENOTSUPP);
3470
3471 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3472 GFP_KERNEL);
3473 if (!acl)
3474 return ERR_PTR(-ENOMEM);
3475
3476 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3477 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3478 i++;
3479 }
3480
3481 acl->n_acl_entries = n_entries;
3482 acl->acl_policy = acl_policy;
3483
3484 return acl;
3485}
3486
3487static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3488{
3489 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3490 struct net_device *dev = info->user_ptr[1];
3491 struct cfg80211_acl_data *acl;
3492 int err;
3493
3494 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3495 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3496 return -EOPNOTSUPP;
3497
3498 if (!dev->ieee80211_ptr->beacon_interval)
3499 return -EINVAL;
3500
3501 acl = parse_acl_data(&rdev->wiphy, info);
3502 if (IS_ERR(acl))
3503 return PTR_ERR(acl);
3504
3505 err = rdev_set_mac_acl(rdev, dev, acl);
3506
3507 kfree(acl);
3508
3509 return err;
3510}
3511
a7c7fbff
PK		 3512static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
3513 u8 *rates, u8 rates_len)
3514{
3515 u8 i;
3516 u32 mask = 0;
3517
3518 for (i = 0; i < rates_len; i++) {
3519 int rate = (rates[i] & 0x7f) * 5;
3520 int ridx;
3521
3522 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
3523 struct ieee80211_rate *srate =
3524 &sband->bitrates[ridx];
3525 if (rate == srate->bitrate) {
3526 mask |= 1 << ridx;
3527 break;
3528 }
3529 }
3530 if (ridx == sband->n_bitrates)
3531 return 0; /* rate not found */
3532 }
3533
3534 return mask;
3535}
3536
3537static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
3538 u8 *rates, u8 rates_len,
3539 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
3540{
3541 u8 i;
3542
3543 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
3544
3545 for (i = 0; i < rates_len; i++) {
3546 int ridx, rbit;
3547
3548 ridx = rates[i] / 8;
3549 rbit = BIT(rates[i] % 8);
3550
3551 /* check validity */
3552 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
3553 return false;
3554
3555 /* check availability */
434a30a6 3556 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
a7c7fbff
PK		 3557 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
3558 mcs[ridx] |= rbit;
3559 else
3560 return false;
3561 }
3562
3563 return true;
3564}
3565
3566static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
3567{
3568 u16 mcs_mask = 0;
3569
3570 switch (vht_mcs_map) {
3571 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
3572 break;
3573 case IEEE80211_VHT_MCS_SUPPORT_0_7:
3574 mcs_mask = 0x00FF;
3575 break;
3576 case IEEE80211_VHT_MCS_SUPPORT_0_8:
3577 mcs_mask = 0x01FF;
3578 break;
3579 case IEEE80211_VHT_MCS_SUPPORT_0_9:
3580 mcs_mask = 0x03FF;
3581 break;
3582 default:
3583 break;
3584 }
3585
3586 return mcs_mask;
3587}
3588
3589static void vht_build_mcs_mask(u16 vht_mcs_map,
3590 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
3591{
3592 u8 nss;
3593
3594 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
3595 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
3596 vht_mcs_map >>= 2;
3597 }
3598}
3599
3600static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
3601 struct nl80211_txrate_vht *txrate,
3602 u16 mcs[NL80211_VHT_NSS_MAX])
3603{
3604 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3605 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
3606 u8 i;
3607
3608 if (!sband->vht_cap.vht_supported)
3609 return false;
3610
3611 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
3612
3613 /* Build vht_mcs_mask from VHT capabilities */
3614 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
3615
3616 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3617 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
3618 mcs[i] = txrate->mcs[i];
3619 else
3620 return false;
3621 }
3622
3623 return true;
3624}
3625
3626static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
3627 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
3628 .len = NL80211_MAX_SUPP_RATES },
3629 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
3630 .len = NL80211_MAX_SUPP_HT_RATES },
3631 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
3632 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
3633};
3634
3635static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
3636 struct cfg80211_bitrate_mask *mask)
3637{
3638 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
3639 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3640 int rem, i;
3641 struct nlattr *tx_rates;
3642 struct ieee80211_supported_band *sband;
3643 u16 vht_tx_mcs_map;
3644
3645 memset(mask, 0, sizeof(*mask));
3646 /* Default to all rates enabled */
3647 for (i = 0; i < NUM_NL80211_BANDS; i++) {
3648 sband = rdev->wiphy.bands[i];
3649
3650 if (!sband)
3651 continue;
3652
3653 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
3654 memcpy(mask->control[i].ht_mcs,
3655 sband->ht_cap.mcs.rx_mask,
3656 sizeof(mask->control[i].ht_mcs));
3657
3658 if (!sband->vht_cap.vht_supported)
3659 continue;
3660
3661 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3662 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
3663 }
3664
3665 /* if no rates are given set it back to the defaults */
3666 if (!info->attrs[NL80211_ATTR_TX_RATES])
3667 goto out;
3668
3669 /* The nested attribute uses enum nl80211_band as the index. This maps
3670 * directly to the enum nl80211_band values used in cfg80211.
3671 */
3672 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
3673 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
3674 enum nl80211_band band = nla_type(tx_rates);
3675 int err;
3676
3677 if (band < 0 || band >= NUM_NL80211_BANDS)
3678 return -EINVAL;
3679 sband = rdev->wiphy.bands[band];
3680 if (sband == NULL)
3681 return -EINVAL;
bfe2c7b1 3682 err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
fe52145f 3683 nl80211_txattr_policy, info->extack);
a7c7fbff
PK		 3684 if (err)
3685 return err;
3686 if (tb[NL80211_TXRATE_LEGACY]) {
3687 mask->control[band].legacy = rateset_to_mask(
3688 sband,
3689 nla_data(tb[NL80211_TXRATE_LEGACY]),
3690 nla_len(tb[NL80211_TXRATE_LEGACY]));
3691 if ((mask->control[band].legacy == 0) &&
3692 nla_len(tb[NL80211_TXRATE_LEGACY]))
3693 return -EINVAL;
3694 }
3695 if (tb[NL80211_TXRATE_HT]) {
3696 if (!ht_rateset_to_mask(
3697 sband,
3698 nla_data(tb[NL80211_TXRATE_HT]),
3699 nla_len(tb[NL80211_TXRATE_HT]),
3700 mask->control[band].ht_mcs))
3701 return -EINVAL;
3702 }
3703 if (tb[NL80211_TXRATE_VHT]) {
3704 if (!vht_set_mcs_mask(
3705 sband,
3706 nla_data(tb[NL80211_TXRATE_VHT]),
3707 mask->control[band].vht_mcs))
3708 return -EINVAL;
3709 }
3710 if (tb[NL80211_TXRATE_GI]) {
3711 mask->control[band].gi =
3712 nla_get_u8(tb[NL80211_TXRATE_GI]);
3713 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
3714 return -EINVAL;
3715 }
3716
3717 if (mask->control[band].legacy == 0) {
3718 /* don't allow empty legacy rates if HT or VHT
3719 * are not even supported.
3720 */
3721 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
3722 rdev->wiphy.bands[band]->vht_cap.vht_supported))
3723 return -EINVAL;
3724
3725 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3726 if (mask->control[band].ht_mcs[i])
3727 goto out;
3728
3729 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3730 if (mask->control[band].vht_mcs[i])
3731 goto out;
3732
3733 /* legacy and mcs rates may not be both empty */
3734 return -EINVAL;
3735 }
3736 }
3737
3738out:
3739 return 0;
3740}
3741
8564e382
JB		 3742static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
3743 enum nl80211_band band,
3744 struct cfg80211_bitrate_mask *beacon_rate)
a7c7fbff 3745{
8564e382
JB		 3746 u32 count_ht, count_vht, i;
3747 u32 rate = beacon_rate->control[band].legacy;
a7c7fbff
PK		 3748
3749 /* Allow only one rate */
3750 if (hweight32(rate) > 1)
3751 return -EINVAL;
3752
3753 count_ht = 0;
3754 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
8564e382 3755 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
a7c7fbff 3756 return -EINVAL;
8564e382 3757 } else if (beacon_rate->control[band].ht_mcs[i]) {
a7c7fbff
PK		 3758 count_ht++;
3759 if (count_ht > 1)
3760 return -EINVAL;
3761 }
3762 if (count_ht && rate)
3763 return -EINVAL;
3764 }
3765
3766 count_vht = 0;
3767 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8564e382 3768 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
a7c7fbff 3769 return -EINVAL;
8564e382 3770 } else if (beacon_rate->control[band].vht_mcs[i]) {
a7c7fbff
PK		 3771 count_vht++;
3772 if (count_vht > 1)
3773 return -EINVAL;
3774 }
3775 if (count_vht && rate)
3776 return -EINVAL;
3777 }
3778
3779 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
3780 return -EINVAL;
3781
8564e382
JB		 3782 if (rate &&
3783 !wiphy_ext_feature_isset(&rdev->wiphy,
3784 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
3785 return -EINVAL;
3786 if (count_ht &&
3787 !wiphy_ext_feature_isset(&rdev->wiphy,
3788 NL80211_EXT_FEATURE_BEACON_RATE_HT))
3789 return -EINVAL;
3790 if (count_vht &&
3791 !wiphy_ext_feature_isset(&rdev->wiphy,
3792 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
3793 return -EINVAL;
3794
a7c7fbff
PK		 3795 return 0;
3796}
3797
a1193be8 3798static int nl80211_parse_beacon(struct nlattr *attrs[],
8860020e 3799 struct cfg80211_beacon_data *bcn)
ed1b6cc7 3800{
8860020e 3801 bool haveinfo = false;
ed1b6cc7 3802
a1193be8
SW		 3803 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3804 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3805 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3806 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
f4a11bb0
JB		 3807 return -EINVAL;
3808
8860020e 3809 memset(bcn, 0, sizeof(*bcn));
ed1b6cc7 3810
a1193be8 3811 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
ffd30d74
JB		 3812 int ret = validate_beacon_head(attrs[NL80211_ATTR_BEACON_HEAD],
3813 NULL);
3814
3815 if (ret)
3816 return ret;
3817
a1193be8
SW		 3818 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3819 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
8860020e
JB		 3820 if (!bcn->head_len)
3821 return -EINVAL;
3822 haveinfo = true;
ed1b6cc7
JB		 3823 }
3824
a1193be8
SW		 3825 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3826 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3827 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
8860020e 3828 haveinfo = true;
ed1b6cc7
JB		 3829 }
3830
4c476991
JB		 3831 if (!haveinfo)
3832 return -EINVAL;
3b85875a 3833
a1193be8
SW		 3834 if (attrs[NL80211_ATTR_IE]) {
3835 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3836 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
9946ecfb
JM		 3837 }
3838
a1193be8 3839 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
8860020e 3840 bcn->proberesp_ies =
a1193be8 3841 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
8860020e 3842 bcn->proberesp_ies_len =
a1193be8 3843 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
9946ecfb
JM		 3844 }
3845
a1193be8 3846 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
8860020e 3847 bcn->assocresp_ies =
a1193be8 3848 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
8860020e 3849 bcn->assocresp_ies_len =
a1193be8 3850 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
9946ecfb
JM		 3851 }
3852
a1193be8
SW		 3853 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3854 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3855 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
00f740e1
AN		 3856 }
3857
8860020e
JB		 3858 return 0;
3859}
3860
66cd794e
JB		 3861static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
3862 const u8 *rates)
3863{
3864 int i;
3865
3866 if (!rates)
3867 return;
3868
3869 for (i = 0; i < rates[1]; i++) {
3870 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
3871 params->ht_required = true;
3872 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
3873 params->vht_required = true;
3874 }
3875}
3876
3877/*
3878 * Since the nl80211 API didn't include, from the beginning, attributes about
3879 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
3880 * benefit of drivers that rebuild IEs in the firmware.
3881 */
3882static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
3883{
3884 const struct cfg80211_beacon_data *bcn = &params->beacon;
ba83bfb1
IM		 3885 size_t ies_len = bcn->tail_len;
3886 const u8 *ies = bcn->tail;
66cd794e
JB		 3887 const u8 *rates;
3888 const u8 *cap;
3889
3890 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
3891 nl80211_check_ap_rate_selectors(params, rates);
3892
3893 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
3894 nl80211_check_ap_rate_selectors(params, rates);
3895
3896 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
3897 if (cap && cap[1] >= sizeof(*params->ht_cap))
3898 params->ht_cap = (void *)(cap + 2);
3899 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
3900 if (cap && cap[1] >= sizeof(*params->vht_cap))
3901 params->vht_cap = (void *)(cap + 2);
3902}
3903
46c1dd0c
FF		 3904static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3905 struct cfg80211_ap_settings *params)
3906{
3907 struct wireless_dev *wdev;
3908 bool ret = false;
3909
53873f13 3910 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
46c1dd0c
FF		 3911 if (wdev->iftype != NL80211_IFTYPE_AP &&
3912 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3913 continue;
3914
683b6d3b 3915 if (!wdev->preset_chandef.chan)
46c1dd0c
FF		 3916 continue;
3917
683b6d3b 3918 params->chandef = wdev->preset_chandef;
46c1dd0c
FF		 3919 ret = true;
3920 break;
3921 }
3922
46c1dd0c
FF		 3923 return ret;
3924}
3925
e39e5b5e
JM		 3926static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3927 enum nl80211_auth_type auth_type,
3928 enum nl80211_commands cmd)
3929{
3930 if (auth_type > NL80211_AUTHTYPE_MAX)
3931 return false;
3932
3933 switch (cmd) {
3934 case NL80211_CMD_AUTHENTICATE:
3935 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3936 auth_type == NL80211_AUTHTYPE_SAE)
3937 return false;
63181060
JM		 3938 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3939 NL80211_EXT_FEATURE_FILS_STA) &&
3940 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3941 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3942 auth_type == NL80211_AUTHTYPE_FILS_PK))
3943 return false;
e39e5b5e
JM		 3944 return true;
3945 case NL80211_CMD_CONNECT:
a3caf744
VK		 3946 /* SAE not supported yet */
3947 if (auth_type == NL80211_AUTHTYPE_SAE)
3948 return false;
3949 /* FILS with SK PFS or PK not supported yet */
3950 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3951 auth_type == NL80211_AUTHTYPE_FILS_PK)
3952 return false;
3953 if (!wiphy_ext_feature_isset(
3954 &rdev->wiphy,
3955 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
3956 auth_type == NL80211_AUTHTYPE_FILS_SK)
3957 return false;
3958 return true;
e39e5b5e
JM		 3959 case NL80211_CMD_START_AP:
3960 /* SAE not supported yet */
3961 if (auth_type == NL80211_AUTHTYPE_SAE)
3962 return false;
63181060
JM		 3963 /* FILS not supported yet */
3964 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3965 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3966 auth_type == NL80211_AUTHTYPE_FILS_PK)
3967 return false;
e39e5b5e
JM		 3968 return true;
3969 default:
3970 return false;
3971 }
3972}
3973
8860020e
JB		 3974static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3975{
3976 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3977 struct net_device *dev = info->user_ptr[1];
3978 struct wireless_dev *wdev = dev->ieee80211_ptr;
3979 struct cfg80211_ap_settings params;
3980 int err;
3981
3982 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3983 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3984 return -EOPNOTSUPP;
3985
3986 if (!rdev->ops->start_ap)
3987 return -EOPNOTSUPP;
3988
3989 if (wdev->beacon_interval)
3990 return -EALREADY;
3991
3992 memset(&params, 0, sizeof(params));
3993
3994 /* these are required for START_AP */
3995 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3996 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3997 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3998 return -EINVAL;
3999
a1193be8 4000 err = nl80211_parse_beacon(info->attrs, &params.beacon);
8860020e
JB		 4001 if (err)
4002 return err;
4003
4004 params.beacon_interval =
4005 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
4006 params.dtim_period =
4007 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
4008
0c317a02
PK		 4009 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
4010 params.beacon_interval);
8860020e
JB		 4011 if (err)
4012 return err;
4013
4014 /*
4015 * In theory, some of these attributes should be required here
4016 * but since they were not used when the command was originally
4017 * added, keep them optional for old user space programs to let
4018 * them continue to work with drivers that do not need the
4019 * additional information -- drivers must check!
4020 */
4021 if (info->attrs[NL80211_ATTR_SSID]) {
4022 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4023 params.ssid_len =
4024 nla_len(info->attrs[NL80211_ATTR_SSID]);
4025 if (params.ssid_len == 0 ||
4026 params.ssid_len > IEEE80211_MAX_SSID_LEN)
4027 return -EINVAL;
4028 }
4029
4030 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
4031 params.hidden_ssid = nla_get_u32(
4032 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
4033 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
4034 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
4035 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
4036 return -EINVAL;
4037 }
4038
4039 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
4040
4041 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
4042 params.auth_type = nla_get_u32(
4043 info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 4044 if (!nl80211_valid_auth_type(rdev, params.auth_type,
4045 NL80211_CMD_START_AP))
8860020e
JB		 4046 return -EINVAL;
4047 } else
4048 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
4049
4050 err = nl80211_crypto_settings(rdev, info, &params.crypto,
4051 NL80211_MAX_NR_CIPHER_SUITES);
4052 if (err)
4053 return err;
4054
1b658f11
VT		 4055 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
4056 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
4057 return -EOPNOTSUPP;
4058 params.inactivity_timeout = nla_get_u16(
4059 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
4060 }
4061
53cabad7
JB		 4062 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4063 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4064 return -EINVAL;
4065 params.p2p_ctwindow =
4066 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4067 if (params.p2p_ctwindow > 127)
4068 return -EINVAL;
4069 if (params.p2p_ctwindow != 0 &&
4070 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4071 return -EINVAL;
4072 }
4073
4074 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4075 u8 tmp;
4076
4077 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4078 return -EINVAL;
4079 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4080 if (tmp > 1)
4081 return -EINVAL;
4082 params.p2p_opp_ps = tmp;
4083 if (params.p2p_opp_ps != 0 &&
4084 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4085 return -EINVAL;
4086 }
4087
aa430da4 4088 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 4089 err = nl80211_parse_chandef(rdev, info, &params.chandef);
4090 if (err)
4091 return err;
4092 } else if (wdev->preset_chandef.chan) {
4093 params.chandef = wdev->preset_chandef;
46c1dd0c 4094 } else if (!nl80211_get_ap_channel(rdev, &params))
aa430da4
JB		 4095 return -EINVAL;
4096
923b352f
AN		 4097 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
4098 wdev->iftype))
aa430da4
JB		 4099 return -EINVAL;
4100
a7c7fbff
PK		 4101 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4102 err = nl80211_parse_tx_bitrate_mask(info, &params.beacon_rate);
4103 if (err)
4104 return err;
4105
8564e382
JB		 4106 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4107 &params.beacon_rate);
a7c7fbff
PK		 4108 if (err)
4109 return err;
4110 }
4111
18998c38
EP		 4112 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4113 params.smps_mode =
4114 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4115 switch (params.smps_mode) {
4116 case NL80211_SMPS_OFF:
4117 break;
4118 case NL80211_SMPS_STATIC:
4119 if (!(rdev->wiphy.features &
4120 NL80211_FEATURE_STATIC_SMPS))
4121 return -EINVAL;
4122 break;
4123 case NL80211_SMPS_DYNAMIC:
4124 if (!(rdev->wiphy.features &
4125 NL80211_FEATURE_DYNAMIC_SMPS))
4126 return -EINVAL;
4127 break;
4128 default:
4129 return -EINVAL;
4130 }
4131 } else {
4132 params.smps_mode = NL80211_SMPS_OFF;
4133 }
4134
6e8ef842
PK		 4135 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4136 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4137 return -EOPNOTSUPP;
4138
4baf6bea
OO		 4139 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4140 params.acl = parse_acl_data(&rdev->wiphy, info);
4141 if (IS_ERR(params.acl))
4142 return PTR_ERR(params.acl);
4143 }
4144
66cd794e
JB		 4145 nl80211_calculate_ap_params(&params);
4146
c56589ed 4147 wdev_lock(wdev);
e35e4d28 4148 err = rdev_start_ap(rdev, dev, &params);
46c1dd0c 4149 if (!err) {
683b6d3b 4150 wdev->preset_chandef = params.chandef;
8860020e 4151 wdev->beacon_interval = params.beacon_interval;
9e0e2961 4152 wdev->chandef = params.chandef;
06e191e2
AQ		 4153 wdev->ssid_len = params.ssid_len;
4154 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
46c1dd0c 4155 }
c56589ed 4156 wdev_unlock(wdev);
77765eaf
VT		 4157
4158 kfree(params.acl);
4159
56d1893d 4160 return err;
ed1b6cc7
JB		 4161}
4162
8860020e
JB		 4163static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4164{
4165 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4166 struct net_device *dev = info->user_ptr[1];
4167 struct wireless_dev *wdev = dev->ieee80211_ptr;
4168 struct cfg80211_beacon_data params;
4169 int err;
4170
4171 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4172 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4173 return -EOPNOTSUPP;
4174
4175 if (!rdev->ops->change_beacon)
4176 return -EOPNOTSUPP;
4177
4178 if (!wdev->beacon_interval)
4179 return -EINVAL;
4180
a1193be8 4181 err = nl80211_parse_beacon(info->attrs, &params);
8860020e
JB		 4182 if (err)
4183 return err;
4184
c56589ed
SW		 4185 wdev_lock(wdev);
4186 err = rdev_change_beacon(rdev, dev, &params);
4187 wdev_unlock(wdev);
4188
4189 return err;
8860020e
JB		 4190}
4191
4192static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
ed1b6cc7 4193{
4c476991
JB		 4194 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4195 struct net_device *dev = info->user_ptr[1];
ed1b6cc7 4196
7c8d5e03 4197 return cfg80211_stop_ap(rdev, dev, false);
ed1b6cc7
JB		 4198}
4199
5727ef1b
JB		 4200static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4201 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4202 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4203 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 4204 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
b39c48fa 4205 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
d83023da 4206 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5727ef1b
JB		 4207};
4208
eccb8e8f 4209static int parse_station_flags(struct genl_info *info,
bdd3ae3d 4210 enum nl80211_iftype iftype,
eccb8e8f 4211 struct station_parameters *params)
5727ef1b
JB		 4212{
4213 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 4214 struct nlattr *nla;
5727ef1b
JB		 4215 int flag;
4216
eccb8e8f
JB		 4217 /*
4218 * Try parsing the new attribute first so userspace
4219 * can specify both for older kernels.
4220 */
4221 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4222 if (nla) {
4223 struct nl80211_sta_flag_update *sta_flags;
4224
4225 sta_flags = nla_data(nla);
4226 params->sta_flags_mask = sta_flags->mask;
4227 params->sta_flags_set = sta_flags->set;
77ee7c89 4228 params->sta_flags_set &= params->sta_flags_mask;
eccb8e8f
JB		 4229 if ((params->sta_flags_mask |
4230 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4231 return -EINVAL;
4232 return 0;
4233 }
4234
4235 /* if present, parse the old attribute */
5727ef1b 4236
eccb8e8f 4237 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 4238 if (!nla)
4239 return 0;
4240
fceb6435 4241 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, nla,
fe52145f 4242 sta_flags_policy, info->extack))
5727ef1b
JB		 4243 return -EINVAL;
4244
bdd3ae3d
JB		 4245 /*
4246 * Only allow certain flags for interface types so that
4247 * other attributes are silently ignored. Remember that
4248 * this is backward compatibility code with old userspace
4249 * and shouldn't be hit in other cases anyway.
4250 */
4251 switch (iftype) {
4252 case NL80211_IFTYPE_AP:
4253 case NL80211_IFTYPE_AP_VLAN:
4254 case NL80211_IFTYPE_P2P_GO:
4255 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4256 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4257 BIT(NL80211_STA_FLAG_WME) |
4258 BIT(NL80211_STA_FLAG_MFP);
4259 break;
4260 case NL80211_IFTYPE_P2P_CLIENT:
4261 case NL80211_IFTYPE_STATION:
4262 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4263 BIT(NL80211_STA_FLAG_TDLS_PEER);
4264 break;
4265 case NL80211_IFTYPE_MESH_POINT:
4266 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4267 BIT(NL80211_STA_FLAG_MFP) |
4268 BIT(NL80211_STA_FLAG_AUTHORIZED);
a1e91aab 4269 break;
bdd3ae3d
JB		 4270 default:
4271 return -EINVAL;
4272 }
5727ef1b 4273
3383b5a6
JB		 4274 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4275 if (flags[flag]) {
eccb8e8f 4276 params->sta_flags_set |= (1<<flag);
5727ef1b 4277
3383b5a6
JB		 4278 /* no longer support new API additions in old API */
4279 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4280 return -EINVAL;
4281 }
4282 }
4283
5727ef1b
JB		 4284 return 0;
4285}
4286
c8dcfd8a
FF		 4287static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
4288 int attr)
4289{
4290 struct nlattr *rate;
8eb41c8d
VK		 4291 u32 bitrate;
4292 u16 bitrate_compat;
bbf67e45 4293 enum nl80211_rate_info rate_flg;
c8dcfd8a
FF		 4294
4295 rate = nla_nest_start(msg, attr);
4296 if (!rate)
db9c64cf 4297 return false;
c8dcfd8a
FF		 4298
4299 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4300 bitrate = cfg80211_calculate_bitrate(info);
8eb41c8d
VK		 4301 /* report 16-bit bitrate only if we can */
4302 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
db9c64cf
JB		 4303 if (bitrate > 0 &&
4304 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4305 return false;
4306 if (bitrate_compat > 0 &&
4307 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4308 return false;
4309
b51f3bee
JB		 4310 switch (info->bw) {
4311 case RATE_INFO_BW_5:
4312 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4313 break;
4314 case RATE_INFO_BW_10:
4315 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4316 break;
4317 default:
4318 WARN_ON(1);
4319 /* fall through */
4320 case RATE_INFO_BW_20:
4321 rate_flg = 0;
4322 break;
4323 case RATE_INFO_BW_40:
4324 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4325 break;
4326 case RATE_INFO_BW_80:
4327 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4328 break;
4329 case RATE_INFO_BW_160:
4330 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4331 break;
4332 }
4333
4334 if (rate_flg && nla_put_flag(msg, rate_flg))
4335 return false;
4336
db9c64cf
JB		 4337 if (info->flags & RATE_INFO_FLAGS_MCS) {
4338 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4339 return false;
db9c64cf
JB		 4340 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4341 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4342 return false;
4343 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4344 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4345 return false;
4346 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4347 return false;
db9c64cf
JB		 4348 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4349 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4350 return false;
4351 }
c8dcfd8a
FF		 4352
4353 nla_nest_end(msg, rate);
4354 return true;
c8dcfd8a
FF		 4355}
4356
119363c7
FF		 4357static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4358 int id)
4359{
4360 void *attr;
4361 int i = 0;
4362
4363 if (!mask)
4364 return true;
4365
4366 attr = nla_nest_start(msg, id);
4367 if (!attr)
4368 return false;
4369
4370 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4371 if (!(mask & BIT(i)))
4372 continue;
4373
4374 if (nla_put_u8(msg, i, signal[i]))
4375 return false;
4376 }
4377
4378 nla_nest_end(msg, attr);
4379
4380 return true;
4381}
4382
cf5ead82
JB		 4383static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4384 u32 seq, int flags,
66266b3a
JL		 4385 struct cfg80211_registered_device *rdev,
4386 struct net_device *dev,
98b62183 4387 const u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 4388{
4389 void *hdr;
f4263c98 4390 struct nlattr *sinfoattr, *bss_param;
fd5b74dc 4391
cf5ead82 4392 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
fd5b74dc
JB		 4393 if (!hdr)
4394 return -1;
4395
9360ffd1
DM		 4396 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4397 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
4398 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
4399 goto nla_put_failure;
f5ea9120 4400
2ec600d6
LCC		 4401 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
4402 if (!sinfoattr)
fd5b74dc 4403 goto nla_put_failure;
319090bf
JB		 4404
4405#define PUT_SINFO(attr, memb, type) do { \
d686b920 4406 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
739960f1 4407 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
319090bf
JB		 4408 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
4409 sinfo->memb)) \
4410 goto nla_put_failure; \
4411 } while (0)
d686b920
JB		 4412#define PUT_SINFO_U64(attr, memb) do { \
4413 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
4414 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
4415 sinfo->memb, NL80211_STA_INFO_PAD)) \
4416 goto nla_put_failure; \
4417 } while (0)
319090bf
JB		 4418
4419 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
4420 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
4421
4422 if (sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES) |
4423 BIT(NL80211_STA_INFO_RX_BYTES64)) &&
9360ffd1 4424 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
42745e03 4425 (u32)sinfo->rx_bytes))
9360ffd1 4426 goto nla_put_failure;
319090bf
JB		 4427
4428 if (sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES) |
4429 BIT(NL80211_STA_INFO_TX_BYTES64)) &&
9360ffd1 4430 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
42745e03
VK		 4431 (u32)sinfo->tx_bytes))
4432 goto nla_put_failure;
319090bf 4433
d686b920
JB		 4434 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
4435 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
319090bf
JB		 4436 PUT_SINFO(LLID, llid, u16);
4437 PUT_SINFO(PLID, plid, u16);
4438 PUT_SINFO(PLINK_STATE, plink_state, u8);
d686b920 4439 PUT_SINFO_U64(RX_DURATION, rx_duration);
319090bf 4440
66266b3a
JL		 4441 switch (rdev->wiphy.signal_type) {
4442 case CFG80211_SIGNAL_TYPE_MBM:
319090bf
JB		 4443 PUT_SINFO(SIGNAL, signal, u8);
4444 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
66266b3a
JL		 4445 break;
4446 default:
4447 break;
4448 }
319090bf 4449 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL)) {
119363c7
FF		 4450 if (!nl80211_put_signal(msg, sinfo->chains,
4451 sinfo->chain_signal,
4452 NL80211_STA_INFO_CHAIN_SIGNAL))
4453 goto nla_put_failure;
4454 }
319090bf 4455 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
119363c7
FF		 4456 if (!nl80211_put_signal(msg, sinfo->chains,
4457 sinfo->chain_signal_avg,
4458 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
4459 goto nla_put_failure;
4460 }
319090bf 4461 if (sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {
c8dcfd8a
FF		 4462 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
4463 NL80211_STA_INFO_TX_BITRATE))
4464 goto nla_put_failure;
4465 }
319090bf 4466 if (sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE)) {
c8dcfd8a
FF		 4467 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
4468 NL80211_STA_INFO_RX_BITRATE))
420e7fab 4469 goto nla_put_failure;
420e7fab 4470 }
319090bf
JB		 4471
4472 PUT_SINFO(RX_PACKETS, rx_packets, u32);
4473 PUT_SINFO(TX_PACKETS, tx_packets, u32);
4474 PUT_SINFO(TX_RETRIES, tx_retries, u32);
4475 PUT_SINFO(TX_FAILED, tx_failed, u32);
4476 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
4477 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
4478 PUT_SINFO(LOCAL_PM, local_pm, u32);
4479 PUT_SINFO(PEER_PM, peer_pm, u32);
4480 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
4481
4482 if (sinfo->filled & BIT(NL80211_STA_INFO_BSS_PARAM)) {
f4263c98
PS		 4483 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
4484 if (!bss_param)
4485 goto nla_put_failure;
4486
9360ffd1
DM		 4487 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
4488 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
4489 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
4490 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
4491 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
4492 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
4493 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
4494 sinfo->bss_param.dtim_period) ||
4495 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
4496 sinfo->bss_param.beacon_interval))
4497 goto nla_put_failure;
f4263c98
PS		 4498
4499 nla_nest_end(msg, bss_param);
4500 }
319090bf 4501 if ((sinfo->filled & BIT(NL80211_STA_INFO_STA_FLAGS)) &&
9360ffd1
DM		 4502 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
4503 sizeof(struct nl80211_sta_flag_update),
4504 &sinfo->sta_flags))
4505 goto nla_put_failure;
319090bf 4506
d686b920
JB		 4507 PUT_SINFO_U64(T_OFFSET, t_offset);
4508 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
4509 PUT_SINFO_U64(BEACON_RX, rx_beacon);
a76b1942 4510 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
319090bf
JB		 4511
4512#undef PUT_SINFO
d686b920 4513#undef PUT_SINFO_U64
6de39808
JB		 4514
4515 if (sinfo->filled & BIT(NL80211_STA_INFO_TID_STATS)) {
4516 struct nlattr *tidsattr;
4517 int tid;
4518
4519 tidsattr = nla_nest_start(msg, NL80211_STA_INFO_TID_STATS);
4520 if (!tidsattr)
4521 goto nla_put_failure;
4522
4523 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
4524 struct cfg80211_tid_stats *tidstats;
4525 struct nlattr *tidattr;
4526
4527 tidstats = &sinfo->pertid[tid];
4528
4529 if (!tidstats->filled)
4530 continue;
4531
4532 tidattr = nla_nest_start(msg, tid + 1);
4533 if (!tidattr)
4534 goto nla_put_failure;
4535
d686b920 4536#define PUT_TIDVAL_U64(attr, memb) do { \
6de39808 4537 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
d686b920
JB		 4538 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
4539 tidstats->memb, NL80211_TID_STATS_PAD)) \
6de39808
JB		 4540 goto nla_put_failure; \
4541 } while (0)
4542
d686b920
JB		 4543 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
4544 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
4545 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
4546 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
6de39808 4547
d686b920 4548#undef PUT_TIDVAL_U64
6de39808
JB		 4549 nla_nest_end(msg, tidattr);
4550 }
4551
4552 nla_nest_end(msg, tidsattr);
4553 }
4554
2ec600d6 4555 nla_nest_end(msg, sinfoattr);
fd5b74dc 4556
319090bf 4557 if (sinfo->assoc_req_ies_len &&
9360ffd1
DM		 4558 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
4559 sinfo->assoc_req_ies))
4560 goto nla_put_failure;
50d3dfb7 4561
053c095a
JB		 4562 genlmsg_end(msg, hdr);
4563 return 0;
fd5b74dc
JB		 4564
4565 nla_put_failure:
bc3ed28c
TG		 4566 genlmsg_cancel(msg, hdr);
4567 return -EMSGSIZE;
fd5b74dc
JB		 4568}
4569
2ec600d6 4570static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 4571 struct netlink_callback *cb)
2ec600d6 4572{
2ec600d6 4573 struct station_info sinfo;
1b8ec87a 4574 struct cfg80211_registered_device *rdev;
97990a06 4575 struct wireless_dev *wdev;
2ec600d6 4576 u8 mac_addr[ETH_ALEN];
97990a06 4577 int sta_idx = cb->args[2];
2ec600d6 4578 int err;
2ec600d6 4579
ea90e0dc 4580 rtnl_lock();
1b8ec87a 4581 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 4582 if (err)
ea90e0dc 4583 goto out_err;
bba95fef 4584
97990a06
JB		 4585 if (!wdev->netdev) {
4586 err = -EINVAL;
4587 goto out_err;
4588 }
4589
1b8ec87a 4590 if (!rdev->ops->dump_station) {
eec60b03 4591 err = -EOPNOTSUPP;
bba95fef
JB		 4592 goto out_err;
4593 }
4594
bba95fef 4595 while (1) {
f612cedf 4596 memset(&sinfo, 0, sizeof(sinfo));
1b8ec87a 4597 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
e35e4d28 4598 mac_addr, &sinfo);
bba95fef
JB		 4599 if (err == -ENOENT)
4600 break;
4601 if (err)
3b85875a 4602 goto out_err;
bba95fef 4603
cf5ead82 4604 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
15e47304 4605 NETLINK_CB(cb->skb).portid,
bba95fef 4606 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1b8ec87a 4607 rdev, wdev->netdev, mac_addr,
bba95fef
JB		 4608 &sinfo) < 0)
4609 goto out;
4610
4611 sta_idx++;
4612 }
4613
bba95fef 4614 out:
97990a06 4615 cb->args[2] = sta_idx;
bba95fef 4616 err = skb->len;
bba95fef 4617 out_err:
ea90e0dc 4618 rtnl_unlock();
bba95fef
JB		 4619
4620 return err;
2ec600d6 4621}
fd5b74dc 4622
5727ef1b
JB		 4623static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
4624{
4c476991
JB		 4625 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4626 struct net_device *dev = info->user_ptr[1];
2ec600d6 4627 struct station_info sinfo;
fd5b74dc
JB		 4628 struct sk_buff *msg;
4629 u8 *mac_addr = NULL;
4c476991 4630 int err;
fd5b74dc 4631
2ec600d6 4632 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 4633
4634 if (!info->attrs[NL80211_ATTR_MAC])
4635 return -EINVAL;
4636
4637 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4638
4c476991
JB		 4639 if (!rdev->ops->get_station)
4640 return -EOPNOTSUPP;
3b85875a 4641
e35e4d28 4642 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
fd5b74dc 4643 if (err)
4c476991 4644 return err;
2ec600d6 4645
fd2120ca 4646 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc 4647 if (!msg)
4c476991 4648 return -ENOMEM;
fd5b74dc 4649
cf5ead82
JB		 4650 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
4651 info->snd_portid, info->snd_seq, 0,
66266b3a 4652 rdev, dev, mac_addr, &sinfo) < 0) {
4c476991
JB		 4653 nlmsg_free(msg);
4654 return -ENOBUFS;
4655 }
3b85875a 4656
4c476991 4657 return genlmsg_reply(msg, info);
5727ef1b
JB		 4658}
4659
77ee7c89
JB		 4660int cfg80211_check_station_change(struct wiphy *wiphy,
4661 struct station_parameters *params,
4662 enum cfg80211_station_type statype)
4663{
e4208427
AB		 4664 if (params->listen_interval != -1 &&
4665 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89 4666 return -EINVAL;
e4208427 4667
17b94247
AB		 4668 if (params->support_p2p_ps != -1 &&
4669 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
4670 return -EINVAL;
4671
c72e1140 4672 if (params->aid &&
e4208427
AB		 4673 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
4674 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89
JB		 4675 return -EINVAL;
4676
4677 /* When you run into this, adjust the code below for the new flag */
4678 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4679
4680 switch (statype) {
eef941e6
TP		 4681 case CFG80211_STA_MESH_PEER_KERNEL:
4682 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 4683 /*
4684 * No ignoring the TDLS flag here -- the userspace mesh
4685 * code doesn't have the bug of including TDLS in the
4686 * mask everywhere.
4687 */
4688 if (params->sta_flags_mask &
4689 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4690 BIT(NL80211_STA_FLAG_MFP) |
4691 BIT(NL80211_STA_FLAG_AUTHORIZED)))
4692 return -EINVAL;
4693 break;
4694 case CFG80211_STA_TDLS_PEER_SETUP:
4695 case CFG80211_STA_TDLS_PEER_ACTIVE:
4696 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4697 return -EINVAL;
4698 /* ignore since it can't change */
4699 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4700 break;
4701 default:
4702 /* disallow mesh-specific things */
4703 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
4704 return -EINVAL;
4705 if (params->local_pm)
4706 return -EINVAL;
4707 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4708 return -EINVAL;
4709 }
4710
4711 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4712 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
4713 /* TDLS can't be set, ... */
4714 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4715 return -EINVAL;
4716 /*
4717 * ... but don't bother the driver with it. This works around
4718 * a hostapd/wpa_supplicant issue -- it always includes the
4719 * TLDS_PEER flag in the mask even for AP mode.
4720 */
4721 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4722 }
4723
47edb11b
AB		 4724 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4725 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4726 /* reject other things that can't change */
4727 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
4728 return -EINVAL;
4729 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
4730 return -EINVAL;
4731 if (params->supported_rates)
4732 return -EINVAL;
4733 if (params->ext_capab || params->ht_capa || params->vht_capa)
4734 return -EINVAL;
4735 }
4736
47edb11b
AB		 4737 if (statype != CFG80211_STA_AP_CLIENT &&
4738 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4739 if (params->vlan)
4740 return -EINVAL;
4741 }
4742
4743 switch (statype) {
4744 case CFG80211_STA_AP_MLME_CLIENT:
4745 /* Use this only for authorizing/unauthorizing a station */
4746 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4747 return -EOPNOTSUPP;
4748 break;
4749 case CFG80211_STA_AP_CLIENT:
47edb11b 4750 case CFG80211_STA_AP_CLIENT_UNASSOC:
77ee7c89
JB		 4751 /* accept only the listed bits */
4752 if (params->sta_flags_mask &
4753 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4754 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4755 BIT(NL80211_STA_FLAG_ASSOCIATED) |
4756 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4757 BIT(NL80211_STA_FLAG_WME) |
4758 BIT(NL80211_STA_FLAG_MFP)))
4759 return -EINVAL;
4760
4761 /* but authenticated/associated only if driver handles it */
4762 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4763 params->sta_flags_mask &
4764 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4765 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4766 return -EINVAL;
4767 break;
4768 case CFG80211_STA_IBSS:
4769 case CFG80211_STA_AP_STA:
4770 /* reject any changes other than AUTHORIZED */
4771 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
4772 return -EINVAL;
4773 break;
4774 case CFG80211_STA_TDLS_PEER_SETUP:
4775 /* reject any changes other than AUTHORIZED or WME */
4776 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4777 BIT(NL80211_STA_FLAG_WME)))
4778 return -EINVAL;
4779 /* force (at least) rates when authorizing */
4780 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
4781 !params->supported_rates)
4782 return -EINVAL;
4783 break;
4784 case CFG80211_STA_TDLS_PEER_ACTIVE:
4785 /* reject any changes */
4786 return -EINVAL;
eef941e6 4787 case CFG80211_STA_MESH_PEER_KERNEL:
77ee7c89
JB		 4788 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4789 return -EINVAL;
4790 break;
eef941e6 4791 case CFG80211_STA_MESH_PEER_USER:
42925040
CYY		 4792 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
4793 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
77ee7c89
JB		 4794 return -EINVAL;
4795 break;
4796 }
4797
06f7c88c
BL		 4798 /*
4799 * Older kernel versions ignored this attribute entirely, so don't
4800 * reject attempts to update it but mark it as unused instead so the
4801 * driver won't look at the data.
4802 */
4803 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
4804 statype != CFG80211_STA_TDLS_PEER_SETUP)
4805 params->opmode_notif_used = false;
4806
77ee7c89
JB		 4807 return 0;
4808}
4809EXPORT_SYMBOL(cfg80211_check_station_change);
4810
5727ef1b 4811/*
c258d2de 4812 * Get vlan interface making sure it is running and on the right wiphy.
5727ef1b 4813 */
80b99899
JB		 4814static struct net_device *get_vlan(struct genl_info *info,
4815 struct cfg80211_registered_device *rdev)
5727ef1b 4816{
463d0183 4817 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
80b99899
JB		 4818 struct net_device *v;
4819 int ret;
4820
4821 if (!vlanattr)
4822 return NULL;
4823
4824 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4825 if (!v)
4826 return ERR_PTR(-ENODEV);
4827
4828 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4829 ret = -EINVAL;
4830 goto error;
5727ef1b 4831 }
80b99899 4832
77ee7c89
JB		 4833 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4834 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4835 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4836 ret = -EINVAL;
4837 goto error;
4838 }
4839
80b99899
JB		 4840 if (!netif_running(v)) {
4841 ret = -ENETDOWN;
4842 goto error;
4843 }
4844
4845 return v;
4846 error:
4847 dev_put(v);
4848 return ERR_PTR(ret);
5727ef1b
JB		 4849}
4850
94e860f1
JB		 4851static const struct nla_policy
4852nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
df881293
JM		 4853 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4854 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4855};
4856
ff276691
JB		 4857static int nl80211_parse_sta_wme(struct genl_info *info,
4858 struct station_parameters *params)
df881293 4859{
df881293
JM		 4860 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4861 struct nlattr *nla;
4862 int err;
4863
df881293
JM		 4864 /* parse WME attributes if present */
4865 if (!info->attrs[NL80211_ATTR_STA_WME])
4866 return 0;
4867
4868 nla = info->attrs[NL80211_ATTR_STA_WME];
4869 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
fe52145f 4870 nl80211_sta_wme_policy, info->extack);
df881293
JM		 4871 if (err)
4872 return err;
4873
4874 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4875 params->uapsd_queues = nla_get_u8(
4876 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4877 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4878 return -EINVAL;
4879
4880 if (tb[NL80211_STA_WME_MAX_SP])
4881 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4882
4883 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4884 return -EINVAL;
4885
4886 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4887
4888 return 0;
4889}
4890
c01fc9ad
SD		 4891static int nl80211_parse_sta_channel_info(struct genl_info *info,
4892 struct station_parameters *params)
4893{
4894 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4895 params->supported_channels =
4896 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4897 params->supported_channels_len =
4898 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4899 /*
4900 * Need to include at least one (first channel, number of
4901 * channels) tuple for each subband, and must have proper
4902 * tuples for the rest of the data as well.
4903 */
4904 if (params->supported_channels_len < 2)
4905 return -EINVAL;
4906 if (params->supported_channels_len % 2)
4907 return -EINVAL;
4908 }
4909
4910 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4911 params->supported_oper_classes =
4912 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4913 params->supported_oper_classes_len =
4914 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4915 /*
4916 * The value of the Length field of the Supported Operating
4917 * Classes element is between 2 and 253.
4918 */
4919 if (params->supported_oper_classes_len < 2 ||
4920 params->supported_oper_classes_len > 253)
4921 return -EINVAL;
4922 }
4923 return 0;
4924}
4925
ff276691
JB		 4926static int nl80211_set_station_tdls(struct genl_info *info,
4927 struct station_parameters *params)
4928{
c01fc9ad 4929 int err;
ff276691 4930 /* Dummy STA entry gets updated once the peer capabilities are known */
5e4b6f56
JM		 4931 if (info->attrs[NL80211_ATTR_PEER_AID])
4932 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
ff276691
JB		 4933 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4934 params->ht_capa =
4935 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4936 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4937 params->vht_capa =
4938 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4939
c01fc9ad
SD		 4940 err = nl80211_parse_sta_channel_info(info, params);
4941 if (err)
4942 return err;
4943
ff276691
JB		 4944 return nl80211_parse_sta_wme(info, params);
4945}
4946
5727ef1b
JB		 4947static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4948{
4c476991 4949 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4950 struct net_device *dev = info->user_ptr[1];
5727ef1b 4951 struct station_parameters params;
77ee7c89
JB		 4952 u8 *mac_addr;
4953 int err;
5727ef1b
JB		 4954
4955 memset(&params, 0, sizeof(params));
4956
77ee7c89
JB		 4957 if (!rdev->ops->change_station)
4958 return -EOPNOTSUPP;
4959
e4208427
AB		 4960 /*
4961 * AID and listen_interval properties can be set only for unassociated
4962 * station. Include these parameters here and will check them in
4963 * cfg80211_check_station_change().
4964 */
a9bc31e4
AB		 4965 if (info->attrs[NL80211_ATTR_STA_AID])
4966 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
e4208427
AB		 4967
4968 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4969 params.listen_interval =
4970 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
4971 else
4972 params.listen_interval = -1;
5727ef1b 4973
17b94247
AB		 4974 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
4975 u8 tmp;
4976
4977 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
4978 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
4979 return -EINVAL;
4980
4981 params.support_p2p_ps = tmp;
4982 } else {
4983 params.support_p2p_ps = -1;
4984 }
4985
5727ef1b
JB		 4986 if (!info->attrs[NL80211_ATTR_MAC])
4987 return -EINVAL;
4988
4989 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4990
4991 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4992 params.supported_rates =
4993 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4994 params.supported_rates_len =
4995 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4996 }
4997
9d62a986
JM		 4998 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4999 params.capability =
5000 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5001 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5002 }
5003
5004 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5005 params.ext_capab =
5006 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5007 params.ext_capab_len =
5008 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5009 }
5010
bdd3ae3d 5011 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 5012 return -EINVAL;
5013
f8bacc21 5014 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
2ec600d6 5015 params.plink_action =
f8bacc21
JB		 5016 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5017 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
5018 return -EINVAL;
5019 }
2ec600d6 5020
f8bacc21 5021 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
9c3990aa 5022 params.plink_state =
f8bacc21
JB		 5023 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
5024 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
5025 return -EINVAL;
7d27a0ba
MH		 5026 if (info->attrs[NL80211_ATTR_MESH_PEER_AID]) {
5027 params.peer_aid = nla_get_u16(
5028 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
5029 if (params.peer_aid > IEEE80211_MAX_AID)
5030 return -EINVAL;
5031 }
f8bacc21
JB		 5032 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
5033 }
9c3990aa 5034
3b1c5a53
MP		 5035 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
5036 enum nl80211_mesh_power_mode pm = nla_get_u32(
5037 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
5038
5039 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
5040 pm > NL80211_MESH_POWER_MAX)
5041 return -EINVAL;
5042
5043 params.local_pm = pm;
5044 }
5045
06f7c88c
BL		 5046 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5047 params.opmode_notif_used = true;
5048 params.opmode_notif =
5049 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5050 }
5051
77ee7c89
JB		 5052 /* Include parameters for TDLS peer (will check later) */
5053 err = nl80211_set_station_tdls(info, &params);
5054 if (err)
5055 return err;
5056
5057 params.vlan = get_vlan(info, rdev);
5058 if (IS_ERR(params.vlan))
5059 return PTR_ERR(params.vlan);
5060
a97f4424
JB		 5061 switch (dev->ieee80211_ptr->iftype) {
5062 case NL80211_IFTYPE_AP:
5063 case NL80211_IFTYPE_AP_VLAN:
074ac8df 5064 case NL80211_IFTYPE_P2P_GO:
074ac8df 5065 case NL80211_IFTYPE_P2P_CLIENT:
a97f4424 5066 case NL80211_IFTYPE_STATION:
267335d6 5067 case NL80211_IFTYPE_ADHOC:
a97f4424 5068 case NL80211_IFTYPE_MESH_POINT:
a97f4424
JB		 5069 break;
5070 default:
77ee7c89
JB		 5071 err = -EOPNOTSUPP;
5072 goto out_put_vlan;
034d655e
JB		 5073 }
5074
77ee7c89 5075 /* driver will call cfg80211_check_station_change() */
e35e4d28 5076 err = rdev_change_station(rdev, dev, mac_addr, &params);
5727ef1b 5077
77ee7c89 5078 out_put_vlan:
5727ef1b
JB		 5079 if (params.vlan)
5080 dev_put(params.vlan);
3b85875a 5081
5727ef1b
JB		 5082 return err;
5083}
5084
5085static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
5086{
4c476991 5087 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5727ef1b 5088 int err;
4c476991 5089 struct net_device *dev = info->user_ptr[1];
5727ef1b
JB		 5090 struct station_parameters params;
5091 u8 *mac_addr = NULL;
bda95eb1
JB		 5092 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5093 BIT(NL80211_STA_FLAG_ASSOCIATED);
5727ef1b
JB		 5094
5095 memset(&params, 0, sizeof(params));
5096
984c311b
JB		 5097 if (!rdev->ops->add_station)
5098 return -EOPNOTSUPP;
5099
5727ef1b
JB		 5100 if (!info->attrs[NL80211_ATTR_MAC])
5101 return -EINVAL;
5102
5727ef1b
JB		 5103 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5104 return -EINVAL;
5105
5106 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5107 return -EINVAL;
5108
5e4b6f56
JM		 5109 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5110 !info->attrs[NL80211_ATTR_PEER_AID])
0e956c13
TLSC		 5111 return -EINVAL;
5112
5727ef1b
JB		 5113 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5114 params.supported_rates =
5115 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5116 params.supported_rates_len =
5117 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5118 params.listen_interval =
5119 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 5120
17b94247
AB		 5121 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5122 u8 tmp;
5123
5124 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5125 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
5126 return -EINVAL;
5127
5128 params.support_p2p_ps = tmp;
5129 } else {
5130 /*
5131 * if not specified, assume it's supported for P2P GO interface,
5132 * and is NOT supported for AP interface
5133 */
5134 params.support_p2p_ps =
5135 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5136 }
5137
3d124ea2 5138 if (info->attrs[NL80211_ATTR_PEER_AID])
5e4b6f56 5139 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
3d124ea2
JM		 5140 else
5141 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
0e956c13
TLSC		 5142 if (!params.aid || params.aid > IEEE80211_MAX_AID)
5143 return -EINVAL;
51b50fbe 5144
9d62a986
JM		 5145 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5146 params.capability =
5147 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5148 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5149 }
5150
5151 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5152 params.ext_capab =
5153 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5154 params.ext_capab_len =
5155 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5156 }
5157
36aedc90
JM		 5158 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5159 params.ht_capa =
5160 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 5161
f461be3e
MP		 5162 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5163 params.vht_capa =
5164 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5165
60f4a7b1
MK		 5166 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5167 params.opmode_notif_used = true;
5168 params.opmode_notif =
5169 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5170 }
5171
f8bacc21 5172 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
96b78dff 5173 params.plink_action =
f8bacc21
JB		 5174 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5175 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
5176 return -EINVAL;
5177 }
96b78dff 5178
c01fc9ad
SD		 5179 err = nl80211_parse_sta_channel_info(info, &params);
5180 if (err)
5181 return err;
5182
ff276691
JB		 5183 err = nl80211_parse_sta_wme(info, &params);
5184 if (err)
5185 return err;
bdd90d5e 5186
bdd3ae3d 5187 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 5188 return -EINVAL;
5189
496fcc29
JB		 5190 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5191 * as userspace might just pass through the capabilities from the IEs
5192 * directly, rather than enforcing this restriction and returning an
5193 * error in this case.
5194 */
5195 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5196 params.ht_capa = NULL;
5197 params.vht_capa = NULL;
5198 }
5199
77ee7c89
JB		 5200 /* When you run into this, adjust the code below for the new flag */
5201 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5202
bdd90d5e
JB		 5203 switch (dev->ieee80211_ptr->iftype) {
5204 case NL80211_IFTYPE_AP:
5205 case NL80211_IFTYPE_AP_VLAN:
5206 case NL80211_IFTYPE_P2P_GO:
984c311b
JB		 5207 /* ignore WME attributes if iface/sta is not capable */
5208 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5209 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5210 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
c75786c9 5211
bdd90d5e 5212 /* TDLS peers cannot be added */
3d124ea2
JM		 5213 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5214 info->attrs[NL80211_ATTR_PEER_AID])
4319e193 5215 return -EINVAL;
bdd90d5e
JB		 5216 /* but don't bother the driver with it */
5217 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3b9ce80c 5218
d582cffb
JB		 5219 /* allow authenticated/associated only if driver handles it */
5220 if (!(rdev->wiphy.features &
5221 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
bda95eb1 5222 params.sta_flags_mask & auth_assoc)
d582cffb
JB		 5223 return -EINVAL;
5224
bda95eb1
JB		 5225 /* Older userspace, or userspace wanting to be compatible with
5226 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5227 * and assoc flags in the mask, but assumes the station will be
5228 * added as associated anyway since this was the required driver
5229 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5230 * introduced.
5231 * In order to not bother drivers with this quirk in the API
5232 * set the flags in both the mask and set for new stations in
5233 * this case.
5234 */
5235 if (!(params.sta_flags_mask & auth_assoc)) {
5236 params.sta_flags_mask |= auth_assoc;
5237 params.sta_flags_set |= auth_assoc;
5238 }
5239
bdd90d5e
JB		 5240 /* must be last in here for error handling */
5241 params.vlan = get_vlan(info, rdev);
5242 if (IS_ERR(params.vlan))
5243 return PTR_ERR(params.vlan);
5244 break;
5245 case NL80211_IFTYPE_MESH_POINT:
984c311b
JB		 5246 /* ignore uAPSD data */
5247 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5248
d582cffb
JB		 5249 /* associated is disallowed */
5250 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5251 return -EINVAL;
bdd90d5e 5252 /* TDLS peers cannot be added */
3d124ea2
JM		 5253 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5254 info->attrs[NL80211_ATTR_PEER_AID])
bdd90d5e
JB		 5255 return -EINVAL;
5256 break;
5257 case NL80211_IFTYPE_STATION:
93d08f0b 5258 case NL80211_IFTYPE_P2P_CLIENT:
984c311b
JB		 5259 /* ignore uAPSD data */
5260 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5261
77ee7c89
JB		 5262 /* these are disallowed */
5263 if (params.sta_flags_mask &
5264 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5265 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
d582cffb 5266 return -EINVAL;
bdd90d5e
JB		 5267 /* Only TDLS peers can be added */
5268 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5269 return -EINVAL;
5270 /* Can only add if TDLS ... */
5271 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5272 return -EOPNOTSUPP;
5273 /* ... with external setup is supported */
5274 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5275 return -EOPNOTSUPP;
77ee7c89
JB		 5276 /*
5277 * Older wpa_supplicant versions always mark the TDLS peer
5278 * as authorized, but it shouldn't yet be.
5279 */
5280 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
bdd90d5e
JB		 5281 break;
5282 default:
5283 return -EOPNOTSUPP;
c75786c9
EP		 5284 }
5285
bdd90d5e 5286 /* be aware of params.vlan when changing code here */
5727ef1b 5287
e35e4d28 5288 err = rdev_add_station(rdev, dev, mac_addr, &params);
5727ef1b 5289
5727ef1b
JB		 5290 if (params.vlan)
5291 dev_put(params.vlan);
5727ef1b
JB		 5292 return err;
5293}
5294
5295static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5296{
4c476991
JB		 5297 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5298 struct net_device *dev = info->user_ptr[1];
89c771e5
JM		 5299 struct station_del_parameters params;
5300
5301 memset(&params, 0, sizeof(params));
5727ef1b
JB		 5302
5303 if (info->attrs[NL80211_ATTR_MAC])
89c771e5 5304 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5727ef1b 5305
e80cf853 5306 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
d5d9de02 5307 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
074ac8df 5308 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4c476991
JB		 5309 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5310 return -EINVAL;
5727ef1b 5311
4c476991
JB		 5312 if (!rdev->ops->del_station)
5313 return -EOPNOTSUPP;
3b85875a 5314
98856866
JM		 5315 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
5316 params.subtype =
5317 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
5318 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
5319 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
5320 return -EINVAL;
5321 } else {
5322 /* Default to Deauthentication frame */
5323 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
5324 }
5325
5326 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
5327 params.reason_code =
5328 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5329 if (params.reason_code == 0)
5330 return -EINVAL; /* 0 is reserved */
5331 } else {
5332 /* Default to reason code 2 */
5333 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
5334 }
5335
89c771e5 5336 return rdev_del_station(rdev, dev, &params);
5727ef1b
JB		 5337}
5338
15e47304 5339static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
2ec600d6
LCC		 5340 int flags, struct net_device *dev,
5341 u8 *dst, u8 *next_hop,
5342 struct mpath_info *pinfo)
5343{
5344 void *hdr;
5345 struct nlattr *pinfoattr;
5346
1ef4c850 5347 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
2ec600d6
LCC		 5348 if (!hdr)
5349 return -1;
5350
9360ffd1
DM		 5351 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5352 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
5353 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
5354 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
5355 goto nla_put_failure;
f5ea9120 5356
2ec600d6
LCC		 5357 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
5358 if (!pinfoattr)
5359 goto nla_put_failure;
9360ffd1
DM		 5360 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
5361 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
5362 pinfo->frame_qlen))
5363 goto nla_put_failure;
5364 if (((pinfo->filled & MPATH_INFO_SN) &&
5365 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
5366 ((pinfo->filled & MPATH_INFO_METRIC) &&
5367 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
5368 pinfo->metric)) ||
5369 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
5370 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
5371 pinfo->exptime)) ||
5372 ((pinfo->filled & MPATH_INFO_FLAGS) &&
5373 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
5374 pinfo->flags)) ||
5375 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
5376 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
5377 pinfo->discovery_timeout)) ||
5378 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
5379 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
5380 pinfo->discovery_retries)))
5381 goto nla_put_failure;
2ec600d6
LCC		 5382
5383 nla_nest_end(msg, pinfoattr);
5384
053c095a
JB		 5385 genlmsg_end(msg, hdr);
5386 return 0;
2ec600d6
LCC		 5387
5388 nla_put_failure:
bc3ed28c
TG		 5389 genlmsg_cancel(msg, hdr);
5390 return -EMSGSIZE;
2ec600d6
LCC		 5391}
5392
5393static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 5394 struct netlink_callback *cb)
2ec600d6 5395{
2ec600d6 5396 struct mpath_info pinfo;
1b8ec87a 5397 struct cfg80211_registered_device *rdev;
97990a06 5398 struct wireless_dev *wdev;
2ec600d6
LCC		 5399 u8 dst[ETH_ALEN];
5400 u8 next_hop[ETH_ALEN];
97990a06 5401 int path_idx = cb->args[2];
2ec600d6 5402 int err;
2ec600d6 5403
ea90e0dc 5404 rtnl_lock();
1b8ec87a 5405 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 5406 if (err)
ea90e0dc 5407 goto out_err;
bba95fef 5408
1b8ec87a 5409 if (!rdev->ops->dump_mpath) {
eec60b03 5410 err = -EOPNOTSUPP;
bba95fef
JB		 5411 goto out_err;
5412 }
5413
97990a06 5414 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
eec60b03 5415 err = -EOPNOTSUPP;
0448b5fc 5416 goto out_err;
eec60b03
JM		 5417 }
5418
bba95fef 5419 while (1) {
1b8ec87a 5420 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
97990a06 5421 next_hop, &pinfo);
bba95fef 5422 if (err == -ENOENT)
2ec600d6 5423 break;
bba95fef 5424 if (err)
3b85875a 5425 goto out_err;
2ec600d6 5426
15e47304 5427 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
bba95fef 5428 cb->nlh->nlmsg_seq, NLM_F_MULTI,
97990a06 5429 wdev->netdev, dst, next_hop,
bba95fef
JB		 5430 &pinfo) < 0)
5431 goto out;
2ec600d6 5432
bba95fef 5433 path_idx++;
2ec600d6 5434 }
2ec600d6 5435
bba95fef 5436 out:
97990a06 5437 cb->args[2] = path_idx;
bba95fef 5438 err = skb->len;
bba95fef 5439 out_err:
ea90e0dc 5440 rtnl_unlock();
bba95fef 5441 return err;
2ec600d6
LCC		 5442}
5443
5444static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
5445{
4c476991 5446 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 5447 int err;
4c476991 5448 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5449 struct mpath_info pinfo;
5450 struct sk_buff *msg;
5451 u8 *dst = NULL;
5452 u8 next_hop[ETH_ALEN];
5453
5454 memset(&pinfo, 0, sizeof(pinfo));
5455
5456 if (!info->attrs[NL80211_ATTR_MAC])
5457 return -EINVAL;
5458
5459 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5460
4c476991
JB		 5461 if (!rdev->ops->get_mpath)
5462 return -EOPNOTSUPP;
2ec600d6 5463
4c476991
JB		 5464 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5465 return -EOPNOTSUPP;
eec60b03 5466
e35e4d28 5467 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
2ec600d6 5468 if (err)
4c476991 5469 return err;
2ec600d6 5470
fd2120ca 5471 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6 5472 if (!msg)
4c476991 5473 return -ENOMEM;
2ec600d6 5474
15e47304 5475 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4c476991
JB		 5476 dev, dst, next_hop, &pinfo) < 0) {
5477 nlmsg_free(msg);
5478 return -ENOBUFS;
5479 }
3b85875a 5480
4c476991 5481 return genlmsg_reply(msg, info);
2ec600d6
LCC		 5482}
5483
5484static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
5485{
4c476991
JB		 5486 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5487 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5488 u8 *dst = NULL;
5489 u8 *next_hop = NULL;
5490
5491 if (!info->attrs[NL80211_ATTR_MAC])
5492 return -EINVAL;
5493
5494 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5495 return -EINVAL;
5496
5497 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5498 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5499
4c476991
JB		 5500 if (!rdev->ops->change_mpath)
5501 return -EOPNOTSUPP;
35a8efe1 5502
4c476991
JB		 5503 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5504 return -EOPNOTSUPP;
2ec600d6 5505
e35e4d28 5506 return rdev_change_mpath(rdev, dev, dst, next_hop);
2ec600d6 5507}
4c476991 5508
2ec600d6
LCC		 5509static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
5510{
4c476991
JB		 5511 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5512 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5513 u8 *dst = NULL;
5514 u8 *next_hop = NULL;
5515
5516 if (!info->attrs[NL80211_ATTR_MAC])
5517 return -EINVAL;
5518
5519 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5520 return -EINVAL;
5521
5522 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5523 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5524
4c476991
JB		 5525 if (!rdev->ops->add_mpath)
5526 return -EOPNOTSUPP;
35a8efe1 5527
4c476991
JB		 5528 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5529 return -EOPNOTSUPP;
2ec600d6 5530
e35e4d28 5531 return rdev_add_mpath(rdev, dev, dst, next_hop);
2ec600d6
LCC		 5532}
5533
5534static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
5535{
4c476991
JB		 5536 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5537 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5538 u8 *dst = NULL;
5539
5540 if (info->attrs[NL80211_ATTR_MAC])
5541 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5542
4c476991
JB		 5543 if (!rdev->ops->del_mpath)
5544 return -EOPNOTSUPP;
3b85875a 5545
d2b373e7
MP		 5546 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5547 return -EOPNOTSUPP;
5548
e35e4d28 5549 return rdev_del_mpath(rdev, dev, dst);
2ec600d6
LCC		 5550}
5551
66be7d2b
HR		 5552static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
5553{
5554 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5555 int err;
5556 struct net_device *dev = info->user_ptr[1];
5557 struct mpath_info pinfo;
5558 struct sk_buff *msg;
5559 u8 *dst = NULL;
5560 u8 mpp[ETH_ALEN];
5561
5562 memset(&pinfo, 0, sizeof(pinfo));
5563
5564 if (!info->attrs[NL80211_ATTR_MAC])
5565 return -EINVAL;
5566
5567 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5568
5569 if (!rdev->ops->get_mpp)
5570 return -EOPNOTSUPP;
5571
5572 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5573 return -EOPNOTSUPP;
5574
5575 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
5576 if (err)
5577 return err;
5578
5579 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5580 if (!msg)
5581 return -ENOMEM;
5582
5583 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
5584 dev, dst, mpp, &pinfo) < 0) {
5585 nlmsg_free(msg);
5586 return -ENOBUFS;
5587 }
5588
5589 return genlmsg_reply(msg, info);
5590}
5591
5592static int nl80211_dump_mpp(struct sk_buff *skb,
5593 struct netlink_callback *cb)
5594{
5595 struct mpath_info pinfo;
5596 struct cfg80211_registered_device *rdev;
5597 struct wireless_dev *wdev;
5598 u8 dst[ETH_ALEN];
5599 u8 mpp[ETH_ALEN];
5600 int path_idx = cb->args[2];
5601 int err;
5602
ea90e0dc 5603 rtnl_lock();
66be7d2b
HR		 5604 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5605 if (err)
ea90e0dc 5606 goto out_err;
66be7d2b
HR		 5607
5608 if (!rdev->ops->dump_mpp) {
5609 err = -EOPNOTSUPP;
5610 goto out_err;
5611 }
5612
5613 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
5614 err = -EOPNOTSUPP;
5615 goto out_err;
5616 }
5617
5618 while (1) {
5619 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
5620 mpp, &pinfo);
5621 if (err == -ENOENT)
5622 break;
5623 if (err)
5624 goto out_err;
5625
5626 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
5627 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5628 wdev->netdev, dst, mpp,
5629 &pinfo) < 0)
5630 goto out;
5631
5632 path_idx++;
5633 }
5634
5635 out:
5636 cb->args[2] = path_idx;
5637 err = skb->len;
5638 out_err:
ea90e0dc 5639 rtnl_unlock();
66be7d2b
HR		 5640 return err;
5641}
5642
9f1ba906
JM		 5643static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
5644{
4c476991
JB		 5645 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5646 struct net_device *dev = info->user_ptr[1];
c56589ed 5647 struct wireless_dev *wdev = dev->ieee80211_ptr;
9f1ba906 5648 struct bss_parameters params;
c56589ed 5649 int err;
9f1ba906
JM		 5650
5651 memset(&params, 0, sizeof(params));
5652 /* default to not changing parameters */
5653 params.use_cts_prot = -1;
5654 params.use_short_preamble = -1;
5655 params.use_short_slot_time = -1;
fd8aaaf3 5656 params.ap_isolate = -1;
50b12f59 5657 params.ht_opmode = -1;
53cabad7
JB		 5658 params.p2p_ctwindow = -1;
5659 params.p2p_opp_ps = -1;
9f1ba906
JM		 5660
5661 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
5662 params.use_cts_prot =
5663 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
5664 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
5665 params.use_short_preamble =
5666 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
5667 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
5668 params.use_short_slot_time =
5669 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 5670 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5671 params.basic_rates =
5672 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5673 params.basic_rates_len =
5674 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5675 }
fd8aaaf3
FF		 5676 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
5677 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
50b12f59
HS		 5678 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
5679 params.ht_opmode =
5680 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9f1ba906 5681
53cabad7
JB		 5682 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
5683 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5684 return -EINVAL;
5685 params.p2p_ctwindow =
5686 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
5687 if (params.p2p_ctwindow < 0)
5688 return -EINVAL;
5689 if (params.p2p_ctwindow != 0 &&
5690 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
5691 return -EINVAL;
5692 }
5693
5694 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
5695 u8 tmp;
5696
5697 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5698 return -EINVAL;
5699 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
5700 if (tmp > 1)
5701 return -EINVAL;
5702 params.p2p_opp_ps = tmp;
5703 if (params.p2p_opp_ps &&
5704 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
5705 return -EINVAL;
5706 }
5707
4c476991
JB		 5708 if (!rdev->ops->change_bss)
5709 return -EOPNOTSUPP;
9f1ba906 5710
074ac8df 5711 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4c476991
JB		 5712 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5713 return -EOPNOTSUPP;
3b85875a 5714
c56589ed
SW		 5715 wdev_lock(wdev);
5716 err = rdev_change_bss(rdev, dev, &params);
5717 wdev_unlock(wdev);
5718
5719 return err;
9f1ba906
JM		 5720}
5721
b2e1b302
LR		 5722static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
5723{
b2e1b302 5724 char *data = NULL;
05050753 5725 bool is_indoor;
57b5ce07 5726 enum nl80211_user_reg_hint_type user_reg_hint_type;
05050753
I		 5727 u32 owner_nlportid;
5728
80778f18
LR		 5729 /*
5730 * You should only get this when cfg80211 hasn't yet initialized
5731 * completely when built-in to the kernel right between the time
5732 * window between nl80211_init() and regulatory_init(), if that is
5733 * even possible.
5734 */
458f4f9e 5735 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
fe33eb39 5736 return -EINPROGRESS;
80778f18 5737
57b5ce07
LR		 5738 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
5739 user_reg_hint_type =
5740 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
5741 else
5742 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
5743
5744 switch (user_reg_hint_type) {
5745 case NL80211_USER_REG_HINT_USER:
5746 case NL80211_USER_REG_HINT_CELL_BASE:
52616f2b
IP		 5747 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5748 return -EINVAL;
5749
5750 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5751 return regulatory_hint_user(data, user_reg_hint_type);
5752 case NL80211_USER_REG_HINT_INDOOR:
05050753
I		 5753 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
5754 owner_nlportid = info->snd_portid;
5755 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
5756 } else {
5757 owner_nlportid = 0;
5758 is_indoor = true;
5759 }
5760
5761 return regulatory_hint_indoor(is_indoor, owner_nlportid);
57b5ce07
LR		 5762 default:
5763 return -EINVAL;
5764 }
b2e1b302
LR		 5765}
5766
1ea4ff3e
JB		 5767static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
5768{
5769 return reg_reload_regdb();
5770}
5771
24bdd9f4 5772static int nl80211_get_mesh_config(struct sk_buff *skb,
29cbe68c 5773 struct genl_info *info)
93da9cc1 5774{
4c476991 5775 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 5776 struct net_device *dev = info->user_ptr[1];
29cbe68c
JB		 5777 struct wireless_dev *wdev = dev->ieee80211_ptr;
5778 struct mesh_config cur_params;
5779 int err = 0;
93da9cc1 5780 void *hdr;
5781 struct nlattr *pinfoattr;
5782 struct sk_buff *msg;
5783
29cbe68c
JB		 5784 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5785 return -EOPNOTSUPP;
5786
24bdd9f4 5787 if (!rdev->ops->get_mesh_config)
4c476991 5788 return -EOPNOTSUPP;
f3f92586 5789
29cbe68c
JB		 5790 wdev_lock(wdev);
5791 /* If not connected, get default parameters */
5792 if (!wdev->mesh_id_len)
5793 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
5794 else
e35e4d28 5795 err = rdev_get_mesh_config(rdev, dev, &cur_params);
29cbe68c
JB		 5796 wdev_unlock(wdev);
5797
93da9cc1 5798 if (err)
4c476991 5799 return err;
93da9cc1 5800
5801 /* Draw up a netlink message to send back */
fd2120ca 5802 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 5803 if (!msg)
5804 return -ENOMEM;
15e47304 5805 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
24bdd9f4 5806 NL80211_CMD_GET_MESH_CONFIG);
93da9cc1 5807 if (!hdr)
efe1cf0c 5808 goto out;
24bdd9f4 5809 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
93da9cc1 5810 if (!pinfoattr)
5811 goto nla_put_failure;
9360ffd1
DM		 5812 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5813 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
5814 cur_params.dot11MeshRetryTimeout) ||
5815 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5816 cur_params.dot11MeshConfirmTimeout) ||
5817 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
5818 cur_params.dot11MeshHoldingTimeout) ||
5819 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
5820 cur_params.dot11MeshMaxPeerLinks) ||
5821 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
5822 cur_params.dot11MeshMaxRetries) ||
5823 nla_put_u8(msg, NL80211_MESHCONF_TTL,
5824 cur_params.dot11MeshTTL) ||
5825 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
5826 cur_params.element_ttl) ||
5827 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5828 cur_params.auto_open_plinks) ||
7eab0f64
JL		 5829 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5830 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
9360ffd1
DM		 5831 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5832 cur_params.dot11MeshHWMPmaxPREQretries) ||
5833 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
5834 cur_params.path_refresh_time) ||
5835 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5836 cur_params.min_discovery_timeout) ||
5837 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5838 cur_params.dot11MeshHWMPactivePathTimeout) ||
5839 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
5840 cur_params.dot11MeshHWMPpreqMinInterval) ||
5841 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
5842 cur_params.dot11MeshHWMPperrMinInterval) ||
5843 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5844 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
5845 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
5846 cur_params.dot11MeshHWMPRootMode) ||
5847 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5848 cur_params.dot11MeshHWMPRannInterval) ||
5849 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5850 cur_params.dot11MeshGateAnnouncementProtocol) ||
5851 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
5852 cur_params.dot11MeshForwarding) ||
335d5349 5853 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
70c33eaa
AN		 5854 cur_params.rssi_threshold) ||
5855 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5856 cur_params.ht_opmode) ||
5857 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5858 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
5859 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5860 cur_params.dot11MeshHWMProotInterval) ||
5861 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3b1c5a53
MP		 5862 cur_params.dot11MeshHWMPconfirmationInterval) ||
5863 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5864 cur_params.power_mode) ||
5865 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8e7c0538
CT		 5866 cur_params.dot11MeshAwakeWindowDuration) ||
5867 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5868 cur_params.plink_timeout))
9360ffd1 5869 goto nla_put_failure;
93da9cc1 5870 nla_nest_end(msg, pinfoattr);
5871 genlmsg_end(msg, hdr);
4c476991 5872 return genlmsg_reply(msg, info);
93da9cc1 5873
3b85875a 5874 nla_put_failure:
93da9cc1 5875 genlmsg_cancel(msg, hdr);
efe1cf0c 5876 out:
d080e275 5877 nlmsg_free(msg);
4c476991 5878 return -ENOBUFS;
93da9cc1 5879}
5880
b54452b0 5881static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
93da9cc1 5882 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5883 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5884 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5885 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5886 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5887 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
45904f21 5888 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
93da9cc1 5889 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
d299a1f2 5890 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
93da9cc1 5891 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5892 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5893 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5894 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5895 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
dca7e943 5896 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
93da9cc1 5897 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
699403db 5898 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
0507e159 5899 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
16dd7267 5900 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
94f90656 5901 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
a4f606ea
CYY		 5902 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5903 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
ac1073a6
CYY		 5904 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5905 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
728b19e5 5906 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3b1c5a53
MP		 5907 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5908 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8e7c0538 5909 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
93da9cc1 5910};
5911
c80d545d
JC		 5912static const struct nla_policy
5913 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
d299a1f2 5914 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
c80d545d
JC		 5915 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5916 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
15d5dda6 5917 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6e16d90b 5918 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
bb2798d4 5919 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
581a8b0f 5920 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
a4f606ea 5921 .len = IEEE80211_MAX_DATA_LEN },
b130e5ce 5922 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
c80d545d
JC		 5923};
5924
f151d9db
AB		 5925static int nl80211_check_bool(const struct nlattr *nla, u8 min, u8 max, bool *out)
5926{
5927 u8 val = nla_get_u8(nla);
5928 if (val < min || val > max)
5929 return -EINVAL;
5930 *out = val;
5931 return 0;
5932}
5933
5934static int nl80211_check_u8(const struct nlattr *nla, u8 min, u8 max, u8 *out)
5935{
5936 u8 val = nla_get_u8(nla);
5937 if (val < min || val > max)
5938 return -EINVAL;
5939 *out = val;
5940 return 0;
5941}
5942
5943static int nl80211_check_u16(const struct nlattr *nla, u16 min, u16 max, u16 *out)
5944{
5945 u16 val = nla_get_u16(nla);
5946 if (val < min || val > max)
5947 return -EINVAL;
5948 *out = val;
5949 return 0;
5950}
5951
5952static int nl80211_check_u32(const struct nlattr *nla, u32 min, u32 max, u32 *out)
5953{
5954 u32 val = nla_get_u32(nla);
5955 if (val < min || val > max)
5956 return -EINVAL;
5957 *out = val;
5958 return 0;
5959}
5960
5961static int nl80211_check_s32(const struct nlattr *nla, s32 min, s32 max, s32 *out)
5962{
5963 s32 val = nla_get_s32(nla);
5964 if (val < min || val > max)
5965 return -EINVAL;
5966 *out = val;
5967 return 0;
5968}
5969
ff9a71af
JB		 5970static int nl80211_check_power_mode(const struct nlattr *nla,
5971 enum nl80211_mesh_power_mode min,
5972 enum nl80211_mesh_power_mode max,
5973 enum nl80211_mesh_power_mode *out)
5974{
5975 u32 val = nla_get_u32(nla);
5976 if (val < min || val > max)
5977 return -EINVAL;
5978 *out = val;
5979 return 0;
5980}
5981
24bdd9f4 5982static int nl80211_parse_mesh_config(struct genl_info *info,
bd90fdcc
JB		 5983 struct mesh_config *cfg,
5984 u32 *mask_out)
93da9cc1 5985{
93da9cc1 5986 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
bd90fdcc 5987 u32 mask = 0;
9757235f 5988 u16 ht_opmode;
93da9cc1 5989
ea54fba2
MP		 5990#define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5991do { \
5992 if (tb[attr]) { \
f151d9db 5993 if (fn(tb[attr], min, max, &cfg->param)) \
ea54fba2 5994 return -EINVAL; \
ea54fba2
MP		 5995 mask |= (1 << (attr - 1)); \
5996 } \
5997} while (0)
bd90fdcc 5998
24bdd9f4 5999 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
93da9cc1 6000 return -EINVAL;
6001 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
24bdd9f4 6002 info->attrs[NL80211_ATTR_MESH_CONFIG],
fe52145f 6003 nl80211_meshconf_params_policy, info->extack))
93da9cc1 6004 return -EINVAL;
6005
93da9cc1 6006 /* This makes sure that there aren't more than 32 mesh config
6007 * parameters (otherwise our bitfield scheme would not work.) */
6008 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
6009
6010 /* Fill in the params struct */
ea54fba2 6011 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
a4f606ea 6012 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
f151d9db 6013 nl80211_check_u16);
ea54fba2 6014 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
a4f606ea 6015 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
f151d9db 6016 nl80211_check_u16);
ea54fba2 6017 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
a4f606ea 6018 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
f151d9db 6019 nl80211_check_u16);
ea54fba2 6020 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
a4f606ea 6021 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
f151d9db 6022 nl80211_check_u16);
ea54fba2 6023 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
a4f606ea 6024 mask, NL80211_MESHCONF_MAX_RETRIES,
f151d9db 6025 nl80211_check_u8);
ea54fba2 6026 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
f151d9db 6027 mask, NL80211_MESHCONF_TTL, nl80211_check_u8);
ea54fba2 6028 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
a4f606ea 6029 mask, NL80211_MESHCONF_ELEMENT_TTL,
f151d9db 6030 nl80211_check_u8);
ea54fba2 6031 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
a4f606ea 6032 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
f151d9db 6033 nl80211_check_bool);
ea54fba2
MP		 6034 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
6035 1, 255, mask,
a4f606ea 6036 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
f151d9db 6037 nl80211_check_u32);
ea54fba2 6038 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
a4f606ea 6039 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
f151d9db 6040 nl80211_check_u8);
ea54fba2 6041 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
a4f606ea 6042 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
f151d9db 6043 nl80211_check_u32);
ea54fba2 6044 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
a4f606ea 6045 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
f151d9db 6046 nl80211_check_u16);
ea54fba2
MP		 6047 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
6048 1, 65535, mask,
a4f606ea 6049 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
f151d9db 6050 nl80211_check_u32);
93da9cc1 6051 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
ea54fba2
MP		 6052 1, 65535, mask,
6053 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
f151d9db 6054 nl80211_check_u16);
dca7e943 6055 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
ea54fba2
MP		 6056 1, 65535, mask,
6057 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
f151d9db 6058 nl80211_check_u16);
93da9cc1 6059 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6060 dot11MeshHWMPnetDiameterTraversalTime,
6061 1, 65535, mask,
a4f606ea 6062 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
f151d9db 6063 nl80211_check_u16);
ea54fba2
MP		 6064 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
6065 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
f151d9db 6066 nl80211_check_u8);
ea54fba2
MP		 6067 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
6068 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
f151d9db 6069 nl80211_check_u16);
63c5723b 6070 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6071 dot11MeshGateAnnouncementProtocol, 0, 1,
6072 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
f151d9db 6073 nl80211_check_bool);
ea54fba2 6074 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
a4f606ea 6075 mask, NL80211_MESHCONF_FORWARDING,
f151d9db 6076 nl80211_check_bool);
83374fe9 6077 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
a4f606ea 6078 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
f151d9db 6079 nl80211_check_s32);
9757235f
MH		 6080 /*
6081 * Check HT operation mode based on
6cc9111f 6082 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
9757235f
MH		 6083 */
6084 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
6085 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
6086
6087 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
6088 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
6089 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6090 return -EINVAL;
6091
6cc9111f
BC		 6092 /* NON_HT_STA bit is reserved, but some programs set it */
6093 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
9757235f 6094
9757235f 6095 cfg->ht_opmode = ht_opmode;
fd551bac 6096 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
9757235f 6097 }
ac1073a6 6098 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
ea54fba2 6099 1, 65535, mask,
ac1073a6 6100 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
f151d9db 6101 nl80211_check_u32);
ea54fba2 6102 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
ac1073a6 6103 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
f151d9db 6104 nl80211_check_u16);
728b19e5 6105 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6106 dot11MeshHWMPconfirmationInterval,
6107 1, 65535, mask,
728b19e5 6108 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
f151d9db 6109 nl80211_check_u16);
3b1c5a53
MP		 6110 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
6111 NL80211_MESH_POWER_ACTIVE,
6112 NL80211_MESH_POWER_MAX,
6113 mask, NL80211_MESHCONF_POWER_MODE,
ff9a71af 6114 nl80211_check_power_mode);
3b1c5a53
MP		 6115 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
6116 0, 65535, mask,
f151d9db 6117 NL80211_MESHCONF_AWAKE_WINDOW, nl80211_check_u16);
31f909a2 6118 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 0, 0xffffffff,
8e7c0538 6119 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
f151d9db 6120 nl80211_check_u32);
bd90fdcc
JB		 6121 if (mask_out)
6122 *mask_out = mask;
c80d545d 6123
bd90fdcc
JB		 6124 return 0;
6125
6126#undef FILL_IN_MESH_PARAM_IF_SET
6127}
6128
c80d545d
JC		 6129static int nl80211_parse_mesh_setup(struct genl_info *info,
6130 struct mesh_setup *setup)
6131{
bb2798d4 6132 struct cfg80211_registered_device *rdev = info->user_ptr[0];
c80d545d
JC		 6133 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6134
6135 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6136 return -EINVAL;
6137 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
6138 info->attrs[NL80211_ATTR_MESH_SETUP],
fe52145f 6139 nl80211_mesh_setup_params_policy, info->extack))
c80d545d
JC		 6140 return -EINVAL;
6141
d299a1f2
JC		 6142 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6143 setup->sync_method =
6144 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6145 IEEE80211_SYNC_METHOD_VENDOR :
6146 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6147
c80d545d
JC		 6148 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6149 setup->path_sel_proto =
6150 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6151 IEEE80211_PATH_PROTOCOL_VENDOR :
6152 IEEE80211_PATH_PROTOCOL_HWMP;
6153
6154 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6155 setup->path_metric =
6156 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6157 IEEE80211_PATH_METRIC_VENDOR :
6158 IEEE80211_PATH_METRIC_AIRTIME;
6159
581a8b0f 6160 if (tb[NL80211_MESH_SETUP_IE]) {
c80d545d 6161 struct nlattr *ieattr =
581a8b0f 6162 tb[NL80211_MESH_SETUP_IE];
c80d545d
JC		 6163 if (!is_valid_ie_attr(ieattr))
6164 return -EINVAL;
581a8b0f
JC		 6165 setup->ie = nla_data(ieattr);
6166 setup->ie_len = nla_len(ieattr);
c80d545d 6167 }
bb2798d4
TP		 6168 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6169 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6170 return -EINVAL;
6171 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
b130e5ce
JC		 6172 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6173 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
bb2798d4
TP		 6174 if (setup->is_secure)
6175 setup->user_mpm = true;
c80d545d 6176
6e16d90b
CT		 6177 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6178 if (!setup->user_mpm)
6179 return -EINVAL;
6180 setup->auth_id =
6181 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6182 }
6183
c80d545d
JC		 6184 return 0;
6185}
6186
24bdd9f4 6187static int nl80211_update_mesh_config(struct sk_buff *skb,
29cbe68c 6188 struct genl_info *info)
bd90fdcc
JB		 6189{
6190 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6191 struct net_device *dev = info->user_ptr[1];
29cbe68c 6192 struct wireless_dev *wdev = dev->ieee80211_ptr;
bd90fdcc
JB		 6193 struct mesh_config cfg;
6194 u32 mask;
6195 int err;
6196
29cbe68c
JB		 6197 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6198 return -EOPNOTSUPP;
6199
24bdd9f4 6200 if (!rdev->ops->update_mesh_config)
bd90fdcc
JB		 6201 return -EOPNOTSUPP;
6202
24bdd9f4 6203 err = nl80211_parse_mesh_config(info, &cfg, &mask);
bd90fdcc
JB		 6204 if (err)
6205 return err;
6206
29cbe68c
JB		 6207 wdev_lock(wdev);
6208 if (!wdev->mesh_id_len)
6209 err = -ENOLINK;
6210
6211 if (!err)
e35e4d28 6212 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
29cbe68c
JB		 6213
6214 wdev_unlock(wdev);
6215
6216 return err;
93da9cc1 6217}
6218
ad30ca2c
AN		 6219static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6220 struct sk_buff *msg)
f130347c 6221{
f130347c
LR		 6222 struct nlattr *nl_reg_rules;
6223 unsigned int i;
f130347c 6224
458f4f9e
JB		 6225 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6226 (regdom->dfs_region &&
6227 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
ad30ca2c 6228 goto nla_put_failure;
458f4f9e 6229
f130347c
LR		 6230 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
6231 if (!nl_reg_rules)
ad30ca2c 6232 goto nla_put_failure;
f130347c 6233
458f4f9e 6234 for (i = 0; i < regdom->n_reg_rules; i++) {
f130347c
LR		 6235 struct nlattr *nl_reg_rule;
6236 const struct ieee80211_reg_rule *reg_rule;
6237 const struct ieee80211_freq_range *freq_range;
6238 const struct ieee80211_power_rule *power_rule;
97524820 6239 unsigned int max_bandwidth_khz;
f130347c 6240
458f4f9e 6241 reg_rule = &regdom->reg_rules[i];
f130347c
LR		 6242 freq_range = &reg_rule->freq_range;
6243 power_rule = &reg_rule->power_rule;
6244
6245 nl_reg_rule = nla_nest_start(msg, i);
6246 if (!nl_reg_rule)
ad30ca2c 6247 goto nla_put_failure;
f130347c 6248
97524820
JD		 6249 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6250 if (!max_bandwidth_khz)
6251 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6252 reg_rule);
6253
9360ffd1
DM		 6254 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6255 reg_rule->flags) ||
6256 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6257 freq_range->start_freq_khz) ||
6258 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6259 freq_range->end_freq_khz) ||
6260 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
97524820 6261 max_bandwidth_khz) ||
9360ffd1
DM		 6262 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6263 power_rule->max_antenna_gain) ||
6264 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
089027e5
JD		 6265 power_rule->max_eirp) ||
6266 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6267 reg_rule->dfs_cac_ms))
ad30ca2c 6268 goto nla_put_failure;
f130347c
LR		 6269
6270 nla_nest_end(msg, nl_reg_rule);
6271 }
6272
6273 nla_nest_end(msg, nl_reg_rules);
ad30ca2c
AN		 6274 return 0;
6275
6276nla_put_failure:
6277 return -EMSGSIZE;
6278}
6279
6280static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6281{
6282 const struct ieee80211_regdomain *regdom = NULL;
6283 struct cfg80211_registered_device *rdev;
6284 struct wiphy *wiphy = NULL;
6285 struct sk_buff *msg;
6286 void *hdr;
6287
6288 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6289 if (!msg)
6290 return -ENOBUFS;
6291
6292 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6293 NL80211_CMD_GET_REG);
6294 if (!hdr)
6295 goto put_failure;
6296
6297 if (info->attrs[NL80211_ATTR_WIPHY]) {
1bdd716c
AN		 6298 bool self_managed;
6299
ad30ca2c
AN		 6300 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6301 if (IS_ERR(rdev)) {
6302 nlmsg_free(msg);
6303 return PTR_ERR(rdev);
6304 }
6305
6306 wiphy = &rdev->wiphy;
1bdd716c
AN		 6307 self_managed = wiphy->regulatory_flags &
6308 REGULATORY_WIPHY_SELF_MANAGED;
ad30ca2c
AN		 6309 regdom = get_wiphy_regdom(wiphy);
6310
1bdd716c
AN		 6311 /* a self-managed-reg device must have a private regdom */
6312 if (WARN_ON(!regdom && self_managed)) {
6313 nlmsg_free(msg);
6314 return -EINVAL;
6315 }
6316
ad30ca2c
AN		 6317 if (regdom &&
6318 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6319 goto nla_put_failure;
6320 }
6321
6322 if (!wiphy && reg_last_request_cell_base() &&
6323 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6324 NL80211_USER_REG_HINT_CELL_BASE))
6325 goto nla_put_failure;
6326
6327 rcu_read_lock();
6328
6329 if (!regdom)
6330 regdom = rcu_dereference(cfg80211_regdomain);
6331
6332 if (nl80211_put_regdom(regdom, msg))
6333 goto nla_put_failure_rcu;
6334
6335 rcu_read_unlock();
f130347c
LR		 6336
6337 genlmsg_end(msg, hdr);
5fe231e8 6338 return genlmsg_reply(msg, info);
f130347c 6339
458f4f9e
JB		 6340nla_put_failure_rcu:
6341 rcu_read_unlock();
f130347c
LR		 6342nla_put_failure:
6343 genlmsg_cancel(msg, hdr);
efe1cf0c 6344put_failure:
d080e275 6345 nlmsg_free(msg);
5fe231e8 6346 return -EMSGSIZE;
f130347c
LR		 6347}
6348
ad30ca2c
AN		 6349static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6350 u32 seq, int flags, struct wiphy *wiphy,
6351 const struct ieee80211_regdomain *regdom)
6352{
6353 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6354 NL80211_CMD_GET_REG);
6355
6356 if (!hdr)
6357 return -1;
6358
0a833c29 6359 genl_dump_check_consistent(cb, hdr);
ad30ca2c
AN		 6360
6361 if (nl80211_put_regdom(regdom, msg))
6362 goto nla_put_failure;
6363
6364 if (!wiphy && reg_last_request_cell_base() &&
6365 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6366 NL80211_USER_REG_HINT_CELL_BASE))
6367 goto nla_put_failure;
6368
6369 if (wiphy &&
6370 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6371 goto nla_put_failure;
6372
1bdd716c
AN		 6373 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
6374 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
6375 goto nla_put_failure;
6376
053c095a
JB		 6377 genlmsg_end(msg, hdr);
6378 return 0;
ad30ca2c
AN		 6379
6380nla_put_failure:
6381 genlmsg_cancel(msg, hdr);
6382 return -EMSGSIZE;
6383}
6384
6385static int nl80211_get_reg_dump(struct sk_buff *skb,
6386 struct netlink_callback *cb)
6387{
6388 const struct ieee80211_regdomain *regdom = NULL;
6389 struct cfg80211_registered_device *rdev;
6390 int err, reg_idx, start = cb->args[2];
6391
6392 rtnl_lock();
6393
6394 if (cfg80211_regdomain && start == 0) {
6395 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6396 NLM_F_MULTI, NULL,
6397 rtnl_dereference(cfg80211_regdomain));
6398 if (err < 0)
6399 goto out_err;
6400 }
6401
6402 /* the global regdom is idx 0 */
6403 reg_idx = 1;
6404 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
6405 regdom = get_wiphy_regdom(&rdev->wiphy);
6406 if (!regdom)
6407 continue;
6408
6409 if (++reg_idx <= start)
6410 continue;
6411
6412 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6413 NLM_F_MULTI, &rdev->wiphy, regdom);
6414 if (err < 0) {
6415 reg_idx--;
6416 break;
6417 }
6418 }
6419
6420 cb->args[2] = reg_idx;
6421 err = skb->len;
6422out_err:
6423 rtnl_unlock();
6424 return err;
6425}
6426
b6863036
JB		 6427#ifdef CONFIG_CFG80211_CRDA_SUPPORT
6428static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
6429 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6430 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6431 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6432 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6433 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6434 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6435 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
6436};
6437
6438static int parse_reg_rule(struct nlattr *tb[],
6439 struct ieee80211_reg_rule *reg_rule)
6440{
6441 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
6442 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
6443
6444 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
6445 return -EINVAL;
6446 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
6447 return -EINVAL;
6448 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
6449 return -EINVAL;
6450 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
6451 return -EINVAL;
6452 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
6453 return -EINVAL;
6454
6455 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
6456
6457 freq_range->start_freq_khz =
6458 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
6459 freq_range->end_freq_khz =
6460 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
6461 freq_range->max_bandwidth_khz =
6462 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
6463
6464 power_rule->max_eirp =
6465 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
6466
6467 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
6468 power_rule->max_antenna_gain =
6469 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
6470
6471 if (tb[NL80211_ATTR_DFS_CAC_TIME])
6472 reg_rule->dfs_cac_ms =
6473 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
6474
6475 return 0;
6476}
6477
b2e1b302
LR		 6478static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
6479{
6480 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
6481 struct nlattr *nl_reg_rule;
ea372c54
JB		 6482 char *alpha2;
6483 int rem_reg_rules, r;
b2e1b302 6484 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4c7d3982 6485 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
ea372c54 6486 struct ieee80211_regdomain *rd;
b2e1b302
LR		 6487
6488 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6489 return -EINVAL;
6490
6491 if (!info->attrs[NL80211_ATTR_REG_RULES])
6492 return -EINVAL;
6493
6494 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6495
8b60b078
LR		 6496 if (info->attrs[NL80211_ATTR_DFS_REGION])
6497 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
6498
b2e1b302 6499 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6500 rem_reg_rules) {
b2e1b302
LR		 6501 num_rules++;
6502 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 6503 return -EINVAL;
b2e1b302
LR		 6504 }
6505
e438768f
LR		 6506 if (!reg_is_valid_request(alpha2))
6507 return -EINVAL;
6508
b2e1b302 6509 size_of_regd = sizeof(struct ieee80211_regdomain) +
1a919318 6510 num_rules * sizeof(struct ieee80211_reg_rule);
b2e1b302
LR		 6511
6512 rd = kzalloc(size_of_regd, GFP_KERNEL);
6913b49a
JB		 6513 if (!rd)
6514 return -ENOMEM;
b2e1b302
LR		 6515
6516 rd->n_reg_rules = num_rules;
6517 rd->alpha2[0] = alpha2[0];
6518 rd->alpha2[1] = alpha2[1];
6519
8b60b078
LR		 6520 /*
6521 * Disable DFS master mode if the DFS region was
6522 * not supported or known on this kernel.
6523 */
6524 if (reg_supported_dfs_region(dfs_region))
6525 rd->dfs_region = dfs_region;
6526
b2e1b302 6527 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6528 rem_reg_rules) {
bfe2c7b1 6529 r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
fe52145f
JB		 6530 nl_reg_rule, reg_rule_policy,
6531 info->extack);
ae811e21
JB		 6532 if (r)
6533 goto bad_reg;
b2e1b302
LR		 6534 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
6535 if (r)
6536 goto bad_reg;
6537
6538 rule_idx++;
6539
d0e18f83
LR		 6540 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
6541 r = -EINVAL;
b2e1b302 6542 goto bad_reg;
d0e18f83 6543 }
b2e1b302
LR		 6544 }
6545
06627990
JB		 6546 /* set_regdom takes ownership of rd */
6547 return set_regdom(rd, REGD_SOURCE_CRDA);
d2372b31 6548 bad_reg:
b2e1b302 6549 kfree(rd);
d0e18f83 6550 return r;
b2e1b302 6551}
b6863036 6552#endif /* CONFIG_CFG80211_CRDA_SUPPORT */
b2e1b302 6553
83f5e2cf
JB		 6554static int validate_scan_freqs(struct nlattr *freqs)
6555{
6556 struct nlattr *attr1, *attr2;
6557 int n_channels = 0, tmp1, tmp2;
6558
d7f13f74
SD		 6559 nla_for_each_nested(attr1, freqs, tmp1)
6560 if (nla_len(attr1) != sizeof(u32))
6561 return 0;
6562
83f5e2cf
JB		 6563 nla_for_each_nested(attr1, freqs, tmp1) {
6564 n_channels++;
6565 /*
6566 * Some hardware has a limited channel list for
6567 * scanning, and it is pretty much nonsensical
6568 * to scan for a channel twice, so disallow that
6569 * and don't require drivers to check that the
6570 * channel list they get isn't longer than what
6571 * they can scan, as long as they can scan all
6572 * the channels they registered at once.
6573 */
6574 nla_for_each_nested(attr2, freqs, tmp2)
6575 if (attr1 != attr2 &&
6576 nla_get_u32(attr1) == nla_get_u32(attr2))
6577 return 0;
6578 }
6579
6580 return n_channels;
6581}
6582
57fbcce3 6583static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
38de03d2 6584{
57fbcce3 6585 return b < NUM_NL80211_BANDS && wiphy->bands[b];
38de03d2
AS		 6586}
6587
6588static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
6589 struct cfg80211_bss_selection *bss_select)
6590{
6591 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
6592 struct nlattr *nest;
6593 int err;
6594 bool found = false;
6595 int i;
6596
6597 /* only process one nested attribute */
6598 nest = nla_data(nla);
6599 if (!nla_ok(nest, nla_len(nest)))
6600 return -EINVAL;
6601
bfe2c7b1 6602 err = nla_parse_nested(attr, NL80211_BSS_SELECT_ATTR_MAX, nest,
fceb6435 6603 nl80211_bss_select_policy, NULL);
38de03d2
AS		 6604 if (err)
6605 return err;
6606
6607 /* only one attribute may be given */
6608 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
6609 if (attr[i]) {
6610 if (found)
6611 return -EINVAL;
6612 found = true;
6613 }
6614 }
6615
6616 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
6617
6618 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
6619 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
6620
6621 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
6622 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
6623 bss_select->param.band_pref =
6624 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
6625 if (!is_band_valid(wiphy, bss_select->param.band_pref))
6626 return -EINVAL;
6627 }
6628
6629 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
6630 struct nl80211_bss_select_rssi_adjust *adj_param;
6631
6632 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
6633 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
6634 bss_select->param.adjust.band = adj_param->band;
6635 bss_select->param.adjust.delta = adj_param->delta;
6636 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
6637 return -EINVAL;
6638 }
6639
6640 /* user-space did not provide behaviour attribute */
6641 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
6642 return -EINVAL;
6643
6644 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
6645 return -EINVAL;
6646
6647 return 0;
6648}
6649
ad2b26ab
JB		 6650static int nl80211_parse_random_mac(struct nlattr **attrs,
6651 u8 *mac_addr, u8 *mac_addr_mask)
6652{
6653 int i;
6654
6655 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
d2beae10
JP		 6656 eth_zero_addr(mac_addr);
6657 eth_zero_addr(mac_addr_mask);
ad2b26ab
JB		 6658 mac_addr[0] = 0x2;
6659 mac_addr_mask[0] = 0x3;
6660
6661 return 0;
6662 }
6663
6664 /* need both or none */
6665 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
6666 return -EINVAL;
6667
6668 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
6669 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
6670
6671 /* don't allow or configure an mcast address */
6672 if (!is_multicast_ether_addr(mac_addr_mask) ||
6673 is_multicast_ether_addr(mac_addr))
6674 return -EINVAL;
6675
6676 /*
6677 * allow users to pass a MAC address that has bits set outside
6678 * of the mask, but don't bother drivers with having to deal
6679 * with such bits
6680 */
6681 for (i = 0; i < ETH_ALEN; i++)
6682 mac_addr[i] &= mac_addr_mask[i];
6683
6684 return 0;
6685}
6686
34373d12
VT		 6687static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
6688{
6689 ASSERT_WDEV_LOCK(wdev);
6690
6691 if (!cfg80211_beaconing_iface_active(wdev))
6692 return true;
6693
6694 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
6695 return true;
6696
6697 return regulatory_pre_cac_allowed(wdev->wiphy);
6698}
6699
2d23d073
RZ		 6700static int
6701nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
6702 void *request, struct nlattr **attrs,
6703 bool is_sched_scan)
6704{
6705 u8 *mac_addr, *mac_addr_mask;
6706 u32 *flags;
6707 enum nl80211_feature_flags randomness_flag;
6708
6709 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
6710 return 0;
6711
6712 if (is_sched_scan) {
6713 struct cfg80211_sched_scan_request *req = request;
6714
6715 randomness_flag = wdev ?
6716 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
6717 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
6718 flags = &req->flags;
6719 mac_addr = req->mac_addr;
6720 mac_addr_mask = req->mac_addr_mask;
6721 } else {
6722 struct cfg80211_scan_request *req = request;
6723
6724 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
6725 flags = &req->flags;
6726 mac_addr = req->mac_addr;
6727 mac_addr_mask = req->mac_addr_mask;
6728 }
6729
6730 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
6731
6732 if ((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
6733 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN))
6734 return -EOPNOTSUPP;
6735
6736 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6737 int err;
6738
6739 if (!(wiphy->features & randomness_flag) ||
6740 (wdev && wdev->current_bss))
6741 return -EOPNOTSUPP;
6742
6743 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
6744 if (err)
6745 return err;
6746 }
6747
6748 if ((*flags & NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME) &&
6749 !wiphy_ext_feature_isset(wiphy,
6750 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME))
6751 return -EOPNOTSUPP;
6752
6753 if ((*flags & NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP) &&
6754 !wiphy_ext_feature_isset(wiphy,
6755 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP))
6756 return -EOPNOTSUPP;
6757
6758 if ((*flags & NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) &&
6759 !wiphy_ext_feature_isset(wiphy,
6760 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION))
6761 return -EOPNOTSUPP;
6762
6763 if ((*flags & NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE) &&
6764 !wiphy_ext_feature_isset(wiphy,
6765 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE))
6766 return -EOPNOTSUPP;
6767
6768 return 0;
6769}
6770
2a519311
JB		 6771static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
6772{
4c476991 6773 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd014284 6774 struct wireless_dev *wdev = info->user_ptr[1];
2a519311 6775 struct cfg80211_scan_request *request;
2a519311
JB		 6776 struct nlattr *attr;
6777 struct wiphy *wiphy;
83f5e2cf 6778 int err, tmp, n_ssids = 0, n_channels, i;
70692ad2 6779 size_t ie_len;
2a519311 6780
f4a11bb0
JB		 6781 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6782 return -EINVAL;
6783
79c97e97 6784 wiphy = &rdev->wiphy;
2a519311 6785
cb3b7d87
AB		 6786 if (wdev->iftype == NL80211_IFTYPE_NAN)
6787 return -EOPNOTSUPP;
6788
4c476991
JB		 6789 if (!rdev->ops->scan)
6790 return -EOPNOTSUPP;
2a519311 6791
f9d15d16 6792 if (rdev->scan_req || rdev->scan_msg) {
f9f47529
JB		 6793 err = -EBUSY;
6794 goto unlock;
6795 }
2a519311
JB		 6796
6797 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 6798 n_channels = validate_scan_freqs(
6799 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
f9f47529
JB		 6800 if (!n_channels) {
6801 err = -EINVAL;
6802 goto unlock;
6803 }
2a519311 6804 } else {
bdfbec2d 6805 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311
JB		 6806 }
6807
6808 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
6809 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
6810 n_ssids++;
6811
f9f47529
JB		 6812 if (n_ssids > wiphy->max_scan_ssids) {
6813 err = -EINVAL;
6814 goto unlock;
6815 }
2a519311 6816
70692ad2
JM		 6817 if (info->attrs[NL80211_ATTR_IE])
6818 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6819 else
6820 ie_len = 0;
6821
f9f47529
JB		 6822 if (ie_len > wiphy->max_scan_ie_len) {
6823 err = -EINVAL;
6824 goto unlock;
6825 }
18a83659 6826
2a519311 6827 request = kzalloc(sizeof(*request)
a2cd43c5
LC		 6828 + sizeof(*request->ssids) * n_ssids
6829 + sizeof(*request->channels) * n_channels
70692ad2 6830 + ie_len, GFP_KERNEL);
f9f47529
JB		 6831 if (!request) {
6832 err = -ENOMEM;
6833 goto unlock;
6834 }
2a519311 6835
2a519311 6836 if (n_ssids)
5ba63533 6837 request->ssids = (void *)&request->channels[n_channels];
2a519311 6838 request->n_ssids = n_ssids;
70692ad2 6839 if (ie_len) {
13874e4b 6840 if (n_ssids)
70692ad2
JM		 6841 request->ie = (void *)(request->ssids + n_ssids);
6842 else
6843 request->ie = (void *)(request->channels + n_channels);
6844 }
2a519311 6845
584991dc 6846 i = 0;
2a519311
JB		 6847 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
6848 /* user specified, bail out if channel not found */
2a519311 6849 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
584991dc
JB		 6850 struct ieee80211_channel *chan;
6851
6852 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
6853
6854 if (!chan) {
2a519311
JB		 6855 err = -EINVAL;
6856 goto out_free;
6857 }
584991dc
JB		 6858
6859 /* ignore disabled channels */
6860 if (chan->flags & IEEE80211_CHAN_DISABLED)
6861 continue;
6862
6863 request->channels[i] = chan;
2a519311
JB		 6864 i++;
6865 }
6866 } else {
57fbcce3 6867 enum nl80211_band band;
34850ab2 6868
2a519311 6869 /* all channels */
57fbcce3 6870 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2a519311 6871 int j;
7a087e74 6872
2a519311
JB		 6873 if (!wiphy->bands[band])
6874 continue;
6875 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dc
JB		 6876 struct ieee80211_channel *chan;
6877
6878 chan = &wiphy->bands[band]->channels[j];
6879
6880 if (chan->flags & IEEE80211_CHAN_DISABLED)
6881 continue;
6882
6883 request->channels[i] = chan;
2a519311
JB		 6884 i++;
6885 }
6886 }
6887 }
6888
584991dc
JB		 6889 if (!i) {
6890 err = -EINVAL;
6891 goto out_free;
6892 }
6893
6894 request->n_channels = i;
6895
34373d12
VT		 6896 wdev_lock(wdev);
6897 if (!cfg80211_off_channel_oper_allowed(wdev)) {
6898 struct ieee80211_channel *chan;
6899
6900 if (request->n_channels != 1) {
6901 wdev_unlock(wdev);
6902 err = -EBUSY;
6903 goto out_free;
6904 }
6905
6906 chan = request->channels[0];
6907 if (chan->center_freq != wdev->chandef.chan->center_freq) {
6908 wdev_unlock(wdev);
6909 err = -EBUSY;
6910 goto out_free;
6911 }
6912 }
6913 wdev_unlock(wdev);
6914
2a519311 6915 i = 0;
13874e4b 6916 if (n_ssids) {
2a519311 6917 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d 6918 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311
JB		 6919 err = -EINVAL;
6920 goto out_free;
6921 }
57a27e1d 6922 request->ssids[i].ssid_len = nla_len(attr);
2a519311 6923 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2a519311
JB		 6924 i++;
6925 }
6926 }
6927
70692ad2
JM		 6928 if (info->attrs[NL80211_ATTR_IE]) {
6929 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 6930 memcpy((void *)request->ie,
6931 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 6932 request->ie_len);
6933 }
6934
57fbcce3 6935 for (i = 0; i < NUM_NL80211_BANDS; i++)
a401d2bb
JB		 6936 if (wiphy->bands[i])
6937 request->rates[i] =
6938 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab2
JB		 6939
6940 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
6941 nla_for_each_nested(attr,
6942 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
6943 tmp) {
57fbcce3 6944 enum nl80211_band band = nla_type(attr);
34850ab2 6945
57fbcce3 6946 if (band < 0 || band >= NUM_NL80211_BANDS) {
34850ab2
JB		 6947 err = -EINVAL;
6948 goto out_free;
6949 }
1b09cd82
FF		 6950
6951 if (!wiphy->bands[band])
6952 continue;
6953
34850ab2
JB		 6954 err = ieee80211_get_ratemask(wiphy->bands[band],
6955 nla_data(attr),
6956 nla_len(attr),
6957 &request->rates[band]);
6958 if (err)
6959 goto out_free;
6960 }
6961 }
6962
1d76250b
AS		 6963 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
6964 if (!wiphy_ext_feature_isset(wiphy,
6965 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
6966 err = -EOPNOTSUPP;
6967 goto out_free;
6968 }
6969
6970 request->duration =
6971 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
6972 request->duration_mandatory =
6973 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
6974 }
6975
2d23d073
RZ		 6976 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
6977 false);
6978 if (err)
6979 goto out_free;
ed473771 6980
e9f935e3
RM		 6981 request->no_cck =
6982 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
6983
2fa436b3
VK		 6984 /* Initial implementation used NL80211_ATTR_MAC to set the specific
6985 * BSSID to scan for. This was problematic because that same attribute
6986 * was already used for another purpose (local random MAC address). The
6987 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
6988 * compatibility with older userspace components, also use the
6989 * NL80211_ATTR_MAC value here if it can be determined to be used for
6990 * the specific BSSID use case instead of the random MAC address
6991 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
6992 */
6993 if (info->attrs[NL80211_ATTR_BSSID])
6994 memcpy(request->bssid,
6995 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
6996 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
6997 info->attrs[NL80211_ATTR_MAC])
818965d3
JM		 6998 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
6999 ETH_ALEN);
7000 else
7001 eth_broadcast_addr(request->bssid);
7002
fd014284 7003 request->wdev = wdev;
79c97e97 7004 request->wiphy = &rdev->wiphy;
15d6030b 7005 request->scan_start = jiffies;
2a519311 7006
79c97e97 7007 rdev->scan_req = request;
e35e4d28 7008 err = rdev_scan(rdev, request);
2a519311 7009
463d0183 7010 if (!err) {
fd014284
JB		 7011 nl80211_send_scan_start(rdev, wdev);
7012 if (wdev->netdev)
7013 dev_hold(wdev->netdev);
4c476991 7014 } else {
2a519311 7015 out_free:
79c97e97 7016 rdev->scan_req = NULL;
2a519311
JB		 7017 kfree(request);
7018 }
3b85875a 7019
f9f47529 7020 unlock:
2a519311
JB		 7021 return err;
7022}
7023
91d3ab46
VK		 7024static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
7025{
7026 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7027 struct wireless_dev *wdev = info->user_ptr[1];
7028
7029 if (!rdev->ops->abort_scan)
7030 return -EOPNOTSUPP;
7031
7032 if (rdev->scan_msg)
7033 return 0;
7034
7035 if (!rdev->scan_req)
7036 return -ENOENT;
7037
7038 rdev_abort_scan(rdev, wdev);
7039 return 0;
7040}
7041
3b06d277
AS		 7042static int
7043nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
7044 struct cfg80211_sched_scan_request *request,
7045 struct nlattr **attrs)
7046{
7047 int tmp, err, i = 0;
7048 struct nlattr *attr;
7049
7050 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7051 u32 interval;
7052
7053 /*
7054 * If scan plans are not specified,
5a88de53 7055 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
3b06d277
AS		 7056 * case one scan plan will be set with the specified scan
7057 * interval and infinite number of iterations.
7058 */
3b06d277
AS		 7059 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
7060 if (!interval)
7061 return -EINVAL;
7062
7063 request->scan_plans[0].interval =
7064 DIV_ROUND_UP(interval, MSEC_PER_SEC);
7065 if (!request->scan_plans[0].interval)
7066 return -EINVAL;
7067
7068 if (request->scan_plans[0].interval >
7069 wiphy->max_sched_scan_plan_interval)
7070 request->scan_plans[0].interval =
7071 wiphy->max_sched_scan_plan_interval;
7072
7073 return 0;
7074 }
7075
7076 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
7077 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
7078
7079 if (WARN_ON(i >= n_plans))
7080 return -EINVAL;
7081
bfe2c7b1 7082 err = nla_parse_nested(plan, NL80211_SCHED_SCAN_PLAN_MAX,
fceb6435 7083 attr, nl80211_plan_policy, NULL);
3b06d277
AS		 7084 if (err)
7085 return err;
7086
7087 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
7088 return -EINVAL;
7089
7090 request->scan_plans[i].interval =
7091 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
7092 if (!request->scan_plans[i].interval ||
7093 request->scan_plans[i].interval >
7094 wiphy->max_sched_scan_plan_interval)
7095 return -EINVAL;
7096
7097 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
7098 request->scan_plans[i].iterations =
7099 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
7100 if (!request->scan_plans[i].iterations ||
7101 (request->scan_plans[i].iterations >
7102 wiphy->max_sched_scan_plan_iterations))
7103 return -EINVAL;
7104 } else if (i < n_plans - 1) {
7105 /*
7106 * All scan plans but the last one must specify
7107 * a finite number of iterations
7108 */
7109 return -EINVAL;
7110 }
7111
7112 i++;
7113 }
7114
7115 /*
7116 * The last scan plan must not specify the number of
7117 * iterations, it is supposed to run infinitely
7118 */
7119 if (request->scan_plans[n_plans - 1].iterations)
7120 return -EINVAL;
7121
7122 return 0;
7123}
7124
256da02d 7125static struct cfg80211_sched_scan_request *
ad2b26ab 7126nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
aad1e812 7127 struct nlattr **attrs, int max_match_sets)
807f8a8c
LC		 7128{
7129 struct cfg80211_sched_scan_request *request;
807f8a8c 7130 struct nlattr *attr;
3b06d277 7131 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
57fbcce3 7132 enum nl80211_band band;
807f8a8c 7133 size_t ie_len;
a1f1c21c 7134 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
ea73cbce 7135 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
807f8a8c 7136
256da02d
LC		 7137 if (!is_valid_ie_attr(attrs[NL80211_ATTR_IE]))
7138 return ERR_PTR(-EINVAL);
807f8a8c 7139
256da02d 7140 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c 7141 n_channels = validate_scan_freqs(
256da02d 7142 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
807f8a8c 7143 if (!n_channels)
256da02d 7144 return ERR_PTR(-EINVAL);
807f8a8c 7145 } else {
bdfbec2d 7146 n_channels = ieee80211_get_num_supported_channels(wiphy);
807f8a8c
LC		 7147 }
7148
256da02d
LC		 7149 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7150 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c
LC		 7151 tmp)
7152 n_ssids++;
7153
93b6aa69 7154 if (n_ssids > wiphy->max_sched_scan_ssids)
256da02d 7155 return ERR_PTR(-EINVAL);
807f8a8c 7156
ea73cbce
JB		 7157 /*
7158 * First, count the number of 'real' matchsets. Due to an issue with
7159 * the old implementation, matchsets containing only the RSSI attribute
7160 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7161 * RSSI for all matchsets, rather than their own matchset for reporting
7162 * all APs with a strong RSSI. This is needed to be compatible with
7163 * older userspace that treated a matchset with only the RSSI as the
7164 * global RSSI for all other matchsets - if there are other matchsets.
7165 */
256da02d 7166 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7167 nla_for_each_nested(attr,
256da02d 7168 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
ea73cbce
JB		 7169 tmp) {
7170 struct nlattr *rssi;
7171
bfe2c7b1
JB		 7172 err = nla_parse_nested(tb,
7173 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7174 attr, nl80211_match_policy,
7175 NULL);
ea73cbce 7176 if (err)
256da02d 7177 return ERR_PTR(err);
3007e352
AVS		 7178
7179 /* SSID and BSSID are mutually exclusive */
7180 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
7181 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
7182 return ERR_PTR(-EINVAL);
7183
ea73cbce 7184 /* add other standalone attributes here */
3007e352
AVS		 7185 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
7186 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
ea73cbce
JB		 7187 n_match_sets++;
7188 continue;
7189 }
7190 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7191 if (rssi)
7192 default_match_rssi = nla_get_s32(rssi);
7193 }
7194 }
7195
7196 /* However, if there's no other matchset, add the RSSI one */
7197 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7198 n_match_sets = 1;
a1f1c21c 7199
aad1e812 7200 if (n_match_sets > max_match_sets)
256da02d 7201 return ERR_PTR(-EINVAL);
a1f1c21c 7202
256da02d
LC		 7203 if (attrs[NL80211_ATTR_IE])
7204 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
807f8a8c
LC		 7205 else
7206 ie_len = 0;
7207
5a865bad 7208 if (ie_len > wiphy->max_sched_scan_ie_len)
256da02d 7209 return ERR_PTR(-EINVAL);
c10841ca 7210
3b06d277
AS		 7211 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7212 /*
7213 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7214 * each scan plan already specifies its own interval
7215 */
7216 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7217 return ERR_PTR(-EINVAL);
7218
7219 nla_for_each_nested(attr,
7220 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7221 n_plans++;
7222 } else {
7223 /*
7224 * The scan interval attribute is kept for backward
7225 * compatibility. If no scan plans are specified and sched scan
7226 * interval is specified, one scan plan will be set with this
7227 * scan interval and infinite number of iterations.
7228 */
7229 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7230 return ERR_PTR(-EINVAL);
7231
7232 n_plans = 1;
7233 }
7234
7235 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7236 return ERR_PTR(-EINVAL);
7237
bf95ecdb 7238 if (!wiphy_ext_feature_isset(
7239 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7240 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7241 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7242 return ERR_PTR(-EINVAL);
7243
807f8a8c 7244 request = kzalloc(sizeof(*request)
a2cd43c5 7245 + sizeof(*request->ssids) * n_ssids
a1f1c21c 7246 + sizeof(*request->match_sets) * n_match_sets
3b06d277 7247 + sizeof(*request->scan_plans) * n_plans
a2cd43c5 7248 + sizeof(*request->channels) * n_channels
807f8a8c 7249 + ie_len, GFP_KERNEL);
256da02d
LC		 7250 if (!request)
7251 return ERR_PTR(-ENOMEM);
807f8a8c
LC		 7252
7253 if (n_ssids)
7254 request->ssids = (void *)&request->channels[n_channels];
7255 request->n_ssids = n_ssids;
7256 if (ie_len) {
13874e4b 7257 if (n_ssids)
807f8a8c
LC		 7258 request->ie = (void *)(request->ssids + n_ssids);
7259 else
7260 request->ie = (void *)(request->channels + n_channels);
7261 }
7262
a1f1c21c
LC		 7263 if (n_match_sets) {
7264 if (request->ie)
7265 request->match_sets = (void *)(request->ie + ie_len);
13874e4b 7266 else if (n_ssids)
a1f1c21c
LC		 7267 request->match_sets =
7268 (void *)(request->ssids + n_ssids);
7269 else
7270 request->match_sets =
7271 (void *)(request->channels + n_channels);
7272 }
7273 request->n_match_sets = n_match_sets;
7274
3b06d277
AS		 7275 if (n_match_sets)
7276 request->scan_plans = (void *)(request->match_sets +
7277 n_match_sets);
7278 else if (request->ie)
7279 request->scan_plans = (void *)(request->ie + ie_len);
7280 else if (n_ssids)
7281 request->scan_plans = (void *)(request->ssids + n_ssids);
7282 else
7283 request->scan_plans = (void *)(request->channels + n_channels);
7284
7285 request->n_scan_plans = n_plans;
7286
807f8a8c 7287 i = 0;
256da02d 7288 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c
LC		 7289 /* user specified, bail out if channel not found */
7290 nla_for_each_nested(attr,
256da02d 7291 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
807f8a8c
LC		 7292 tmp) {
7293 struct ieee80211_channel *chan;
7294
7295 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7296
7297 if (!chan) {
7298 err = -EINVAL;
7299 goto out_free;
7300 }
7301
7302 /* ignore disabled channels */
7303 if (chan->flags & IEEE80211_CHAN_DISABLED)
7304 continue;
7305
7306 request->channels[i] = chan;
7307 i++;
7308 }
7309 } else {
7310 /* all channels */
57fbcce3 7311 for (band = 0; band < NUM_NL80211_BANDS; band++) {
807f8a8c 7312 int j;
7a087e74 7313
807f8a8c
LC		 7314 if (!wiphy->bands[band])
7315 continue;
7316 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7317 struct ieee80211_channel *chan;
7318
7319 chan = &wiphy->bands[band]->channels[j];
7320
7321 if (chan->flags & IEEE80211_CHAN_DISABLED)
7322 continue;
7323
7324 request->channels[i] = chan;
7325 i++;
7326 }
7327 }
7328 }
7329
7330 if (!i) {
7331 err = -EINVAL;
7332 goto out_free;
7333 }
7334
7335 request->n_channels = i;
7336
7337 i = 0;
13874e4b 7338 if (n_ssids) {
256da02d 7339 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c 7340 tmp) {
57a27e1d 7341 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
807f8a8c
LC		 7342 err = -EINVAL;
7343 goto out_free;
7344 }
57a27e1d 7345 request->ssids[i].ssid_len = nla_len(attr);
807f8a8c
LC		 7346 memcpy(request->ssids[i].ssid, nla_data(attr),
7347 nla_len(attr));
807f8a8c
LC		 7348 i++;
7349 }
7350 }
7351
a1f1c21c 7352 i = 0;
256da02d 7353 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7354 nla_for_each_nested(attr,
256da02d 7355 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
a1f1c21c 7356 tmp) {
3007e352 7357 struct nlattr *ssid, *bssid, *rssi;
a1f1c21c 7358
bfe2c7b1
JB		 7359 err = nla_parse_nested(tb,
7360 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7361 attr, nl80211_match_policy,
7362 NULL);
ae811e21
JB		 7363 if (err)
7364 goto out_free;
4a4ab0d7 7365 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
3007e352
AVS		 7366 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
7367 if (ssid || bssid) {
ea73cbce
JB		 7368 if (WARN_ON(i >= n_match_sets)) {
7369 /* this indicates a programming error,
7370 * the loop above should have verified
7371 * things properly
7372 */
7373 err = -EINVAL;
7374 goto out_free;
7375 }
7376
3007e352
AVS		 7377 if (ssid) {
7378 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
7379 err = -EINVAL;
7380 goto out_free;
7381 }
7382 memcpy(request->match_sets[i].ssid.ssid,
7383 nla_data(ssid), nla_len(ssid));
7384 request->match_sets[i].ssid.ssid_len =
7385 nla_len(ssid);
7386 }
7387 if (bssid) {
7388 if (nla_len(bssid) != ETH_ALEN) {
7389 err = -EINVAL;
7390 goto out_free;
7391 }
7392 memcpy(request->match_sets[i].bssid,
7393 nla_data(bssid), ETH_ALEN);
a1f1c21c 7394 }
3007e352 7395
56ab364f 7396 /* special attribute - old implementation w/a */
ea73cbce
JB		 7397 request->match_sets[i].rssi_thold =
7398 default_match_rssi;
7399 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7400 if (rssi)
7401 request->match_sets[i].rssi_thold =
7402 nla_get_s32(rssi);
a1f1c21c
LC		 7403 }
7404 i++;
7405 }
ea73cbce
JB		 7406
7407 /* there was no other matchset, so the RSSI one is alone */
f89f46cf 7408 if (i == 0 && n_match_sets)
ea73cbce
JB		 7409 request->match_sets[0].rssi_thold = default_match_rssi;
7410
7411 request->min_rssi_thold = INT_MAX;
7412 for (i = 0; i < n_match_sets; i++)
7413 request->min_rssi_thold =
7414 min(request->match_sets[i].rssi_thold,
7415 request->min_rssi_thold);
7416 } else {
7417 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
a1f1c21c
LC		 7418 }
7419
9900e484
JB		 7420 if (ie_len) {
7421 request->ie_len = ie_len;
807f8a8c 7422 memcpy((void *)request->ie,
256da02d 7423 nla_data(attrs[NL80211_ATTR_IE]),
807f8a8c
LC		 7424 request->ie_len);
7425 }
7426
2d23d073
RZ		 7427 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
7428 if (err)
7429 goto out_free;
ed473771 7430
9c748934
LC		 7431 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
7432 request->delay =
7433 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
7434
bf95ecdb 7435 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
7436 request->relative_rssi = nla_get_s8(
7437 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
7438 request->relative_rssi_set = true;
7439 }
7440
7441 if (request->relative_rssi_set &&
7442 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
7443 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
7444
7445 rssi_adjust = nla_data(
7446 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
7447 request->rssi_adjust.band = rssi_adjust->band;
7448 request->rssi_adjust.delta = rssi_adjust->delta;
7449 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
7450 err = -EINVAL;
7451 goto out_free;
7452 }
7453 }
7454
3b06d277
AS		 7455 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
7456 if (err)
7457 goto out_free;
7458
15d6030b 7459 request->scan_start = jiffies;
807f8a8c 7460
256da02d 7461 return request;
807f8a8c
LC		 7462
7463out_free:
7464 kfree(request);
256da02d
LC		 7465 return ERR_PTR(err);
7466}
7467
7468static int nl80211_start_sched_scan(struct sk_buff *skb,
7469 struct genl_info *info)
7470{
7471 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7472 struct net_device *dev = info->user_ptr[1];
ad2b26ab 7473 struct wireless_dev *wdev = dev->ieee80211_ptr;
31a60ed1 7474 struct cfg80211_sched_scan_request *sched_scan_req;
ca986ad9 7475 bool want_multi;
256da02d
LC		 7476 int err;
7477
ca986ad9 7478 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
256da02d
LC		 7479 return -EOPNOTSUPP;
7480
ca986ad9
AVS		 7481 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
7482 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
7483 if (err)
7484 return err;
256da02d 7485
31a60ed1 7486 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
aad1e812
AVS		 7487 info->attrs,
7488 rdev->wiphy.max_match_sets);
31a60ed1
JR		 7489
7490 err = PTR_ERR_OR_ZERO(sched_scan_req);
256da02d
LC		 7491 if (err)
7492 goto out_err;
7493
ca986ad9
AVS		 7494 /* leave request id zero for legacy request
7495 * or if driver does not support multi-scheduled scan
7496 */
7497 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) {
7498 while (!sched_scan_req->reqid)
7499 sched_scan_req->reqid = rdev->wiphy.cookie_counter++;
7500 }
7501
31a60ed1 7502 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
256da02d
LC		 7503 if (err)
7504 goto out_free;
7505
31a60ed1
JR		 7506 sched_scan_req->dev = dev;
7507 sched_scan_req->wiphy = &rdev->wiphy;
7508
93a1e86c
JR		 7509 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
7510 sched_scan_req->owner_nlportid = info->snd_portid;
7511
ca986ad9 7512 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
256da02d 7513
96b08fd6 7514 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
256da02d
LC		 7515 return 0;
7516
7517out_free:
31a60ed1 7518 kfree(sched_scan_req);
256da02d 7519out_err:
807f8a8c
LC		 7520 return err;
7521}
7522
7523static int nl80211_stop_sched_scan(struct sk_buff *skb,
7524 struct genl_info *info)
7525{
ca986ad9 7526 struct cfg80211_sched_scan_request *req;
807f8a8c 7527 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ca986ad9 7528 u64 cookie;
807f8a8c 7529
ca986ad9 7530 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
807f8a8c
LC		 7531 return -EOPNOTSUPP;
7532
ca986ad9
AVS		 7533 if (info->attrs[NL80211_ATTR_COOKIE]) {
7534 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7535 return __cfg80211_stop_sched_scan(rdev, cookie, false);
7536 }
7537
7538 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
7539 struct cfg80211_sched_scan_request,
7540 list);
7541 if (!req || req->reqid ||
7542 (req->owner_nlportid &&
7543 req->owner_nlportid != info->snd_portid))
7544 return -ENOENT;
7545
7546 return cfg80211_stop_sched_scan_req(rdev, req, false);
807f8a8c
LC		 7547}
7548
04f39047
SW		 7549static int nl80211_start_radar_detection(struct sk_buff *skb,
7550 struct genl_info *info)
7551{
7552 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7553 struct net_device *dev = info->user_ptr[1];
7554 struct wireless_dev *wdev = dev->ieee80211_ptr;
7555 struct cfg80211_chan_def chandef;
55f7435c 7556 enum nl80211_dfs_regions dfs_region;
31559f35 7557 unsigned int cac_time_ms;
04f39047
SW		 7558 int err;
7559
55f7435c
LR		 7560 dfs_region = reg_get_dfs_region(wdev->wiphy);
7561 if (dfs_region == NL80211_DFS_UNSET)
7562 return -EINVAL;
7563
04f39047
SW		 7564 err = nl80211_parse_chandef(rdev, info, &chandef);
7565 if (err)
7566 return err;
7567
ff311bc1
SW		 7568 if (netif_carrier_ok(dev))
7569 return -EBUSY;
7570
04f39047
SW		 7571 if (wdev->cac_started)
7572 return -EBUSY;
7573
2beb6dab 7574 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
00ec75fc 7575 wdev->iftype);
04f39047
SW		 7576 if (err < 0)
7577 return err;
7578
7579 if (err == 0)
7580 return -EINVAL;
7581
fe7c3a1f 7582 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
04f39047
SW		 7583 return -EINVAL;
7584
7585 if (!rdev->ops->start_radar_detection)
7586 return -EOPNOTSUPP;
7587
31559f35
JD		 7588 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
7589 if (WARN_ON(!cac_time_ms))
7590 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
7591
a1056b1b 7592 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
04f39047 7593 if (!err) {
9e0e2961 7594 wdev->chandef = chandef;
04f39047
SW		 7595 wdev->cac_started = true;
7596 wdev->cac_start_time = jiffies;
31559f35 7597 wdev->cac_time_ms = cac_time_ms;
04f39047 7598 }
04f39047
SW		 7599 return err;
7600}
7601
16ef1fe2
SW		 7602static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
7603{
7604 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7605 struct net_device *dev = info->user_ptr[1];
7606 struct wireless_dev *wdev = dev->ieee80211_ptr;
7607 struct cfg80211_csa_settings params;
7608 /* csa_attrs is defined static to avoid waste of stack size - this
7609 * function is called under RTNL lock, so this should not be a problem.
7610 */
7611 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
16ef1fe2 7612 int err;
ee4bc9e7 7613 bool need_new_beacon = false;
8d9de16f 7614 bool need_handle_dfs_flag = true;
9a774c78 7615 int len, i;
252e07ca 7616 u32 cs_count;
16ef1fe2
SW		 7617
7618 if (!rdev->ops->channel_switch ||
7619 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
7620 return -EOPNOTSUPP;
7621
ee4bc9e7
SW		 7622 switch (dev->ieee80211_ptr->iftype) {
7623 case NL80211_IFTYPE_AP:
7624 case NL80211_IFTYPE_P2P_GO:
7625 need_new_beacon = true;
8d9de16f
BB		 7626 /* For all modes except AP the handle_dfs flag needs to be
7627 * supplied to tell the kernel that userspace will handle radar
7628 * events when they happen. Otherwise a switch to a channel
7629 * requiring DFS will be rejected.
7630 */
7631 need_handle_dfs_flag = false;
ee4bc9e7
SW		 7632
7633 /* useless if AP is not running */
7634 if (!wdev->beacon_interval)
1ff79dfa 7635 return -ENOTCONN;
ee4bc9e7
SW		 7636 break;
7637 case NL80211_IFTYPE_ADHOC:
1ff79dfa
JB		 7638 if (!wdev->ssid_len)
7639 return -ENOTCONN;
7640 break;
c6da674a 7641 case NL80211_IFTYPE_MESH_POINT:
1ff79dfa
JB		 7642 if (!wdev->mesh_id_len)
7643 return -ENOTCONN;
ee4bc9e7
SW		 7644 break;
7645 default:
16ef1fe2 7646 return -EOPNOTSUPP;
ee4bc9e7 7647 }
16ef1fe2
SW		 7648
7649 memset(&params, 0, sizeof(params));
7650
7651 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7652 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
7653 return -EINVAL;
7654
7655 /* only important for AP, IBSS and mesh create IEs internally */
d0a361a5 7656 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
16ef1fe2
SW		 7657 return -EINVAL;
7658
252e07ca
LC		 7659 /* Even though the attribute is u32, the specification says
7660 * u8, so let's make sure we don't overflow.
7661 */
7662 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
7663 if (cs_count > 255)
7664 return -EINVAL;
7665
7666 params.count = cs_count;
16ef1fe2 7667
ee4bc9e7
SW		 7668 if (!need_new_beacon)
7669 goto skip_beacons;
7670
16ef1fe2
SW		 7671 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
7672 if (err)
7673 return err;
7674
7675 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
7676 info->attrs[NL80211_ATTR_CSA_IES],
fe52145f 7677 nl80211_policy, info->extack);
16ef1fe2
SW		 7678 if (err)
7679 return err;
7680
7681 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
7682 if (err)
7683 return err;
7684
7685 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
7686 return -EINVAL;
7687
9a774c78
AO		 7688 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7689 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7690 return -EINVAL;
7691
9a774c78
AO		 7692 params.n_counter_offsets_beacon = len / sizeof(u16);
7693 if (rdev->wiphy.max_num_csa_counters &&
7694 (params.n_counter_offsets_beacon >
7695 rdev->wiphy.max_num_csa_counters))
16ef1fe2
SW		 7696 return -EINVAL;
7697
9a774c78
AO		 7698 params.counter_offsets_beacon =
7699 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7700
7701 /* sanity checks - counters should fit and be the same */
7702 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
7703 u16 offset = params.counter_offsets_beacon[i];
7704
7705 if (offset >= params.beacon_csa.tail_len)
7706 return -EINVAL;
7707
7708 if (params.beacon_csa.tail[offset] != params.count)
7709 return -EINVAL;
7710 }
7711
16ef1fe2 7712 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
9a774c78
AO		 7713 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7714 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7715 return -EINVAL;
7716
9a774c78
AO		 7717 params.n_counter_offsets_presp = len / sizeof(u16);
7718 if (rdev->wiphy.max_num_csa_counters &&
ad5987b4 7719 (params.n_counter_offsets_presp >
9a774c78 7720 rdev->wiphy.max_num_csa_counters))
16ef1fe2 7721 return -EINVAL;
9a774c78
AO		 7722
7723 params.counter_offsets_presp =
7724 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7725
7726 /* sanity checks - counters should fit and be the same */
7727 for (i = 0; i < params.n_counter_offsets_presp; i++) {
7728 u16 offset = params.counter_offsets_presp[i];
7729
7730 if (offset >= params.beacon_csa.probe_resp_len)
7731 return -EINVAL;
7732
7733 if (params.beacon_csa.probe_resp[offset] !=
7734 params.count)
7735 return -EINVAL;
7736 }
16ef1fe2
SW		 7737 }
7738
ee4bc9e7 7739skip_beacons:
16ef1fe2
SW		 7740 err = nl80211_parse_chandef(rdev, info, &params.chandef);
7741 if (err)
7742 return err;
7743
923b352f
AN		 7744 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
7745 wdev->iftype))
16ef1fe2
SW		 7746 return -EINVAL;
7747
2beb6dab
LC		 7748 err = cfg80211_chandef_dfs_required(wdev->wiphy,
7749 &params.chandef,
7750 wdev->iftype);
7751 if (err < 0)
7752 return err;
7753
8d9de16f 7754 if (err > 0) {
2beb6dab 7755 params.radar_required = true;
8d9de16f
BB		 7756 if (need_handle_dfs_flag &&
7757 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
7758 return -EINVAL;
7759 }
7760 }
16ef1fe2 7761
16ef1fe2
SW		 7762 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
7763 params.block_tx = true;
7764
c56589ed
SW		 7765 wdev_lock(wdev);
7766 err = rdev_channel_switch(rdev, dev, &params);
7767 wdev_unlock(wdev);
7768
7769 return err;
16ef1fe2
SW		 7770}
7771
9720bb3a
JB		 7772static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
7773 u32 seq, int flags,
2a519311 7774 struct cfg80211_registered_device *rdev,
48ab905d
JB		 7775 struct wireless_dev *wdev,
7776 struct cfg80211_internal_bss *intbss)
2a519311 7777{
48ab905d 7778 struct cfg80211_bss *res = &intbss->pub;
9caf0364 7779 const struct cfg80211_bss_ies *ies;
2a519311
JB		 7780 void *hdr;
7781 struct nlattr *bss;
48ab905d
JB		 7782
7783 ASSERT_WDEV_LOCK(wdev);
2a519311 7784
15e47304 7785 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
2a519311
JB		 7786 NL80211_CMD_NEW_SCAN_RESULTS);
7787 if (!hdr)
7788 return -1;
7789
0a833c29 7790 genl_dump_check_consistent(cb, hdr);
9720bb3a 7791
97990a06
JB		 7792 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
7793 goto nla_put_failure;
7794 if (wdev->netdev &&
9360ffd1
DM		 7795 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
7796 goto nla_put_failure;
2dad624e
ND		 7797 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
7798 NL80211_ATTR_PAD))
97990a06 7799 goto nla_put_failure;
2a519311
JB		 7800
7801 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
7802 if (!bss)
7803 goto nla_put_failure;
9360ffd1 7804 if ((!is_zero_ether_addr(res->bssid) &&
9caf0364 7805 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9360ffd1 7806 goto nla_put_failure;
9caf0364
JB		 7807
7808 rcu_read_lock();
0e227084
JB		 7809 /* indicate whether we have probe response data or not */
7810 if (rcu_access_pointer(res->proberesp_ies) &&
7811 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
7812 goto fail_unlock_rcu;
7813
7814 /* this pointer prefers to be pointed to probe response data
7815 * but is always valid
7816 */
9caf0364 7817 ies = rcu_dereference(res->ies);
8cef2c9d 7818 if (ies) {
2dad624e
ND		 7819 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
7820 NL80211_BSS_PAD))
8cef2c9d 7821 goto fail_unlock_rcu;
8cef2c9d
JB		 7822 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
7823 ies->len, ies->data))
7824 goto fail_unlock_rcu;
9caf0364 7825 }
0e227084
JB		 7826
7827 /* and this pointer is always (unless driver didn't know) beacon data */
9caf0364 7828 ies = rcu_dereference(res->beacon_ies);
0e227084 7829 if (ies && ies->from_beacon) {
2dad624e
ND		 7830 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
7831 NL80211_BSS_PAD))
8cef2c9d
JB		 7832 goto fail_unlock_rcu;
7833 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
7834 ies->len, ies->data))
7835 goto fail_unlock_rcu;
9caf0364
JB		 7836 }
7837 rcu_read_unlock();
7838
9360ffd1
DM		 7839 if (res->beacon_interval &&
7840 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
7841 goto nla_put_failure;
7842 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
7843 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
dcd6eac1 7844 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9360ffd1
DM		 7845 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
7846 jiffies_to_msecs(jiffies - intbss->ts)))
7847 goto nla_put_failure;
2a519311 7848
1d76250b
AS		 7849 if (intbss->parent_tsf &&
7850 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
7851 intbss->parent_tsf, NL80211_BSS_PAD) ||
7852 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
7853 intbss->parent_bssid)))
7854 goto nla_put_failure;
7855
6e19bc4b 7856 if (intbss->ts_boottime &&
2dad624e
ND		 7857 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
7858 intbss->ts_boottime, NL80211_BSS_PAD))
6e19bc4b
DS		 7859 goto nla_put_failure;
7860
77965c97 7861 switch (rdev->wiphy.signal_type) {
2a519311 7862 case CFG80211_SIGNAL_TYPE_MBM:
9360ffd1
DM		 7863 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
7864 goto nla_put_failure;
2a519311
JB		 7865 break;
7866 case CFG80211_SIGNAL_TYPE_UNSPEC:
9360ffd1
DM		 7867 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
7868 goto nla_put_failure;
2a519311
JB		 7869 break;
7870 default:
7871 break;
7872 }
7873
48ab905d 7874 switch (wdev->iftype) {
074ac8df 7875 case NL80211_IFTYPE_P2P_CLIENT:
48ab905d 7876 case NL80211_IFTYPE_STATION:
9360ffd1
DM		 7877 if (intbss == wdev->current_bss &&
7878 nla_put_u32(msg, NL80211_BSS_STATUS,
7879 NL80211_BSS_STATUS_ASSOCIATED))
7880 goto nla_put_failure;
48ab905d
JB		 7881 break;
7882 case NL80211_IFTYPE_ADHOC:
9360ffd1
DM		 7883 if (intbss == wdev->current_bss &&
7884 nla_put_u32(msg, NL80211_BSS_STATUS,
7885 NL80211_BSS_STATUS_IBSS_JOINED))
7886 goto nla_put_failure;
48ab905d
JB		 7887 break;
7888 default:
7889 break;
7890 }
7891
2a519311
JB		 7892 nla_nest_end(msg, bss);
7893
053c095a
JB		 7894 genlmsg_end(msg, hdr);
7895 return 0;
2a519311 7896
8cef2c9d
JB		 7897 fail_unlock_rcu:
7898 rcu_read_unlock();
2a519311
JB		 7899 nla_put_failure:
7900 genlmsg_cancel(msg, hdr);
7901 return -EMSGSIZE;
7902}
7903
97990a06 7904static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
2a519311 7905{
48ab905d 7906 struct cfg80211_registered_device *rdev;
2a519311 7907 struct cfg80211_internal_bss *scan;
48ab905d 7908 struct wireless_dev *wdev;
97990a06 7909 int start = cb->args[2], idx = 0;
2a519311
JB		 7910 int err;
7911
ea90e0dc 7912 rtnl_lock();
97990a06 7913 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
ea90e0dc
JB		 7914 if (err) {
7915 rtnl_unlock();
67748893 7916 return err;
ea90e0dc 7917 }
2a519311 7918
48ab905d
JB		 7919 wdev_lock(wdev);
7920 spin_lock_bh(&rdev->bss_lock);
7921 cfg80211_bss_expire(rdev);
7922
9720bb3a
JB		 7923 cb->seq = rdev->bss_generation;
7924
48ab905d 7925 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 7926 if (++idx <= start)
7927 continue;
9720bb3a 7928 if (nl80211_send_bss(skb, cb,
2a519311 7929 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 7930 rdev, wdev, scan) < 0) {
2a519311 7931 idx--;
67748893 7932 break;
2a519311
JB		 7933 }
7934 }
7935
48ab905d
JB		 7936 spin_unlock_bh(&rdev->bss_lock);
7937 wdev_unlock(wdev);
2a519311 7938
97990a06 7939 cb->args[2] = idx;
ea90e0dc 7940 rtnl_unlock();
2a519311 7941
67748893 7942 return skb->len;
2a519311
JB		 7943}
7944
15e47304 7945static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
11f78ac3
JB		 7946 int flags, struct net_device *dev,
7947 bool allow_radio_stats,
7948 struct survey_info *survey)
61fa713c
HS		 7949{
7950 void *hdr;
7951 struct nlattr *infoattr;
7952
11f78ac3
JB		 7953 /* skip radio stats if userspace didn't request them */
7954 if (!survey->channel && !allow_radio_stats)
7955 return 0;
7956
15e47304 7957 hdr = nl80211hdr_put(msg, portid, seq, flags,
61fa713c
HS		 7958 NL80211_CMD_NEW_SURVEY_RESULTS);
7959 if (!hdr)
7960 return -ENOMEM;
7961
9360ffd1
DM		 7962 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
7963 goto nla_put_failure;
61fa713c
HS		 7964
7965 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
7966 if (!infoattr)
7967 goto nla_put_failure;
7968
11f78ac3
JB		 7969 if (survey->channel &&
7970 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9360ffd1
DM		 7971 survey->channel->center_freq))
7972 goto nla_put_failure;
7973
7974 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
7975 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
7976 goto nla_put_failure;
7977 if ((survey->filled & SURVEY_INFO_IN_USE) &&
7978 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
7979 goto nla_put_failure;
4ed20beb 7980 if ((survey->filled & SURVEY_INFO_TIME) &&
2dad624e
ND		 7981 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
7982 survey->time, NL80211_SURVEY_INFO_PAD))
9360ffd1 7983 goto nla_put_failure;
4ed20beb 7984 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
2dad624e
ND		 7985 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
7986 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7987 goto nla_put_failure;
4ed20beb 7988 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
2dad624e
ND		 7989 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
7990 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7991 goto nla_put_failure;
4ed20beb 7992 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
2dad624e
ND		 7993 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
7994 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7995 goto nla_put_failure;
4ed20beb 7996 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
2dad624e
ND		 7997 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
7998 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7999 goto nla_put_failure;
052536ab 8000 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
2dad624e
ND		 8001 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
8002 survey->time_scan, NL80211_SURVEY_INFO_PAD))
052536ab 8003 goto nla_put_failure;
61fa713c
HS		 8004
8005 nla_nest_end(msg, infoattr);
8006
053c095a
JB		 8007 genlmsg_end(msg, hdr);
8008 return 0;
61fa713c
HS		 8009
8010 nla_put_failure:
8011 genlmsg_cancel(msg, hdr);
8012 return -EMSGSIZE;
8013}
8014
11f78ac3 8015static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
61fa713c 8016{
c90c39da 8017 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
61fa713c 8018 struct survey_info survey;
1b8ec87a 8019 struct cfg80211_registered_device *rdev;
97990a06
JB		 8020 struct wireless_dev *wdev;
8021 int survey_idx = cb->args[2];
61fa713c 8022 int res;
11f78ac3 8023 bool radio_stats;
61fa713c 8024
ea90e0dc 8025 rtnl_lock();
1b8ec87a 8026 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 8027 if (res)
ea90e0dc 8028 goto out_err;
61fa713c 8029
11f78ac3 8030 /* prepare_wdev_dump parsed the attributes */
c90c39da 8031 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
11f78ac3 8032
97990a06
JB		 8033 if (!wdev->netdev) {
8034 res = -EINVAL;
8035 goto out_err;
8036 }
8037
1b8ec87a 8038 if (!rdev->ops->dump_survey) {
61fa713c
HS		 8039 res = -EOPNOTSUPP;
8040 goto out_err;
8041 }
8042
8043 while (1) {
1b8ec87a 8044 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
61fa713c
HS		 8045 if (res == -ENOENT)
8046 break;
8047 if (res)
8048 goto out_err;
8049
11f78ac3
JB		 8050 /* don't send disabled channels, but do send non-channel data */
8051 if (survey.channel &&
8052 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
180cdc79
LR		 8053 survey_idx++;
8054 continue;
8055 }
8056
61fa713c 8057 if (nl80211_send_survey(skb,
15e47304 8058 NETLINK_CB(cb->skb).portid,
61fa713c 8059 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11f78ac3 8060 wdev->netdev, radio_stats, &survey) < 0)
61fa713c
HS		 8061 goto out;
8062 survey_idx++;
8063 }
8064
8065 out:
97990a06 8066 cb->args[2] = survey_idx;
61fa713c
HS		 8067 res = skb->len;
8068 out_err:
ea90e0dc 8069 rtnl_unlock();
61fa713c
HS		 8070 return res;
8071}
8072
b23aa676
SO		 8073static bool nl80211_valid_wpa_versions(u32 wpa_versions)
8074{
8075 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
8076 NL80211_WPA_VERSION_2));
8077}
8078
636a5d36
JM		 8079static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
8080{
4c476991
JB		 8081 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8082 struct net_device *dev = info->user_ptr[1];
19957bb3 8083 struct ieee80211_channel *chan;
11b6b5a4
JM		 8084 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
8085 int err, ssid_len, ie_len = 0, auth_data_len = 0;
19957bb3 8086 enum nl80211_auth_type auth_type;
fffd0934 8087 struct key_parse key;
d5cdfacb 8088 bool local_state_change;
636a5d36 8089
f4a11bb0
JB		 8090 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8091 return -EINVAL;
8092
8093 if (!info->attrs[NL80211_ATTR_MAC])
8094 return -EINVAL;
8095
1778092e
JM		 8096 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
8097 return -EINVAL;
8098
19957bb3
JB		 8099 if (!info->attrs[NL80211_ATTR_SSID])
8100 return -EINVAL;
8101
8102 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
8103 return -EINVAL;
8104
fffd0934
JB		 8105 err = nl80211_parse_key(info, &key);
8106 if (err)
8107 return err;
8108
8109 if (key.idx >= 0) {
e31b8213
JB		 8110 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
8111 return -EINVAL;
fffd0934
JB		 8112 if (!key.p.key || !key.p.key_len)
8113 return -EINVAL;
8114 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
8115 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
8116 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
8117 key.p.key_len != WLAN_KEY_LEN_WEP104))
8118 return -EINVAL;
b6b5555b 8119 if (key.idx > 3)
fffd0934
JB		 8120 return -EINVAL;
8121 } else {
8122 key.p.key_len = 0;
8123 key.p.key = NULL;
8124 }
8125
afea0b7a
JB		 8126 if (key.idx >= 0) {
8127 int i;
8128 bool ok = false;
7a087e74 8129
afea0b7a
JB		 8130 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
8131 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
8132 ok = true;
8133 break;
8134 }
8135 }
4c476991
JB		 8136 if (!ok)
8137 return -EINVAL;
afea0b7a
JB		 8138 }
8139
4c476991
JB		 8140 if (!rdev->ops->auth)
8141 return -EOPNOTSUPP;
636a5d36 8142
074ac8df 8143 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8144 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8145 return -EOPNOTSUPP;
eec60b03 8146
19957bb3 8147 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
664834de
JM		 8148 chan = nl80211_get_valid_chan(&rdev->wiphy,
8149 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8150 if (!chan)
4c476991 8151 return -EINVAL;
636a5d36 8152
19957bb3
JB		 8153 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8154 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8155
8156 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8157 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8158 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8159 }
8160
19957bb3 8161 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e 8162 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
4c476991 8163 return -EINVAL;
636a5d36 8164
63181060
JM		 8165 if ((auth_type == NL80211_AUTHTYPE_SAE ||
8166 auth_type == NL80211_AUTHTYPE_FILS_SK ||
8167 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
8168 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
11b6b5a4 8169 !info->attrs[NL80211_ATTR_AUTH_DATA])
e39e5b5e
JM		 8170 return -EINVAL;
8171
11b6b5a4 8172 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
63181060
JM		 8173 if (auth_type != NL80211_AUTHTYPE_SAE &&
8174 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8175 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8176 auth_type != NL80211_AUTHTYPE_FILS_PK)
e39e5b5e 8177 return -EINVAL;
11b6b5a4
JM		 8178 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8179 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
e39e5b5e 8180 /* need to include at least Auth Transaction and Status Code */
11b6b5a4 8181 if (auth_data_len < 4)
e39e5b5e
JM		 8182 return -EINVAL;
8183 }
8184
d5cdfacb
JM		 8185 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8186
95de817b
JB		 8187 /*
8188 * Since we no longer track auth state, ignore
8189 * requests to only change local state.
8190 */
8191 if (local_state_change)
8192 return 0;
8193
91bf9b26
JB		 8194 wdev_lock(dev->ieee80211_ptr);
8195 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8196 ssid, ssid_len, ie, ie_len,
8197 key.p.key, key.p.key_len, key.idx,
11b6b5a4 8198 auth_data, auth_data_len);
91bf9b26
JB		 8199 wdev_unlock(dev->ieee80211_ptr);
8200 return err;
636a5d36
JM		 8201}
8202
c0692b8f
JB		 8203static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8204 struct genl_info *info,
3dc27d25
JB		 8205 struct cfg80211_crypto_settings *settings,
8206 int cipher_limit)
b23aa676 8207{
c0b2bbd8
JB		 8208 memset(settings, 0, sizeof(*settings));
8209
b23aa676
SO		 8210 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
8211
c0692b8f
JB		 8212 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
8213 u16 proto;
7a087e74 8214
c0692b8f
JB		 8215 proto = nla_get_u16(
8216 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
8217 settings->control_port_ethertype = cpu_to_be16(proto);
8218 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
8219 proto != ETH_P_PAE)
8220 return -EINVAL;
8221 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
8222 settings->control_port_no_encrypt = true;
8223 } else
8224 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
8225
b23aa676
SO		 8226 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
8227 void *data;
8228 int len, i;
8229
8230 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8231 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8232 settings->n_ciphers_pairwise = len / sizeof(u32);
8233
8234 if (len % sizeof(u32))
8235 return -EINVAL;
8236
3dc27d25 8237 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 8238 return -EINVAL;
8239
8240 memcpy(settings->ciphers_pairwise, data, len);
8241
8242 for (i = 0; i < settings->n_ciphers_pairwise; i++)
38ba3c57
JM		 8243 if (!cfg80211_supported_cipher_suite(
8244 &rdev->wiphy,
b23aa676
SO		 8245 settings->ciphers_pairwise[i]))
8246 return -EINVAL;
8247 }
8248
8249 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
8250 settings->cipher_group =
8251 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
38ba3c57
JM		 8252 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
8253 settings->cipher_group))
b23aa676
SO		 8254 return -EINVAL;
8255 }
8256
8257 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
8258 settings->wpa_versions =
8259 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
8260 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
8261 return -EINVAL;
8262 }
8263
8264 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
8265 void *data;
6d30240e 8266 int len;
b23aa676
SO		 8267
8268 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
8269 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
8270 settings->n_akm_suites = len / sizeof(u32);
8271
8272 if (len % sizeof(u32))
8273 return -EINVAL;
8274
1b9ca027
JM		 8275 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
8276 return -EINVAL;
8277
b23aa676 8278 memcpy(settings->akm_suites, data, len);
b23aa676
SO		 8279 }
8280
91b5ab62
EP		 8281 if (info->attrs[NL80211_ATTR_PMK]) {
8282 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
8283 return -EINVAL;
8284 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8285 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
8286 return -EINVAL;
8287 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
8288 }
8289
b23aa676
SO		 8290 return 0;
8291}
8292
636a5d36
JM		 8293static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
8294{
4c476991
JB		 8295 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8296 struct net_device *dev = info->user_ptr[1];
f444de05 8297 struct ieee80211_channel *chan;
f62fab73
JB		 8298 struct cfg80211_assoc_request req = {};
8299 const u8 *bssid, *ssid;
8300 int err, ssid_len = 0;
636a5d36 8301
f4a11bb0
JB		 8302 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8303 return -EINVAL;
8304
8305 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 8306 !info->attrs[NL80211_ATTR_SSID] ||
8307 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 8308 return -EINVAL;
8309
4c476991
JB		 8310 if (!rdev->ops->assoc)
8311 return -EOPNOTSUPP;
636a5d36 8312
074ac8df 8313 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8314 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8315 return -EOPNOTSUPP;
eec60b03 8316
19957bb3 8317 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8318
664834de
JM		 8319 chan = nl80211_get_valid_chan(&rdev->wiphy,
8320 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8321 if (!chan)
4c476991 8322 return -EINVAL;
636a5d36 8323
19957bb3
JB		 8324 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8325 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8326
8327 if (info->attrs[NL80211_ATTR_IE]) {
f62fab73
JB		 8328 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8329 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8330 }
8331
dc6382ce 8332 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 8333 enum nl80211_mfp mfp =
dc6382ce 8334 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 8335 if (mfp == NL80211_MFP_REQUIRED)
f62fab73 8336 req.use_mfp = true;
4c476991
JB		 8337 else if (mfp != NL80211_MFP_NO)
8338 return -EINVAL;
dc6382ce
JM		 8339 }
8340
3e5d7649 8341 if (info->attrs[NL80211_ATTR_PREV_BSSID])
f62fab73 8342 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3e5d7649 8343
7e7c8926 8344 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
f62fab73 8345 req.flags |= ASSOC_REQ_DISABLE_HT;
7e7c8926
BG		 8346
8347 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
f62fab73
JB		 8348 memcpy(&req.ht_capa_mask,
8349 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8350 sizeof(req.ht_capa_mask));
7e7c8926
BG		 8351
8352 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
f62fab73 8353 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7e7c8926 8354 return -EINVAL;
f62fab73
JB		 8355 memcpy(&req.ht_capa,
8356 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8357 sizeof(req.ht_capa));
7e7c8926
BG		 8358 }
8359
ee2aca34 8360 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
f62fab73 8361 req.flags |= ASSOC_REQ_DISABLE_VHT;
ee2aca34
JB		 8362
8363 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
f62fab73
JB		 8364 memcpy(&req.vht_capa_mask,
8365 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8366 sizeof(req.vht_capa_mask));
ee2aca34
JB		 8367
8368 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
f62fab73 8369 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
ee2aca34 8370 return -EINVAL;
f62fab73
JB		 8371 memcpy(&req.vht_capa,
8372 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8373 sizeof(req.vht_capa));
ee2aca34
JB		 8374 }
8375
bab5ab7d 8376 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8377 if (!((rdev->wiphy.features &
8378 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8379 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8380 !wiphy_ext_feature_isset(&rdev->wiphy,
8381 NL80211_EXT_FEATURE_RRM))
bab5ab7d
AK		 8382 return -EINVAL;
8383 req.flags |= ASSOC_REQ_USE_RRM;
8384 }
8385
348bd456
JM		 8386 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
8387 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
8388 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
8389 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
8390 return -EINVAL;
8391 req.fils_nonces =
8392 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
8393 }
8394
f62fab73 8395 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
91bf9b26
JB		 8396 if (!err) {
8397 wdev_lock(dev->ieee80211_ptr);
bd2522b1 8398
f62fab73
JB		 8399 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
8400 ssid, ssid_len, &req);
bd2522b1
AZ		 8401
8402 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8403 dev->ieee80211_ptr->conn_owner_nlportid =
8404 info->snd_portid;
8405 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8406 bssid, ETH_ALEN);
8407 }
8408
91bf9b26
JB		 8409 wdev_unlock(dev->ieee80211_ptr);
8410 }
636a5d36 8411
636a5d36
JM		 8412 return err;
8413}
8414
8415static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
8416{
4c476991
JB		 8417 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8418 struct net_device *dev = info->user_ptr[1];
19957bb3 8419 const u8 *ie = NULL, *bssid;
91bf9b26 8420 int ie_len = 0, err;
19957bb3 8421 u16 reason_code;
d5cdfacb 8422 bool local_state_change;
636a5d36 8423
f4a11bb0
JB		 8424 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8425 return -EINVAL;
8426
8427 if (!info->attrs[NL80211_ATTR_MAC])
8428 return -EINVAL;
8429
8430 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8431 return -EINVAL;
8432
4c476991
JB		 8433 if (!rdev->ops->deauth)
8434 return -EOPNOTSUPP;
636a5d36 8435
074ac8df 8436 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8437 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8438 return -EOPNOTSUPP;
eec60b03 8439
19957bb3 8440 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8441
19957bb3
JB		 8442 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8443 if (reason_code == 0) {
f4a11bb0 8444 /* Reason Code 0 is reserved */
4c476991 8445 return -EINVAL;
255e737e 8446 }
636a5d36
JM		 8447
8448 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8449 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8450 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8451 }
8452
d5cdfacb
JM		 8453 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8454
91bf9b26
JB		 8455 wdev_lock(dev->ieee80211_ptr);
8456 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
8457 local_state_change);
8458 wdev_unlock(dev->ieee80211_ptr);
8459 return err;
636a5d36
JM		 8460}
8461
8462static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
8463{
4c476991
JB		 8464 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8465 struct net_device *dev = info->user_ptr[1];
19957bb3 8466 const u8 *ie = NULL, *bssid;
91bf9b26 8467 int ie_len = 0, err;
19957bb3 8468 u16 reason_code;
d5cdfacb 8469 bool local_state_change;
636a5d36 8470
f4a11bb0
JB		 8471 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8472 return -EINVAL;
8473
8474 if (!info->attrs[NL80211_ATTR_MAC])
8475 return -EINVAL;
8476
8477 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8478 return -EINVAL;
8479
4c476991
JB		 8480 if (!rdev->ops->disassoc)
8481 return -EOPNOTSUPP;
636a5d36 8482
074ac8df 8483 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8484 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8485 return -EOPNOTSUPP;
eec60b03 8486
19957bb3 8487 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8488
19957bb3
JB		 8489 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8490 if (reason_code == 0) {
f4a11bb0 8491 /* Reason Code 0 is reserved */
4c476991 8492 return -EINVAL;
255e737e 8493 }
636a5d36
JM		 8494
8495 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8496 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8497 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8498 }
8499
d5cdfacb
JM		 8500 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8501
91bf9b26
JB		 8502 wdev_lock(dev->ieee80211_ptr);
8503 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
8504 local_state_change);
8505 wdev_unlock(dev->ieee80211_ptr);
8506 return err;
636a5d36
JM		 8507}
8508
dd5b4cc7
FF		 8509static bool
8510nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
57fbcce3 8511 int mcast_rate[NUM_NL80211_BANDS],
dd5b4cc7
FF		 8512 int rateval)
8513{
8514 struct wiphy *wiphy = &rdev->wiphy;
8515 bool found = false;
8516 int band, i;
8517
57fbcce3 8518 for (band = 0; band < NUM_NL80211_BANDS; band++) {
dd5b4cc7
FF		 8519 struct ieee80211_supported_band *sband;
8520
8521 sband = wiphy->bands[band];
8522 if (!sband)
8523 continue;
8524
8525 for (i = 0; i < sband->n_bitrates; i++) {
8526 if (sband->bitrates[i].bitrate == rateval) {
8527 mcast_rate[band] = i + 1;
8528 found = true;
8529 break;
8530 }
8531 }
8532 }
8533
8534 return found;
8535}
8536
04a773ad
JB		 8537static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
8538{
4c476991
JB		 8539 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8540 struct net_device *dev = info->user_ptr[1];
04a773ad
JB		 8541 struct cfg80211_ibss_params ibss;
8542 struct wiphy *wiphy;
fffd0934 8543 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 8544 int err;
8545
8e30bc55
JB		 8546 memset(&ibss, 0, sizeof(ibss));
8547
04a773ad
JB		 8548 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8549 return -EINVAL;
8550
683b6d3b 8551 if (!info->attrs[NL80211_ATTR_SSID] ||
04a773ad
JB		 8552 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8553 return -EINVAL;
8554
8e30bc55
JB		 8555 ibss.beacon_interval = 100;
8556
12d20fc9 8557 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
8e30bc55
JB		 8558 ibss.beacon_interval =
8559 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 8560
0c317a02
PK		 8561 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
8562 ibss.beacon_interval);
12d20fc9
PK		 8563 if (err)
8564 return err;
8e30bc55 8565
4c476991
JB		 8566 if (!rdev->ops->join_ibss)
8567 return -EOPNOTSUPP;
04a773ad 8568
4c476991
JB		 8569 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8570 return -EOPNOTSUPP;
04a773ad 8571
79c97e97 8572 wiphy = &rdev->wiphy;
04a773ad 8573
39193498 8574 if (info->attrs[NL80211_ATTR_MAC]) {
04a773ad 8575 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
39193498
JB		 8576
8577 if (!is_valid_ether_addr(ibss.bssid))
8578 return -EINVAL;
8579 }
04a773ad
JB		 8580 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8581 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8582
8583 if (info->attrs[NL80211_ATTR_IE]) {
8584 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8585 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8586 }
8587
683b6d3b
JB		 8588 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
8589 if (err)
8590 return err;
04a773ad 8591
174e0cd2
IP		 8592 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
8593 NL80211_IFTYPE_ADHOC))
54858ee5
AS		 8594 return -EINVAL;
8595
2f301ab2 8596 switch (ibss.chandef.width) {
bf372645
SW		 8597 case NL80211_CHAN_WIDTH_5:
8598 case NL80211_CHAN_WIDTH_10:
2f301ab2
SW		 8599 case NL80211_CHAN_WIDTH_20_NOHT:
8600 break;
8601 case NL80211_CHAN_WIDTH_20:
8602 case NL80211_CHAN_WIDTH_40:
ffc11991
JD		 8603 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8604 return -EINVAL;
8605 break;
8606 case NL80211_CHAN_WIDTH_80:
8607 case NL80211_CHAN_WIDTH_80P80:
8608 case NL80211_CHAN_WIDTH_160:
8609 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8610 return -EINVAL;
8611 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8612 NL80211_EXT_FEATURE_VHT_IBSS))
8613 return -EINVAL;
8614 break;
2f301ab2 8615 default:
c04d6150 8616 return -EINVAL;
2f301ab2 8617 }
db9c64cf 8618
04a773ad 8619 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 8620 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
8621
fbd2c8dc
TP		 8622 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8623 u8 *rates =
8624 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8625 int n_rates =
8626 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8627 struct ieee80211_supported_band *sband =
683b6d3b 8628 wiphy->bands[ibss.chandef.chan->band];
fbd2c8dc 8629
34850ab2
JB		 8630 err = ieee80211_get_ratemask(sband, rates, n_rates,
8631 &ibss.basic_rates);
8632 if (err)
8633 return err;
fbd2c8dc 8634 }
dd5b4cc7 8635
803768f5
SW		 8636 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8637 memcpy(&ibss.ht_capa_mask,
8638 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8639 sizeof(ibss.ht_capa_mask));
8640
8641 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
8642 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8643 return -EINVAL;
8644 memcpy(&ibss.ht_capa,
8645 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8646 sizeof(ibss.ht_capa));
8647 }
8648
dd5b4cc7
FF		 8649 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8650 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
8651 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8652 return -EINVAL;
fbd2c8dc 8653
4c476991 8654 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
de7044ee
SM		 8655 bool no_ht = false;
8656
4c476991 8657 connkeys = nl80211_parse_connkeys(rdev,
de7044ee
SM		 8658 info->attrs[NL80211_ATTR_KEYS],
8659 &no_ht);
4c476991
JB		 8660 if (IS_ERR(connkeys))
8661 return PTR_ERR(connkeys);
de7044ee 8662
3d9d1d66
JB		 8663 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
8664 no_ht) {
5e950a78 8665 kzfree(connkeys);
de7044ee
SM		 8666 return -EINVAL;
8667 }
4c476991 8668 }
04a773ad 8669
267335d6
AQ		 8670 ibss.control_port =
8671 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
8672
5336fa88
SW		 8673 ibss.userspace_handles_dfs =
8674 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
8675
4c476991 8676 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
fffd0934 8677 if (err)
b47f610b 8678 kzfree(connkeys);
04a773ad
JB		 8679 return err;
8680}
8681
8682static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
8683{
4c476991
JB		 8684 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8685 struct net_device *dev = info->user_ptr[1];
04a773ad 8686
4c476991
JB		 8687 if (!rdev->ops->leave_ibss)
8688 return -EOPNOTSUPP;
04a773ad 8689
4c476991
JB		 8690 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8691 return -EOPNOTSUPP;
04a773ad 8692
4c476991 8693 return cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 8694}
8695
f4e583c8
AQ		 8696static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
8697{
8698 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8699 struct net_device *dev = info->user_ptr[1];
57fbcce3 8700 int mcast_rate[NUM_NL80211_BANDS];
f4e583c8
AQ		 8701 u32 nla_rate;
8702 int err;
8703
8704 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
876dc930
BVB		 8705 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
8706 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
f4e583c8
AQ		 8707 return -EOPNOTSUPP;
8708
8709 if (!rdev->ops->set_mcast_rate)
8710 return -EOPNOTSUPP;
8711
8712 memset(mcast_rate, 0, sizeof(mcast_rate));
8713
8714 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
8715 return -EINVAL;
8716
8717 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
8718 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
8719 return -EINVAL;
8720
a1056b1b 8721 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
f4e583c8
AQ		 8722
8723 return err;
8724}
8725
ad7e718c
JB		 8726static struct sk_buff *
8727__cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
6c09e791
AK		 8728 struct wireless_dev *wdev, int approxlen,
8729 u32 portid, u32 seq, enum nl80211_commands cmd,
567ffc35
JB		 8730 enum nl80211_attrs attr,
8731 const struct nl80211_vendor_cmd_info *info,
8732 gfp_t gfp)
ad7e718c
JB		 8733{
8734 struct sk_buff *skb;
8735 void *hdr;
8736 struct nlattr *data;
8737
8738 skb = nlmsg_new(approxlen + 100, gfp);
8739 if (!skb)
8740 return NULL;
8741
8742 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
8743 if (!hdr) {
8744 kfree_skb(skb);
8745 return NULL;
8746 }
8747
8748 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
8749 goto nla_put_failure;
567ffc35
JB		 8750
8751 if (info) {
8752 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
8753 info->vendor_id))
8754 goto nla_put_failure;
8755 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
8756 info->subcmd))
8757 goto nla_put_failure;
8758 }
8759
6c09e791 8760 if (wdev) {
2dad624e
ND		 8761 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
8762 wdev_id(wdev), NL80211_ATTR_PAD))
6c09e791
AK		 8763 goto nla_put_failure;
8764 if (wdev->netdev &&
8765 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
8766 wdev->netdev->ifindex))
8767 goto nla_put_failure;
8768 }
8769
ad7e718c 8770 data = nla_nest_start(skb, attr);
76e1fb4b
JB		 8771 if (!data)
8772 goto nla_put_failure;
ad7e718c
JB		 8773
8774 ((void **)skb->cb)[0] = rdev;
8775 ((void **)skb->cb)[1] = hdr;
8776 ((void **)skb->cb)[2] = data;
8777
8778 return skb;
8779
8780 nla_put_failure:
8781 kfree_skb(skb);
8782 return NULL;
8783}
f4e583c8 8784
e03ad6ea 8785struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
6c09e791 8786 struct wireless_dev *wdev,
e03ad6ea
JB		 8787 enum nl80211_commands cmd,
8788 enum nl80211_attrs attr,
8789 int vendor_event_idx,
8790 int approxlen, gfp_t gfp)
8791{
f26cbf40 8792 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
e03ad6ea
JB		 8793 const struct nl80211_vendor_cmd_info *info;
8794
8795 switch (cmd) {
8796 case NL80211_CMD_TESTMODE:
8797 if (WARN_ON(vendor_event_idx != -1))
8798 return NULL;
8799 info = NULL;
8800 break;
8801 case NL80211_CMD_VENDOR:
8802 if (WARN_ON(vendor_event_idx < 0 ||
8803 vendor_event_idx >= wiphy->n_vendor_events))
8804 return NULL;
8805 info = &wiphy->vendor_events[vendor_event_idx];
8806 break;
8807 default:
8808 WARN_ON(1);
8809 return NULL;
8810 }
8811
6c09e791 8812 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, 0, 0,
e03ad6ea
JB		 8813 cmd, attr, info, gfp);
8814}
8815EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
8816
8817void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
8818{
8819 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
8820 void *hdr = ((void **)skb->cb)[1];
8821 struct nlattr *data = ((void **)skb->cb)[2];
8822 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
8823
bd8c78e7
JB		 8824 /* clear CB data for netlink core to own from now on */
8825 memset(skb->cb, 0, sizeof(skb->cb));
8826
e03ad6ea
JB		 8827 nla_nest_end(skb, data);
8828 genlmsg_end(skb, hdr);
8829
8830 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
8831 mcgrp = NL80211_MCGRP_VENDOR;
8832
8833 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
8834 mcgrp, gfp);
8835}
8836EXPORT_SYMBOL(__cfg80211_send_event_skb);
8837
aff89a9b 8838#ifdef CONFIG_NL80211_TESTMODE
aff89a9b
JB		 8839static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
8840{
4c476991 8841 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fc73f11f
DS		 8842 struct wireless_dev *wdev =
8843 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
aff89a9b
JB		 8844 int err;
8845
fc73f11f
DS		 8846 if (!rdev->ops->testmode_cmd)
8847 return -EOPNOTSUPP;
8848
8849 if (IS_ERR(wdev)) {
8850 err = PTR_ERR(wdev);
8851 if (err != -EINVAL)
8852 return err;
8853 wdev = NULL;
8854 } else if (wdev->wiphy != &rdev->wiphy) {
8855 return -EINVAL;
8856 }
8857
aff89a9b
JB		 8858 if (!info->attrs[NL80211_ATTR_TESTDATA])
8859 return -EINVAL;
8860
ad7e718c 8861 rdev->cur_cmd_info = info;
fc73f11f 8862 err = rdev_testmode_cmd(rdev, wdev,
aff89a9b
JB		 8863 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
8864 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
ad7e718c 8865 rdev->cur_cmd_info = NULL;
aff89a9b 8866
aff89a9b
JB		 8867 return err;
8868}
8869
71063f0e
WYG		 8870static int nl80211_testmode_dump(struct sk_buff *skb,
8871 struct netlink_callback *cb)
8872{
00918d33 8873 struct cfg80211_registered_device *rdev;
71063f0e
WYG		 8874 int err;
8875 long phy_idx;
8876 void *data = NULL;
8877 int data_len = 0;
8878
5fe231e8
JB		 8879 rtnl_lock();
8880
71063f0e
WYG		 8881 if (cb->args[0]) {
8882 /*
8883 * 0 is a valid index, but not valid for args[0],
8884 * so we need to offset by 1.
8885 */
8886 phy_idx = cb->args[0] - 1;
a4956dca
LC		 8887
8888 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
8889 if (!rdev) {
8890 err = -ENOENT;
8891 goto out_err;
8892 }
71063f0e 8893 } else {
c90c39da
JB		 8894 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
8895
71063f0e 8896 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
fceb6435
JB		 8897 attrbuf, nl80211_fam.maxattr,
8898 nl80211_policy, NULL);
71063f0e 8899 if (err)
5fe231e8 8900 goto out_err;
00918d33 8901
c90c39da 8902 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
2bd7e35d 8903 if (IS_ERR(rdev)) {
5fe231e8
JB		 8904 err = PTR_ERR(rdev);
8905 goto out_err;
00918d33 8906 }
2bd7e35d 8907 phy_idx = rdev->wiphy_idx;
2bd7e35d 8908
c90c39da
JB		 8909 if (attrbuf[NL80211_ATTR_TESTDATA])
8910 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
71063f0e
WYG		 8911 }
8912
8913 if (cb->args[1]) {
8914 data = nla_data((void *)cb->args[1]);
8915 data_len = nla_len((void *)cb->args[1]);
8916 }
8917
00918d33 8918 if (!rdev->ops->testmode_dump) {
71063f0e
WYG		 8919 err = -EOPNOTSUPP;
8920 goto out_err;
8921 }
8922
8923 while (1) {
15e47304 8924 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
71063f0e
WYG		 8925 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8926 NL80211_CMD_TESTMODE);
8927 struct nlattr *tmdata;
8928
cb35fba3
DC		 8929 if (!hdr)
8930 break;
8931
9360ffd1 8932 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
71063f0e
WYG		 8933 genlmsg_cancel(skb, hdr);
8934 break;
8935 }
8936
8937 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
8938 if (!tmdata) {
8939 genlmsg_cancel(skb, hdr);
8940 break;
8941 }
e35e4d28 8942 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
71063f0e
WYG		 8943 nla_nest_end(skb, tmdata);
8944
8945 if (err == -ENOBUFS || err == -ENOENT) {
8946 genlmsg_cancel(skb, hdr);
8947 break;
8948 } else if (err) {
8949 genlmsg_cancel(skb, hdr);
8950 goto out_err;
8951 }
8952
8953 genlmsg_end(skb, hdr);
8954 }
8955
8956 err = skb->len;
8957 /* see above */
8958 cb->args[0] = phy_idx + 1;
8959 out_err:
5fe231e8 8960 rtnl_unlock();
71063f0e
WYG		 8961 return err;
8962}
aff89a9b
JB		 8963#endif
8964
b23aa676
SO		 8965static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
8966{
4c476991
JB		 8967 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8968 struct net_device *dev = info->user_ptr[1];
b23aa676
SO		 8969 struct cfg80211_connect_params connect;
8970 struct wiphy *wiphy;
fffd0934 8971 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 8972 int err;
8973
8974 memset(&connect, 0, sizeof(connect));
8975
8976 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8977 return -EINVAL;
8978
8979 if (!info->attrs[NL80211_ATTR_SSID] ||
8980 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8981 return -EINVAL;
8982
8983 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
8984 connect.auth_type =
8985 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 8986 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
8987 NL80211_CMD_CONNECT))
b23aa676
SO		 8988 return -EINVAL;
8989 } else
8990 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
8991
8992 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
8993
3a00df57
AS		 8994 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
8995 !wiphy_ext_feature_isset(&rdev->wiphy,
8996 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
8997 return -EINVAL;
8998 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
8999
c0692b8f 9000 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
3dc27d25 9001 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 9002 if (err)
9003 return err;
b23aa676 9004
074ac8df 9005 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9006 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9007 return -EOPNOTSUPP;
b23aa676 9008
79c97e97 9009 wiphy = &rdev->wiphy;
b23aa676 9010
4486ea98
BS		 9011 connect.bg_scan_period = -1;
9012 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
9013 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
9014 connect.bg_scan_period =
9015 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
9016 }
9017
b23aa676
SO		 9018 if (info->attrs[NL80211_ATTR_MAC])
9019 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1df4a510
JM		 9020 else if (info->attrs[NL80211_ATTR_MAC_HINT])
9021 connect.bssid_hint =
9022 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
b23aa676
SO		 9023 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9024 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9025
9026 if (info->attrs[NL80211_ATTR_IE]) {
9027 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9028 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9029 }
9030
cee00a95
JM		 9031 if (info->attrs[NL80211_ATTR_USE_MFP]) {
9032 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
65026002
EG		 9033 if (connect.mfp == NL80211_MFP_OPTIONAL &&
9034 !wiphy_ext_feature_isset(&rdev->wiphy,
9035 NL80211_EXT_FEATURE_MFP_OPTIONAL))
9036 return -EOPNOTSUPP;
9037
cee00a95 9038 if (connect.mfp != NL80211_MFP_REQUIRED &&
65026002
EG		 9039 connect.mfp != NL80211_MFP_NO &&
9040 connect.mfp != NL80211_MFP_OPTIONAL)
cee00a95
JM		 9041 return -EINVAL;
9042 } else {
9043 connect.mfp = NL80211_MFP_NO;
9044 }
9045
ba6fbacf
JM		 9046 if (info->attrs[NL80211_ATTR_PREV_BSSID])
9047 connect.prev_bssid =
9048 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
9049
b23aa676 9050 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
664834de
JM		 9051 connect.channel = nl80211_get_valid_chan(
9052 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9053 if (!connect.channel)
1df4a510
JM		 9054 return -EINVAL;
9055 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
664834de
JM		 9056 connect.channel_hint = nl80211_get_valid_chan(
9057 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
9058 if (!connect.channel_hint)
4c476991 9059 return -EINVAL;
b23aa676
SO		 9060 }
9061
fffd0934
JB		 9062 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9063 connkeys = nl80211_parse_connkeys(rdev,
de7044ee 9064 info->attrs[NL80211_ATTR_KEYS], NULL);
4c476991
JB		 9065 if (IS_ERR(connkeys))
9066 return PTR_ERR(connkeys);
fffd0934
JB		 9067 }
9068
7e7c8926
BG		 9069 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
9070 connect.flags |= ASSOC_REQ_DISABLE_HT;
9071
9072 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9073 memcpy(&connect.ht_capa_mask,
9074 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9075 sizeof(connect.ht_capa_mask));
9076
9077 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
b4e4f47e 9078 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
b47f610b 9079 kzfree(connkeys);
7e7c8926 9080 return -EINVAL;
b4e4f47e 9081 }
7e7c8926
BG		 9082 memcpy(&connect.ht_capa,
9083 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9084 sizeof(connect.ht_capa));
9085 }
9086
ee2aca34
JB		 9087 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
9088 connect.flags |= ASSOC_REQ_DISABLE_VHT;
9089
9090 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9091 memcpy(&connect.vht_capa_mask,
9092 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
9093 sizeof(connect.vht_capa_mask));
9094
9095 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
9096 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
b47f610b 9097 kzfree(connkeys);
ee2aca34
JB		 9098 return -EINVAL;
9099 }
9100 memcpy(&connect.vht_capa,
9101 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
9102 sizeof(connect.vht_capa));
9103 }
9104
bab5ab7d 9105 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 9106 if (!((rdev->wiphy.features &
9107 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9108 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9109 !wiphy_ext_feature_isset(&rdev->wiphy,
9110 NL80211_EXT_FEATURE_RRM)) {
707554b4 9111 kzfree(connkeys);
bab5ab7d 9112 return -EINVAL;
707554b4 9113 }
bab5ab7d
AK		 9114 connect.flags |= ASSOC_REQ_USE_RRM;
9115 }
9116
34d50519 9117 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
57fbcce3 9118 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
34d50519
LD		 9119 kzfree(connkeys);
9120 return -EOPNOTSUPP;
9121 }
9122
38de03d2
AS		 9123 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
9124 /* bss selection makes no sense if bssid is set */
9125 if (connect.bssid) {
9126 kzfree(connkeys);
9127 return -EINVAL;
9128 }
9129
9130 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
9131 wiphy, &connect.bss_select);
9132 if (err) {
9133 kzfree(connkeys);
9134 return err;
9135 }
9136 }
9137
a3caf744
VK		 9138 if (wiphy_ext_feature_isset(&rdev->wiphy,
9139 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
9140 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
9141 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
9142 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
9143 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9144 connect.fils_erp_username =
9145 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9146 connect.fils_erp_username_len =
9147 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9148 connect.fils_erp_realm =
9149 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9150 connect.fils_erp_realm_len =
9151 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9152 connect.fils_erp_next_seq_num =
9153 nla_get_u16(
9154 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9155 connect.fils_erp_rrk =
9156 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9157 connect.fils_erp_rrk_len =
9158 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9159 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9160 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9161 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9162 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9163 kzfree(connkeys);
9164 return -EINVAL;
9165 }
9166
83739b03 9167 wdev_lock(dev->ieee80211_ptr);
bd2522b1 9168
4ce2bd9c
JM		 9169 err = cfg80211_connect(rdev, dev, &connect, connkeys,
9170 connect.prev_bssid);
fffd0934 9171 if (err)
b47f610b 9172 kzfree(connkeys);
bd2522b1
AZ		 9173
9174 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9175 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9176 if (connect.bssid)
9177 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9178 connect.bssid, ETH_ALEN);
9179 else
9180 memset(dev->ieee80211_ptr->disconnect_bssid,
9181 0, ETH_ALEN);
9182 }
9183
9184 wdev_unlock(dev->ieee80211_ptr);
9185
b23aa676
SO		 9186 return err;
9187}
9188
088e8df8 9189static int nl80211_update_connect_params(struct sk_buff *skb,
9190 struct genl_info *info)
9191{
9192 struct cfg80211_connect_params connect = {};
9193 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9194 struct net_device *dev = info->user_ptr[1];
9195 struct wireless_dev *wdev = dev->ieee80211_ptr;
9196 u32 changed = 0;
9197 int ret;
9198
9199 if (!rdev->ops->update_connect_params)
9200 return -EOPNOTSUPP;
9201
9202 if (info->attrs[NL80211_ATTR_IE]) {
9203 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9204 return -EINVAL;
9205 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9206 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9207 changed |= UPDATE_ASSOC_IES;
9208 }
9209
9210 wdev_lock(dev->ieee80211_ptr);
9211 if (!wdev->current_bss)
9212 ret = -ENOLINK;
9213 else
9214 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
9215 wdev_unlock(dev->ieee80211_ptr);
9216
9217 return ret;
9218}
9219
b23aa676
SO		 9220static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
9221{
4c476991
JB		 9222 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9223 struct net_device *dev = info->user_ptr[1];
b23aa676 9224 u16 reason;
83739b03 9225 int ret;
b23aa676
SO		 9226
9227 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9228 reason = WLAN_REASON_DEAUTH_LEAVING;
9229 else
9230 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9231
9232 if (reason == 0)
9233 return -EINVAL;
9234
074ac8df 9235 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9236 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9237 return -EOPNOTSUPP;
b23aa676 9238
83739b03
JB		 9239 wdev_lock(dev->ieee80211_ptr);
9240 ret = cfg80211_disconnect(rdev, dev, reason, true);
9241 wdev_unlock(dev->ieee80211_ptr);
9242 return ret;
b23aa676
SO		 9243}
9244
463d0183
JB		 9245static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
9246{
4c476991 9247 struct cfg80211_registered_device *rdev = info->user_ptr[0];
463d0183
JB		 9248 struct net *net;
9249 int err;
463d0183 9250
4b681c82
VK		 9251 if (info->attrs[NL80211_ATTR_PID]) {
9252 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
9253
9254 net = get_net_ns_by_pid(pid);
9255 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
9256 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
463d0183 9257
4b681c82
VK		 9258 net = get_net_ns_by_fd(fd);
9259 } else {
9260 return -EINVAL;
9261 }
463d0183 9262
4c476991
JB		 9263 if (IS_ERR(net))
9264 return PTR_ERR(net);
463d0183
JB		 9265
9266 err = 0;
9267
9268 /* check if anything to do */
4c476991
JB		 9269 if (!net_eq(wiphy_net(&rdev->wiphy), net))
9270 err = cfg80211_switch_netns(rdev, net);
463d0183 9271
463d0183 9272 put_net(net);
463d0183
JB		 9273 return err;
9274}
9275
67fbb16b
SO		 9276static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
9277{
4c476991 9278 struct cfg80211_registered_device *rdev = info->user_ptr[0];
67fbb16b
SO		 9279 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
9280 struct cfg80211_pmksa *pmksa) = NULL;
4c476991 9281 struct net_device *dev = info->user_ptr[1];
67fbb16b
SO		 9282 struct cfg80211_pmksa pmksa;
9283
9284 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
9285
67fbb16b
SO		 9286 if (!info->attrs[NL80211_ATTR_PMKID])
9287 return -EINVAL;
9288
67fbb16b 9289 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
a3caf744
VK		 9290
9291 if (info->attrs[NL80211_ATTR_MAC]) {
9292 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9293 } else if (info->attrs[NL80211_ATTR_SSID] &&
9294 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
9295 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
9296 info->attrs[NL80211_ATTR_PMK])) {
9297 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9298 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9299 pmksa.cache_id =
9300 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
9301 } else {
9302 return -EINVAL;
9303 }
9304 if (info->attrs[NL80211_ATTR_PMK]) {
9305 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9306 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
9307 }
67fbb16b 9308
074ac8df 9309 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9310 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9311 return -EOPNOTSUPP;
67fbb16b
SO		 9312
9313 switch (info->genlhdr->cmd) {
9314 case NL80211_CMD_SET_PMKSA:
9315 rdev_ops = rdev->ops->set_pmksa;
9316 break;
9317 case NL80211_CMD_DEL_PMKSA:
9318 rdev_ops = rdev->ops->del_pmksa;
9319 break;
9320 default:
9321 WARN_ON(1);
9322 break;
9323 }
9324
4c476991
JB		 9325 if (!rdev_ops)
9326 return -EOPNOTSUPP;
67fbb16b 9327
4c476991 9328 return rdev_ops(&rdev->wiphy, dev, &pmksa);
67fbb16b
SO		 9329}
9330
9331static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
9332{
4c476991
JB		 9333 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9334 struct net_device *dev = info->user_ptr[1];
67fbb16b 9335
074ac8df 9336 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9337 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9338 return -EOPNOTSUPP;
67fbb16b 9339
4c476991
JB		 9340 if (!rdev->ops->flush_pmksa)
9341 return -EOPNOTSUPP;
67fbb16b 9342
e35e4d28 9343 return rdev_flush_pmksa(rdev, dev);
67fbb16b
SO		 9344}
9345
109086ce
AN		 9346static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
9347{
9348 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9349 struct net_device *dev = info->user_ptr[1];
9350 u8 action_code, dialog_token;
df942e7b 9351 u32 peer_capability = 0;
109086ce
AN		 9352 u16 status_code;
9353 u8 *peer;
31fa97c5 9354 bool initiator;
109086ce
AN		 9355
9356 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9357 !rdev->ops->tdls_mgmt)
9358 return -EOPNOTSUPP;
9359
9360 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
9361 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
9362 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
9363 !info->attrs[NL80211_ATTR_IE] ||
9364 !info->attrs[NL80211_ATTR_MAC])
9365 return -EINVAL;
9366
9367 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9368 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
9369 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
9370 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
31fa97c5 9371 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
df942e7b
SDU		 9372 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
9373 peer_capability =
9374 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
109086ce 9375
e35e4d28 9376 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
df942e7b 9377 dialog_token, status_code, peer_capability,
31fa97c5 9378 initiator,
e35e4d28
HG		 9379 nla_data(info->attrs[NL80211_ATTR_IE]),
9380 nla_len(info->attrs[NL80211_ATTR_IE]));
109086ce
AN		 9381}
9382
9383static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
9384{
9385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9386 struct net_device *dev = info->user_ptr[1];
9387 enum nl80211_tdls_operation operation;
9388 u8 *peer;
9389
9390 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9391 !rdev->ops->tdls_oper)
9392 return -EOPNOTSUPP;
9393
9394 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
9395 !info->attrs[NL80211_ATTR_MAC])
9396 return -EINVAL;
9397
9398 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
9399 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9400
e35e4d28 9401 return rdev_tdls_oper(rdev, dev, peer, operation);
109086ce
AN		 9402}
9403
9588bbd5
JM		 9404static int nl80211_remain_on_channel(struct sk_buff *skb,
9405 struct genl_info *info)
9406{
4c476991 9407 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9408 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9409 struct cfg80211_chan_def chandef;
34373d12 9410 const struct cfg80211_chan_def *compat_chandef;
9588bbd5
JM		 9411 struct sk_buff *msg;
9412 void *hdr;
9413 u64 cookie;
683b6d3b 9414 u32 duration;
9588bbd5
JM		 9415 int err;
9416
9417 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9418 !info->attrs[NL80211_ATTR_DURATION])
9419 return -EINVAL;
9420
9421 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
9422
ebf348fc
JB		 9423 if (!rdev->ops->remain_on_channel ||
9424 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
9425 return -EOPNOTSUPP;
9426
9588bbd5 9427 /*
ebf348fc
JB		 9428 * We should be on that channel for at least a minimum amount of
9429 * time (10ms) but no longer than the driver supports.
9588bbd5 9430 */
ebf348fc 9431 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
a293911d 9432 duration > rdev->wiphy.max_remain_on_channel_duration)
9588bbd5
JM		 9433 return -EINVAL;
9434
683b6d3b
JB		 9435 err = nl80211_parse_chandef(rdev, info, &chandef);
9436 if (err)
9437 return err;
9588bbd5 9438
34373d12
VT		 9439 wdev_lock(wdev);
9440 if (!cfg80211_off_channel_oper_allowed(wdev) &&
9441 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
9442 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
9443 &chandef);
9444 if (compat_chandef != &chandef) {
9445 wdev_unlock(wdev);
9446 return -EBUSY;
9447 }
9448 }
9449 wdev_unlock(wdev);
9450
9588bbd5 9451 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9452 if (!msg)
9453 return -ENOMEM;
9588bbd5 9454
15e47304 9455 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9588bbd5 9456 NL80211_CMD_REMAIN_ON_CHANNEL);
cb35fba3
DC		 9457 if (!hdr) {
9458 err = -ENOBUFS;
9588bbd5
JM		 9459 goto free_msg;
9460 }
9461
683b6d3b
JB		 9462 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
9463 duration, &cookie);
9588bbd5
JM		 9464
9465 if (err)
9466 goto free_msg;
9467
2dad624e
ND		 9468 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9469 NL80211_ATTR_PAD))
9360ffd1 9470 goto nla_put_failure;
9588bbd5
JM		 9471
9472 genlmsg_end(msg, hdr);
4c476991
JB		 9473
9474 return genlmsg_reply(msg, info);
9588bbd5
JM		 9475
9476 nla_put_failure:
9477 err = -ENOBUFS;
9478 free_msg:
9479 nlmsg_free(msg);
9588bbd5
JM		 9480 return err;
9481}
9482
9483static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
9484 struct genl_info *info)
9485{
4c476991 9486 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9487 struct wireless_dev *wdev = info->user_ptr[1];
9588bbd5 9488 u64 cookie;
9588bbd5
JM		 9489
9490 if (!info->attrs[NL80211_ATTR_COOKIE])
9491 return -EINVAL;
9492
4c476991
JB		 9493 if (!rdev->ops->cancel_remain_on_channel)
9494 return -EOPNOTSUPP;
9588bbd5 9495
9588bbd5
JM		 9496 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9497
e35e4d28 9498 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
9588bbd5
JM		 9499}
9500
13ae75b1
JM		 9501static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
9502 struct genl_info *info)
9503{
13ae75b1 9504 struct cfg80211_bitrate_mask mask;
a7c7fbff 9505 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9506 struct net_device *dev = info->user_ptr[1];
a7c7fbff 9507 int err;
13ae75b1 9508
4c476991
JB		 9509 if (!rdev->ops->set_bitrate_mask)
9510 return -EOPNOTSUPP;
13ae75b1 9511
a7c7fbff
PK		 9512 err = nl80211_parse_tx_bitrate_mask(info, &mask);
9513 if (err)
9514 return err;
13ae75b1 9515
e35e4d28 9516 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
13ae75b1
JM		 9517}
9518
2e161f78 9519static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9520{
4c476991 9521 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9522 struct wireless_dev *wdev = info->user_ptr[1];
2e161f78 9523 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
026331c4
JM		 9524
9525 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
9526 return -EINVAL;
9527
2e161f78
JB		 9528 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
9529 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
026331c4 9530
71bbc994
JB		 9531 switch (wdev->iftype) {
9532 case NL80211_IFTYPE_STATION:
9533 case NL80211_IFTYPE_ADHOC:
9534 case NL80211_IFTYPE_P2P_CLIENT:
9535 case NL80211_IFTYPE_AP:
9536 case NL80211_IFTYPE_AP_VLAN:
9537 case NL80211_IFTYPE_MESH_POINT:
9538 case NL80211_IFTYPE_P2P_GO:
98104fde 9539 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9540 break;
cb3b7d87 9541 case NL80211_IFTYPE_NAN:
71bbc994 9542 default:
4c476991 9543 return -EOPNOTSUPP;
71bbc994 9544 }
026331c4
JM		 9545
9546 /* not much point in registering if we can't reply */
4c476991
JB		 9547 if (!rdev->ops->mgmt_tx)
9548 return -EOPNOTSUPP;
026331c4 9549
15e47304 9550 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
026331c4
JM		 9551 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
9552 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
026331c4
JM		 9553}
9554
2e161f78 9555static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9556{
4c476991 9557 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9558 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9559 struct cfg80211_chan_def chandef;
026331c4 9560 int err;
d64d373f 9561 void *hdr = NULL;
026331c4 9562 u64 cookie;
e247bd90 9563 struct sk_buff *msg = NULL;
b176e629
AO		 9564 struct cfg80211_mgmt_tx_params params = {
9565 .dont_wait_for_ack =
9566 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
9567 };
026331c4 9568
683b6d3b 9569 if (!info->attrs[NL80211_ATTR_FRAME])
026331c4
JM		 9570 return -EINVAL;
9571
4c476991
JB		 9572 if (!rdev->ops->mgmt_tx)
9573 return -EOPNOTSUPP;
026331c4 9574
71bbc994 9575 switch (wdev->iftype) {
ea141b75
AQ		 9576 case NL80211_IFTYPE_P2P_DEVICE:
9577 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9578 return -EINVAL;
71bbc994
JB		 9579 case NL80211_IFTYPE_STATION:
9580 case NL80211_IFTYPE_ADHOC:
9581 case NL80211_IFTYPE_P2P_CLIENT:
9582 case NL80211_IFTYPE_AP:
9583 case NL80211_IFTYPE_AP_VLAN:
9584 case NL80211_IFTYPE_MESH_POINT:
9585 case NL80211_IFTYPE_P2P_GO:
9586 break;
cb3b7d87 9587 case NL80211_IFTYPE_NAN:
71bbc994 9588 default:
4c476991 9589 return -EOPNOTSUPP;
71bbc994 9590 }
026331c4 9591
f7ca38df 9592 if (info->attrs[NL80211_ATTR_DURATION]) {
7c4ef712 9593 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
f7ca38df 9594 return -EINVAL;
b176e629 9595 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
ebf348fc
JB		 9596
9597 /*
9598 * We should wait on the channel for at least a minimum amount
9599 * of time (10ms) but no longer than the driver supports.
9600 */
b176e629
AO		 9601 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
9602 params.wait > rdev->wiphy.max_remain_on_channel_duration)
ebf348fc 9603 return -EINVAL;
f7ca38df
JB		 9604 }
9605
b176e629 9606 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
f7ca38df 9607
b176e629 9608 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7c4ef712
JB		 9609 return -EINVAL;
9610
b176e629 9611 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3 9612
ea141b75
AQ		 9613 /* get the channel if any has been specified, otherwise pass NULL to
9614 * the driver. The latter will use the current one
9615 */
9616 chandef.chan = NULL;
9617 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9618 err = nl80211_parse_chandef(rdev, info, &chandef);
9619 if (err)
9620 return err;
9621 }
9622
b176e629 9623 if (!chandef.chan && params.offchan)
ea141b75 9624 return -EINVAL;
026331c4 9625
34373d12
VT		 9626 wdev_lock(wdev);
9627 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
9628 wdev_unlock(wdev);
9629 return -EBUSY;
9630 }
9631 wdev_unlock(wdev);
9632
34d22ce2
AO		 9633 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
9634 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
9635
9636 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
9637 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9638 int i;
9639
9640 if (len % sizeof(u16))
9641 return -EINVAL;
9642
9643 params.n_csa_offsets = len / sizeof(u16);
9644 params.csa_offsets =
9645 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9646
9647 /* check that all the offsets fit the frame */
9648 for (i = 0; i < params.n_csa_offsets; i++) {
9649 if (params.csa_offsets[i] >= params.len)
9650 return -EINVAL;
9651 }
9652 }
9653
b176e629 9654 if (!params.dont_wait_for_ack) {
e247bd90
JB		 9655 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9656 if (!msg)
9657 return -ENOMEM;
026331c4 9658
15e47304 9659 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
e247bd90 9660 NL80211_CMD_FRAME);
cb35fba3
DC		 9661 if (!hdr) {
9662 err = -ENOBUFS;
e247bd90
JB		 9663 goto free_msg;
9664 }
026331c4 9665 }
e247bd90 9666
b176e629
AO		 9667 params.chan = chandef.chan;
9668 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
026331c4
JM		 9669 if (err)
9670 goto free_msg;
9671
e247bd90 9672 if (msg) {
2dad624e
ND		 9673 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9674 NL80211_ATTR_PAD))
9360ffd1 9675 goto nla_put_failure;
026331c4 9676
e247bd90
JB		 9677 genlmsg_end(msg, hdr);
9678 return genlmsg_reply(msg, info);
9679 }
9680
9681 return 0;
026331c4
JM		 9682
9683 nla_put_failure:
9684 err = -ENOBUFS;
9685 free_msg:
9686 nlmsg_free(msg);
026331c4
JM		 9687 return err;
9688}
9689
f7ca38df
JB		 9690static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
9691{
9692 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9693 struct wireless_dev *wdev = info->user_ptr[1];
f7ca38df
JB		 9694 u64 cookie;
9695
9696 if (!info->attrs[NL80211_ATTR_COOKIE])
9697 return -EINVAL;
9698
9699 if (!rdev->ops->mgmt_tx_cancel_wait)
9700 return -EOPNOTSUPP;
9701
71bbc994
JB		 9702 switch (wdev->iftype) {
9703 case NL80211_IFTYPE_STATION:
9704 case NL80211_IFTYPE_ADHOC:
9705 case NL80211_IFTYPE_P2P_CLIENT:
9706 case NL80211_IFTYPE_AP:
9707 case NL80211_IFTYPE_AP_VLAN:
9708 case NL80211_IFTYPE_P2P_GO:
98104fde 9709 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9710 break;
cb3b7d87 9711 case NL80211_IFTYPE_NAN:
71bbc994 9712 default:
f7ca38df 9713 return -EOPNOTSUPP;
71bbc994 9714 }
f7ca38df
JB		 9715
9716 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9717
e35e4d28 9718 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
f7ca38df
JB		 9719}
9720
ffb9eb3d
KV		 9721static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
9722{
4c476991 9723 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d 9724 struct wireless_dev *wdev;
4c476991 9725 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9726 u8 ps_state;
9727 bool state;
9728 int err;
9729
4c476991
JB		 9730 if (!info->attrs[NL80211_ATTR_PS_STATE])
9731 return -EINVAL;
ffb9eb3d
KV		 9732
9733 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
9734
4c476991
JB		 9735 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
9736 return -EINVAL;
ffb9eb3d
KV		 9737
9738 wdev = dev->ieee80211_ptr;
9739
4c476991
JB		 9740 if (!rdev->ops->set_power_mgmt)
9741 return -EOPNOTSUPP;
ffb9eb3d
KV		 9742
9743 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
9744
9745 if (state == wdev->ps)
4c476991 9746 return 0;
ffb9eb3d 9747
e35e4d28 9748 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
4c476991
JB		 9749 if (!err)
9750 wdev->ps = state;
ffb9eb3d
KV		 9751 return err;
9752}
9753
9754static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
9755{
4c476991 9756 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d
KV		 9757 enum nl80211_ps_state ps_state;
9758 struct wireless_dev *wdev;
4c476991 9759 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9760 struct sk_buff *msg;
9761 void *hdr;
9762 int err;
9763
ffb9eb3d
KV		 9764 wdev = dev->ieee80211_ptr;
9765
4c476991
JB		 9766 if (!rdev->ops->set_power_mgmt)
9767 return -EOPNOTSUPP;
ffb9eb3d
KV		 9768
9769 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9770 if (!msg)
9771 return -ENOMEM;
ffb9eb3d 9772
15e47304 9773 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ffb9eb3d
KV		 9774 NL80211_CMD_GET_POWER_SAVE);
9775 if (!hdr) {
4c476991 9776 err = -ENOBUFS;
ffb9eb3d
KV		 9777 goto free_msg;
9778 }
9779
9780 if (wdev->ps)
9781 ps_state = NL80211_PS_ENABLED;
9782 else
9783 ps_state = NL80211_PS_DISABLED;
9784
9360ffd1
DM		 9785 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
9786 goto nla_put_failure;
ffb9eb3d
KV		 9787
9788 genlmsg_end(msg, hdr);
4c476991 9789 return genlmsg_reply(msg, info);
ffb9eb3d 9790
4c476991 9791 nla_put_failure:
ffb9eb3d 9792 err = -ENOBUFS;
4c476991 9793 free_msg:
ffb9eb3d 9794 nlmsg_free(msg);
ffb9eb3d
KV		 9795 return err;
9796}
9797
94e860f1
JB		 9798static const struct nla_policy
9799nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
4a4b8169 9800 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
d6dc1a38
JO		 9801 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
9802 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
84f10708
TP		 9803 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
9804 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
9805 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
bee427b8 9806 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
d6dc1a38
JO		 9807};
9808
84f10708 9809static int nl80211_set_cqm_txe(struct genl_info *info,
d9d8b019 9810 u32 rate, u32 pkts, u32 intvl)
84f10708
TP		 9811{
9812 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84f10708 9813 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9814 struct wireless_dev *wdev = dev->ieee80211_ptr;
84f10708 9815
d9d8b019 9816 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
84f10708
TP		 9817 return -EINVAL;
9818
84f10708
TP		 9819 if (!rdev->ops->set_cqm_txe_config)
9820 return -EOPNOTSUPP;
9821
9822 if (wdev->iftype != NL80211_IFTYPE_STATION &&
9823 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9824 return -EOPNOTSUPP;
9825
e35e4d28 9826 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
84f10708
TP		 9827}
9828
4a4b8169
AZ		 9829static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
9830 struct net_device *dev)
9831{
9832 struct wireless_dev *wdev = dev->ieee80211_ptr;
9833 s32 last, low, high;
9834 u32 hyst;
45c6bc6c 9835 int i, n, low_index;
4a4b8169
AZ		 9836 int err;
9837
9838 /* RSSI reporting disabled? */
9839 if (!wdev->cqm_config)
9840 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
9841
9842 /*
9843 * Obtain current RSSI value if possible, if not and no RSSI threshold
9844 * event has been received yet, we should receive an event after a
9845 * connection is established and enough beacons received to calculate
9846 * the average.
9847 */
9848 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
9849 rdev->ops->get_station) {
5762d7d3 9850 struct station_info sinfo = {};
4a4b8169
AZ		 9851 u8 *mac_addr;
9852
9853 mac_addr = wdev->current_bss->pub.bssid;
9854
9855 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
9856 if (err)
9857 return err;
9858
9859 if (sinfo.filled & BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
9860 wdev->cqm_config->last_rssi_event_value =
9861 (s8) sinfo.rx_beacon_signal_avg;
9862 }
9863
9864 last = wdev->cqm_config->last_rssi_event_value;
9865 hyst = wdev->cqm_config->rssi_hyst;
9866 n = wdev->cqm_config->n_rssi_thresholds;
9867
fb05f0db
MH		 9868 for (i = 0; i < n; i++) {
9869 i = array_index_nospec(i, n);
4a4b8169
AZ		 9870 if (last < wdev->cqm_config->rssi_thresholds[i])
9871 break;
fb05f0db 9872 }
4a4b8169 9873
45c6bc6c
MH		 9874 low_index = i - 1;
9875 if (low_index >= 0) {
9876 low_index = array_index_nospec(low_index, n);
9877 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
9878 } else {
9879 low = S32_MIN;
9880 }
9881 if (i < n) {
9882 i = array_index_nospec(i, n);
9883 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
9884 } else {
9885 high = S32_MAX;
9886 }
4a4b8169
AZ		 9887
9888 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
9889}
9890
d6dc1a38 9891static int nl80211_set_cqm_rssi(struct genl_info *info,
4a4b8169
AZ		 9892 const s32 *thresholds, int n_thresholds,
9893 u32 hysteresis)
d6dc1a38 9894{
4c476991 9895 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9896 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9897 struct wireless_dev *wdev = dev->ieee80211_ptr;
4a4b8169
AZ		 9898 int i, err;
9899 s32 prev = S32_MIN;
d6dc1a38 9900
4a4b8169
AZ		 9901 /* Check all values negative and sorted */
9902 for (i = 0; i < n_thresholds; i++) {
9903 if (thresholds[i] > 0 || thresholds[i] <= prev)
9904 return -EINVAL;
d6dc1a38 9905
4a4b8169
AZ		 9906 prev = thresholds[i];
9907 }
d6dc1a38 9908
074ac8df 9909 if (wdev->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9910 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9911 return -EOPNOTSUPP;
d6dc1a38 9912
4a4b8169
AZ		 9913 wdev_lock(wdev);
9914 cfg80211_cqm_config_free(wdev);
9915 wdev_unlock(wdev);
9916
9917 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
9918 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
9919 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
9920
9921 return rdev_set_cqm_rssi_config(rdev, dev,
9922 thresholds[0], hysteresis);
9923 }
9924
9925 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9926 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
9927 return -EOPNOTSUPP;
9928
9929 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
9930 n_thresholds = 0;
9931
9932 wdev_lock(wdev);
9933 if (n_thresholds) {
9934 struct cfg80211_cqm_config *cqm_config;
9935
9936 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
9937 n_thresholds * sizeof(s32), GFP_KERNEL);
9938 if (!cqm_config) {
9939 err = -ENOMEM;
9940 goto unlock;
9941 }
9942
9943 cqm_config->rssi_hyst = hysteresis;
9944 cqm_config->n_rssi_thresholds = n_thresholds;
9945 memcpy(cqm_config->rssi_thresholds, thresholds,
9946 n_thresholds * sizeof(s32));
9947
9948 wdev->cqm_config = cqm_config;
9949 }
9950
9951 err = cfg80211_cqm_rssi_update(rdev, dev);
9952
9953unlock:
9954 wdev_unlock(wdev);
9955
9956 return err;
d6dc1a38
JO		 9957}
9958
9959static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
9960{
9961 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
9962 struct nlattr *cqm;
9963 int err;
9964
9965 cqm = info->attrs[NL80211_ATTR_CQM];
1da5fcc8
JB		 9966 if (!cqm)
9967 return -EINVAL;
d6dc1a38
JO		 9968
9969 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
fe52145f 9970 nl80211_attr_cqm_policy, info->extack);
d6dc1a38 9971 if (err)
1da5fcc8 9972 return err;
d6dc1a38
JO		 9973
9974 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
9975 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
4a4b8169
AZ		 9976 const s32 *thresholds =
9977 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
9978 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
1da5fcc8 9979 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
d6dc1a38 9980
4a4b8169
AZ		 9981 if (len % 4)
9982 return -EINVAL;
9983
9984 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
9985 hysteresis);
1da5fcc8
JB		 9986 }
9987
9988 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
9989 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
9990 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
9991 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
9992 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
9993 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
9994
9995 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
9996 }
9997
9998 return -EINVAL;
d6dc1a38
JO		 9999}
10000
6e0bd6c3
RL		 10001static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
10002{
10003 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10004 struct net_device *dev = info->user_ptr[1];
10005 struct ocb_setup setup = {};
10006 int err;
10007
10008 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10009 if (err)
10010 return err;
10011
10012 return cfg80211_join_ocb(rdev, dev, &setup);
10013}
10014
10015static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
10016{
10017 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10018 struct net_device *dev = info->user_ptr[1];
10019
10020 return cfg80211_leave_ocb(rdev, dev);
10021}
10022
29cbe68c
JB		 10023static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
10024{
10025 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10026 struct net_device *dev = info->user_ptr[1];
10027 struct mesh_config cfg;
c80d545d 10028 struct mesh_setup setup;
29cbe68c
JB		 10029 int err;
10030
10031 /* start with default */
10032 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
c80d545d 10033 memcpy(&setup, &default_mesh_setup, sizeof(setup));
29cbe68c 10034
24bdd9f4 10035 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
29cbe68c 10036 /* and parse parameters if given */
24bdd9f4 10037 err = nl80211_parse_mesh_config(info, &cfg, NULL);
29cbe68c
JB		 10038 if (err)
10039 return err;
10040 }
10041
10042 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
10043 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
10044 return -EINVAL;
10045
c80d545d
JC		 10046 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
10047 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
10048
4bb62344
CYY		 10049 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
10050 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
10051 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
10052 return -EINVAL;
10053
9bdbf04d
MP		 10054 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
10055 setup.beacon_interval =
10056 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 10057
0c317a02
PK		 10058 err = cfg80211_validate_beacon_int(rdev,
10059 NL80211_IFTYPE_MESH_POINT,
10060 setup.beacon_interval);
12d20fc9
PK		 10061 if (err)
10062 return err;
9bdbf04d
MP		 10063 }
10064
10065 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
10066 setup.dtim_period =
10067 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
10068 if (setup.dtim_period < 1 || setup.dtim_period > 100)
10069 return -EINVAL;
10070 }
10071
c80d545d
JC		 10072 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
10073 /* parse additional setup parameters if given */
10074 err = nl80211_parse_mesh_setup(info, &setup);
10075 if (err)
10076 return err;
10077 }
10078
d37bb18a
TP		 10079 if (setup.user_mpm)
10080 cfg.auto_open_plinks = false;
10081
cc1d2806 10082 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 10083 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10084 if (err)
10085 return err;
cc1d2806
JB		 10086 } else {
10087 /* cfg80211_join_mesh() will sort it out */
683b6d3b 10088 setup.chandef.chan = NULL;
cc1d2806
JB		 10089 }
10090
ffb3cf30
AN		 10091 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
10092 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10093 int n_rates =
10094 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10095 struct ieee80211_supported_band *sband;
10096
10097 if (!setup.chandef.chan)
10098 return -EINVAL;
10099
10100 sband = rdev->wiphy.bands[setup.chandef.chan->band];
10101
10102 err = ieee80211_get_ratemask(sband, rates, n_rates,
10103 &setup.basic_rates);
10104 if (err)
10105 return err;
10106 }
10107
8564e382
JB		 10108 if (info->attrs[NL80211_ATTR_TX_RATES]) {
10109 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
10110 if (err)
10111 return err;
10112
265698d7
JB		 10113 if (!setup.chandef.chan)
10114 return -EINVAL;
10115
8564e382
JB		 10116 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
10117 &setup.beacon_rate);
10118 if (err)
10119 return err;
10120 }
10121
d37d49c2
BB		 10122 setup.userspace_handles_dfs =
10123 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
10124
c80d545d 10125 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
29cbe68c
JB		 10126}
10127
10128static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
10129{
10130 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10131 struct net_device *dev = info->user_ptr[1];
10132
10133 return cfg80211_leave_mesh(rdev, dev);
10134}
10135
dfb89c56 10136#ifdef CONFIG_PM
bb92d199
AK		 10137static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
10138 struct cfg80211_registered_device *rdev)
10139{
6abb9cb9 10140 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
bb92d199
AK		 10141 struct nlattr *nl_pats, *nl_pat;
10142 int i, pat_len;
10143
6abb9cb9 10144 if (!wowlan->n_patterns)
bb92d199
AK		 10145 return 0;
10146
10147 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
10148 if (!nl_pats)
10149 return -ENOBUFS;
10150
6abb9cb9 10151 for (i = 0; i < wowlan->n_patterns; i++) {
bb92d199
AK		 10152 nl_pat = nla_nest_start(msg, i + 1);
10153 if (!nl_pat)
10154 return -ENOBUFS;
6abb9cb9 10155 pat_len = wowlan->patterns[i].pattern_len;
50ac6607 10156 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
6abb9cb9 10157 wowlan->patterns[i].mask) ||
50ac6607
AK		 10158 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10159 wowlan->patterns[i].pattern) ||
10160 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
6abb9cb9 10161 wowlan->patterns[i].pkt_offset))
bb92d199
AK		 10162 return -ENOBUFS;
10163 nla_nest_end(msg, nl_pat);
10164 }
10165 nla_nest_end(msg, nl_pats);
10166
10167 return 0;
10168}
10169
2a0e047e
JB		 10170static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
10171 struct cfg80211_wowlan_tcp *tcp)
10172{
10173 struct nlattr *nl_tcp;
10174
10175 if (!tcp)
10176 return 0;
10177
10178 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
10179 if (!nl_tcp)
10180 return -ENOBUFS;
10181
930345ea
JB		 10182 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
10183 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
2a0e047e
JB		 10184 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
10185 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
10186 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
10187 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
10188 tcp->payload_len, tcp->payload) ||
10189 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
10190 tcp->data_interval) ||
10191 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
10192 tcp->wake_len, tcp->wake_data) ||
10193 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
10194 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
10195 return -ENOBUFS;
10196
10197 if (tcp->payload_seq.len &&
10198 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
10199 sizeof(tcp->payload_seq), &tcp->payload_seq))
10200 return -ENOBUFS;
10201
10202 if (tcp->payload_tok.len &&
10203 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
10204 sizeof(tcp->payload_tok) + tcp->tokens_size,
10205 &tcp->payload_tok))
10206 return -ENOBUFS;
10207
e248ad30
JB		 10208 nla_nest_end(msg, nl_tcp);
10209
2a0e047e
JB		 10210 return 0;
10211}
10212
75453ccb
LC		 10213static int nl80211_send_wowlan_nd(struct sk_buff *msg,
10214 struct cfg80211_sched_scan_request *req)
10215{
3b06d277 10216 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
75453ccb
LC		 10217 int i;
10218
10219 if (!req)
10220 return 0;
10221
10222 nd = nla_nest_start(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
10223 if (!nd)
10224 return -ENOBUFS;
10225
3b06d277
AS		 10226 if (req->n_scan_plans == 1 &&
10227 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
10228 req->scan_plans[0].interval * 1000))
75453ccb
LC		 10229 return -ENOBUFS;
10230
21fea567
LC		 10231 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
10232 return -ENOBUFS;
10233
bf95ecdb 10234 if (req->relative_rssi_set) {
10235 struct nl80211_bss_select_rssi_adjust rssi_adjust;
10236
10237 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
10238 req->relative_rssi))
10239 return -ENOBUFS;
10240
10241 rssi_adjust.band = req->rssi_adjust.band;
10242 rssi_adjust.delta = req->rssi_adjust.delta;
10243 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
10244 sizeof(rssi_adjust), &rssi_adjust))
10245 return -ENOBUFS;
10246 }
10247
75453ccb
LC		 10248 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10249 if (!freqs)
10250 return -ENOBUFS;
10251
53b18980
JB		 10252 for (i = 0; i < req->n_channels; i++) {
10253 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10254 return -ENOBUFS;
10255 }
75453ccb
LC		 10256
10257 nla_nest_end(msg, freqs);
10258
10259 if (req->n_match_sets) {
10260 matches = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
76e1fb4b
JB		 10261 if (!matches)
10262 return -ENOBUFS;
10263
75453ccb
LC		 10264 for (i = 0; i < req->n_match_sets; i++) {
10265 match = nla_nest_start(msg, i);
76e1fb4b
JB		 10266 if (!match)
10267 return -ENOBUFS;
10268
53b18980
JB		 10269 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
10270 req->match_sets[i].ssid.ssid_len,
10271 req->match_sets[i].ssid.ssid))
10272 return -ENOBUFS;
75453ccb
LC		 10273 nla_nest_end(msg, match);
10274 }
10275 nla_nest_end(msg, matches);
10276 }
10277
3b06d277
AS		 10278 scan_plans = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
10279 if (!scan_plans)
10280 return -ENOBUFS;
10281
10282 for (i = 0; i < req->n_scan_plans; i++) {
10283 scan_plan = nla_nest_start(msg, i + 1);
76e1fb4b
JB		 10284 if (!scan_plan)
10285 return -ENOBUFS;
10286
3b06d277
AS		 10287 if (!scan_plan ||
10288 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
10289 req->scan_plans[i].interval) ||
10290 (req->scan_plans[i].iterations &&
10291 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
10292 req->scan_plans[i].iterations)))
10293 return -ENOBUFS;
10294 nla_nest_end(msg, scan_plan);
10295 }
10296 nla_nest_end(msg, scan_plans);
10297
75453ccb
LC		 10298 nla_nest_end(msg, nd);
10299
10300 return 0;
10301}
10302
ff1b6e69
JB		 10303static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
10304{
10305 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10306 struct sk_buff *msg;
10307 void *hdr;
2a0e047e 10308 u32 size = NLMSG_DEFAULT_SIZE;
ff1b6e69 10309
964dc9e2 10310 if (!rdev->wiphy.wowlan)
ff1b6e69
JB		 10311 return -EOPNOTSUPP;
10312
6abb9cb9 10313 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
2a0e047e 10314 /* adjust size to have room for all the data */
6abb9cb9
JB		 10315 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
10316 rdev->wiphy.wowlan_config->tcp->payload_len +
10317 rdev->wiphy.wowlan_config->tcp->wake_len +
10318 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
2a0e047e
JB		 10319 }
10320
10321 msg = nlmsg_new(size, GFP_KERNEL);
ff1b6e69
JB		 10322 if (!msg)
10323 return -ENOMEM;
10324
15e47304 10325 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ff1b6e69
JB		 10326 NL80211_CMD_GET_WOWLAN);
10327 if (!hdr)
10328 goto nla_put_failure;
10329
6abb9cb9 10330 if (rdev->wiphy.wowlan_config) {
ff1b6e69
JB		 10331 struct nlattr *nl_wowlan;
10332
10333 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10334 if (!nl_wowlan)
10335 goto nla_put_failure;
10336
6abb9cb9 10337 if ((rdev->wiphy.wowlan_config->any &&
9360ffd1 10338 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6abb9cb9 10339 (rdev->wiphy.wowlan_config->disconnect &&
9360ffd1 10340 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6abb9cb9 10341 (rdev->wiphy.wowlan_config->magic_pkt &&
9360ffd1 10342 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6abb9cb9 10343 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
9360ffd1 10344 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6abb9cb9 10345 (rdev->wiphy.wowlan_config->eap_identity_req &&
9360ffd1 10346 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6abb9cb9 10347 (rdev->wiphy.wowlan_config->four_way_handshake &&
9360ffd1 10348 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6abb9cb9 10349 (rdev->wiphy.wowlan_config->rfkill_release &&
9360ffd1
DM		 10350 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
10351 goto nla_put_failure;
2a0e047e 10352
bb92d199
AK		 10353 if (nl80211_send_wowlan_patterns(msg, rdev))
10354 goto nla_put_failure;
2a0e047e 10355
6abb9cb9
JB		 10356 if (nl80211_send_wowlan_tcp(msg,
10357 rdev->wiphy.wowlan_config->tcp))
2a0e047e 10358 goto nla_put_failure;
75453ccb
LC		 10359
10360 if (nl80211_send_wowlan_nd(
10361 msg,
10362 rdev->wiphy.wowlan_config->nd_config))
10363 goto nla_put_failure;
2a0e047e 10364
ff1b6e69
JB		 10365 nla_nest_end(msg, nl_wowlan);
10366 }
10367
10368 genlmsg_end(msg, hdr);
10369 return genlmsg_reply(msg, info);
10370
10371nla_put_failure:
10372 nlmsg_free(msg);
10373 return -ENOBUFS;
10374}
10375
2a0e047e
JB		 10376static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
10377 struct nlattr *attr,
10378 struct cfg80211_wowlan *trig)
10379{
10380 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
10381 struct cfg80211_wowlan_tcp *cfg;
10382 struct nl80211_wowlan_tcp_data_token *tok = NULL;
10383 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
10384 u32 size;
10385 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
10386 int err, port;
10387
964dc9e2 10388 if (!rdev->wiphy.wowlan->tcp)
2a0e047e
JB		 10389 return -EINVAL;
10390
bfe2c7b1 10391 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TCP, attr,
fceb6435 10392 nl80211_wowlan_tcp_policy, NULL);
2a0e047e
JB		 10393 if (err)
10394 return err;
10395
10396 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
10397 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
10398 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
10399 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
10400 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
10401 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
10402 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
10403 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
10404 return -EINVAL;
10405
10406 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
964dc9e2 10407 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
2a0e047e
JB		 10408 return -EINVAL;
10409
10410 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
964dc9e2 10411 rdev->wiphy.wowlan->tcp->data_interval_max ||
723d568a 10412 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
2a0e047e
JB		 10413 return -EINVAL;
10414
10415 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
964dc9e2 10416 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
2a0e047e
JB		 10417 return -EINVAL;
10418
10419 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
10420 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
10421 return -EINVAL;
10422
10423 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
10424 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10425
10426 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10427 tokens_size = tokln - sizeof(*tok);
10428
10429 if (!tok->len || tokens_size % tok->len)
10430 return -EINVAL;
964dc9e2 10431 if (!rdev->wiphy.wowlan->tcp->tok)
2a0e047e 10432 return -EINVAL;
964dc9e2 10433 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
2a0e047e 10434 return -EINVAL;
964dc9e2 10435 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
2a0e047e 10436 return -EINVAL;
964dc9e2 10437 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
2a0e047e
JB		 10438 return -EINVAL;
10439 if (tok->offset + tok->len > data_size)
10440 return -EINVAL;
10441 }
10442
10443 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
10444 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
964dc9e2 10445 if (!rdev->wiphy.wowlan->tcp->seq)
2a0e047e
JB		 10446 return -EINVAL;
10447 if (seq->len == 0 || seq->len > 4)
10448 return -EINVAL;
10449 if (seq->len + seq->offset > data_size)
10450 return -EINVAL;
10451 }
10452
10453 size = sizeof(*cfg);
10454 size += data_size;
10455 size += wake_size + wake_mask_size;
10456 size += tokens_size;
10457
10458 cfg = kzalloc(size, GFP_KERNEL);
10459 if (!cfg)
10460 return -ENOMEM;
67b61f6c
JB		 10461 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
10462 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
2a0e047e
JB		 10463 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
10464 ETH_ALEN);
10465 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
10466 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
10467 else
10468 port = 0;
10469#ifdef CONFIG_INET
10470 /* allocate a socket and port for it and use it */
10471 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
10472 IPPROTO_TCP, &cfg->sock, 1);
10473 if (err) {
10474 kfree(cfg);
10475 return err;
10476 }
10477 if (inet_csk_get_port(cfg->sock->sk, port)) {
10478 sock_release(cfg->sock);
10479 kfree(cfg);
10480 return -EADDRINUSE;
10481 }
10482 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
10483#else
10484 if (!port) {
10485 kfree(cfg);
10486 return -EINVAL;
10487 }
10488 cfg->src_port = port;
10489#endif
10490
10491 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
10492 cfg->payload_len = data_size;
10493 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
10494 memcpy((void *)cfg->payload,
10495 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
10496 data_size);
10497 if (seq)
10498 cfg->payload_seq = *seq;
10499 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
10500 cfg->wake_len = wake_size;
10501 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
10502 memcpy((void *)cfg->wake_data,
10503 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
10504 wake_size);
10505 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
10506 data_size + wake_size;
10507 memcpy((void *)cfg->wake_mask,
10508 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
10509 wake_mask_size);
10510 if (tok) {
10511 cfg->tokens_size = tokens_size;
10512 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
10513 }
10514
10515 trig->tcp = cfg;
10516
10517 return 0;
10518}
10519
8cd4d456
LC		 10520static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
10521 const struct wiphy_wowlan_support *wowlan,
10522 struct nlattr *attr,
10523 struct cfg80211_wowlan *trig)
10524{
10525 struct nlattr **tb;
10526 int err;
10527
10528 tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL);
10529 if (!tb)
10530 return -ENOMEM;
10531
10532 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
10533 err = -EOPNOTSUPP;
10534 goto out;
10535 }
10536
fceb6435
JB		 10537 err = nla_parse_nested(tb, NL80211_ATTR_MAX, attr, nl80211_policy,
10538 NULL);
8cd4d456
LC		 10539 if (err)
10540 goto out;
10541
aad1e812
AVS		 10542 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
10543 wowlan->max_nd_match_sets);
8cd4d456
LC		 10544 err = PTR_ERR_OR_ZERO(trig->nd_config);
10545 if (err)
10546 trig->nd_config = NULL;
10547
10548out:
10549 kfree(tb);
10550 return err;
10551}
10552
ff1b6e69
JB		 10553static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
10554{
10555 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10556 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
ff1b6e69 10557 struct cfg80211_wowlan new_triggers = {};
ae33bd81 10558 struct cfg80211_wowlan *ntrig;
964dc9e2 10559 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
ff1b6e69 10560 int err, i;
6abb9cb9 10561 bool prev_enabled = rdev->wiphy.wowlan_config;
98fc4386 10562 bool regular = false;
ff1b6e69 10563
964dc9e2 10564 if (!wowlan)
ff1b6e69
JB		 10565 return -EOPNOTSUPP;
10566
ae33bd81
JB		 10567 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
10568 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10569 rdev->wiphy.wowlan_config = NULL;
ae33bd81
JB		 10570 goto set_wakeup;
10571 }
ff1b6e69 10572
bfe2c7b1
JB		 10573 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
10574 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
fe52145f 10575 nl80211_wowlan_policy, info->extack);
ff1b6e69
JB		 10576 if (err)
10577 return err;
10578
10579 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
10580 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
10581 return -EINVAL;
10582 new_triggers.any = true;
10583 }
10584
10585 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
10586 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
10587 return -EINVAL;
10588 new_triggers.disconnect = true;
98fc4386 10589 regular = true;
ff1b6e69
JB		 10590 }
10591
10592 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
10593 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
10594 return -EINVAL;
10595 new_triggers.magic_pkt = true;
98fc4386 10596 regular = true;
ff1b6e69
JB		 10597 }
10598
77dbbb13
JB		 10599 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
10600 return -EINVAL;
10601
10602 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
10603 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
10604 return -EINVAL;
10605 new_triggers.gtk_rekey_failure = true;
98fc4386 10606 regular = true;
77dbbb13
JB		 10607 }
10608
10609 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
10610 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
10611 return -EINVAL;
10612 new_triggers.eap_identity_req = true;
98fc4386 10613 regular = true;
77dbbb13
JB		 10614 }
10615
10616 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
10617 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
10618 return -EINVAL;
10619 new_triggers.four_way_handshake = true;
98fc4386 10620 regular = true;
77dbbb13
JB		 10621 }
10622
10623 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
10624 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
10625 return -EINVAL;
10626 new_triggers.rfkill_release = true;
98fc4386 10627 regular = true;
77dbbb13
JB		 10628 }
10629
ff1b6e69
JB		 10630 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
10631 struct nlattr *pat;
10632 int n_patterns = 0;
bb92d199 10633 int rem, pat_len, mask_len, pkt_offset;
50ac6607 10634 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
ff1b6e69 10635
98fc4386
JB		 10636 regular = true;
10637
ff1b6e69
JB		 10638 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10639 rem)
10640 n_patterns++;
10641 if (n_patterns > wowlan->n_patterns)
10642 return -EINVAL;
10643
10644 new_triggers.patterns = kcalloc(n_patterns,
10645 sizeof(new_triggers.patterns[0]),
10646 GFP_KERNEL);
10647 if (!new_triggers.patterns)
10648 return -ENOMEM;
10649
10650 new_triggers.n_patterns = n_patterns;
10651 i = 0;
10652
10653 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10654 rem) {
922bd80f
JB		 10655 u8 *mask_pat;
10656
6d40e985
JB		 10657 err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
10658 nl80211_packet_pattern_policy,
10659 info->extack);
10660 if (err)
10661 goto error;
10662
ff1b6e69 10663 err = -EINVAL;
50ac6607
AK		 10664 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10665 !pat_tb[NL80211_PKTPAT_PATTERN])
ff1b6e69 10666 goto error;
50ac6607 10667 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
ff1b6e69 10668 mask_len = DIV_ROUND_UP(pat_len, 8);
50ac6607 10669 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
ff1b6e69
JB		 10670 goto error;
10671 if (pat_len > wowlan->pattern_max_len ||
10672 pat_len < wowlan->pattern_min_len)
10673 goto error;
10674
50ac6607 10675 if (!pat_tb[NL80211_PKTPAT_OFFSET])
bb92d199
AK		 10676 pkt_offset = 0;
10677 else
10678 pkt_offset = nla_get_u32(
50ac6607 10679 pat_tb[NL80211_PKTPAT_OFFSET]);
bb92d199
AK		 10680 if (pkt_offset > wowlan->max_pkt_offset)
10681 goto error;
10682 new_triggers.patterns[i].pkt_offset = pkt_offset;
10683
922bd80f
JB		 10684 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10685 if (!mask_pat) {
ff1b6e69
JB		 10686 err = -ENOMEM;
10687 goto error;
10688 }
922bd80f
JB		 10689 new_triggers.patterns[i].mask = mask_pat;
10690 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
ff1b6e69 10691 mask_len);
922bd80f
JB		 10692 mask_pat += mask_len;
10693 new_triggers.patterns[i].pattern = mask_pat;
ff1b6e69 10694 new_triggers.patterns[i].pattern_len = pat_len;
922bd80f 10695 memcpy(mask_pat,
50ac6607 10696 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
ff1b6e69
JB		 10697 pat_len);
10698 i++;
10699 }
10700 }
10701
2a0e047e 10702 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
98fc4386 10703 regular = true;
2a0e047e
JB		 10704 err = nl80211_parse_wowlan_tcp(
10705 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
10706 &new_triggers);
10707 if (err)
10708 goto error;
10709 }
10710
8cd4d456 10711 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
98fc4386 10712 regular = true;
8cd4d456
LC		 10713 err = nl80211_parse_wowlan_nd(
10714 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
10715 &new_triggers);
10716 if (err)
10717 goto error;
10718 }
10719
98fc4386
JB		 10720 /* The 'any' trigger means the device continues operating more or less
10721 * as in its normal operation mode and wakes up the host on most of the
10722 * normal interrupts (like packet RX, ...)
10723 * It therefore makes little sense to combine with the more constrained
10724 * wakeup trigger modes.
10725 */
10726 if (new_triggers.any && regular) {
10727 err = -EINVAL;
10728 goto error;
10729 }
10730
ae33bd81
JB		 10731 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
10732 if (!ntrig) {
10733 err = -ENOMEM;
10734 goto error;
ff1b6e69 10735 }
ae33bd81 10736 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10737 rdev->wiphy.wowlan_config = ntrig;
ff1b6e69 10738
ae33bd81 10739 set_wakeup:
6abb9cb9
JB		 10740 if (rdev->ops->set_wakeup &&
10741 prev_enabled != !!rdev->wiphy.wowlan_config)
10742 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
6d52563f 10743
ff1b6e69
JB		 10744 return 0;
10745 error:
10746 for (i = 0; i < new_triggers.n_patterns; i++)
10747 kfree(new_triggers.patterns[i].mask);
10748 kfree(new_triggers.patterns);
2a0e047e
JB		 10749 if (new_triggers.tcp && new_triggers.tcp->sock)
10750 sock_release(new_triggers.tcp->sock);
10751 kfree(new_triggers.tcp);
e5dbe070 10752 kfree(new_triggers.nd_config);
ff1b6e69
JB		 10753 return err;
10754}
dfb89c56 10755#endif
ff1b6e69 10756
be29b99a
AK		 10757static int nl80211_send_coalesce_rules(struct sk_buff *msg,
10758 struct cfg80211_registered_device *rdev)
10759{
10760 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
10761 int i, j, pat_len;
10762 struct cfg80211_coalesce_rules *rule;
10763
10764 if (!rdev->coalesce->n_rules)
10765 return 0;
10766
10767 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
10768 if (!nl_rules)
10769 return -ENOBUFS;
10770
10771 for (i = 0; i < rdev->coalesce->n_rules; i++) {
10772 nl_rule = nla_nest_start(msg, i + 1);
10773 if (!nl_rule)
10774 return -ENOBUFS;
10775
10776 rule = &rdev->coalesce->rules[i];
10777 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
10778 rule->delay))
10779 return -ENOBUFS;
10780
10781 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
10782 rule->condition))
10783 return -ENOBUFS;
10784
10785 nl_pats = nla_nest_start(msg,
10786 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
10787 if (!nl_pats)
10788 return -ENOBUFS;
10789
10790 for (j = 0; j < rule->n_patterns; j++) {
10791 nl_pat = nla_nest_start(msg, j + 1);
10792 if (!nl_pat)
10793 return -ENOBUFS;
10794 pat_len = rule->patterns[j].pattern_len;
10795 if (nla_put(msg, NL80211_PKTPAT_MASK,
10796 DIV_ROUND_UP(pat_len, 8),
10797 rule->patterns[j].mask) ||
10798 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10799 rule->patterns[j].pattern) ||
10800 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
10801 rule->patterns[j].pkt_offset))
10802 return -ENOBUFS;
10803 nla_nest_end(msg, nl_pat);
10804 }
10805 nla_nest_end(msg, nl_pats);
10806 nla_nest_end(msg, nl_rule);
10807 }
10808 nla_nest_end(msg, nl_rules);
10809
10810 return 0;
10811}
10812
10813static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
10814{
10815 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10816 struct sk_buff *msg;
10817 void *hdr;
10818
10819 if (!rdev->wiphy.coalesce)
10820 return -EOPNOTSUPP;
10821
10822 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10823 if (!msg)
10824 return -ENOMEM;
10825
10826 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10827 NL80211_CMD_GET_COALESCE);
10828 if (!hdr)
10829 goto nla_put_failure;
10830
10831 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
10832 goto nla_put_failure;
10833
10834 genlmsg_end(msg, hdr);
10835 return genlmsg_reply(msg, info);
10836
10837nla_put_failure:
10838 nlmsg_free(msg);
10839 return -ENOBUFS;
10840}
10841
10842void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
10843{
10844 struct cfg80211_coalesce *coalesce = rdev->coalesce;
10845 int i, j;
10846 struct cfg80211_coalesce_rules *rule;
10847
10848 if (!coalesce)
10849 return;
10850
10851 for (i = 0; i < coalesce->n_rules; i++) {
10852 rule = &coalesce->rules[i];
10853 for (j = 0; j < rule->n_patterns; j++)
10854 kfree(rule->patterns[j].mask);
10855 kfree(rule->patterns);
10856 }
10857 kfree(coalesce->rules);
10858 kfree(coalesce);
10859 rdev->coalesce = NULL;
10860}
10861
10862static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
10863 struct nlattr *rule,
10864 struct cfg80211_coalesce_rules *new_rule)
10865{
10866 int err, i;
10867 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10868 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
10869 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
10870 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
10871
bfe2c7b1 10872 err = nla_parse_nested(tb, NL80211_ATTR_COALESCE_RULE_MAX, rule,
fceb6435 10873 nl80211_coalesce_policy, NULL);
be29b99a
AK		 10874 if (err)
10875 return err;
10876
10877 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
10878 new_rule->delay =
10879 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
10880 if (new_rule->delay > coalesce->max_delay)
10881 return -EINVAL;
10882
10883 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
10884 new_rule->condition =
10885 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
10886 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
10887 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
10888 return -EINVAL;
10889
10890 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
10891 return -EINVAL;
10892
10893 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10894 rem)
10895 n_patterns++;
10896 if (n_patterns > coalesce->n_patterns)
10897 return -EINVAL;
10898
10899 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
10900 GFP_KERNEL);
10901 if (!new_rule->patterns)
10902 return -ENOMEM;
10903
10904 new_rule->n_patterns = n_patterns;
10905 i = 0;
10906
10907 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10908 rem) {
922bd80f
JB		 10909 u8 *mask_pat;
10910
6d40e985
JB		 10911 err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
10912 nl80211_packet_pattern_policy, NULL);
10913 if (err)
10914 return err;
10915
be29b99a
AK		 10916 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10917 !pat_tb[NL80211_PKTPAT_PATTERN])
10918 return -EINVAL;
10919 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
10920 mask_len = DIV_ROUND_UP(pat_len, 8);
10921 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
10922 return -EINVAL;
10923 if (pat_len > coalesce->pattern_max_len ||
10924 pat_len < coalesce->pattern_min_len)
10925 return -EINVAL;
10926
10927 if (!pat_tb[NL80211_PKTPAT_OFFSET])
10928 pkt_offset = 0;
10929 else
10930 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
10931 if (pkt_offset > coalesce->max_pkt_offset)
10932 return -EINVAL;
10933 new_rule->patterns[i].pkt_offset = pkt_offset;
10934
922bd80f
JB		 10935 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10936 if (!mask_pat)
be29b99a 10937 return -ENOMEM;
922bd80f
JB		 10938
10939 new_rule->patterns[i].mask = mask_pat;
10940 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
10941 mask_len);
10942
10943 mask_pat += mask_len;
10944 new_rule->patterns[i].pattern = mask_pat;
be29b99a 10945 new_rule->patterns[i].pattern_len = pat_len;
922bd80f
JB		 10946 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
10947 pat_len);
be29b99a
AK		 10948 i++;
10949 }
10950
10951 return 0;
10952}
10953
10954static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
10955{
10956 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10957 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10958 struct cfg80211_coalesce new_coalesce = {};
10959 struct cfg80211_coalesce *n_coalesce;
10960 int err, rem_rule, n_rules = 0, i, j;
10961 struct nlattr *rule;
10962 struct cfg80211_coalesce_rules *tmp_rule;
10963
10964 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
10965 return -EOPNOTSUPP;
10966
10967 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
10968 cfg80211_rdev_free_coalesce(rdev);
a1056b1b 10969 rdev_set_coalesce(rdev, NULL);
be29b99a
AK		 10970 return 0;
10971 }
10972
10973 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10974 rem_rule)
10975 n_rules++;
10976 if (n_rules > coalesce->n_rules)
10977 return -EINVAL;
10978
10979 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
10980 GFP_KERNEL);
10981 if (!new_coalesce.rules)
10982 return -ENOMEM;
10983
10984 new_coalesce.n_rules = n_rules;
10985 i = 0;
10986
10987 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10988 rem_rule) {
10989 err = nl80211_parse_coalesce_rule(rdev, rule,
10990 &new_coalesce.rules[i]);
10991 if (err)
10992 goto error;
10993
10994 i++;
10995 }
10996
a1056b1b 10997 err = rdev_set_coalesce(rdev, &new_coalesce);
be29b99a
AK		 10998 if (err)
10999 goto error;
11000
11001 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
11002 if (!n_coalesce) {
11003 err = -ENOMEM;
11004 goto error;
11005 }
11006 cfg80211_rdev_free_coalesce(rdev);
11007 rdev->coalesce = n_coalesce;
11008
11009 return 0;
11010error:
11011 for (i = 0; i < new_coalesce.n_rules; i++) {
11012 tmp_rule = &new_coalesce.rules[i];
11013 for (j = 0; j < tmp_rule->n_patterns; j++)
11014 kfree(tmp_rule->patterns[j].mask);
11015 kfree(tmp_rule->patterns);
11016 }
11017 kfree(new_coalesce.rules);
11018
11019 return err;
11020}
11021
e5497d76
JB		 11022static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
11023{
11024 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11025 struct net_device *dev = info->user_ptr[1];
11026 struct wireless_dev *wdev = dev->ieee80211_ptr;
11027 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
11028 struct cfg80211_gtk_rekey_data rekey_data;
11029 int err;
11030
11031 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
11032 return -EINVAL;
11033
bfe2c7b1
JB		 11034 err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
11035 info->attrs[NL80211_ATTR_REKEY_DATA],
fe52145f 11036 nl80211_rekey_policy, info->extack);
e5497d76
JB		 11037 if (err)
11038 return err;
11039
e785fa0a
VD		 11040 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
11041 !tb[NL80211_REKEY_DATA_KCK])
11042 return -EINVAL;
e5497d76
JB		 11043 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
11044 return -ERANGE;
11045 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
11046 return -ERANGE;
11047 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
11048 return -ERANGE;
11049
78f686ca
JB		 11050 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
11051 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
11052 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
e5497d76
JB		 11053
11054 wdev_lock(wdev);
11055 if (!wdev->current_bss) {
11056 err = -ENOTCONN;
11057 goto out;
11058 }
11059
11060 if (!rdev->ops->set_rekey_data) {
11061 err = -EOPNOTSUPP;
11062 goto out;
11063 }
11064
e35e4d28 11065 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
e5497d76
JB		 11066 out:
11067 wdev_unlock(wdev);
11068 return err;
11069}
11070
28946da7
JB		 11071static int nl80211_register_unexpected_frame(struct sk_buff *skb,
11072 struct genl_info *info)
11073{
11074 struct net_device *dev = info->user_ptr[1];
11075 struct wireless_dev *wdev = dev->ieee80211_ptr;
11076
11077 if (wdev->iftype != NL80211_IFTYPE_AP &&
11078 wdev->iftype != NL80211_IFTYPE_P2P_GO)
11079 return -EINVAL;
11080
15e47304 11081 if (wdev->ap_unexpected_nlportid)
28946da7
JB		 11082 return -EBUSY;
11083
15e47304 11084 wdev->ap_unexpected_nlportid = info->snd_portid;
28946da7
JB		 11085 return 0;
11086}
11087
7f6cf311
JB		 11088static int nl80211_probe_client(struct sk_buff *skb,
11089 struct genl_info *info)
11090{
11091 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11092 struct net_device *dev = info->user_ptr[1];
11093 struct wireless_dev *wdev = dev->ieee80211_ptr;
11094 struct sk_buff *msg;
11095 void *hdr;
11096 const u8 *addr;
11097 u64 cookie;
11098 int err;
11099
11100 if (wdev->iftype != NL80211_IFTYPE_AP &&
11101 wdev->iftype != NL80211_IFTYPE_P2P_GO)
11102 return -EOPNOTSUPP;
11103
11104 if (!info->attrs[NL80211_ATTR_MAC])
11105 return -EINVAL;
11106
11107 if (!rdev->ops->probe_client)
11108 return -EOPNOTSUPP;
11109
11110 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11111 if (!msg)
11112 return -ENOMEM;
11113
15e47304 11114 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7f6cf311 11115 NL80211_CMD_PROBE_CLIENT);
cb35fba3
DC		 11116 if (!hdr) {
11117 err = -ENOBUFS;
7f6cf311
JB		 11118 goto free_msg;
11119 }
11120
11121 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
11122
e35e4d28 11123 err = rdev_probe_client(rdev, dev, addr, &cookie);
7f6cf311
JB		 11124 if (err)
11125 goto free_msg;
11126
2dad624e
ND		 11127 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11128 NL80211_ATTR_PAD))
9360ffd1 11129 goto nla_put_failure;
7f6cf311
JB		 11130
11131 genlmsg_end(msg, hdr);
11132
11133 return genlmsg_reply(msg, info);
11134
11135 nla_put_failure:
11136 err = -ENOBUFS;
11137 free_msg:
11138 nlmsg_free(msg);
11139 return err;
11140}
11141
5e760230
JB		 11142static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
11143{
11144 struct cfg80211_registered_device *rdev = info->user_ptr[0];
37c73b5f
BG		 11145 struct cfg80211_beacon_registration *reg, *nreg;
11146 int rv;
5e760230
JB		 11147
11148 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
11149 return -EOPNOTSUPP;
11150
37c73b5f
BG		 11151 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
11152 if (!nreg)
11153 return -ENOMEM;
11154
11155 /* First, check if already registered. */
11156 spin_lock_bh(&rdev->beacon_registrations_lock);
11157 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
11158 if (reg->nlportid == info->snd_portid) {
11159 rv = -EALREADY;
11160 goto out_err;
11161 }
11162 }
11163 /* Add it to the list */
11164 nreg->nlportid = info->snd_portid;
11165 list_add(&nreg->list, &rdev->beacon_registrations);
5e760230 11166
37c73b5f 11167 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 11168
11169 return 0;
37c73b5f
BG		 11170out_err:
11171 spin_unlock_bh(&rdev->beacon_registrations_lock);
11172 kfree(nreg);
11173 return rv;
5e760230
JB		 11174}
11175
98104fde
JB		 11176static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
11177{
11178 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11179 struct wireless_dev *wdev = info->user_ptr[1];
11180 int err;
11181
11182 if (!rdev->ops->start_p2p_device)
11183 return -EOPNOTSUPP;
11184
11185 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11186 return -EOPNOTSUPP;
11187
73c7da3d 11188 if (wdev_running(wdev))
98104fde
JB		 11189 return 0;
11190
b6a55015
LC		 11191 if (rfkill_blocked(rdev->rfkill))
11192 return -ERFKILL;
98104fde 11193
eeb126e9 11194 err = rdev_start_p2p_device(rdev, wdev);
98104fde
JB		 11195 if (err)
11196 return err;
11197
73c7da3d 11198 wdev->is_running = true;
98104fde 11199 rdev->opencount++;
98104fde
JB		 11200
11201 return 0;
11202}
11203
11204static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
11205{
11206 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11207 struct wireless_dev *wdev = info->user_ptr[1];
11208
11209 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11210 return -EOPNOTSUPP;
11211
11212 if (!rdev->ops->stop_p2p_device)
11213 return -EOPNOTSUPP;
11214
f9f47529 11215 cfg80211_stop_p2p_device(rdev, wdev);
98104fde
JB		 11216
11217 return 0;
11218}
11219
cb3b7d87
AB		 11220static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
11221{
11222 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11223 struct wireless_dev *wdev = info->user_ptr[1];
11224 struct cfg80211_nan_conf conf = {};
11225 int err;
11226
11227 if (wdev->iftype != NL80211_IFTYPE_NAN)
11228 return -EOPNOTSUPP;
11229
eeb04a96 11230 if (wdev_running(wdev))
cb3b7d87
AB		 11231 return -EEXIST;
11232
11233 if (rfkill_blocked(rdev->rfkill))
11234 return -ERFKILL;
11235
11236 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
11237 return -EINVAL;
11238
cb3b7d87
AB		 11239 conf.master_pref =
11240 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11241 if (!conf.master_pref)
11242 return -EINVAL;
11243
8585989d
LC		 11244 if (info->attrs[NL80211_ATTR_BANDS]) {
11245 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11246
11247 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11248 return -EOPNOTSUPP;
11249
11250 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11251 return -EINVAL;
11252
11253 conf.bands = bands;
11254 }
cb3b7d87
AB		 11255
11256 err = rdev_start_nan(rdev, wdev, &conf);
11257 if (err)
11258 return err;
11259
73c7da3d 11260 wdev->is_running = true;
cb3b7d87
AB		 11261 rdev->opencount++;
11262
11263 return 0;
11264}
11265
11266static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
11267{
11268 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11269 struct wireless_dev *wdev = info->user_ptr[1];
11270
11271 if (wdev->iftype != NL80211_IFTYPE_NAN)
11272 return -EOPNOTSUPP;
11273
11274 cfg80211_stop_nan(rdev, wdev);
11275
11276 return 0;
11277}
11278
a442b761
AB		 11279static int validate_nan_filter(struct nlattr *filter_attr)
11280{
11281 struct nlattr *attr;
11282 int len = 0, n_entries = 0, rem;
11283
11284 nla_for_each_nested(attr, filter_attr, rem) {
11285 len += nla_len(attr);
11286 n_entries++;
11287 }
11288
11289 if (len >= U8_MAX)
11290 return -EINVAL;
11291
11292 return n_entries;
11293}
11294
11295static int handle_nan_filter(struct nlattr *attr_filter,
11296 struct cfg80211_nan_func *func,
11297 bool tx)
11298{
11299 struct nlattr *attr;
11300 int n_entries, rem, i;
11301 struct cfg80211_nan_func_filter *filter;
11302
11303 n_entries = validate_nan_filter(attr_filter);
11304 if (n_entries < 0)
11305 return n_entries;
11306
11307 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
11308
11309 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
11310 if (!filter)
11311 return -ENOMEM;
11312
11313 i = 0;
11314 nla_for_each_nested(attr, attr_filter, rem) {
b15ca182 11315 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
a442b761
AB		 11316 filter[i].len = nla_len(attr);
11317 i++;
11318 }
11319 if (tx) {
11320 func->num_tx_filters = n_entries;
11321 func->tx_filters = filter;
11322 } else {
11323 func->num_rx_filters = n_entries;
11324 func->rx_filters = filter;
11325 }
11326
11327 return 0;
11328}
11329
11330static int nl80211_nan_add_func(struct sk_buff *skb,
11331 struct genl_info *info)
11332{
11333 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11334 struct wireless_dev *wdev = info->user_ptr[1];
11335 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
11336 struct cfg80211_nan_func *func;
11337 struct sk_buff *msg = NULL;
11338 void *hdr = NULL;
11339 int err = 0;
11340
11341 if (wdev->iftype != NL80211_IFTYPE_NAN)
11342 return -EOPNOTSUPP;
11343
73c7da3d 11344 if (!wdev_running(wdev))
a442b761
AB		 11345 return -ENOTCONN;
11346
11347 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
11348 return -EINVAL;
11349
bfe2c7b1
JB		 11350 err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
11351 info->attrs[NL80211_ATTR_NAN_FUNC],
fe52145f 11352 nl80211_nan_func_policy, info->extack);
a442b761
AB		 11353 if (err)
11354 return err;
11355
11356 func = kzalloc(sizeof(*func), GFP_KERNEL);
11357 if (!func)
11358 return -ENOMEM;
11359
11360 func->cookie = wdev->wiphy->cookie_counter++;
11361
11362 if (!tb[NL80211_NAN_FUNC_TYPE] ||
11363 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
11364 err = -EINVAL;
11365 goto out;
11366 }
11367
11368
11369 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
11370
11371 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
11372 err = -EINVAL;
11373 goto out;
11374 }
11375
11376 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
11377 sizeof(func->service_id));
11378
11379 func->close_range =
11380 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
11381
11382 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
11383 func->serv_spec_info_len =
11384 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
11385 func->serv_spec_info =
11386 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
11387 func->serv_spec_info_len,
11388 GFP_KERNEL);
11389 if (!func->serv_spec_info) {
11390 err = -ENOMEM;
11391 goto out;
11392 }
11393 }
11394
11395 if (tb[NL80211_NAN_FUNC_TTL])
11396 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
11397
11398 switch (func->type) {
11399 case NL80211_NAN_FUNC_PUBLISH:
11400 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
11401 err = -EINVAL;
11402 goto out;
11403 }
11404
11405 func->publish_type =
11406 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
11407 func->publish_bcast =
11408 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
11409
11410 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
11411 func->publish_bcast) {
11412 err = -EINVAL;
11413 goto out;
11414 }
11415 break;
11416 case NL80211_NAN_FUNC_SUBSCRIBE:
11417 func->subscribe_active =
11418 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
11419 break;
11420 case NL80211_NAN_FUNC_FOLLOW_UP:
11421 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
3ea15452
HC		 11422 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
11423 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
a442b761
AB		 11424 err = -EINVAL;
11425 goto out;
11426 }
11427
11428 func->followup_id =
11429 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
11430 func->followup_reqid =
11431 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
11432 memcpy(func->followup_dest.addr,
11433 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
11434 sizeof(func->followup_dest.addr));
11435 if (func->ttl) {
11436 err = -EINVAL;
11437 goto out;
11438 }
11439 break;
11440 default:
11441 err = -EINVAL;
11442 goto out;
11443 }
11444
11445 if (tb[NL80211_NAN_FUNC_SRF]) {
11446 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
11447
bfe2c7b1
JB		 11448 err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
11449 tb[NL80211_NAN_FUNC_SRF],
fe52145f 11450 nl80211_nan_srf_policy, info->extack);
a442b761
AB		 11451 if (err)
11452 goto out;
11453
11454 func->srf_include =
11455 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
11456
11457 if (srf_tb[NL80211_NAN_SRF_BF]) {
11458 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
11459 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
11460 err = -EINVAL;
11461 goto out;
11462 }
11463
11464 func->srf_bf_len =
11465 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
11466 func->srf_bf =
11467 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
11468 func->srf_bf_len, GFP_KERNEL);
11469 if (!func->srf_bf) {
11470 err = -ENOMEM;
11471 goto out;
11472 }
11473
11474 func->srf_bf_idx =
11475 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
11476 } else {
11477 struct nlattr *attr, *mac_attr =
11478 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
11479 int n_entries, rem, i = 0;
11480
11481 if (!mac_attr) {
11482 err = -EINVAL;
11483 goto out;
11484 }
11485
11486 n_entries = validate_acl_mac_addrs(mac_attr);
11487 if (n_entries <= 0) {
11488 err = -EINVAL;
11489 goto out;
11490 }
11491
11492 func->srf_num_macs = n_entries;
11493 func->srf_macs =
11494 kzalloc(sizeof(*func->srf_macs) * n_entries,
11495 GFP_KERNEL);
11496 if (!func->srf_macs) {
11497 err = -ENOMEM;
11498 goto out;
11499 }
11500
11501 nla_for_each_nested(attr, mac_attr, rem)
11502 memcpy(func->srf_macs[i++].addr, nla_data(attr),
11503 sizeof(*func->srf_macs));
11504 }
11505 }
11506
11507 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
11508 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
11509 func, true);
11510 if (err)
11511 goto out;
11512 }
11513
11514 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
11515 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
11516 func, false);
11517 if (err)
11518 goto out;
11519 }
11520
11521 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11522 if (!msg) {
11523 err = -ENOMEM;
11524 goto out;
11525 }
11526
11527 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11528 NL80211_CMD_ADD_NAN_FUNCTION);
11529 /* This can't really happen - we just allocated 4KB */
11530 if (WARN_ON(!hdr)) {
11531 err = -ENOMEM;
11532 goto out;
11533 }
11534
11535 err = rdev_add_nan_func(rdev, wdev, func);
11536out:
11537 if (err < 0) {
11538 cfg80211_free_nan_func(func);
11539 nlmsg_free(msg);
11540 return err;
11541 }
11542
11543 /* propagate the instance id and cookie to userspace */
11544 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
11545 NL80211_ATTR_PAD))
11546 goto nla_put_failure;
11547
11548 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11549 if (!func_attr)
11550 goto nla_put_failure;
11551
11552 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
11553 func->instance_id))
11554 goto nla_put_failure;
11555
11556 nla_nest_end(msg, func_attr);
11557
11558 genlmsg_end(msg, hdr);
11559 return genlmsg_reply(msg, info);
11560
11561nla_put_failure:
11562 nlmsg_free(msg);
11563 return -ENOBUFS;
11564}
11565
11566static int nl80211_nan_del_func(struct sk_buff *skb,
11567 struct genl_info *info)
11568{
11569 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11570 struct wireless_dev *wdev = info->user_ptr[1];
11571 u64 cookie;
11572
11573 if (wdev->iftype != NL80211_IFTYPE_NAN)
11574 return -EOPNOTSUPP;
11575
73c7da3d 11576 if (!wdev_running(wdev))
a442b761
AB		 11577 return -ENOTCONN;
11578
11579 if (!info->attrs[NL80211_ATTR_COOKIE])
11580 return -EINVAL;
11581
a442b761
AB		 11582 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11583
11584 rdev_del_nan_func(rdev, wdev, cookie);
11585
11586 return 0;
11587}
11588
a5a9dcf2
AB		 11589static int nl80211_nan_change_config(struct sk_buff *skb,
11590 struct genl_info *info)
11591{
11592 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11593 struct wireless_dev *wdev = info->user_ptr[1];
11594 struct cfg80211_nan_conf conf = {};
11595 u32 changed = 0;
11596
11597 if (wdev->iftype != NL80211_IFTYPE_NAN)
11598 return -EOPNOTSUPP;
11599
73c7da3d 11600 if (!wdev_running(wdev))
a5a9dcf2
AB		 11601 return -ENOTCONN;
11602
11603 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
11604 conf.master_pref =
11605 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11606 if (conf.master_pref <= 1 || conf.master_pref == 255)
11607 return -EINVAL;
11608
11609 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
11610 }
11611
8585989d
LC		 11612 if (info->attrs[NL80211_ATTR_BANDS]) {
11613 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11614
11615 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11616 return -EOPNOTSUPP;
11617
11618 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11619 return -EINVAL;
11620
11621 conf.bands = bands;
11622 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
a5a9dcf2
AB		 11623 }
11624
11625 if (!changed)
11626 return -EINVAL;
11627
11628 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
11629}
11630
50bcd31d
AB		 11631void cfg80211_nan_match(struct wireless_dev *wdev,
11632 struct cfg80211_nan_match_params *match, gfp_t gfp)
11633{
11634 struct wiphy *wiphy = wdev->wiphy;
11635 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11636 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
11637 struct sk_buff *msg;
11638 void *hdr;
11639
11640 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
11641 return;
11642
11643 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11644 if (!msg)
11645 return;
11646
11647 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
11648 if (!hdr) {
11649 nlmsg_free(msg);
11650 return;
11651 }
11652
11653 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11654 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11655 wdev->netdev->ifindex)) ||
11656 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11657 NL80211_ATTR_PAD))
11658 goto nla_put_failure;
11659
11660 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
11661 NL80211_ATTR_PAD) ||
11662 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
11663 goto nla_put_failure;
11664
11665 match_attr = nla_nest_start(msg, NL80211_ATTR_NAN_MATCH);
11666 if (!match_attr)
11667 goto nla_put_failure;
11668
11669 local_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_LOCAL);
11670 if (!local_func_attr)
11671 goto nla_put_failure;
11672
11673 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
11674 goto nla_put_failure;
11675
11676 nla_nest_end(msg, local_func_attr);
11677
11678 peer_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_PEER);
11679 if (!peer_func_attr)
11680 goto nla_put_failure;
11681
11682 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
11683 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
11684 goto nla_put_failure;
11685
11686 if (match->info && match->info_len &&
11687 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
11688 match->info))
11689 goto nla_put_failure;
11690
11691 nla_nest_end(msg, peer_func_attr);
11692 nla_nest_end(msg, match_attr);
11693 genlmsg_end(msg, hdr);
11694
11695 if (!wdev->owner_nlportid)
11696 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11697 msg, 0, NL80211_MCGRP_NAN, gfp);
11698 else
11699 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11700 wdev->owner_nlportid);
11701
11702 return;
11703
11704nla_put_failure:
11705 nlmsg_free(msg);
11706}
11707EXPORT_SYMBOL(cfg80211_nan_match);
11708
368e5a7b
AB		 11709void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
11710 u8 inst_id,
11711 enum nl80211_nan_func_term_reason reason,
11712 u64 cookie, gfp_t gfp)
11713{
11714 struct wiphy *wiphy = wdev->wiphy;
11715 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11716 struct sk_buff *msg;
11717 struct nlattr *func_attr;
11718 void *hdr;
11719
11720 if (WARN_ON(!inst_id))
11721 return;
11722
11723 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11724 if (!msg)
11725 return;
11726
11727 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
11728 if (!hdr) {
11729 nlmsg_free(msg);
11730 return;
11731 }
11732
11733 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11734 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11735 wdev->netdev->ifindex)) ||
11736 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11737 NL80211_ATTR_PAD))
11738 goto nla_put_failure;
11739
11740 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11741 NL80211_ATTR_PAD))
11742 goto nla_put_failure;
11743
11744 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11745 if (!func_attr)
11746 goto nla_put_failure;
11747
11748 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
11749 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
11750 goto nla_put_failure;
11751
11752 nla_nest_end(msg, func_attr);
11753 genlmsg_end(msg, hdr);
11754
11755 if (!wdev->owner_nlportid)
11756 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11757 msg, 0, NL80211_MCGRP_NAN, gfp);
11758 else
11759 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11760 wdev->owner_nlportid);
11761
11762 return;
11763
11764nla_put_failure:
11765 nlmsg_free(msg);
11766}
11767EXPORT_SYMBOL(cfg80211_nan_func_terminated);
11768
3713b4e3
JB		 11769static int nl80211_get_protocol_features(struct sk_buff *skb,
11770 struct genl_info *info)
11771{
11772 void *hdr;
11773 struct sk_buff *msg;
11774
11775 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11776 if (!msg)
11777 return -ENOMEM;
11778
11779 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11780 NL80211_CMD_GET_PROTOCOL_FEATURES);
11781 if (!hdr)
11782 goto nla_put_failure;
11783
11784 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
11785 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
11786 goto nla_put_failure;
11787
11788 genlmsg_end(msg, hdr);
11789 return genlmsg_reply(msg, info);
11790
11791 nla_put_failure:
11792 kfree_skb(msg);
11793 return -ENOBUFS;
11794}
11795
355199e0
JM		 11796static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
11797{
11798 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11799 struct cfg80211_update_ft_ies_params ft_params;
11800 struct net_device *dev = info->user_ptr[1];
11801
11802 if (!rdev->ops->update_ft_ies)
11803 return -EOPNOTSUPP;
11804
11805 if (!info->attrs[NL80211_ATTR_MDID] ||
3f6d3db5 11806 !info->attrs[NL80211_ATTR_IE] ||
355199e0
JM		 11807 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
11808 return -EINVAL;
11809
11810 memset(&ft_params, 0, sizeof(ft_params));
11811 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
11812 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11813 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11814
11815 return rdev_update_ft_ies(rdev, dev, &ft_params);
11816}
11817
5de17984
AS		 11818static int nl80211_crit_protocol_start(struct sk_buff *skb,
11819 struct genl_info *info)
11820{
11821 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11822 struct wireless_dev *wdev = info->user_ptr[1];
11823 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
11824 u16 duration;
11825 int ret;
11826
11827 if (!rdev->ops->crit_proto_start)
11828 return -EOPNOTSUPP;
11829
11830 if (WARN_ON(!rdev->ops->crit_proto_stop))
11831 return -EINVAL;
11832
11833 if (rdev->crit_proto_nlportid)
11834 return -EBUSY;
11835
11836 /* determine protocol if provided */
11837 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
11838 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
11839
11840 if (proto >= NUM_NL80211_CRIT_PROTO)
11841 return -EINVAL;
11842
11843 /* timeout must be provided */
11844 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
11845 return -EINVAL;
11846
11847 duration =
11848 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
11849
11850 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
11851 return -ERANGE;
11852
11853 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
11854 if (!ret)
11855 rdev->crit_proto_nlportid = info->snd_portid;
11856
11857 return ret;
11858}
11859
11860static int nl80211_crit_protocol_stop(struct sk_buff *skb,
11861 struct genl_info *info)
11862{
11863 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11864 struct wireless_dev *wdev = info->user_ptr[1];
11865
11866 if (!rdev->ops->crit_proto_stop)
11867 return -EOPNOTSUPP;
11868
11869 if (rdev->crit_proto_nlportid) {
11870 rdev->crit_proto_nlportid = 0;
11871 rdev_crit_proto_stop(rdev, wdev);
11872 }
11873 return 0;
11874}
11875
ad7e718c
JB		 11876static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
11877{
11878 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11879 struct wireless_dev *wdev =
11880 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
11881 int i, err;
11882 u32 vid, subcmd;
11883
11884 if (!rdev->wiphy.vendor_commands)
11885 return -EOPNOTSUPP;
11886
11887 if (IS_ERR(wdev)) {
11888 err = PTR_ERR(wdev);
11889 if (err != -EINVAL)
11890 return err;
11891 wdev = NULL;
11892 } else if (wdev->wiphy != &rdev->wiphy) {
11893 return -EINVAL;
11894 }
11895
11896 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
11897 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
11898 return -EINVAL;
11899
11900 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
11901 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
11902 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
11903 const struct wiphy_vendor_command *vcmd;
11904 void *data = NULL;
11905 int len = 0;
11906
11907 vcmd = &rdev->wiphy.vendor_commands[i];
11908
11909 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11910 continue;
11911
11912 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11913 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
11914 if (!wdev)
11915 return -EINVAL;
11916 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
11917 !wdev->netdev)
11918 return -EINVAL;
11919
11920 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
73c7da3d 11921 if (!wdev_running(wdev))
ad7e718c
JB		 11922 return -ENETDOWN;
11923 }
7bdbe400
JB		 11924
11925 if (!vcmd->doit)
11926 return -EOPNOTSUPP;
ad7e718c
JB		 11927 } else {
11928 wdev = NULL;
11929 }
11930
11931 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
11932 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11933 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11934 }
11935
11936 rdev->cur_cmd_info = info;
11937 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
11938 data, len);
11939 rdev->cur_cmd_info = NULL;
11940 return err;
11941 }
11942
11943 return -EOPNOTSUPP;
11944}
11945
7bdbe400
JB		 11946static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
11947 struct netlink_callback *cb,
11948 struct cfg80211_registered_device **rdev,
11949 struct wireless_dev **wdev)
11950{
c90c39da 11951 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
7bdbe400
JB		 11952 u32 vid, subcmd;
11953 unsigned int i;
11954 int vcmd_idx = -1;
11955 int err;
11956 void *data = NULL;
11957 unsigned int data_len = 0;
11958
7bdbe400
JB		 11959 if (cb->args[0]) {
11960 /* subtract the 1 again here */
11961 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
11962 struct wireless_dev *tmp;
11963
ea90e0dc
JB		 11964 if (!wiphy)
11965 return -ENODEV;
7bdbe400
JB		 11966 *rdev = wiphy_to_rdev(wiphy);
11967 *wdev = NULL;
11968
11969 if (cb->args[1]) {
53873f13 11970 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
7bdbe400
JB		 11971 if (tmp->identifier == cb->args[1] - 1) {
11972 *wdev = tmp;
11973 break;
11974 }
11975 }
11976 }
11977
11978 /* keep rtnl locked in successful case */
11979 return 0;
11980 }
11981
fceb6435
JB		 11982 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, attrbuf,
11983 nl80211_fam.maxattr, nl80211_policy, NULL);
7bdbe400 11984 if (err)
ea90e0dc 11985 return err;
7bdbe400 11986
c90c39da 11987 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
ea90e0dc
JB		 11988 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD])
11989 return -EINVAL;
7bdbe400 11990
c90c39da 11991 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
7bdbe400
JB		 11992 if (IS_ERR(*wdev))
11993 *wdev = NULL;
11994
c90c39da 11995 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
ea90e0dc
JB		 11996 if (IS_ERR(*rdev))
11997 return PTR_ERR(*rdev);
7bdbe400 11998
c90c39da
JB		 11999 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
12000 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
7bdbe400
JB		 12001
12002 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
12003 const struct wiphy_vendor_command *vcmd;
12004
12005 vcmd = &(*rdev)->wiphy.vendor_commands[i];
12006
12007 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
12008 continue;
12009
ea90e0dc
JB		 12010 if (!vcmd->dumpit)
12011 return -EOPNOTSUPP;
7bdbe400
JB		 12012
12013 vcmd_idx = i;
12014 break;
12015 }
12016
ea90e0dc
JB		 12017 if (vcmd_idx < 0)
12018 return -EOPNOTSUPP;
7bdbe400 12019
c90c39da
JB		 12020 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
12021 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
12022 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
7bdbe400
JB		 12023 }
12024
12025 /* 0 is the first index - add 1 to parse only once */
12026 cb->args[0] = (*rdev)->wiphy_idx + 1;
12027 /* add 1 to know if it was NULL */
12028 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
12029 cb->args[2] = vcmd_idx;
12030 cb->args[3] = (unsigned long)data;
12031 cb->args[4] = data_len;
12032
12033 /* keep rtnl locked in successful case */
12034 return 0;
7bdbe400
JB		 12035}
12036
12037static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
12038 struct netlink_callback *cb)
12039{
12040 struct cfg80211_registered_device *rdev;
12041 struct wireless_dev *wdev;
12042 unsigned int vcmd_idx;
12043 const struct wiphy_vendor_command *vcmd;
12044 void *data;
12045 int data_len;
12046 int err;
12047 struct nlattr *vendor_data;
12048
ea90e0dc 12049 rtnl_lock();
7bdbe400
JB		 12050 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
12051 if (err)
ea90e0dc 12052 goto out;
7bdbe400
JB		 12053
12054 vcmd_idx = cb->args[2];
12055 data = (void *)cb->args[3];
12056 data_len = cb->args[4];
12057 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
12058
12059 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
12060 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
ea90e0dc
JB		 12061 if (!wdev) {
12062 err = -EINVAL;
12063 goto out;
12064 }
7bdbe400 12065 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
ea90e0dc
JB		 12066 !wdev->netdev) {
12067 err = -EINVAL;
12068 goto out;
12069 }
7bdbe400
JB		 12070
12071 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
ea90e0dc
JB		 12072 if (!wdev_running(wdev)) {
12073 err = -ENETDOWN;
12074 goto out;
12075 }
7bdbe400
JB		 12076 }
12077 }
12078
12079 while (1) {
12080 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
12081 cb->nlh->nlmsg_seq, NLM_F_MULTI,
12082 NL80211_CMD_VENDOR);
12083 if (!hdr)
12084 break;
12085
12086 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 12087 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
12088 wdev_id(wdev),
12089 NL80211_ATTR_PAD))) {
7bdbe400
JB		 12090 genlmsg_cancel(skb, hdr);
12091 break;
12092 }
12093
12094 vendor_data = nla_nest_start(skb, NL80211_ATTR_VENDOR_DATA);
12095 if (!vendor_data) {
12096 genlmsg_cancel(skb, hdr);
12097 break;
12098 }
12099
12100 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
12101 (unsigned long *)&cb->args[5]);
12102 nla_nest_end(skb, vendor_data);
12103
12104 if (err == -ENOBUFS || err == -ENOENT) {
12105 genlmsg_cancel(skb, hdr);
12106 break;
12107 } else if (err) {
12108 genlmsg_cancel(skb, hdr);
12109 goto out;
12110 }
12111
12112 genlmsg_end(skb, hdr);
12113 }
12114
12115 err = skb->len;
12116 out:
12117 rtnl_unlock();
12118 return err;
12119}
12120
ad7e718c
JB		 12121struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
12122 enum nl80211_commands cmd,
12123 enum nl80211_attrs attr,
12124 int approxlen)
12125{
f26cbf40 12126 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ad7e718c
JB		 12127
12128 if (WARN_ON(!rdev->cur_cmd_info))
12129 return NULL;
12130
6c09e791 12131 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
ad7e718c
JB		 12132 rdev->cur_cmd_info->snd_portid,
12133 rdev->cur_cmd_info->snd_seq,
567ffc35 12134 cmd, attr, NULL, GFP_KERNEL);
ad7e718c
JB		 12135}
12136EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
12137
12138int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
12139{
12140 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
12141 void *hdr = ((void **)skb->cb)[1];
12142 struct nlattr *data = ((void **)skb->cb)[2];
12143
bd8c78e7
JB		 12144 /* clear CB data for netlink core to own from now on */
12145 memset(skb->cb, 0, sizeof(skb->cb));
12146
ad7e718c
JB		 12147 if (WARN_ON(!rdev->cur_cmd_info)) {
12148 kfree_skb(skb);
12149 return -EINVAL;
12150 }
12151
12152 nla_nest_end(skb, data);
12153 genlmsg_end(skb, hdr);
12154 return genlmsg_reply(skb, rdev->cur_cmd_info);
12155}
12156EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
12157
fa9ffc74
KP		 12158static int nl80211_set_qos_map(struct sk_buff *skb,
12159 struct genl_info *info)
12160{
12161 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12162 struct cfg80211_qos_map *qos_map = NULL;
12163 struct net_device *dev = info->user_ptr[1];
12164 u8 *pos, len, num_des, des_len, des;
12165 int ret;
12166
12167 if (!rdev->ops->set_qos_map)
12168 return -EOPNOTSUPP;
12169
12170 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
12171 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
12172 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
12173
12174 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
12175 len > IEEE80211_QOS_MAP_LEN_MAX)
12176 return -EINVAL;
12177
12178 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
12179 if (!qos_map)
12180 return -ENOMEM;
12181
12182 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
12183 if (num_des) {
12184 des_len = num_des *
12185 sizeof(struct cfg80211_dscp_exception);
12186 memcpy(qos_map->dscp_exception, pos, des_len);
12187 qos_map->num_des = num_des;
12188 for (des = 0; des < num_des; des++) {
12189 if (qos_map->dscp_exception[des].up > 7) {
12190 kfree(qos_map);
12191 return -EINVAL;
12192 }
12193 }
12194 pos += des_len;
12195 }
12196 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
12197 }
12198
12199 wdev_lock(dev->ieee80211_ptr);
12200 ret = nl80211_key_allowed(dev->ieee80211_ptr);
12201 if (!ret)
12202 ret = rdev_set_qos_map(rdev, dev, qos_map);
12203 wdev_unlock(dev->ieee80211_ptr);
12204
12205 kfree(qos_map);
12206 return ret;
12207}
12208
960d01ac
JB		 12209static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
12210{
12211 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12212 struct net_device *dev = info->user_ptr[1];
12213 struct wireless_dev *wdev = dev->ieee80211_ptr;
12214 const u8 *peer;
12215 u8 tsid, up;
12216 u16 admitted_time = 0;
12217 int err;
12218
723e73ac 12219 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
960d01ac
JB		 12220 return -EOPNOTSUPP;
12221
12222 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
12223 !info->attrs[NL80211_ATTR_USER_PRIO])
12224 return -EINVAL;
12225
12226 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12227 if (tsid >= IEEE80211_NUM_TIDS)
12228 return -EINVAL;
12229
12230 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
12231 if (up >= IEEE80211_NUM_UPS)
12232 return -EINVAL;
12233
12234 /* WMM uses TIDs 0-7 even for TSPEC */
723e73ac 12235 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
960d01ac 12236 /* TODO: handle 802.11 TSPEC/admission control
723e73ac
JB		 12237 * need more attributes for that (e.g. BA session requirement);
12238 * change the WMM adminssion test above to allow both then
960d01ac
JB		 12239 */
12240 return -EINVAL;
12241 }
12242
12243 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12244
12245 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
12246 admitted_time =
12247 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
12248 if (!admitted_time)
12249 return -EINVAL;
12250 }
12251
12252 wdev_lock(wdev);
12253 switch (wdev->iftype) {
12254 case NL80211_IFTYPE_STATION:
12255 case NL80211_IFTYPE_P2P_CLIENT:
12256 if (wdev->current_bss)
12257 break;
12258 err = -ENOTCONN;
12259 goto out;
12260 default:
12261 err = -EOPNOTSUPP;
12262 goto out;
12263 }
12264
12265 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
12266
12267 out:
12268 wdev_unlock(wdev);
12269 return err;
12270}
12271
12272static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
12273{
12274 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12275 struct net_device *dev = info->user_ptr[1];
12276 struct wireless_dev *wdev = dev->ieee80211_ptr;
12277 const u8 *peer;
12278 u8 tsid;
12279 int err;
12280
12281 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
12282 return -EINVAL;
12283
12284 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12285 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12286
12287 wdev_lock(wdev);
12288 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
12289 wdev_unlock(wdev);
12290
12291 return err;
12292}
12293
1057d35e
AN		 12294static int nl80211_tdls_channel_switch(struct sk_buff *skb,
12295 struct genl_info *info)
12296{
12297 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12298 struct net_device *dev = info->user_ptr[1];
12299 struct wireless_dev *wdev = dev->ieee80211_ptr;
12300 struct cfg80211_chan_def chandef = {};
12301 const u8 *addr;
12302 u8 oper_class;
12303 int err;
12304
12305 if (!rdev->ops->tdls_channel_switch ||
12306 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12307 return -EOPNOTSUPP;
12308
12309 switch (dev->ieee80211_ptr->iftype) {
12310 case NL80211_IFTYPE_STATION:
12311 case NL80211_IFTYPE_P2P_CLIENT:
12312 break;
12313 default:
12314 return -EOPNOTSUPP;
12315 }
12316
12317 if (!info->attrs[NL80211_ATTR_MAC] ||
12318 !info->attrs[NL80211_ATTR_OPER_CLASS])
12319 return -EINVAL;
12320
12321 err = nl80211_parse_chandef(rdev, info, &chandef);
12322 if (err)
12323 return err;
12324
12325 /*
12326 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
12327 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
12328 * specification is not defined for them.
12329 */
57fbcce3 12330 if (chandef.chan->band == NL80211_BAND_2GHZ &&
1057d35e
AN		 12331 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
12332 chandef.width != NL80211_CHAN_WIDTH_20)
12333 return -EINVAL;
12334
12335 /* we will be active on the TDLS link */
923b352f
AN		 12336 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
12337 wdev->iftype))
1057d35e
AN		 12338 return -EINVAL;
12339
12340 /* don't allow switching to DFS channels */
12341 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
12342 return -EINVAL;
12343
12344 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12345 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
12346
12347 wdev_lock(wdev);
12348 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
12349 wdev_unlock(wdev);
12350
12351 return err;
12352}
12353
12354static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
12355 struct genl_info *info)
12356{
12357 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12358 struct net_device *dev = info->user_ptr[1];
12359 struct wireless_dev *wdev = dev->ieee80211_ptr;
12360 const u8 *addr;
12361
12362 if (!rdev->ops->tdls_channel_switch ||
12363 !rdev->ops->tdls_cancel_channel_switch ||
12364 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12365 return -EOPNOTSUPP;
12366
12367 switch (dev->ieee80211_ptr->iftype) {
12368 case NL80211_IFTYPE_STATION:
12369 case NL80211_IFTYPE_P2P_CLIENT:
12370 break;
12371 default:
12372 return -EOPNOTSUPP;
12373 }
12374
12375 if (!info->attrs[NL80211_ATTR_MAC])
12376 return -EINVAL;
12377
12378 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12379
12380 wdev_lock(wdev);
12381 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
12382 wdev_unlock(wdev);
12383
12384 return 0;
12385}
12386
ce0ce13a
MB		 12387static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
12388 struct genl_info *info)
12389{
12390 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12391 struct net_device *dev = info->user_ptr[1];
12392 struct wireless_dev *wdev = dev->ieee80211_ptr;
12393 const struct nlattr *nla;
12394 bool enabled;
12395
ce0ce13a
MB		 12396 if (!rdev->ops->set_multicast_to_unicast)
12397 return -EOPNOTSUPP;
12398
12399 if (wdev->iftype != NL80211_IFTYPE_AP &&
12400 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12401 return -EOPNOTSUPP;
12402
12403 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
12404 enabled = nla_get_flag(nla);
12405
12406 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
12407}
12408
3a00df57
AS		 12409static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
12410{
12411 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12412 struct net_device *dev = info->user_ptr[1];
12413 struct wireless_dev *wdev = dev->ieee80211_ptr;
12414 struct cfg80211_pmk_conf pmk_conf = {};
12415 int ret;
12416
12417 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12418 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12419 return -EOPNOTSUPP;
12420
12421 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12422 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
12423 return -EOPNOTSUPP;
12424
12425 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
12426 return -EINVAL;
12427
12428 wdev_lock(wdev);
12429 if (!wdev->current_bss) {
12430 ret = -ENOTCONN;
12431 goto out;
12432 }
12433
12434 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
12435 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
12436 ret = -EINVAL;
12437 goto out;
12438 }
12439
12440 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
12441 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
12442 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
12443 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
12444 ret = -EINVAL;
12445 goto out;
12446 }
12447
12448 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) {
12449 int r0_name_len = nla_len(info->attrs[NL80211_ATTR_PMKR0_NAME]);
12450
12451 if (r0_name_len != WLAN_PMK_NAME_LEN) {
12452 ret = -EINVAL;
12453 goto out;
12454 }
12455
12456 pmk_conf.pmk_r0_name =
12457 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
12458 }
12459
12460 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
12461out:
12462 wdev_unlock(wdev);
12463 return ret;
12464}
12465
12466static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
12467{
12468 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12469 struct net_device *dev = info->user_ptr[1];
12470 struct wireless_dev *wdev = dev->ieee80211_ptr;
12471 const u8 *aa;
12472 int ret;
12473
12474 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12475 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12476 return -EOPNOTSUPP;
12477
12478 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12479 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
12480 return -EOPNOTSUPP;
12481
12482 if (!info->attrs[NL80211_ATTR_MAC])
12483 return -EINVAL;
12484
12485 wdev_lock(wdev);
12486 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
12487 ret = rdev_del_pmk(rdev, dev, aa);
12488 wdev_unlock(wdev);
12489
12490 return ret;
12491}
12492
4c476991
JB		 12493#define NL80211_FLAG_NEED_WIPHY 0x01
12494#define NL80211_FLAG_NEED_NETDEV 0x02
12495#define NL80211_FLAG_NEED_RTNL 0x04
41265714
JB		 12496#define NL80211_FLAG_CHECK_NETDEV_UP 0x08
12497#define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
12498 NL80211_FLAG_CHECK_NETDEV_UP)
1bf614ef 12499#define NL80211_FLAG_NEED_WDEV 0x10
98104fde 12500/* If a netdev is associated, it must be UP, P2P must be started */
1bf614ef
JB		 12501#define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
12502 NL80211_FLAG_CHECK_NETDEV_UP)
5393b917 12503#define NL80211_FLAG_CLEAR_SKB 0x20
4c476991 12504
f84f771d 12505static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12506 struct genl_info *info)
12507{
12508 struct cfg80211_registered_device *rdev;
89a54e48 12509 struct wireless_dev *wdev;
4c476991 12510 struct net_device *dev;
4c476991
JB		 12511 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
12512
12513 if (rtnl)
12514 rtnl_lock();
12515
12516 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
4f7eff10 12517 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
4c476991
JB		 12518 if (IS_ERR(rdev)) {
12519 if (rtnl)
12520 rtnl_unlock();
12521 return PTR_ERR(rdev);
12522 }
12523 info->user_ptr[0] = rdev;
1bf614ef
JB		 12524 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
12525 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
5fe231e8
JB		 12526 ASSERT_RTNL();
12527
89a54e48
JB		 12528 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
12529 info->attrs);
12530 if (IS_ERR(wdev)) {
4c476991
JB		 12531 if (rtnl)
12532 rtnl_unlock();
89a54e48 12533 return PTR_ERR(wdev);
4c476991 12534 }
89a54e48 12535
89a54e48 12536 dev = wdev->netdev;
f26cbf40 12537 rdev = wiphy_to_rdev(wdev->wiphy);
89a54e48 12538
1bf614ef
JB		 12539 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
12540 if (!dev) {
1bf614ef
JB		 12541 if (rtnl)
12542 rtnl_unlock();
12543 return -EINVAL;
12544 }
12545
12546 info->user_ptr[1] = dev;
12547 } else {
12548 info->user_ptr[1] = wdev;
41265714 12549 }
1bf614ef 12550
73c7da3d
AVS		 12551 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
12552 !wdev_running(wdev)) {
12553 if (rtnl)
12554 rtnl_unlock();
12555 return -ENETDOWN;
12556 }
1bf614ef 12557
73c7da3d 12558 if (dev)
1bf614ef 12559 dev_hold(dev);
89a54e48 12560
4c476991 12561 info->user_ptr[0] = rdev;
4c476991
JB		 12562 }
12563
12564 return 0;
12565}
12566
f84f771d 12567static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12568 struct genl_info *info)
12569{
1bf614ef
JB		 12570 if (info->user_ptr[1]) {
12571 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
12572 struct wireless_dev *wdev = info->user_ptr[1];
12573
12574 if (wdev->netdev)
12575 dev_put(wdev->netdev);
12576 } else {
12577 dev_put(info->user_ptr[1]);
12578 }
12579 }
5393b917 12580
4c476991
JB		 12581 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
12582 rtnl_unlock();
5393b917
JB		 12583
12584 /* If needed, clear the netlink message payload from the SKB
12585 * as it might contain key data that shouldn't stick around on
12586 * the heap after the SKB is freed. The netlink message header
12587 * is still needed for further processing, so leave it intact.
12588 */
12589 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
12590 struct nlmsghdr *nlh = nlmsg_hdr(skb);
12591
12592 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
12593 }
4c476991
JB		 12594}
12595
4534de83 12596static const struct genl_ops nl80211_ops[] = {
55682965
JB		 12597 {
12598 .cmd = NL80211_CMD_GET_WIPHY,
12599 .doit = nl80211_get_wiphy,
12600 .dumpit = nl80211_dump_wiphy,
86e8cf98 12601 .done = nl80211_dump_wiphy_done,
55682965
JB		 12602 .policy = nl80211_policy,
12603 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12604 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12605 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12606 },
12607 {
12608 .cmd = NL80211_CMD_SET_WIPHY,
12609 .doit = nl80211_set_wiphy,
12610 .policy = nl80211_policy,
5617c6cd 12611 .flags = GENL_UNS_ADMIN_PERM,
4c476991 12612 .internal_flags = NL80211_FLAG_NEED_RTNL,
55682965
JB		 12613 },
12614 {
12615 .cmd = NL80211_CMD_GET_INTERFACE,
12616 .doit = nl80211_get_interface,
12617 .dumpit = nl80211_dump_interface,
12618 .policy = nl80211_policy,
12619 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12620 .internal_flags = NL80211_FLAG_NEED_WDEV |
12621 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12622 },
12623 {
12624 .cmd = NL80211_CMD_SET_INTERFACE,
12625 .doit = nl80211_set_interface,
12626 .policy = nl80211_policy,
5617c6cd 12627 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12628 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12629 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12630 },
12631 {
12632 .cmd = NL80211_CMD_NEW_INTERFACE,
12633 .doit = nl80211_new_interface,
12634 .policy = nl80211_policy,
5617c6cd 12635 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12636 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12637 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12638 },
12639 {
12640 .cmd = NL80211_CMD_DEL_INTERFACE,
12641 .doit = nl80211_del_interface,
12642 .policy = nl80211_policy,
5617c6cd 12643 .flags = GENL_UNS_ADMIN_PERM,
84efbb84 12644 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12645 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12646 },
12647 {
12648 .cmd = NL80211_CMD_GET_KEY,
12649 .doit = nl80211_get_key,
12650 .policy = nl80211_policy,
5617c6cd 12651 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12652 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12653 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12654 },
12655 {
12656 .cmd = NL80211_CMD_SET_KEY,
12657 .doit = nl80211_set_key,
12658 .policy = nl80211_policy,
5617c6cd 12659 .flags = GENL_UNS_ADMIN_PERM,
41265714 12660 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12661 NL80211_FLAG_NEED_RTNL |
12662 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12663 },
12664 {
12665 .cmd = NL80211_CMD_NEW_KEY,
12666 .doit = nl80211_new_key,
12667 .policy = nl80211_policy,
5617c6cd 12668 .flags = GENL_UNS_ADMIN_PERM,
41265714 12669 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12670 NL80211_FLAG_NEED_RTNL |
12671 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12672 },
12673 {
12674 .cmd = NL80211_CMD_DEL_KEY,
12675 .doit = nl80211_del_key,
12676 .policy = nl80211_policy,
5617c6cd 12677 .flags = GENL_UNS_ADMIN_PERM,
41265714 12678 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12679 NL80211_FLAG_NEED_RTNL,
55682965 12680 },
ed1b6cc7
JB		 12681 {
12682 .cmd = NL80211_CMD_SET_BEACON,
12683 .policy = nl80211_policy,
5617c6cd 12684 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12685 .doit = nl80211_set_beacon,
2b5f8b0b 12686 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12687 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12688 },
12689 {
8860020e 12690 .cmd = NL80211_CMD_START_AP,
ed1b6cc7 12691 .policy = nl80211_policy,
5617c6cd 12692 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12693 .doit = nl80211_start_ap,
2b5f8b0b 12694 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12695 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12696 },
12697 {
8860020e 12698 .cmd = NL80211_CMD_STOP_AP,
ed1b6cc7 12699 .policy = nl80211_policy,
5617c6cd 12700 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12701 .doit = nl80211_stop_ap,
2b5f8b0b 12702 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12703 NL80211_FLAG_NEED_RTNL,
ed1b6cc7 12704 },
5727ef1b
JB		 12705 {
12706 .cmd = NL80211_CMD_GET_STATION,
12707 .doit = nl80211_get_station,
2ec600d6 12708 .dumpit = nl80211_dump_station,
5727ef1b 12709 .policy = nl80211_policy,
4c476991
JB		 12710 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12711 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12712 },
12713 {
12714 .cmd = NL80211_CMD_SET_STATION,
12715 .doit = nl80211_set_station,
12716 .policy = nl80211_policy,
5617c6cd 12717 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12718 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12719 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12720 },
12721 {
12722 .cmd = NL80211_CMD_NEW_STATION,
12723 .doit = nl80211_new_station,
12724 .policy = nl80211_policy,
5617c6cd 12725 .flags = GENL_UNS_ADMIN_PERM,
41265714 12726 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12727 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12728 },
12729 {
12730 .cmd = NL80211_CMD_DEL_STATION,
12731 .doit = nl80211_del_station,
12732 .policy = nl80211_policy,
5617c6cd 12733 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12734 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12735 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12736 },
12737 {
12738 .cmd = NL80211_CMD_GET_MPATH,
12739 .doit = nl80211_get_mpath,
12740 .dumpit = nl80211_dump_mpath,
12741 .policy = nl80211_policy,
5617c6cd 12742 .flags = GENL_UNS_ADMIN_PERM,
41265714 12743 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12744 NL80211_FLAG_NEED_RTNL,
2ec600d6 12745 },
66be7d2b
HR		 12746 {
12747 .cmd = NL80211_CMD_GET_MPP,
12748 .doit = nl80211_get_mpp,
12749 .dumpit = nl80211_dump_mpp,
12750 .policy = nl80211_policy,
5617c6cd 12751 .flags = GENL_UNS_ADMIN_PERM,
66be7d2b
HR		 12752 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12753 NL80211_FLAG_NEED_RTNL,
12754 },
2ec600d6
LCC		 12755 {
12756 .cmd = NL80211_CMD_SET_MPATH,
12757 .doit = nl80211_set_mpath,
12758 .policy = nl80211_policy,
5617c6cd 12759 .flags = GENL_UNS_ADMIN_PERM,
41265714 12760 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12761 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12762 },
12763 {
12764 .cmd = NL80211_CMD_NEW_MPATH,
12765 .doit = nl80211_new_mpath,
12766 .policy = nl80211_policy,
5617c6cd 12767 .flags = GENL_UNS_ADMIN_PERM,
41265714 12768 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12769 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12770 },
12771 {
12772 .cmd = NL80211_CMD_DEL_MPATH,
12773 .doit = nl80211_del_mpath,
12774 .policy = nl80211_policy,
5617c6cd 12775 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12776 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12777 NL80211_FLAG_NEED_RTNL,
9f1ba906
JM		 12778 },
12779 {
12780 .cmd = NL80211_CMD_SET_BSS,
12781 .doit = nl80211_set_bss,
12782 .policy = nl80211_policy,
5617c6cd 12783 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12784 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12785 NL80211_FLAG_NEED_RTNL,
b2e1b302 12786 },
f130347c
LR		 12787 {
12788 .cmd = NL80211_CMD_GET_REG,
ad30ca2c
AN		 12789 .doit = nl80211_get_reg_do,
12790 .dumpit = nl80211_get_reg_dump,
f130347c 12791 .policy = nl80211_policy,
5fe231e8 12792 .internal_flags = NL80211_FLAG_NEED_RTNL,
f130347c
LR		 12793 /* can be retrieved by unprivileged users */
12794 },
b6863036 12795#ifdef CONFIG_CFG80211_CRDA_SUPPORT
b2e1b302
LR		 12796 {
12797 .cmd = NL80211_CMD_SET_REG,
12798 .doit = nl80211_set_reg,
12799 .policy = nl80211_policy,
12800 .flags = GENL_ADMIN_PERM,
5fe231e8 12801 .internal_flags = NL80211_FLAG_NEED_RTNL,
b2e1b302 12802 },
b6863036 12803#endif
b2e1b302
LR		 12804 {
12805 .cmd = NL80211_CMD_REQ_SET_REG,
12806 .doit = nl80211_req_set_reg,
12807 .policy = nl80211_policy,
93da9cc1 12808 .flags = GENL_ADMIN_PERM,
12809 },
1ea4ff3e
JB		 12810 {
12811 .cmd = NL80211_CMD_RELOAD_REGDB,
12812 .doit = nl80211_reload_regdb,
12813 .policy = nl80211_policy,
12814 .flags = GENL_ADMIN_PERM,
12815 },
93da9cc1 12816 {
24bdd9f4
JC		 12817 .cmd = NL80211_CMD_GET_MESH_CONFIG,
12818 .doit = nl80211_get_mesh_config,
93da9cc1 12819 .policy = nl80211_policy,
12820 /* can be retrieved by unprivileged users */
2b5f8b0b 12821 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12822 NL80211_FLAG_NEED_RTNL,
93da9cc1 12823 },
12824 {
24bdd9f4
JC		 12825 .cmd = NL80211_CMD_SET_MESH_CONFIG,
12826 .doit = nl80211_update_mesh_config,
93da9cc1 12827 .policy = nl80211_policy,
5617c6cd 12828 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c 12829 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12830 NL80211_FLAG_NEED_RTNL,
9aed3cc1 12831 },
2a519311
JB		 12832 {
12833 .cmd = NL80211_CMD_TRIGGER_SCAN,
12834 .doit = nl80211_trigger_scan,
12835 .policy = nl80211_policy,
5617c6cd 12836 .flags = GENL_UNS_ADMIN_PERM,
fd014284 12837 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12838 NL80211_FLAG_NEED_RTNL,
2a519311 12839 },
91d3ab46
VK		 12840 {
12841 .cmd = NL80211_CMD_ABORT_SCAN,
12842 .doit = nl80211_abort_scan,
12843 .policy = nl80211_policy,
5617c6cd 12844 .flags = GENL_UNS_ADMIN_PERM,
91d3ab46
VK		 12845 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12846 NL80211_FLAG_NEED_RTNL,
12847 },
2a519311
JB		 12848 {
12849 .cmd = NL80211_CMD_GET_SCAN,
12850 .policy = nl80211_policy,
12851 .dumpit = nl80211_dump_scan,
12852 },
807f8a8c
LC		 12853 {
12854 .cmd = NL80211_CMD_START_SCHED_SCAN,
12855 .doit = nl80211_start_sched_scan,
12856 .policy = nl80211_policy,
5617c6cd 12857 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12858 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12859 NL80211_FLAG_NEED_RTNL,
12860 },
12861 {
12862 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
12863 .doit = nl80211_stop_sched_scan,
12864 .policy = nl80211_policy,
5617c6cd 12865 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12866 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12867 NL80211_FLAG_NEED_RTNL,
12868 },
636a5d36
JM		 12869 {
12870 .cmd = NL80211_CMD_AUTHENTICATE,
12871 .doit = nl80211_authenticate,
12872 .policy = nl80211_policy,
5617c6cd 12873 .flags = GENL_UNS_ADMIN_PERM,
41265714 12874 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12875 NL80211_FLAG_NEED_RTNL |
12876 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 12877 },
12878 {
12879 .cmd = NL80211_CMD_ASSOCIATE,
12880 .doit = nl80211_associate,
12881 .policy = nl80211_policy,
5617c6cd 12882 .flags = GENL_UNS_ADMIN_PERM,
41265714 12883 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
a55d0b3d
SD		 12884 NL80211_FLAG_NEED_RTNL |
12885 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 12886 },
12887 {
12888 .cmd = NL80211_CMD_DEAUTHENTICATE,
12889 .doit = nl80211_deauthenticate,
12890 .policy = nl80211_policy,
5617c6cd 12891 .flags = GENL_UNS_ADMIN_PERM,
41265714 12892 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12893 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12894 },
12895 {
12896 .cmd = NL80211_CMD_DISASSOCIATE,
12897 .doit = nl80211_disassociate,
12898 .policy = nl80211_policy,
5617c6cd 12899 .flags = GENL_UNS_ADMIN_PERM,
41265714 12900 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12901 NL80211_FLAG_NEED_RTNL,
636a5d36 12902 },
04a773ad
JB		 12903 {
12904 .cmd = NL80211_CMD_JOIN_IBSS,
12905 .doit = nl80211_join_ibss,
12906 .policy = nl80211_policy,
5617c6cd 12907 .flags = GENL_UNS_ADMIN_PERM,
41265714 12908 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12909 NL80211_FLAG_NEED_RTNL,
04a773ad
JB		 12910 },
12911 {
12912 .cmd = NL80211_CMD_LEAVE_IBSS,
12913 .doit = nl80211_leave_ibss,
12914 .policy = nl80211_policy,
5617c6cd 12915 .flags = GENL_UNS_ADMIN_PERM,
41265714 12916 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12917 NL80211_FLAG_NEED_RTNL,
04a773ad 12918 },
aff89a9b
JB		 12919#ifdef CONFIG_NL80211_TESTMODE
12920 {
12921 .cmd = NL80211_CMD_TESTMODE,
12922 .doit = nl80211_testmode_do,
71063f0e 12923 .dumpit = nl80211_testmode_dump,
aff89a9b 12924 .policy = nl80211_policy,
5617c6cd 12925 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12926 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12927 NL80211_FLAG_NEED_RTNL,
aff89a9b
JB		 12928 },
12929#endif
b23aa676
SO		 12930 {
12931 .cmd = NL80211_CMD_CONNECT,
12932 .doit = nl80211_connect,
12933 .policy = nl80211_policy,
5617c6cd 12934 .flags = GENL_UNS_ADMIN_PERM,
41265714 12935 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
a55d0b3d
SD		 12936 NL80211_FLAG_NEED_RTNL |
12937 NL80211_FLAG_CLEAR_SKB,
b23aa676 12938 },
088e8df8 12939 {
12940 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
12941 .doit = nl80211_update_connect_params,
12942 .policy = nl80211_policy,
12943 .flags = GENL_ADMIN_PERM,
12944 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
a55d0b3d
SD		 12945 NL80211_FLAG_NEED_RTNL |
12946 NL80211_FLAG_CLEAR_SKB,
088e8df8 12947 },
b23aa676
SO		 12948 {
12949 .cmd = NL80211_CMD_DISCONNECT,
12950 .doit = nl80211_disconnect,
12951 .policy = nl80211_policy,
5617c6cd 12952 .flags = GENL_UNS_ADMIN_PERM,
41265714 12953 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12954 NL80211_FLAG_NEED_RTNL,
b23aa676 12955 },
463d0183
JB		 12956 {
12957 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
12958 .doit = nl80211_wiphy_netns,
12959 .policy = nl80211_policy,
5617c6cd 12960 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12961 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12962 NL80211_FLAG_NEED_RTNL,
463d0183 12963 },
61fa713c
HS		 12964 {
12965 .cmd = NL80211_CMD_GET_SURVEY,
12966 .policy = nl80211_policy,
12967 .dumpit = nl80211_dump_survey,
12968 },
67fbb16b
SO		 12969 {
12970 .cmd = NL80211_CMD_SET_PMKSA,
12971 .doit = nl80211_setdel_pmksa,
12972 .policy = nl80211_policy,
5617c6cd 12973 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12974 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
a55d0b3d
SD		 12975 NL80211_FLAG_NEED_RTNL |
12976 NL80211_FLAG_CLEAR_SKB,
67fbb16b
SO		 12977 },
12978 {
12979 .cmd = NL80211_CMD_DEL_PMKSA,
12980 .doit = nl80211_setdel_pmksa,
12981 .policy = nl80211_policy,
5617c6cd 12982 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12983 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12984 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12985 },
12986 {
12987 .cmd = NL80211_CMD_FLUSH_PMKSA,
12988 .doit = nl80211_flush_pmksa,
12989 .policy = nl80211_policy,
5617c6cd 12990 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12991 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12992 NL80211_FLAG_NEED_RTNL,
67fbb16b 12993 },
9588bbd5
JM		 12994 {
12995 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
12996 .doit = nl80211_remain_on_channel,
12997 .policy = nl80211_policy,
5617c6cd 12998 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12999 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 13000 NL80211_FLAG_NEED_RTNL,
9588bbd5
JM		 13001 },
13002 {
13003 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
13004 .doit = nl80211_cancel_remain_on_channel,
13005 .policy = nl80211_policy,
5617c6cd 13006 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 13007 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 13008 NL80211_FLAG_NEED_RTNL,
9588bbd5 13009 },
13ae75b1
JM		 13010 {
13011 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
13012 .doit = nl80211_set_tx_bitrate_mask,
13013 .policy = nl80211_policy,
5617c6cd 13014 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 13015 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13016 NL80211_FLAG_NEED_RTNL,
13ae75b1 13017 },
026331c4 13018 {
2e161f78
JB		 13019 .cmd = NL80211_CMD_REGISTER_FRAME,
13020 .doit = nl80211_register_mgmt,
026331c4 13021 .policy = nl80211_policy,
5617c6cd 13022 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 13023 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 13024 NL80211_FLAG_NEED_RTNL,
026331c4
JM		 13025 },
13026 {
2e161f78
JB		 13027 .cmd = NL80211_CMD_FRAME,
13028 .doit = nl80211_tx_mgmt,
026331c4 13029 .policy = nl80211_policy,
5617c6cd 13030 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 13031 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
f7ca38df
JB		 13032 NL80211_FLAG_NEED_RTNL,
13033 },
13034 {
13035 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
13036 .doit = nl80211_tx_mgmt_cancel_wait,
13037 .policy = nl80211_policy,
5617c6cd 13038 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 13039 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 13040 NL80211_FLAG_NEED_RTNL,
026331c4 13041 },
ffb9eb3d
KV		 13042 {
13043 .cmd = NL80211_CMD_SET_POWER_SAVE,
13044 .doit = nl80211_set_power_save,
13045 .policy = nl80211_policy,
5617c6cd 13046 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 13047 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13048 NL80211_FLAG_NEED_RTNL,
ffb9eb3d
KV		 13049 },
13050 {
13051 .cmd = NL80211_CMD_GET_POWER_SAVE,
13052 .doit = nl80211_get_power_save,
13053 .policy = nl80211_policy,
13054 /* can be retrieved by unprivileged users */
4c476991
JB		 13055 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13056 NL80211_FLAG_NEED_RTNL,
ffb9eb3d 13057 },
d6dc1a38
JO		 13058 {
13059 .cmd = NL80211_CMD_SET_CQM,
13060 .doit = nl80211_set_cqm,
13061 .policy = nl80211_policy,
5617c6cd 13062 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 13063 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13064 NL80211_FLAG_NEED_RTNL,
d6dc1a38 13065 },
f444de05
JB		 13066 {
13067 .cmd = NL80211_CMD_SET_CHANNEL,
13068 .doit = nl80211_set_channel,
13069 .policy = nl80211_policy,
5617c6cd 13070 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 13071 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13072 NL80211_FLAG_NEED_RTNL,
f444de05 13073 },
e8347eba
BJ		 13074 {
13075 .cmd = NL80211_CMD_SET_WDS_PEER,
13076 .doit = nl80211_set_wds_peer,
13077 .policy = nl80211_policy,
5617c6cd 13078 .flags = GENL_UNS_ADMIN_PERM,
43b19952
JB		 13079 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13080 NL80211_FLAG_NEED_RTNL,
e8347eba 13081 },
29cbe68c
JB		 13082 {
13083 .cmd = NL80211_CMD_JOIN_MESH,
13084 .doit = nl80211_join_mesh,
13085 .policy = nl80211_policy,
5617c6cd 13086 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 13087 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13088 NL80211_FLAG_NEED_RTNL,
13089 },
13090 {
13091 .cmd = NL80211_CMD_LEAVE_MESH,
13092 .doit = nl80211_leave_mesh,
13093 .policy = nl80211_policy,
5617c6cd 13094 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 13095 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13096 NL80211_FLAG_NEED_RTNL,
13097 },
6e0bd6c3
RL		 13098 {
13099 .cmd = NL80211_CMD_JOIN_OCB,
13100 .doit = nl80211_join_ocb,
13101 .policy = nl80211_policy,
5617c6cd 13102 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 13103 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13104 NL80211_FLAG_NEED_RTNL,
13105 },
13106 {
13107 .cmd = NL80211_CMD_LEAVE_OCB,
13108 .doit = nl80211_leave_ocb,
13109 .policy = nl80211_policy,
5617c6cd 13110 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 13111 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13112 NL80211_FLAG_NEED_RTNL,
13113 },
dfb89c56 13114#ifdef CONFIG_PM
ff1b6e69
JB		 13115 {
13116 .cmd = NL80211_CMD_GET_WOWLAN,
13117 .doit = nl80211_get_wowlan,
13118 .policy = nl80211_policy,
13119 /* can be retrieved by unprivileged users */
13120 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13121 NL80211_FLAG_NEED_RTNL,
13122 },
13123 {
13124 .cmd = NL80211_CMD_SET_WOWLAN,
13125 .doit = nl80211_set_wowlan,
13126 .policy = nl80211_policy,
5617c6cd 13127 .flags = GENL_UNS_ADMIN_PERM,
ff1b6e69
JB		 13128 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13129 NL80211_FLAG_NEED_RTNL,
13130 },
dfb89c56 13131#endif
e5497d76
JB		 13132 {
13133 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
13134 .doit = nl80211_set_rekey_data,
13135 .policy = nl80211_policy,
5617c6cd 13136 .flags = GENL_UNS_ADMIN_PERM,
e5497d76 13137 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 13138 NL80211_FLAG_NEED_RTNL |
13139 NL80211_FLAG_CLEAR_SKB,
e5497d76 13140 },
109086ce
AN		 13141 {
13142 .cmd = NL80211_CMD_TDLS_MGMT,
13143 .doit = nl80211_tdls_mgmt,
13144 .policy = nl80211_policy,
5617c6cd 13145 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 13146 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13147 NL80211_FLAG_NEED_RTNL,
13148 },
13149 {
13150 .cmd = NL80211_CMD_TDLS_OPER,
13151 .doit = nl80211_tdls_oper,
13152 .policy = nl80211_policy,
5617c6cd 13153 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 13154 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13155 NL80211_FLAG_NEED_RTNL,
13156 },
28946da7
JB		 13157 {
13158 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
13159 .doit = nl80211_register_unexpected_frame,
13160 .policy = nl80211_policy,
5617c6cd 13161 .flags = GENL_UNS_ADMIN_PERM,
28946da7
JB		 13162 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13163 NL80211_FLAG_NEED_RTNL,
13164 },
7f6cf311
JB		 13165 {
13166 .cmd = NL80211_CMD_PROBE_CLIENT,
13167 .doit = nl80211_probe_client,
13168 .policy = nl80211_policy,
5617c6cd 13169 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 13170 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7f6cf311
JB		 13171 NL80211_FLAG_NEED_RTNL,
13172 },
5e760230
JB		 13173 {
13174 .cmd = NL80211_CMD_REGISTER_BEACONS,
13175 .doit = nl80211_register_beacons,
13176 .policy = nl80211_policy,
5617c6cd 13177 .flags = GENL_UNS_ADMIN_PERM,
5e760230
JB		 13178 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13179 NL80211_FLAG_NEED_RTNL,
13180 },
1d9d9213
SW		 13181 {
13182 .cmd = NL80211_CMD_SET_NOACK_MAP,
13183 .doit = nl80211_set_noack_map,
13184 .policy = nl80211_policy,
5617c6cd 13185 .flags = GENL_UNS_ADMIN_PERM,
1d9d9213
SW		 13186 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13187 NL80211_FLAG_NEED_RTNL,
13188 },
98104fde
JB		 13189 {
13190 .cmd = NL80211_CMD_START_P2P_DEVICE,
13191 .doit = nl80211_start_p2p_device,
13192 .policy = nl80211_policy,
5617c6cd 13193 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 13194 .internal_flags = NL80211_FLAG_NEED_WDEV |
13195 NL80211_FLAG_NEED_RTNL,
13196 },
13197 {
13198 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
13199 .doit = nl80211_stop_p2p_device,
13200 .policy = nl80211_policy,
5617c6cd 13201 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 13202 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13203 NL80211_FLAG_NEED_RTNL,
cb3b7d87
AB		 13204 },
13205 {
13206 .cmd = NL80211_CMD_START_NAN,
13207 .doit = nl80211_start_nan,
13208 .policy = nl80211_policy,
13209 .flags = GENL_ADMIN_PERM,
13210 .internal_flags = NL80211_FLAG_NEED_WDEV |
13211 NL80211_FLAG_NEED_RTNL,
13212 },
13213 {
13214 .cmd = NL80211_CMD_STOP_NAN,
13215 .doit = nl80211_stop_nan,
13216 .policy = nl80211_policy,
13217 .flags = GENL_ADMIN_PERM,
13218 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13219 NL80211_FLAG_NEED_RTNL,
a442b761
AB		 13220 },
13221 {
13222 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
13223 .doit = nl80211_nan_add_func,
13224 .policy = nl80211_policy,
13225 .flags = GENL_ADMIN_PERM,
13226 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13227 NL80211_FLAG_NEED_RTNL,
13228 },
13229 {
13230 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
13231 .doit = nl80211_nan_del_func,
13232 .policy = nl80211_policy,
13233 .flags = GENL_ADMIN_PERM,
13234 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13235 NL80211_FLAG_NEED_RTNL,
a5a9dcf2
AB		 13236 },
13237 {
13238 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
13239 .doit = nl80211_nan_change_config,
13240 .policy = nl80211_policy,
13241 .flags = GENL_ADMIN_PERM,
13242 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13243 NL80211_FLAG_NEED_RTNL,
98104fde 13244 },
f4e583c8
AQ		 13245 {
13246 .cmd = NL80211_CMD_SET_MCAST_RATE,
13247 .doit = nl80211_set_mcast_rate,
77765eaf 13248 .policy = nl80211_policy,
5617c6cd 13249 .flags = GENL_UNS_ADMIN_PERM,
77765eaf
VT		 13250 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13251 NL80211_FLAG_NEED_RTNL,
13252 },
13253 {
13254 .cmd = NL80211_CMD_SET_MAC_ACL,
13255 .doit = nl80211_set_mac_acl,
f4e583c8 13256 .policy = nl80211_policy,
5617c6cd 13257 .flags = GENL_UNS_ADMIN_PERM,
f4e583c8
AQ		 13258 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13259 NL80211_FLAG_NEED_RTNL,
13260 },
04f39047
SW		 13261 {
13262 .cmd = NL80211_CMD_RADAR_DETECT,
13263 .doit = nl80211_start_radar_detection,
13264 .policy = nl80211_policy,
5617c6cd 13265 .flags = GENL_UNS_ADMIN_PERM,
04f39047
SW		 13266 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13267 NL80211_FLAG_NEED_RTNL,
13268 },
3713b4e3
JB		 13269 {
13270 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
13271 .doit = nl80211_get_protocol_features,
13272 .policy = nl80211_policy,
13273 },
355199e0
JM		 13274 {
13275 .cmd = NL80211_CMD_UPDATE_FT_IES,
13276 .doit = nl80211_update_ft_ies,
13277 .policy = nl80211_policy,
5617c6cd 13278 .flags = GENL_UNS_ADMIN_PERM,
355199e0
JM		 13279 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13280 NL80211_FLAG_NEED_RTNL,
13281 },
5de17984
AS		 13282 {
13283 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
13284 .doit = nl80211_crit_protocol_start,
13285 .policy = nl80211_policy,
5617c6cd 13286 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13287 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13288 NL80211_FLAG_NEED_RTNL,
13289 },
13290 {
13291 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
13292 .doit = nl80211_crit_protocol_stop,
13293 .policy = nl80211_policy,
5617c6cd 13294 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13295 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13296 NL80211_FLAG_NEED_RTNL,
be29b99a
AK		 13297 },
13298 {
13299 .cmd = NL80211_CMD_GET_COALESCE,
13300 .doit = nl80211_get_coalesce,
13301 .policy = nl80211_policy,
13302 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13303 NL80211_FLAG_NEED_RTNL,
13304 },
13305 {
13306 .cmd = NL80211_CMD_SET_COALESCE,
13307 .doit = nl80211_set_coalesce,
13308 .policy = nl80211_policy,
5617c6cd 13309 .flags = GENL_UNS_ADMIN_PERM,
be29b99a
AK		 13310 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13311 NL80211_FLAG_NEED_RTNL,
16ef1fe2
SW		 13312 },
13313 {
13314 .cmd = NL80211_CMD_CHANNEL_SWITCH,
13315 .doit = nl80211_channel_switch,
13316 .policy = nl80211_policy,
5617c6cd 13317 .flags = GENL_UNS_ADMIN_PERM,
16ef1fe2
SW		 13318 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13319 NL80211_FLAG_NEED_RTNL,
13320 },
ad7e718c
JB		 13321 {
13322 .cmd = NL80211_CMD_VENDOR,
13323 .doit = nl80211_vendor_cmd,
7bdbe400 13324 .dumpit = nl80211_vendor_cmd_dump,
ad7e718c 13325 .policy = nl80211_policy,
5617c6cd 13326 .flags = GENL_UNS_ADMIN_PERM,
ad7e718c 13327 .internal_flags = NL80211_FLAG_NEED_WIPHY |
a55d0b3d
SD		 13328 NL80211_FLAG_NEED_RTNL |
13329 NL80211_FLAG_CLEAR_SKB,
ad7e718c 13330 },
fa9ffc74
KP		 13331 {
13332 .cmd = NL80211_CMD_SET_QOS_MAP,
13333 .doit = nl80211_set_qos_map,
13334 .policy = nl80211_policy,
5617c6cd 13335 .flags = GENL_UNS_ADMIN_PERM,
fa9ffc74
KP		 13336 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13337 NL80211_FLAG_NEED_RTNL,
13338 },
960d01ac
JB		 13339 {
13340 .cmd = NL80211_CMD_ADD_TX_TS,
13341 .doit = nl80211_add_tx_ts,
13342 .policy = nl80211_policy,
5617c6cd 13343 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13344 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13345 NL80211_FLAG_NEED_RTNL,
13346 },
13347 {
13348 .cmd = NL80211_CMD_DEL_TX_TS,
13349 .doit = nl80211_del_tx_ts,
13350 .policy = nl80211_policy,
5617c6cd 13351 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13352 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13353 NL80211_FLAG_NEED_RTNL,
13354 },
1057d35e
AN		 13355 {
13356 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
13357 .doit = nl80211_tdls_channel_switch,
13358 .policy = nl80211_policy,
5617c6cd 13359 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13360 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13361 NL80211_FLAG_NEED_RTNL,
13362 },
13363 {
13364 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
13365 .doit = nl80211_tdls_cancel_channel_switch,
13366 .policy = nl80211_policy,
5617c6cd 13367 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13368 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13369 NL80211_FLAG_NEED_RTNL,
13370 },
ce0ce13a
MB		 13371 {
13372 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
13373 .doit = nl80211_set_multicast_to_unicast,
13374 .policy = nl80211_policy,
13375 .flags = GENL_UNS_ADMIN_PERM,
13376 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13377 NL80211_FLAG_NEED_RTNL,
13378 },
3a00df57
AS		 13379 {
13380 .cmd = NL80211_CMD_SET_PMK,
13381 .doit = nl80211_set_pmk,
13382 .policy = nl80211_policy,
13383 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
a55d0b3d
SD		 13384 NL80211_FLAG_NEED_RTNL |
13385 NL80211_FLAG_CLEAR_SKB,
3a00df57
AS		 13386 },
13387 {
13388 .cmd = NL80211_CMD_DEL_PMK,
13389 .doit = nl80211_del_pmk,
13390 .policy = nl80211_policy,
13391 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13392 NL80211_FLAG_NEED_RTNL,
13393 },
13394
55682965 13395};
9588bbd5 13396
56989f6d 13397static struct genl_family nl80211_fam __ro_after_init = {
489111e5
JB		 13398 .name = NL80211_GENL_NAME, /* have users key off the name instead */
13399 .hdrsize = 0, /* no private header */
13400 .version = 1, /* no particular meaning now */
13401 .maxattr = NL80211_ATTR_MAX,
13402 .netnsok = true,
13403 .pre_doit = nl80211_pre_doit,
13404 .post_doit = nl80211_post_doit,
13405 .module = THIS_MODULE,
13406 .ops = nl80211_ops,
13407 .n_ops = ARRAY_SIZE(nl80211_ops),
13408 .mcgrps = nl80211_mcgrps,
13409 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
13410};
13411
55682965
JB		 13412/* notification functions */
13413
3bb20556
JB		 13414void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
13415 enum nl80211_commands cmd)
55682965
JB		 13416{
13417 struct sk_buff *msg;
86e8cf98 13418 struct nl80211_dump_wiphy_state state = {};
55682965 13419
3bb20556
JB		 13420 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
13421 cmd != NL80211_CMD_DEL_WIPHY);
13422
fd2120ca 13423 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 13424 if (!msg)
13425 return;
13426
3bb20556 13427 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
55682965
JB		 13428 nlmsg_free(msg);
13429 return;
13430 }
13431
68eb5503 13432 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13433 NL80211_MCGRP_CONFIG, GFP_KERNEL);
55682965
JB		 13434}
13435
896ff063
DK		 13436void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
13437 struct wireless_dev *wdev,
13438 enum nl80211_commands cmd)
13439{
13440 struct sk_buff *msg;
13441
13442 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
13443 cmd != NL80211_CMD_DEL_INTERFACE);
13444
13445 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13446 if (!msg)
13447 return;
13448
13449 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev,
13450 cmd == NL80211_CMD_DEL_INTERFACE) < 0) {
13451 nlmsg_free(msg);
13452 return;
13453 }
13454
13455 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
13456 NL80211_MCGRP_CONFIG, GFP_KERNEL);
13457}
13458
362a415d
JB		 13459static int nl80211_add_scan_req(struct sk_buff *msg,
13460 struct cfg80211_registered_device *rdev)
13461{
13462 struct cfg80211_scan_request *req = rdev->scan_req;
13463 struct nlattr *nest;
13464 int i;
13465
13466 if (WARN_ON(!req))
13467 return 0;
13468
13469 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
13470 if (!nest)
13471 goto nla_put_failure;
9360ffd1
DM		 13472 for (i = 0; i < req->n_ssids; i++) {
13473 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
13474 goto nla_put_failure;
13475 }
362a415d
JB		 13476 nla_nest_end(msg, nest);
13477
13478 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
13479 if (!nest)
13480 goto nla_put_failure;
9360ffd1
DM		 13481 for (i = 0; i < req->n_channels; i++) {
13482 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
13483 goto nla_put_failure;
13484 }
362a415d
JB		 13485 nla_nest_end(msg, nest);
13486
9360ffd1
DM		 13487 if (req->ie &&
13488 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
13489 goto nla_put_failure;
362a415d 13490
ae917c9f
JB		 13491 if (req->flags &&
13492 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
13493 goto nla_put_failure;
ed473771 13494
1d76250b
AS		 13495 if (req->info.scan_start_tsf &&
13496 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
13497 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
13498 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
13499 req->info.tsf_bssid)))
13500 goto nla_put_failure;
13501
362a415d
JB		 13502 return 0;
13503 nla_put_failure:
13504 return -ENOBUFS;
13505}
13506
505a2e88 13507static int nl80211_prep_scan_msg(struct sk_buff *msg,
a538e2d5 13508 struct cfg80211_registered_device *rdev,
fd014284 13509 struct wireless_dev *wdev,
15e47304 13510 u32 portid, u32 seq, int flags,
a538e2d5 13511 u32 cmd)
2a519311
JB		 13512{
13513 void *hdr;
13514
15e47304 13515 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2a519311
JB		 13516 if (!hdr)
13517 return -1;
13518
9360ffd1 13519 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
fd014284
JB		 13520 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13521 wdev->netdev->ifindex)) ||
2dad624e
ND		 13522 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13523 NL80211_ATTR_PAD))
9360ffd1 13524 goto nla_put_failure;
2a519311 13525
362a415d
JB		 13526 /* ignore errors and send incomplete event anyway */
13527 nl80211_add_scan_req(msg, rdev);
2a519311 13528
053c095a
JB		 13529 genlmsg_end(msg, hdr);
13530 return 0;
2a519311
JB		 13531
13532 nla_put_failure:
13533 genlmsg_cancel(msg, hdr);
13534 return -EMSGSIZE;
13535}
13536
807f8a8c 13537static int
505a2e88 13538nl80211_prep_sched_scan_msg(struct sk_buff *msg,
96b08fd6 13539 struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13540{
13541 void *hdr;
13542
96b08fd6 13543 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
807f8a8c
LC		 13544 if (!hdr)
13545 return -1;
13546
96b08fd6
AVS		 13547 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
13548 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
13549 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
13550 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
13551 NL80211_ATTR_PAD))
9360ffd1 13552 goto nla_put_failure;
807f8a8c 13553
053c095a
JB		 13554 genlmsg_end(msg, hdr);
13555 return 0;
807f8a8c
LC		 13556
13557 nla_put_failure:
13558 genlmsg_cancel(msg, hdr);
13559 return -EMSGSIZE;
13560}
13561
a538e2d5 13562void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
fd014284 13563 struct wireless_dev *wdev)
a538e2d5
JB		 13564{
13565 struct sk_buff *msg;
13566
58050fce 13567 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
a538e2d5
JB		 13568 if (!msg)
13569 return;
13570
505a2e88 13571 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
a538e2d5
JB		 13572 NL80211_CMD_TRIGGER_SCAN) < 0) {
13573 nlmsg_free(msg);
13574 return;
13575 }
13576
68eb5503 13577 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13578 NL80211_MCGRP_SCAN, GFP_KERNEL);
a538e2d5
JB		 13579}
13580
f9d15d16
JB		 13581struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
13582 struct wireless_dev *wdev, bool aborted)
2a519311
JB		 13583{
13584 struct sk_buff *msg;
13585
fd2120ca 13586 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311 13587 if (!msg)
f9d15d16 13588 return NULL;
2a519311 13589
505a2e88 13590 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
f9d15d16
JB		 13591 aborted ? NL80211_CMD_SCAN_ABORTED :
13592 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311 13593 nlmsg_free(msg);
f9d15d16 13594 return NULL;
2a519311
JB		 13595 }
13596
f9d15d16 13597 return msg;
2a519311
JB		 13598}
13599
505a2e88
AVS		 13600/* send message created by nl80211_build_scan_msg() */
13601void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
13602 struct sk_buff *msg)
807f8a8c 13603{
807f8a8c
LC		 13604 if (!msg)
13605 return;
13606
68eb5503 13607 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13608 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13609}
13610
96b08fd6 13611void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13612{
13613 struct sk_buff *msg;
13614
58050fce 13615 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
807f8a8c
LC		 13616 if (!msg)
13617 return;
13618
96b08fd6 13619 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
807f8a8c
LC		 13620 nlmsg_free(msg);
13621 return;
13622 }
13623
96b08fd6 13624 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
2a94fe48 13625 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13626}
13627
b0d7aa59
JD		 13628static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
13629 struct regulatory_request *request)
73d54c9e 13630{
73d54c9e 13631 /* Userspace can always count this one always being set */
9360ffd1
DM		 13632 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
13633 goto nla_put_failure;
13634
13635 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
13636 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13637 NL80211_REGDOM_TYPE_WORLD))
13638 goto nla_put_failure;
13639 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
13640 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13641 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
13642 goto nla_put_failure;
13643 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
13644 request->intersect) {
13645 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13646 NL80211_REGDOM_TYPE_INTERSECTION))
13647 goto nla_put_failure;
13648 } else {
13649 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13650 NL80211_REGDOM_TYPE_COUNTRY) ||
13651 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
13652 request->alpha2))
13653 goto nla_put_failure;
13654 }
13655
ad30ca2c
AN		 13656 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
13657 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
13658
13659 if (wiphy &&
13660 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
13661 goto nla_put_failure;
1bdd716c
AN		 13662
13663 if (wiphy &&
13664 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
13665 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
13666 goto nla_put_failure;
ad30ca2c 13667 }
73d54c9e 13668
b0d7aa59
JD		 13669 return true;
13670
13671nla_put_failure:
13672 return false;
13673}
13674
13675/*
13676 * This can happen on global regulatory changes or device specific settings
13677 * based on custom regulatory domains.
13678 */
13679void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
13680 struct regulatory_request *request)
13681{
13682 struct sk_buff *msg;
13683 void *hdr;
13684
13685 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13686 if (!msg)
13687 return;
13688
13689 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
13690 if (!hdr) {
13691 nlmsg_free(msg);
13692 return;
13693 }
13694
13695 if (nl80211_reg_change_event_fill(msg, request) == false)
13696 goto nla_put_failure;
13697
3b7b72ee 13698 genlmsg_end(msg, hdr);
73d54c9e 13699
bc43b28c 13700 rcu_read_lock();
68eb5503 13701 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13702 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
bc43b28c 13703 rcu_read_unlock();
73d54c9e
LR		 13704
13705 return;
13706
13707nla_put_failure:
13708 genlmsg_cancel(msg, hdr);
13709 nlmsg_free(msg);
13710}
13711
6039f6d2
JM		 13712static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
13713 struct net_device *netdev,
13714 const u8 *buf, size_t len,
b0b6aa2c
EP		 13715 enum nl80211_commands cmd, gfp_t gfp,
13716 int uapsd_queues)
6039f6d2
JM		 13717{
13718 struct sk_buff *msg;
13719 void *hdr;
13720
4ef8c1c9 13721 msg = nlmsg_new(100 + len, gfp);
6039f6d2
JM		 13722 if (!msg)
13723 return;
13724
13725 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13726 if (!hdr) {
13727 nlmsg_free(msg);
13728 return;
13729 }
13730
9360ffd1
DM		 13731 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13732 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13733 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
13734 goto nla_put_failure;
6039f6d2 13735
b0b6aa2c
EP		 13736 if (uapsd_queues >= 0) {
13737 struct nlattr *nla_wmm =
13738 nla_nest_start(msg, NL80211_ATTR_STA_WME);
13739 if (!nla_wmm)
13740 goto nla_put_failure;
13741
13742 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
13743 uapsd_queues))
13744 goto nla_put_failure;
13745
13746 nla_nest_end(msg, nla_wmm);
13747 }
13748
3b7b72ee 13749 genlmsg_end(msg, hdr);
6039f6d2 13750
68eb5503 13751 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13752 NL80211_MCGRP_MLME, gfp);
6039f6d2
JM		 13753 return;
13754
13755 nla_put_failure:
13756 genlmsg_cancel(msg, hdr);
13757 nlmsg_free(msg);
13758}
13759
13760void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13761 struct net_device *netdev, const u8 *buf,
13762 size_t len, gfp_t gfp)
6039f6d2
JM		 13763{
13764 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13765 NL80211_CMD_AUTHENTICATE, gfp, -1);
6039f6d2
JM		 13766}
13767
13768void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
13769 struct net_device *netdev, const u8 *buf,
b0b6aa2c 13770 size_t len, gfp_t gfp, int uapsd_queues)
6039f6d2 13771{
e6d6e342 13772 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13773 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
6039f6d2
JM		 13774}
13775
53b46b84 13776void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13777 struct net_device *netdev, const u8 *buf,
13778 size_t len, gfp_t gfp)
6039f6d2
JM		 13779{
13780 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13781 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
6039f6d2
JM		 13782}
13783
53b46b84
JM		 13784void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
13785 struct net_device *netdev, const u8 *buf,
e6d6e342 13786 size_t len, gfp_t gfp)
6039f6d2
JM		 13787{
13788 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13789 NL80211_CMD_DISASSOCIATE, gfp, -1);
6039f6d2
JM		 13790}
13791
6ff57cf8
JB		 13792void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
13793 size_t len)
cf4e594e 13794{
947add36
JB		 13795 struct wireless_dev *wdev = dev->ieee80211_ptr;
13796 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13797 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
6ff57cf8
JB		 13798 const struct ieee80211_mgmt *mgmt = (void *)buf;
13799 u32 cmd;
947add36 13800
6ff57cf8
JB		 13801 if (WARN_ON(len < 2))
13802 return;
cf4e594e 13803
6ff57cf8
JB		 13804 if (ieee80211_is_deauth(mgmt->frame_control))
13805 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
13806 else
13807 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
947add36 13808
6ff57cf8 13809 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
b0b6aa2c 13810 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
cf4e594e 13811}
6ff57cf8 13812EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
cf4e594e 13813
1b06bb40
LR		 13814static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
13815 struct net_device *netdev, int cmd,
e6d6e342 13816 const u8 *addr, gfp_t gfp)
1965c853
JM		 13817{
13818 struct sk_buff *msg;
13819 void *hdr;
13820
e6d6e342 13821 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 13822 if (!msg)
13823 return;
13824
13825 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13826 if (!hdr) {
13827 nlmsg_free(msg);
13828 return;
13829 }
13830
9360ffd1
DM		 13831 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13832 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13833 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
13834 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
13835 goto nla_put_failure;
1965c853 13836
3b7b72ee 13837 genlmsg_end(msg, hdr);
1965c853 13838
68eb5503 13839 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13840 NL80211_MCGRP_MLME, gfp);
1965c853
JM		 13841 return;
13842
13843 nla_put_failure:
13844 genlmsg_cancel(msg, hdr);
13845 nlmsg_free(msg);
13846}
13847
13848void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13849 struct net_device *netdev, const u8 *addr,
13850 gfp_t gfp)
1965c853
JM		 13851{
13852 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 13853 addr, gfp);
1965c853
JM		 13854}
13855
13856void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13857 struct net_device *netdev, const u8 *addr,
13858 gfp_t gfp)
1965c853 13859{
e6d6e342
JB		 13860 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
13861 addr, gfp);
1965c853
JM		 13862}
13863
b23aa676 13864void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
5349a0f7
VK		 13865 struct net_device *netdev,
13866 struct cfg80211_connect_resp_params *cr,
3093ebbe 13867 gfp_t gfp)
b23aa676
SO		 13868{
13869 struct sk_buff *msg;
13870 void *hdr;
13871
a3caf744
VK		 13872 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
13873 cr->fils_kek_len + cr->pmk_len +
13874 (cr->pmkid ? WLAN_PMKID_LEN : 0), gfp);
b23aa676
SO		 13875 if (!msg)
13876 return;
13877
13878 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
13879 if (!hdr) {
13880 nlmsg_free(msg);
13881 return;
13882 }
13883
9360ffd1
DM		 13884 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13885 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
5349a0f7
VK		 13886 (cr->bssid &&
13887 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
bf1ecd21 13888 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
5349a0f7
VK		 13889 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
13890 cr->status) ||
13891 (cr->status < 0 &&
3093ebbe 13892 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
5349a0f7
VK		 13893 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
13894 cr->timeout_reason))) ||
13895 (cr->req_ie &&
13896 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
13897 (cr->resp_ie &&
13898 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
a3caf744
VK		 13899 cr->resp_ie)) ||
13900 (cr->update_erp_next_seq_num &&
13901 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
13902 cr->fils_erp_next_seq_num)) ||
13903 (cr->status == WLAN_STATUS_SUCCESS &&
13904 ((cr->fils_kek &&
13905 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils_kek_len,
13906 cr->fils_kek)) ||
13907 (cr->pmk &&
13908 nla_put(msg, NL80211_ATTR_PMK, cr->pmk_len, cr->pmk)) ||
13909 (cr->pmkid &&
13910 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->pmkid)))))
9360ffd1 13911 goto nla_put_failure;
b23aa676 13912
3b7b72ee 13913 genlmsg_end(msg, hdr);
b23aa676 13914
68eb5503 13915 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13916 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13917 return;
13918
13919 nla_put_failure:
13920 genlmsg_cancel(msg, hdr);
13921 nlmsg_free(msg);
b23aa676
SO		 13922}
13923
13924void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
29ce6ecb
AS		 13925 struct net_device *netdev,
13926 struct cfg80211_roam_info *info, gfp_t gfp)
b23aa676
SO		 13927{
13928 struct sk_buff *msg;
13929 void *hdr;
29ce6ecb 13930 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
b23aa676 13931
29ce6ecb 13932 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len, gfp);
b23aa676
SO		 13933 if (!msg)
13934 return;
13935
13936 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
13937 if (!hdr) {
13938 nlmsg_free(msg);
13939 return;
13940 }
13941
9360ffd1
DM		 13942 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13943 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13944 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
29ce6ecb
AS		 13945 (info->req_ie &&
13946 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
13947 info->req_ie)) ||
13948 (info->resp_ie &&
13949 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
503c1fb9 13950 info->resp_ie)))
9360ffd1 13951 goto nla_put_failure;
b23aa676 13952
3b7b72ee 13953 genlmsg_end(msg, hdr);
b23aa676 13954
68eb5503 13955 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13956 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13957 return;
13958
503c1fb9
AS		 13959 nla_put_failure:
13960 genlmsg_cancel(msg, hdr);
13961 nlmsg_free(msg);
13962}
13963
13964void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
13965 struct net_device *netdev, const u8 *bssid)
13966{
13967 struct sk_buff *msg;
13968 void *hdr;
13969
13970 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13971 if (!msg)
13972 return;
13973
13974 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
13975 if (!hdr) {
13976 nlmsg_free(msg);
13977 return;
13978 }
13979
13980 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
13981 goto nla_put_failure;
13982
13983 genlmsg_end(msg, hdr);
13984
13985 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
13986 NL80211_MCGRP_MLME, GFP_KERNEL);
13987 return;
13988
b23aa676
SO		 13989 nla_put_failure:
13990 genlmsg_cancel(msg, hdr);
13991 nlmsg_free(msg);
b23aa676
SO		 13992}
13993
13994void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
13995 struct net_device *netdev, u16 reason,
667503dd 13996 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 13997{
13998 struct sk_buff *msg;
13999 void *hdr;
14000
4ef8c1c9 14001 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
b23aa676
SO		 14002 if (!msg)
14003 return;
14004
14005 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
14006 if (!hdr) {
14007 nlmsg_free(msg);
14008 return;
14009 }
14010
9360ffd1
DM		 14011 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14012 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14013 (from_ap && reason &&
14014 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
14015 (from_ap &&
14016 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
14017 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
14018 goto nla_put_failure;
b23aa676 14019
3b7b72ee 14020 genlmsg_end(msg, hdr);
b23aa676 14021
68eb5503 14022 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14023 NL80211_MCGRP_MLME, GFP_KERNEL);
b23aa676
SO		 14024 return;
14025
14026 nla_put_failure:
14027 genlmsg_cancel(msg, hdr);
14028 nlmsg_free(msg);
b23aa676
SO		 14029}
14030
04a773ad
JB		 14031void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
14032 struct net_device *netdev, const u8 *bssid,
14033 gfp_t gfp)
14034{
14035 struct sk_buff *msg;
14036 void *hdr;
14037
fd2120ca 14038 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 14039 if (!msg)
14040 return;
14041
14042 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
14043 if (!hdr) {
14044 nlmsg_free(msg);
14045 return;
14046 }
14047
9360ffd1
DM		 14048 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14049 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14050 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14051 goto nla_put_failure;
04a773ad 14052
3b7b72ee 14053 genlmsg_end(msg, hdr);
04a773ad 14054
68eb5503 14055 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14056 NL80211_MCGRP_MLME, gfp);
04a773ad
JB		 14057 return;
14058
14059 nla_put_failure:
14060 genlmsg_cancel(msg, hdr);
14061 nlmsg_free(msg);
14062}
14063
947add36
JB		 14064void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
14065 const u8* ie, u8 ie_len, gfp_t gfp)
c93b5e71 14066{
947add36 14067 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14068 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
c93b5e71
JC		 14069 struct sk_buff *msg;
14070 void *hdr;
14071
947add36
JB		 14072 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
14073 return;
14074
14075 trace_cfg80211_notify_new_peer_candidate(dev, addr);
14076
4ef8c1c9 14077 msg = nlmsg_new(100 + ie_len, gfp);
c93b5e71
JC		 14078 if (!msg)
14079 return;
14080
14081 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
14082 if (!hdr) {
14083 nlmsg_free(msg);
14084 return;
14085 }
14086
9360ffd1 14087 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36
JB		 14088 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14089 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9360ffd1
DM		 14090 (ie_len && ie &&
14091 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
14092 goto nla_put_failure;
c93b5e71 14093
3b7b72ee 14094 genlmsg_end(msg, hdr);
c93b5e71 14095
68eb5503 14096 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14097 NL80211_MCGRP_MLME, gfp);
c93b5e71
JC		 14098 return;
14099
14100 nla_put_failure:
14101 genlmsg_cancel(msg, hdr);
14102 nlmsg_free(msg);
14103}
947add36 14104EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
c93b5e71 14105
a3b8b056
JM		 14106void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
14107 struct net_device *netdev, const u8 *addr,
14108 enum nl80211_key_type key_type, int key_id,
e6d6e342 14109 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 14110{
14111 struct sk_buff *msg;
14112 void *hdr;
14113
e6d6e342 14114 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 14115 if (!msg)
14116 return;
14117
14118 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
14119 if (!hdr) {
14120 nlmsg_free(msg);
14121 return;
14122 }
14123
9360ffd1
DM		 14124 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14125 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14126 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
14127 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
14128 (key_id != -1 &&
14129 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
14130 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
14131 goto nla_put_failure;
a3b8b056 14132
3b7b72ee 14133 genlmsg_end(msg, hdr);
a3b8b056 14134
68eb5503 14135 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14136 NL80211_MCGRP_MLME, gfp);
a3b8b056
JM		 14137 return;
14138
14139 nla_put_failure:
14140 genlmsg_cancel(msg, hdr);
14141 nlmsg_free(msg);
14142}
14143
6bad8766
LR		 14144void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
14145 struct ieee80211_channel *channel_before,
14146 struct ieee80211_channel *channel_after)
14147{
14148 struct sk_buff *msg;
14149 void *hdr;
14150 struct nlattr *nl_freq;
14151
fd2120ca 14152 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 14153 if (!msg)
14154 return;
14155
14156 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
14157 if (!hdr) {
14158 nlmsg_free(msg);
14159 return;
14160 }
14161
14162 /*
14163 * Since we are applying the beacon hint to a wiphy we know its
14164 * wiphy_idx is valid
14165 */
9360ffd1
DM		 14166 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
14167 goto nla_put_failure;
6bad8766
LR		 14168
14169 /* Before */
14170 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
14171 if (!nl_freq)
14172 goto nla_put_failure;
cdc89b97 14173 if (nl80211_msg_put_channel(msg, channel_before, false))
6bad8766
LR		 14174 goto nla_put_failure;
14175 nla_nest_end(msg, nl_freq);
14176
14177 /* After */
14178 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
14179 if (!nl_freq)
14180 goto nla_put_failure;
cdc89b97 14181 if (nl80211_msg_put_channel(msg, channel_after, false))
6bad8766
LR		 14182 goto nla_put_failure;
14183 nla_nest_end(msg, nl_freq);
14184
3b7b72ee 14185 genlmsg_end(msg, hdr);
6bad8766 14186
463d0183 14187 rcu_read_lock();
68eb5503 14188 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 14189 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
463d0183 14190 rcu_read_unlock();
6bad8766
LR		 14191
14192 return;
14193
14194nla_put_failure:
14195 genlmsg_cancel(msg, hdr);
14196 nlmsg_free(msg);
14197}
14198
9588bbd5
JM		 14199static void nl80211_send_remain_on_chan_event(
14200 int cmd, struct cfg80211_registered_device *rdev,
71bbc994 14201 struct wireless_dev *wdev, u64 cookie,
9588bbd5 14202 struct ieee80211_channel *chan,
9588bbd5
JM		 14203 unsigned int duration, gfp_t gfp)
14204{
14205 struct sk_buff *msg;
14206 void *hdr;
14207
14208 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14209 if (!msg)
14210 return;
14211
14212 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14213 if (!hdr) {
14214 nlmsg_free(msg);
14215 return;
14216 }
14217
9360ffd1 14218 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14219 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14220 wdev->netdev->ifindex)) ||
2dad624e
ND		 14221 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14222 NL80211_ATTR_PAD) ||
9360ffd1 14223 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
42d97a59
JB		 14224 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
14225 NL80211_CHAN_NO_HT) ||
2dad624e
ND		 14226 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14227 NL80211_ATTR_PAD))
9360ffd1 14228 goto nla_put_failure;
9588bbd5 14229
9360ffd1
DM		 14230 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
14231 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
14232 goto nla_put_failure;
9588bbd5 14233
3b7b72ee 14234 genlmsg_end(msg, hdr);
9588bbd5 14235
68eb5503 14236 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14237 NL80211_MCGRP_MLME, gfp);
9588bbd5
JM		 14238 return;
14239
14240 nla_put_failure:
14241 genlmsg_cancel(msg, hdr);
14242 nlmsg_free(msg);
14243}
14244
947add36
JB		 14245void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
14246 struct ieee80211_channel *chan,
14247 unsigned int duration, gfp_t gfp)
9588bbd5 14248{
947add36 14249 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14250 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14251
14252 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9588bbd5 14253 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
71bbc994 14254 rdev, wdev, cookie, chan,
42d97a59 14255 duration, gfp);
9588bbd5 14256}
947add36 14257EXPORT_SYMBOL(cfg80211_ready_on_channel);
9588bbd5 14258
947add36
JB		 14259void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
14260 struct ieee80211_channel *chan,
14261 gfp_t gfp)
9588bbd5 14262{
947add36 14263 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14264 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14265
14266 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9588bbd5 14267 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
42d97a59 14268 rdev, wdev, cookie, chan, 0, gfp);
9588bbd5 14269}
947add36 14270EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9588bbd5 14271
947add36
JB		 14272void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
14273 struct station_info *sinfo, gfp_t gfp)
98b62183 14274{
947add36 14275 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14276 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
98b62183
JB		 14277 struct sk_buff *msg;
14278
947add36
JB		 14279 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
14280
58050fce 14281 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
98b62183
JB		 14282 if (!msg)
14283 return;
14284
cf5ead82 14285 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
66266b3a 14286 rdev, dev, mac_addr, sinfo) < 0) {
98b62183
JB		 14287 nlmsg_free(msg);
14288 return;
14289 }
14290
68eb5503 14291 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14292 NL80211_MCGRP_MLME, gfp);
98b62183 14293}
947add36 14294EXPORT_SYMBOL(cfg80211_new_sta);
98b62183 14295
cf5ead82
JB		 14296void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
14297 struct station_info *sinfo, gfp_t gfp)
ec15e68b 14298{
947add36 14299 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14300 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ec15e68b 14301 struct sk_buff *msg;
cf5ead82
JB		 14302 struct station_info empty_sinfo = {};
14303
14304 if (!sinfo)
14305 sinfo = &empty_sinfo;
ec15e68b 14306
947add36
JB		 14307 trace_cfg80211_del_sta(dev, mac_addr);
14308
58050fce 14309 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
ec15e68b
JM		 14310 if (!msg)
14311 return;
14312
cf5ead82 14313 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
57007121 14314 rdev, dev, mac_addr, sinfo) < 0) {
ec15e68b
JM		 14315 nlmsg_free(msg);
14316 return;
14317 }
14318
68eb5503 14319 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14320 NL80211_MCGRP_MLME, gfp);
ec15e68b 14321}
cf5ead82 14322EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
ec15e68b 14323
947add36
JB		 14324void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
14325 enum nl80211_connect_failed_reason reason,
14326 gfp_t gfp)
ed44a951 14327{
947add36 14328 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14329 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ed44a951
PP		 14330 struct sk_buff *msg;
14331 void *hdr;
14332
14333 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
14334 if (!msg)
14335 return;
14336
14337 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
14338 if (!hdr) {
14339 nlmsg_free(msg);
14340 return;
14341 }
14342
14343 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14344 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
14345 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
14346 goto nla_put_failure;
14347
14348 genlmsg_end(msg, hdr);
14349
68eb5503 14350 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14351 NL80211_MCGRP_MLME, gfp);
ed44a951
PP		 14352 return;
14353
14354 nla_put_failure:
14355 genlmsg_cancel(msg, hdr);
14356 nlmsg_free(msg);
14357}
947add36 14358EXPORT_SYMBOL(cfg80211_conn_failed);
ed44a951 14359
b92ab5d8
JB		 14360static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
14361 const u8 *addr, gfp_t gfp)
28946da7
JB		 14362{
14363 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14364 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
28946da7
JB		 14365 struct sk_buff *msg;
14366 void *hdr;
6aa7de05 14367 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
28946da7 14368
15e47304 14369 if (!nlportid)
28946da7
JB		 14370 return false;
14371
14372 msg = nlmsg_new(100, gfp);
14373 if (!msg)
14374 return true;
14375
b92ab5d8 14376 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
28946da7
JB		 14377 if (!hdr) {
14378 nlmsg_free(msg);
14379 return true;
14380 }
14381
9360ffd1
DM		 14382 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14383 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14384 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
14385 goto nla_put_failure;
28946da7 14386
9c90a9f6 14387 genlmsg_end(msg, hdr);
15e47304 14388 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
28946da7
JB		 14389 return true;
14390
14391 nla_put_failure:
14392 genlmsg_cancel(msg, hdr);
14393 nlmsg_free(msg);
14394 return true;
14395}
14396
947add36
JB		 14397bool cfg80211_rx_spurious_frame(struct net_device *dev,
14398 const u8 *addr, gfp_t gfp)
b92ab5d8 14399{
947add36
JB		 14400 struct wireless_dev *wdev = dev->ieee80211_ptr;
14401 bool ret;
14402
14403 trace_cfg80211_rx_spurious_frame(dev, addr);
14404
14405 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14406 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
14407 trace_cfg80211_return_bool(false);
14408 return false;
14409 }
14410 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
14411 addr, gfp);
14412 trace_cfg80211_return_bool(ret);
14413 return ret;
b92ab5d8 14414}
947add36 14415EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
b92ab5d8 14416
947add36
JB		 14417bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
14418 const u8 *addr, gfp_t gfp)
b92ab5d8 14419{
947add36
JB		 14420 struct wireless_dev *wdev = dev->ieee80211_ptr;
14421 bool ret;
14422
14423 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
14424
14425 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14426 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
14427 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
14428 trace_cfg80211_return_bool(false);
14429 return false;
14430 }
14431 ret = __nl80211_unexpected_frame(dev,
14432 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
14433 addr, gfp);
14434 trace_cfg80211_return_bool(ret);
14435 return ret;
b92ab5d8 14436}
947add36 14437EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
b92ab5d8 14438
2e161f78 14439int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15e47304 14440 struct wireless_dev *wdev, u32 nlportid,
804483e9 14441 int freq, int sig_dbm,
19504cf5 14442 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
026331c4 14443{
71bbc994 14444 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14445 struct sk_buff *msg;
14446 void *hdr;
026331c4 14447
4ef8c1c9 14448 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14449 if (!msg)
14450 return -ENOMEM;
14451
2e161f78 14452 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
026331c4
JM		 14453 if (!hdr) {
14454 nlmsg_free(msg);
14455 return -ENOMEM;
14456 }
14457
9360ffd1 14458 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14459 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14460 netdev->ifindex)) ||
2dad624e
ND		 14461 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14462 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14463 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
14464 (sig_dbm &&
14465 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19504cf5
VK		 14466 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
14467 (flags &&
14468 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
9360ffd1 14469 goto nla_put_failure;
026331c4 14470
3b7b72ee 14471 genlmsg_end(msg, hdr);
026331c4 14472
15e47304 14473 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
026331c4
JM		 14474
14475 nla_put_failure:
14476 genlmsg_cancel(msg, hdr);
14477 nlmsg_free(msg);
14478 return -ENOBUFS;
14479}
14480
947add36
JB		 14481void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
14482 const u8 *buf, size_t len, bool ack, gfp_t gfp)
026331c4 14483{
947add36 14484 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14485 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
71bbc994 14486 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14487 struct sk_buff *msg;
14488 void *hdr;
14489
947add36
JB		 14490 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
14491
4ef8c1c9 14492 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14493 if (!msg)
14494 return;
14495
2e161f78 14496 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
026331c4
JM		 14497 if (!hdr) {
14498 nlmsg_free(msg);
14499 return;
14500 }
14501
9360ffd1 14502 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14503 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14504 netdev->ifindex)) ||
2dad624e
ND		 14505 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14506 NL80211_ATTR_PAD) ||
9360ffd1 14507 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
2dad624e
ND		 14508 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14509 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14510 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
14511 goto nla_put_failure;
026331c4 14512
3b7b72ee 14513 genlmsg_end(msg, hdr);
026331c4 14514
68eb5503 14515 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14516 NL80211_MCGRP_MLME, gfp);
026331c4
JM		 14517 return;
14518
14519 nla_put_failure:
14520 genlmsg_cancel(msg, hdr);
14521 nlmsg_free(msg);
14522}
947add36 14523EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
026331c4 14524
5b97f49d
JB		 14525static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
14526 const char *mac, gfp_t gfp)
d6dc1a38 14527{
947add36 14528 struct wireless_dev *wdev = dev->ieee80211_ptr;
5b97f49d
JB		 14529 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
14530 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14531 void **cb;
947add36 14532
d6dc1a38 14533 if (!msg)
5b97f49d 14534 return NULL;
d6dc1a38 14535
5b97f49d
JB		 14536 cb = (void **)msg->cb;
14537
14538 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
14539 if (!cb[0]) {
d6dc1a38 14540 nlmsg_free(msg);
5b97f49d 14541 return NULL;
d6dc1a38
JO		 14542 }
14543
9360ffd1 14544 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36 14545 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9360ffd1 14546 goto nla_put_failure;
d6dc1a38 14547
5b97f49d 14548 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
d6dc1a38
JO		 14549 goto nla_put_failure;
14550
5b97f49d
JB		 14551 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
14552 if (!cb[1])
9360ffd1 14553 goto nla_put_failure;
d6dc1a38 14554
5b97f49d 14555 cb[2] = rdev;
d6dc1a38 14556
5b97f49d
JB		 14557 return msg;
14558 nla_put_failure:
14559 nlmsg_free(msg);
14560 return NULL;
14561}
14562
14563static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
14564{
14565 void **cb = (void **)msg->cb;
14566 struct cfg80211_registered_device *rdev = cb[2];
14567
14568 nla_nest_end(msg, cb[1]);
14569 genlmsg_end(msg, cb[0]);
14570
14571 memset(msg->cb, 0, sizeof(msg->cb));
d6dc1a38 14572
68eb5503 14573 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14574 NL80211_MCGRP_MLME, gfp);
5b97f49d
JB		 14575}
14576
14577void cfg80211_cqm_rssi_notify(struct net_device *dev,
14578 enum nl80211_cqm_rssi_threshold_event rssi_event,
bee427b8 14579 s32 rssi_level, gfp_t gfp)
5b97f49d
JB		 14580{
14581 struct sk_buff *msg;
4a4b8169
AZ		 14582 struct wireless_dev *wdev = dev->ieee80211_ptr;
14583 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
5b97f49d 14584
bee427b8 14585 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
5b97f49d 14586
98f03342
JB		 14587 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
14588 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
14589 return;
14590
4a4b8169
AZ		 14591 if (wdev->cqm_config) {
14592 wdev->cqm_config->last_rssi_event_value = rssi_level;
14593
14594 cfg80211_cqm_rssi_update(rdev, dev);
14595
14596 if (rssi_level == 0)
14597 rssi_level = wdev->cqm_config->last_rssi_event_value;
14598 }
14599
5b97f49d
JB		 14600 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14601 if (!msg)
14602 return;
14603
14604 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
14605 rssi_event))
14606 goto nla_put_failure;
14607
bee427b8
AZ		 14608 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
14609 rssi_level))
14610 goto nla_put_failure;
14611
5b97f49d
JB		 14612 cfg80211_send_cqm(msg, gfp);
14613
d6dc1a38
JO		 14614 return;
14615
14616 nla_put_failure:
d6dc1a38
JO		 14617 nlmsg_free(msg);
14618}
947add36 14619EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
d6dc1a38 14620
5b97f49d
JB		 14621void cfg80211_cqm_txe_notify(struct net_device *dev,
14622 const u8 *peer, u32 num_packets,
14623 u32 rate, u32 intvl, gfp_t gfp)
14624{
14625 struct sk_buff *msg;
14626
14627 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14628 if (!msg)
14629 return;
14630
14631 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
14632 goto nla_put_failure;
14633
14634 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
14635 goto nla_put_failure;
14636
14637 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
14638 goto nla_put_failure;
14639
14640 cfg80211_send_cqm(msg, gfp);
14641 return;
14642
14643 nla_put_failure:
14644 nlmsg_free(msg);
14645}
14646EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
14647
14648void cfg80211_cqm_pktloss_notify(struct net_device *dev,
14649 const u8 *peer, u32 num_packets, gfp_t gfp)
14650{
14651 struct sk_buff *msg;
14652
14653 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
14654
14655 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14656 if (!msg)
14657 return;
14658
14659 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
14660 goto nla_put_failure;
14661
14662 cfg80211_send_cqm(msg, gfp);
14663 return;
14664
14665 nla_put_failure:
14666 nlmsg_free(msg);
14667}
14668EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
14669
98f03342
JB		 14670void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
14671{
14672 struct sk_buff *msg;
14673
14674 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14675 if (!msg)
14676 return;
14677
14678 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
14679 goto nla_put_failure;
14680
14681 cfg80211_send_cqm(msg, gfp);
14682 return;
14683
14684 nla_put_failure:
14685 nlmsg_free(msg);
14686}
14687EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
14688
947add36
JB		 14689static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
14690 struct net_device *netdev, const u8 *bssid,
14691 const u8 *replay_ctr, gfp_t gfp)
e5497d76
JB		 14692{
14693 struct sk_buff *msg;
14694 struct nlattr *rekey_attr;
14695 void *hdr;
14696
58050fce 14697 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
e5497d76
JB		 14698 if (!msg)
14699 return;
14700
14701 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
14702 if (!hdr) {
14703 nlmsg_free(msg);
14704 return;
14705 }
14706
9360ffd1
DM		 14707 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14708 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14709 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14710 goto nla_put_failure;
e5497d76
JB		 14711
14712 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
14713 if (!rekey_attr)
14714 goto nla_put_failure;
14715
9360ffd1
DM		 14716 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
14717 NL80211_REPLAY_CTR_LEN, replay_ctr))
14718 goto nla_put_failure;
e5497d76
JB		 14719
14720 nla_nest_end(msg, rekey_attr);
14721
3b7b72ee 14722 genlmsg_end(msg, hdr);
e5497d76 14723
68eb5503 14724 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14725 NL80211_MCGRP_MLME, gfp);
e5497d76
JB		 14726 return;
14727
14728 nla_put_failure:
14729 genlmsg_cancel(msg, hdr);
14730 nlmsg_free(msg);
14731}
14732
947add36
JB		 14733void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
14734 const u8 *replay_ctr, gfp_t gfp)
14735{
14736 struct wireless_dev *wdev = dev->ieee80211_ptr;
14737 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14738 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14739
14740 trace_cfg80211_gtk_rekey_notify(dev, bssid);
14741 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
14742}
14743EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
14744
14745static void
14746nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
14747 struct net_device *netdev, int index,
14748 const u8 *bssid, bool preauth, gfp_t gfp)
c9df56b4
JM		 14749{
14750 struct sk_buff *msg;
14751 struct nlattr *attr;
14752 void *hdr;
14753
58050fce 14754 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
c9df56b4
JM		 14755 if (!msg)
14756 return;
14757
14758 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
14759 if (!hdr) {
14760 nlmsg_free(msg);
14761 return;
14762 }
14763
9360ffd1
DM		 14764 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14765 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14766 goto nla_put_failure;
c9df56b4
JM		 14767
14768 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
14769 if (!attr)
14770 goto nla_put_failure;
14771
9360ffd1
DM		 14772 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
14773 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
14774 (preauth &&
14775 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
14776 goto nla_put_failure;
c9df56b4
JM		 14777
14778 nla_nest_end(msg, attr);
14779
3b7b72ee 14780 genlmsg_end(msg, hdr);
c9df56b4 14781
68eb5503 14782 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14783 NL80211_MCGRP_MLME, gfp);
c9df56b4
JM		 14784 return;
14785
14786 nla_put_failure:
14787 genlmsg_cancel(msg, hdr);
14788 nlmsg_free(msg);
14789}
14790
947add36
JB		 14791void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
14792 const u8 *bssid, bool preauth, gfp_t gfp)
14793{
14794 struct wireless_dev *wdev = dev->ieee80211_ptr;
14795 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14796 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14797
14798 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
14799 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
14800}
14801EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
14802
14803static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
14804 struct net_device *netdev,
14805 struct cfg80211_chan_def *chandef,
f8d7552e
LC		 14806 gfp_t gfp,
14807 enum nl80211_commands notif,
14808 u8 count)
5314526b
TP		 14809{
14810 struct sk_buff *msg;
14811 void *hdr;
14812
58050fce 14813 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5314526b
TP		 14814 if (!msg)
14815 return;
14816
f8d7552e 14817 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
5314526b
TP		 14818 if (!hdr) {
14819 nlmsg_free(msg);
14820 return;
14821 }
14822
683b6d3b
JB		 14823 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14824 goto nla_put_failure;
14825
14826 if (nl80211_send_chandef(msg, chandef))
7eab0f64 14827 goto nla_put_failure;
5314526b 14828
f8d7552e
LC		 14829 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
14830 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
14831 goto nla_put_failure;
14832
5314526b
TP		 14833 genlmsg_end(msg, hdr);
14834
68eb5503 14835 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14836 NL80211_MCGRP_MLME, gfp);
5314526b
TP		 14837 return;
14838
14839 nla_put_failure:
14840 genlmsg_cancel(msg, hdr);
14841 nlmsg_free(msg);
14842}
14843
947add36
JB		 14844void cfg80211_ch_switch_notify(struct net_device *dev,
14845 struct cfg80211_chan_def *chandef)
84f10708 14846{
947add36
JB		 14847 struct wireless_dev *wdev = dev->ieee80211_ptr;
14848 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14849 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36 14850
e487eaeb 14851 ASSERT_WDEV_LOCK(wdev);
947add36 14852
e487eaeb 14853 trace_cfg80211_ch_switch_notify(dev, chandef);
947add36 14854
9e0e2961 14855 wdev->chandef = *chandef;
96f55f12 14856 wdev->preset_chandef = *chandef;
10b56e14
SM		 14857
14858 if (wdev->iftype == NL80211_IFTYPE_STATION &&
14859 !WARN_ON(!wdev->current_bss))
14860 wdev->current_bss->pub.channel = chandef->chan;
14861
f8d7552e
LC		 14862 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14863 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
947add36
JB		 14864}
14865EXPORT_SYMBOL(cfg80211_ch_switch_notify);
14866
f8d7552e
LC		 14867void cfg80211_ch_switch_started_notify(struct net_device *dev,
14868 struct cfg80211_chan_def *chandef,
14869 u8 count)
14870{
14871 struct wireless_dev *wdev = dev->ieee80211_ptr;
14872 struct wiphy *wiphy = wdev->wiphy;
14873 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14874
14875 trace_cfg80211_ch_switch_started_notify(dev, chandef);
14876
14877 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14878 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
14879}
14880EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
14881
04f39047
SW		 14882void
14883nl80211_radar_notify(struct cfg80211_registered_device *rdev,
d2859df5 14884 const struct cfg80211_chan_def *chandef,
04f39047
SW		 14885 enum nl80211_radar_event event,
14886 struct net_device *netdev, gfp_t gfp)
14887{
14888 struct sk_buff *msg;
14889 void *hdr;
14890
14891 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14892 if (!msg)
14893 return;
14894
14895 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
14896 if (!hdr) {
14897 nlmsg_free(msg);
14898 return;
14899 }
14900
14901 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
14902 goto nla_put_failure;
14903
14904 /* NOP and radar events don't need a netdev parameter */
14905 if (netdev) {
14906 struct wireless_dev *wdev = netdev->ieee80211_ptr;
14907
14908 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
2dad624e
ND		 14909 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14910 NL80211_ATTR_PAD))
04f39047
SW		 14911 goto nla_put_failure;
14912 }
14913
14914 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
14915 goto nla_put_failure;
14916
14917 if (nl80211_send_chandef(msg, chandef))
14918 goto nla_put_failure;
14919
9c90a9f6 14920 genlmsg_end(msg, hdr);
04f39047 14921
68eb5503 14922 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14923 NL80211_MCGRP_MLME, gfp);
04f39047
SW		 14924 return;
14925
14926 nla_put_failure:
14927 genlmsg_cancel(msg, hdr);
14928 nlmsg_free(msg);
14929}
14930
7f6cf311
JB		 14931void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
14932 u64 cookie, bool acked, gfp_t gfp)
14933{
14934 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14935 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
7f6cf311
JB		 14936 struct sk_buff *msg;
14937 void *hdr;
7f6cf311 14938
4ee3e063
BL		 14939 trace_cfg80211_probe_status(dev, addr, cookie, acked);
14940
58050fce 14941 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4ee3e063 14942
7f6cf311
JB		 14943 if (!msg)
14944 return;
14945
14946 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
14947 if (!hdr) {
14948 nlmsg_free(msg);
14949 return;
14950 }
14951
9360ffd1
DM		 14952 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14953 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14954 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
2dad624e
ND		 14955 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14956 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14957 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
14958 goto nla_put_failure;
7f6cf311 14959
9c90a9f6 14960 genlmsg_end(msg, hdr);
7f6cf311 14961
68eb5503 14962 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14963 NL80211_MCGRP_MLME, gfp);
7f6cf311
JB		 14964 return;
14965
14966 nla_put_failure:
14967 genlmsg_cancel(msg, hdr);
14968 nlmsg_free(msg);
14969}
14970EXPORT_SYMBOL(cfg80211_probe_status);
14971
5e760230
JB		 14972void cfg80211_report_obss_beacon(struct wiphy *wiphy,
14973 const u8 *frame, size_t len,
37c73b5f 14974 int freq, int sig_dbm)
5e760230 14975{
f26cbf40 14976 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5e760230
JB		 14977 struct sk_buff *msg;
14978 void *hdr;
37c73b5f 14979 struct cfg80211_beacon_registration *reg;
5e760230 14980
4ee3e063
BL		 14981 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
14982
37c73b5f
BG		 14983 spin_lock_bh(&rdev->beacon_registrations_lock);
14984 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
14985 msg = nlmsg_new(len + 100, GFP_ATOMIC);
14986 if (!msg) {
14987 spin_unlock_bh(&rdev->beacon_registrations_lock);
14988 return;
14989 }
5e760230 14990
37c73b5f
BG		 14991 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
14992 if (!hdr)
14993 goto nla_put_failure;
5e760230 14994
37c73b5f
BG		 14995 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14996 (freq &&
14997 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
14998 (sig_dbm &&
14999 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
15000 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
15001 goto nla_put_failure;
5e760230 15002
37c73b5f 15003 genlmsg_end(msg, hdr);
5e760230 15004
37c73b5f
BG		 15005 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
15006 }
15007 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 15008 return;
15009
15010 nla_put_failure:
37c73b5f
BG		 15011 spin_unlock_bh(&rdev->beacon_registrations_lock);
15012 if (hdr)
15013 genlmsg_cancel(msg, hdr);
5e760230
JB		 15014 nlmsg_free(msg);
15015}
15016EXPORT_SYMBOL(cfg80211_report_obss_beacon);
15017
cd8f7cb4 15018#ifdef CONFIG_PM
8cd4d456
LC		 15019static int cfg80211_net_detect_results(struct sk_buff *msg,
15020 struct cfg80211_wowlan_wakeup *wakeup)
15021{
15022 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
15023 struct nlattr *nl_results, *nl_match, *nl_freqs;
15024 int i, j;
15025
15026 nl_results = nla_nest_start(
15027 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
15028 if (!nl_results)
15029 return -EMSGSIZE;
15030
15031 for (i = 0; i < nd->n_matches; i++) {
15032 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
15033
15034 nl_match = nla_nest_start(msg, i);
15035 if (!nl_match)
15036 break;
15037
15038 /* The SSID attribute is optional in nl80211, but for
15039 * simplicity reasons it's always present in the
15040 * cfg80211 structure. If a driver can't pass the
15041 * SSID, that needs to be changed. A zero length SSID
15042 * is still a valid SSID (wildcard), so it cannot be
15043 * used for this purpose.
15044 */
15045 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
15046 match->ssid.ssid)) {
15047 nla_nest_cancel(msg, nl_match);
15048 goto out;
15049 }
15050
15051 if (match->n_channels) {
15052 nl_freqs = nla_nest_start(
15053 msg, NL80211_ATTR_SCAN_FREQUENCIES);
15054 if (!nl_freqs) {
15055 nla_nest_cancel(msg, nl_match);
15056 goto out;
15057 }
15058
15059 for (j = 0; j < match->n_channels; j++) {
5528fae8 15060 if (nla_put_u32(msg, j, match->channels[j])) {
8cd4d456
LC		 15061 nla_nest_cancel(msg, nl_freqs);
15062 nla_nest_cancel(msg, nl_match);
15063 goto out;
15064 }
15065 }
15066
15067 nla_nest_end(msg, nl_freqs);
15068 }
15069
15070 nla_nest_end(msg, nl_match);
15071 }
15072
15073out:
15074 nla_nest_end(msg, nl_results);
15075 return 0;
15076}
15077
cd8f7cb4
JB		 15078void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
15079 struct cfg80211_wowlan_wakeup *wakeup,
15080 gfp_t gfp)
15081{
f26cbf40 15082 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
cd8f7cb4
JB		 15083 struct sk_buff *msg;
15084 void *hdr;
9c90a9f6 15085 int size = 200;
cd8f7cb4
JB		 15086
15087 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
15088
15089 if (wakeup)
15090 size += wakeup->packet_present_len;
15091
15092 msg = nlmsg_new(size, gfp);
15093 if (!msg)
15094 return;
15095
15096 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
15097 if (!hdr)
15098 goto free_msg;
15099
15100 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 15101 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15102 NL80211_ATTR_PAD))
cd8f7cb4
JB		 15103 goto free_msg;
15104
15105 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15106 wdev->netdev->ifindex))
15107 goto free_msg;
15108
15109 if (wakeup) {
15110 struct nlattr *reasons;
15111
15112 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7fa322c8
JB		 15113 if (!reasons)
15114 goto free_msg;
cd8f7cb4
JB		 15115
15116 if (wakeup->disconnect &&
15117 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
15118 goto free_msg;
15119 if (wakeup->magic_pkt &&
15120 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
15121 goto free_msg;
15122 if (wakeup->gtk_rekey_failure &&
15123 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
15124 goto free_msg;
15125 if (wakeup->eap_identity_req &&
15126 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
15127 goto free_msg;
15128 if (wakeup->four_way_handshake &&
15129 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
15130 goto free_msg;
15131 if (wakeup->rfkill_release &&
15132 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
15133 goto free_msg;
15134
15135 if (wakeup->pattern_idx >= 0 &&
15136 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
15137 wakeup->pattern_idx))
15138 goto free_msg;
15139
ae917c9f
JB		 15140 if (wakeup->tcp_match &&
15141 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
15142 goto free_msg;
2a0e047e 15143
ae917c9f
JB		 15144 if (wakeup->tcp_connlost &&
15145 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
15146 goto free_msg;
2a0e047e 15147
ae917c9f
JB		 15148 if (wakeup->tcp_nomoretokens &&
15149 nla_put_flag(msg,
15150 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
15151 goto free_msg;
2a0e047e 15152
cd8f7cb4
JB		 15153 if (wakeup->packet) {
15154 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
15155 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
15156
15157 if (!wakeup->packet_80211) {
15158 pkt_attr =
15159 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
15160 len_attr =
15161 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
15162 }
15163
15164 if (wakeup->packet_len &&
15165 nla_put_u32(msg, len_attr, wakeup->packet_len))
15166 goto free_msg;
15167
15168 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
15169 wakeup->packet))
15170 goto free_msg;
15171 }
15172
8cd4d456
LC		 15173 if (wakeup->net_detect &&
15174 cfg80211_net_detect_results(msg, wakeup))
15175 goto free_msg;
15176
cd8f7cb4
JB		 15177 nla_nest_end(msg, reasons);
15178 }
15179
9c90a9f6 15180 genlmsg_end(msg, hdr);
cd8f7cb4 15181
68eb5503 15182 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15183 NL80211_MCGRP_MLME, gfp);
cd8f7cb4
JB		 15184 return;
15185
15186 free_msg:
15187 nlmsg_free(msg);
15188}
15189EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
15190#endif
15191
3475b094
JM		 15192void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
15193 enum nl80211_tdls_operation oper,
15194 u16 reason_code, gfp_t gfp)
15195{
15196 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 15197 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
3475b094
JM		 15198 struct sk_buff *msg;
15199 void *hdr;
3475b094
JM		 15200
15201 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
15202 reason_code);
15203
15204 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15205 if (!msg)
15206 return;
15207
15208 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
15209 if (!hdr) {
15210 nlmsg_free(msg);
15211 return;
15212 }
15213
15214 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15215 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15216 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
15217 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
15218 (reason_code > 0 &&
15219 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
15220 goto nla_put_failure;
15221
9c90a9f6 15222 genlmsg_end(msg, hdr);
3475b094 15223
68eb5503 15224 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15225 NL80211_MCGRP_MLME, gfp);
3475b094
JM		 15226 return;
15227
15228 nla_put_failure:
15229 genlmsg_cancel(msg, hdr);
15230 nlmsg_free(msg);
15231}
15232EXPORT_SYMBOL(cfg80211_tdls_oper_request);
15233
026331c4
JM		 15234static int nl80211_netlink_notify(struct notifier_block * nb,
15235 unsigned long state,
15236 void *_notify)
15237{
15238 struct netlink_notify *notify = _notify;
15239 struct cfg80211_registered_device *rdev;
15240 struct wireless_dev *wdev;
37c73b5f 15241 struct cfg80211_beacon_registration *reg, *tmp;
026331c4 15242
8f815cdd 15243 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
026331c4
JM		 15244 return NOTIFY_DONE;
15245
15246 rcu_read_lock();
15247
5e760230 15248 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
ca986ad9 15249 struct cfg80211_sched_scan_request *sched_scan_req;
753aacfd 15250
ca986ad9
AVS		 15251 list_for_each_entry_rcu(sched_scan_req,
15252 &rdev->sched_scan_req_list,
15253 list) {
15254 if (sched_scan_req->owner_nlportid == notify->portid) {
15255 sched_scan_req->nl_owner_dead = true;
753aacfd 15256 schedule_work(&rdev->sched_scan_stop_wk);
ca986ad9 15257 }
753aacfd 15258 }
78f22b6a 15259
53873f13 15260 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
15e47304 15261 cfg80211_mlme_unregister_socket(wdev, notify->portid);
37c73b5f 15262
ab81007a
JB		 15263 if (wdev->owner_nlportid == notify->portid) {
15264 wdev->nl_owner_dead = true;
15265 schedule_work(&rdev->destroy_work);
15266 } else if (wdev->conn_owner_nlportid == notify->portid) {
bd2522b1 15267 schedule_work(&wdev->disconnect_wk);
ab81007a 15268 }
78f22b6a
JB		 15269 }
15270
37c73b5f
BG		 15271 spin_lock_bh(&rdev->beacon_registrations_lock);
15272 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
15273 list) {
15274 if (reg->nlportid == notify->portid) {
15275 list_del(&reg->list);
15276 kfree(reg);
15277 break;
15278 }
15279 }
15280 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230 15281 }
026331c4
JM		 15282
15283 rcu_read_unlock();
15284
05050753
I		 15285 /*
15286 * It is possible that the user space process that is controlling the
15287 * indoor setting disappeared, so notify the regulatory core.
15288 */
15289 regulatory_netlink_notify(notify->portid);
6784c7db 15290 return NOTIFY_OK;
026331c4
JM		 15291}
15292
15293static struct notifier_block nl80211_netlink_notifier = {
15294 .notifier_call = nl80211_netlink_notify,
15295};
15296
355199e0
JM		 15297void cfg80211_ft_event(struct net_device *netdev,
15298 struct cfg80211_ft_event_params *ft_event)
15299{
15300 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
f26cbf40 15301 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
355199e0
JM		 15302 struct sk_buff *msg;
15303 void *hdr;
355199e0
JM		 15304
15305 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
15306
15307 if (!ft_event->target_ap)
15308 return;
15309
4ef8c1c9 15310 msg = nlmsg_new(100 + ft_event->ric_ies_len, GFP_KERNEL);
355199e0
JM		 15311 if (!msg)
15312 return;
15313
15314 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
ae917c9f
JB		 15315 if (!hdr)
15316 goto out;
355199e0 15317
ae917c9f
JB		 15318 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15319 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15320 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
15321 goto out;
355199e0 15322
ae917c9f
JB		 15323 if (ft_event->ies &&
15324 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
15325 goto out;
15326 if (ft_event->ric_ies &&
15327 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
15328 ft_event->ric_ies))
15329 goto out;
355199e0 15330
9c90a9f6 15331 genlmsg_end(msg, hdr);
355199e0 15332
68eb5503 15333 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15334 NL80211_MCGRP_MLME, GFP_KERNEL);
ae917c9f
JB		 15335 return;
15336 out:
15337 nlmsg_free(msg);
355199e0
JM		 15338}
15339EXPORT_SYMBOL(cfg80211_ft_event);
15340
5de17984
AS		 15341void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
15342{
15343 struct cfg80211_registered_device *rdev;
15344 struct sk_buff *msg;
15345 void *hdr;
15346 u32 nlportid;
15347
f26cbf40 15348 rdev = wiphy_to_rdev(wdev->wiphy);
5de17984
AS		 15349 if (!rdev->crit_proto_nlportid)
15350 return;
15351
15352 nlportid = rdev->crit_proto_nlportid;
15353 rdev->crit_proto_nlportid = 0;
15354
15355 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15356 if (!msg)
15357 return;
15358
15359 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
15360 if (!hdr)
15361 goto nla_put_failure;
15362
15363 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 15364 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15365 NL80211_ATTR_PAD))
5de17984
AS		 15366 goto nla_put_failure;
15367
15368 genlmsg_end(msg, hdr);
15369
15370 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15371 return;
15372
15373 nla_put_failure:
15374 if (hdr)
15375 genlmsg_cancel(msg, hdr);
15376 nlmsg_free(msg);
5de17984
AS		 15377}
15378EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
15379
348baf0e
JB		 15380void nl80211_send_ap_stopped(struct wireless_dev *wdev)
15381{
15382 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 15383 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
348baf0e
JB		 15384 struct sk_buff *msg;
15385 void *hdr;
15386
15387 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15388 if (!msg)
15389 return;
15390
15391 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
15392 if (!hdr)
15393 goto out;
15394
15395 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15396 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
2dad624e
ND		 15397 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15398 NL80211_ATTR_PAD))
348baf0e
JB		 15399 goto out;
15400
15401 genlmsg_end(msg, hdr);
15402
15403 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
15404 NL80211_MCGRP_MLME, GFP_KERNEL);
15405 return;
15406 out:
15407 nlmsg_free(msg);
15408}
15409
55682965
JB		 15410/* initialisation/exit functions */
15411
56989f6d 15412int __init nl80211_init(void)
55682965 15413{
0d63cbb5 15414 int err;
55682965 15415
489111e5 15416 err = genl_register_family(&nl80211_fam);
55682965
JB		 15417 if (err)
15418 return err;
15419
026331c4
JM		 15420 err = netlink_register_notifier(&nl80211_netlink_notifier);
15421 if (err)
15422 goto err_out;
15423
55682965
JB		 15424 return 0;
15425 err_out:
15426 genl_unregister_family(&nl80211_fam);
15427 return err;
15428}
15429
15430void nl80211_exit(void)
15431{
026331c4 15432 netlink_unregister_notifier(&nl80211_netlink_notifier);
55682965
JB		 15433 genl_unregister_family(&nl80211_fam);
15434}
ubuntu-bionic-kernel mirror