]> 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
cfg80211: Check if PMKID attribute is of expected size
[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>
2a519311 19#include <linux/etherdevice.h>
463d0183 20#include <net/net_namespace.h>
55682965
JB		 21#include <net/genetlink.h>
22#include <net/cfg80211.h>
463d0183 23#include <net/sock.h>
2a0e047e 24#include <net/inet_connection_sock.h>
55682965
JB		 25#include "core.h"
26#include "nl80211.h"
b2e1b302 27#include "reg.h"
e35e4d28 28#include "rdev-ops.h"
55682965 29
5fb628e9
JM		 30static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
31 struct genl_info *info,
32 struct cfg80211_crypto_settings *settings,
33 int cipher_limit);
34
55682965 35/* the netlink family */
489111e5 36static struct genl_family nl80211_fam;
55682965 37
2a94fe48
JB		 38/* multicast groups */
39enum nl80211_multicast_groups {
40 NL80211_MCGRP_CONFIG,
41 NL80211_MCGRP_SCAN,
42 NL80211_MCGRP_REGULATORY,
43 NL80211_MCGRP_MLME,
567ffc35 44 NL80211_MCGRP_VENDOR,
50bcd31d 45 NL80211_MCGRP_NAN,
2a94fe48
JB		 46 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
47};
48
49static const struct genl_multicast_group nl80211_mcgrps[] = {
71b836ec
JB		 50 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
51 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
52 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
53 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
54 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
50bcd31d 55 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN },
2a94fe48 56#ifdef CONFIG_NL80211_TESTMODE
71b836ec 57 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
2a94fe48
JB		 58#endif
59};
60
89a54e48
JB		 61/* returns ERR_PTR values */
62static struct wireless_dev *
63__cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
55682965 64{
89a54e48
JB		 65 struct cfg80211_registered_device *rdev;
66 struct wireless_dev *result = NULL;
67 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
68 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
69 u64 wdev_id;
70 int wiphy_idx = -1;
71 int ifidx = -1;
55682965 72
5fe231e8 73 ASSERT_RTNL();
55682965 74
89a54e48
JB		 75 if (!have_ifidx && !have_wdev_id)
76 return ERR_PTR(-EINVAL);
55682965 77
89a54e48
JB		 78 if (have_ifidx)
79 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
80 if (have_wdev_id) {
81 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
82 wiphy_idx = wdev_id >> 32;
55682965
JB		 83 }
84
89a54e48
JB		 85 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
86 struct wireless_dev *wdev;
87
88 if (wiphy_net(&rdev->wiphy) != netns)
89 continue;
90
91 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
92 continue;
93
53873f13 94 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
89a54e48
JB		 95 if (have_ifidx && wdev->netdev &&
96 wdev->netdev->ifindex == ifidx) {
97 result = wdev;
98 break;
99 }
100 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
101 result = wdev;
102 break;
103 }
104 }
89a54e48
JB		 105
106 if (result)
107 break;
108 }
109
110 if (result)
111 return result;
112 return ERR_PTR(-ENODEV);
55682965
JB		 113}
114
a9455408 115static struct cfg80211_registered_device *
878d9ec7 116__cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
a9455408 117{
7fee4778
JB		 118 struct cfg80211_registered_device *rdev = NULL, *tmp;
119 struct net_device *netdev;
a9455408 120
5fe231e8 121 ASSERT_RTNL();
a9455408 122
878d9ec7 123 if (!attrs[NL80211_ATTR_WIPHY] &&
89a54e48
JB		 124 !attrs[NL80211_ATTR_IFINDEX] &&
125 !attrs[NL80211_ATTR_WDEV])
7fee4778
JB		 126 return ERR_PTR(-EINVAL);
127
878d9ec7 128 if (attrs[NL80211_ATTR_WIPHY])
7fee4778 129 rdev = cfg80211_rdev_by_wiphy_idx(
878d9ec7 130 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
a9455408 131
89a54e48
JB		 132 if (attrs[NL80211_ATTR_WDEV]) {
133 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
134 struct wireless_dev *wdev;
135 bool found = false;
136
137 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
138 if (tmp) {
139 /* make sure wdev exists */
53873f13 140 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
89a54e48
JB		 141 if (wdev->identifier != (u32)wdev_id)
142 continue;
143 found = true;
144 break;
145 }
89a54e48
JB		 146
147 if (!found)
148 tmp = NULL;
149
150 if (rdev && tmp != rdev)
151 return ERR_PTR(-EINVAL);
152 rdev = tmp;
153 }
154 }
155
878d9ec7
JB		 156 if (attrs[NL80211_ATTR_IFINDEX]) {
157 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
7a087e74 158
7f2b8562 159 netdev = __dev_get_by_index(netns, ifindex);
7fee4778
JB		 160 if (netdev) {
161 if (netdev->ieee80211_ptr)
f26cbf40
ZG		 162 tmp = wiphy_to_rdev(
163 netdev->ieee80211_ptr->wiphy);
7fee4778
JB		 164 else
165 tmp = NULL;
166
7fee4778
JB		 167 /* not wireless device -- return error */
168 if (!tmp)
169 return ERR_PTR(-EINVAL);
170
171 /* mismatch -- return error */
172 if (rdev && tmp != rdev)
173 return ERR_PTR(-EINVAL);
174
175 rdev = tmp;
a9455408 176 }
a9455408 177 }
a9455408 178
4f7eff10
JB		 179 if (!rdev)
180 return ERR_PTR(-ENODEV);
a9455408 181
4f7eff10
JB		 182 if (netns != wiphy_net(&rdev->wiphy))
183 return ERR_PTR(-ENODEV);
184
185 return rdev;
a9455408
JB		 186}
187
188/*
189 * This function returns a pointer to the driver
190 * that the genl_info item that is passed refers to.
a9455408
JB		 191 *
192 * The result of this can be a PTR_ERR and hence must
193 * be checked with IS_ERR() for errors.
194 */
195static struct cfg80211_registered_device *
4f7eff10 196cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
a9455408 197{
5fe231e8 198 return __cfg80211_rdev_from_attrs(netns, info->attrs);
a9455408
JB		 199}
200
55682965 201/* policy for the attributes */
8cd4d456 202static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
55682965
JB		 203 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
204 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
079e24ed 205 .len = 20-1 },
31888487 206 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
3d9d1d66 207
72bdcf34 208 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
094d05dc 209 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
3d9d1d66
JB		 210 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
211 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
212 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
213
b9a5f8ca
JM		 214 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
215 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
216 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
217 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
81077e82 218 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
3057dbfd 219 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
55682965
JB		 220
221 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
222 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
223 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
41ade00f 224
e007b857
EP		 225 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
226 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
41ade00f 227
b9454e83 228 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
41ade00f
JB		 229 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
230 .len = WLAN_MAX_KEY_LEN },
231 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
232 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
233 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
81962267 234 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
e31b8213 235 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
ed1b6cc7
JB		 236
237 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
238 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
239 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
240 .len = IEEE80211_MAX_DATA_LEN },
241 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
242 .len = IEEE80211_MAX_DATA_LEN },
5727ef1b
JB		 243 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
244 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
245 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
246 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
247 .len = NL80211_MAX_SUPP_RATES },
2ec600d6 248 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
5727ef1b 249 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
0a9542ee 250 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
2ec600d6 251 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
a4f606ea 252 .len = IEEE80211_MAX_MESH_ID_LEN },
2ec600d6 253 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
9f1ba906 254
b2e1b302
LR		 255 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
256 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
257
9f1ba906
JM		 258 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
259 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
260 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
90c97a04
JM		 261 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
262 .len = NL80211_MAX_SUPP_RATES },
50b12f59 263 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
36aedc90 264
24bdd9f4 265 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
15d5dda6 266 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
93da9cc1 267
6c739419 268 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
9aed3cc1
JM		 269
270 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
271 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
272 .len = IEEE80211_MAX_DATA_LEN },
2a519311
JB		 273 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
274 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
636a5d36
JM		 275
276 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
277 .len = IEEE80211_MAX_SSID_LEN },
278 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
279 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
04a773ad 280 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
1965c853 281 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
dc6382ce 282 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
eccb8e8f
JB		 283 [NL80211_ATTR_STA_FLAGS2] = {
284 .len = sizeof(struct nl80211_sta_flag_update),
285 },
3f77316c 286 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
c0692b8f
JB		 287 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
288 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
b23aa676
SO		 289 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
290 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
291 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
463d0183 292 [NL80211_ATTR_PID] = { .type = NLA_U32 },
8b787643 293 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
9361df14 294 [NL80211_ATTR_PMKID] = { .len = WLAN_PMKID_LEN },
9588bbd5
JM		 295 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
296 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
13ae75b1 297 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
026331c4
JM		 298 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
299 .len = IEEE80211_MAX_DATA_LEN },
300 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
ffb9eb3d 301 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
d6dc1a38 302 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
d5cdfacb 303 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
fd8aaaf3 304 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
98d2ff8b
JO		 305 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
306 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
2e161f78 307 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
afe0cbf8
BR		 308 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
309 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
885a46d0 310 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
f7ca38df 311 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
dbd2fd65 312 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
ff1b6e69 313 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
9c3990aa 314 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
bbe6ad6d 315 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
e5497d76 316 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
34850ab2 317 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
32e9de84 318 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
9946ecfb
JM		 319 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
320 .len = IEEE80211_MAX_DATA_LEN },
321 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
322 .len = IEEE80211_MAX_DATA_LEN },
f4b34b55 323 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
a1f1c21c 324 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
e9f935e3 325 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
109086ce
AN		 326 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
327 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
328 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
329 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
330 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
31fa97c5 331 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
e247bd90 332 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
00f740e1
AN		 333 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
334 .len = IEEE80211_MAX_DATA_LEN },
8b60b078 335 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
7e7c8926
BG		 336 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
337 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
338 .len = NL80211_HT_CAPABILITY_LEN
339 },
1d9d9213 340 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
1b658f11 341 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
4486ea98 342 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
89a54e48 343 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
57b5ce07 344 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
11b6b5a4 345 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
f461be3e 346 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
ed473771 347 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
53cabad7
JB		 348 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
349 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
77765eaf
VT		 350 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
351 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
9d62a986
JM		 352 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
353 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
3713b4e3 354 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
ee2aca34
JB		 355 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
356 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
357 .len = NL80211_VHT_CAPABILITY_LEN,
358 },
355199e0
JM		 359 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
360 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
361 .len = IEEE80211_MAX_DATA_LEN },
5e4b6f56 362 [NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
16ef1fe2
SW		 363 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
364 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
365 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
9a774c78
AO		 366 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
367 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
c01fc9ad
SD		 368 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
369 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
5336fa88 370 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
60f4a7b1 371 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
ad7e718c
JB		 372 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
373 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
374 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
fa9ffc74
KP		 375 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
376 .len = IEEE80211_QOS_MAP_LEN_MAX },
1df4a510
JM		 377 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
378 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
df942e7b 379 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
18e5ca65 380 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
34d22ce2 381 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
bab5ab7d 382 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
960d01ac
JB		 383 [NL80211_ATTR_TSID] = { .type = NLA_U8 },
384 [NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
385 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
18998c38 386 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
ad2b26ab 387 [NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
1bdd716c 388 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
4b681c82 389 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
9c748934 390 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
05050753 391 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
34d50519 392 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
38de03d2 393 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
17b94247 394 [NL80211_ATTR_STA_SUPPORT_P2P_PS] = { .type = NLA_U8 },
c6e6a0c8
AE		 395 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
396 .len = VHT_MUMIMO_GROUPS_DATA_LEN
397 },
398 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = { .len = ETH_ALEN },
cb3b7d87 399 [NL80211_ATTR_NAN_MASTER_PREF] = { .type = NLA_U8 },
8585989d 400 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
a442b761 401 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
348bd456
JM		 402 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
403 .len = FILS_MAX_KEK_LEN },
404 [NL80211_ATTR_FILS_NONCES] = { .len = 2 * FILS_NONCE_LEN },
ce0ce13a 405 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
2fa436b3 406 [NL80211_ATTR_BSSID] = { .len = ETH_ALEN },
bf95ecdb 407 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
408 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
409 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
410 },
3093ebbe 411 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
a3caf744
VK		 412 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
413 .len = FILS_ERP_MAX_USERNAME_LEN },
414 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
415 .len = FILS_ERP_MAX_REALM_LEN },
416 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
417 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
418 .len = FILS_ERP_MAX_RRK_LEN },
419 [NL80211_ATTR_FILS_CACHE_ID] = { .len = 2 },
420 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
ca986ad9 421 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
55682965
JB		 422};
423
e31b8213 424/* policy for the key attributes */
b54452b0 425static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
fffd0934 426 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 427 [NL80211_KEY_IDX] = { .type = NLA_U8 },
428 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
81962267 429 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
b9454e83
JB		 430 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
431 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
e31b8213 432 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
dbd2fd65
JB		 433 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
434};
435
436/* policy for the key default flags */
437static const struct nla_policy
438nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
439 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
440 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
b9454e83
JB		 441};
442
f83ace3b 443#ifdef CONFIG_PM
ff1b6e69
JB		 444/* policy for WoWLAN attributes */
445static const struct nla_policy
446nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
447 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
448 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
449 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
450 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
77dbbb13
JB		 451 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
452 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
453 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
454 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
2a0e047e 455 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
8cd4d456 456 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
2a0e047e
JB		 457};
458
459static const struct nla_policy
460nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
461 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
462 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
463 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
464 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
465 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
466 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
467 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
468 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
469 },
470 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
471 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
472 },
473 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
474 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
475 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
ff1b6e69 476};
f83ace3b 477#endif /* CONFIG_PM */
ff1b6e69 478
be29b99a
AK		 479/* policy for coalesce rule attributes */
480static const struct nla_policy
481nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
482 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
483 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
484 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
485};
486
e5497d76
JB		 487/* policy for GTK rekey offload attributes */
488static const struct nla_policy
489nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
490 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
491 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
492 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
493};
494
a1f1c21c
LC		 495static const struct nla_policy
496nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
4a4ab0d7 497 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
a1f1c21c 498 .len = IEEE80211_MAX_SSID_LEN },
3007e352 499 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = { .len = ETH_ALEN },
88e920b4 500 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
a1f1c21c
LC		 501};
502
3b06d277
AS		 503static const struct nla_policy
504nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
505 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
506 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
507};
508
38de03d2
AS		 509static const struct nla_policy
510nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
511 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
512 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
513 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
514 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
515 },
516};
517
a442b761
AB		 518/* policy for NAN function attributes */
519static const struct nla_policy
520nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
521 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
522 [NL80211_NAN_FUNC_SERVICE_ID] = { .type = NLA_BINARY,
523 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
524 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
525 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
526 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
527 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
528 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
529 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { .len = ETH_ALEN },
530 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
531 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
532 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
533 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
534 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
535 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
536 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
537 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
538 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
539};
540
541/* policy for Service Response Filter attributes */
542static const struct nla_policy
543nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
544 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
545 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
546 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
547 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
548 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
549};
550
97990a06
JB		 551static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
552 struct netlink_callback *cb,
553 struct cfg80211_registered_device **rdev,
554 struct wireless_dev **wdev)
a043897a 555{
97990a06 556 int err;
a043897a 557
97990a06
JB		 558 if (!cb->args[0]) {
559 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da 560 genl_family_attrbuf(&nl80211_fam),
fceb6435 561 nl80211_fam.maxattr, nl80211_policy, NULL);
97990a06 562 if (err)
ea90e0dc 563 return err;
67748893 564
c90c39da
JB		 565 *wdev = __cfg80211_wdev_from_attrs(
566 sock_net(skb->sk),
567 genl_family_attrbuf(&nl80211_fam));
ea90e0dc
JB		 568 if (IS_ERR(*wdev))
569 return PTR_ERR(*wdev);
f26cbf40 570 *rdev = wiphy_to_rdev((*wdev)->wiphy);
c319d50b
JB		 571 /* 0 is the first index - add 1 to parse only once */
572 cb->args[0] = (*rdev)->wiphy_idx + 1;
97990a06
JB		 573 cb->args[1] = (*wdev)->identifier;
574 } else {
c319d50b
JB		 575 /* subtract the 1 again here */
576 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
97990a06 577 struct wireless_dev *tmp;
67748893 578
ea90e0dc
JB		 579 if (!wiphy)
580 return -ENODEV;
f26cbf40 581 *rdev = wiphy_to_rdev(wiphy);
97990a06 582 *wdev = NULL;
67748893 583
53873f13 584 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
97990a06
JB		 585 if (tmp->identifier == cb->args[1]) {
586 *wdev = tmp;
587 break;
588 }
589 }
67748893 590
ea90e0dc
JB		 591 if (!*wdev)
592 return -ENODEV;
67748893
JB		 593 }
594
67748893 595 return 0;
67748893
JB		 596}
597
f4a11bb0
JB		 598/* IE validation */
599static bool is_valid_ie_attr(const struct nlattr *attr)
600{
601 const u8 *pos;
602 int len;
603
604 if (!attr)
605 return true;
606
607 pos = nla_data(attr);
608 len = nla_len(attr);
609
610 while (len) {
611 u8 elemlen;
612
613 if (len < 2)
614 return false;
615 len -= 2;
616
617 elemlen = pos[1];
618 if (elemlen > len)
619 return false;
620
621 len -= elemlen;
622 pos += 2 + elemlen;
623 }
624
625 return true;
626}
627
55682965 628/* message building helper */
15e47304 629static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
55682965
JB		 630 int flags, u8 cmd)
631{
632 /* since there is no private header just add the generic one */
15e47304 633 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
55682965
JB		 634}
635
5dab3b8a 636static int nl80211_msg_put_channel(struct sk_buff *msg,
cdc89b97
JB		 637 struct ieee80211_channel *chan,
638 bool large)
5dab3b8a 639{
ea077c1c
RL		 640 /* Some channels must be completely excluded from the
641 * list to protect old user-space tools from breaking
642 */
643 if (!large && chan->flags &
644 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
645 return 0;
646
9360ffd1
DM		 647 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
648 chan->center_freq))
649 goto nla_put_failure;
5dab3b8a 650
9360ffd1
DM		 651 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
652 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
653 goto nla_put_failure;
8fe02e16
LR		 654 if (chan->flags & IEEE80211_CHAN_NO_IR) {
655 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
656 goto nla_put_failure;
657 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
658 goto nla_put_failure;
659 }
cdc89b97
JB		 660 if (chan->flags & IEEE80211_CHAN_RADAR) {
661 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
662 goto nla_put_failure;
663 if (large) {
664 u32 time;
665
666 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
667
668 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
669 chan->dfs_state))
670 goto nla_put_failure;
671 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
672 time))
673 goto nla_put_failure;
089027e5
JD		 674 if (nla_put_u32(msg,
675 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
676 chan->dfs_cac_ms))
677 goto nla_put_failure;
cdc89b97
JB		 678 }
679 }
5dab3b8a 680
fe1abafd
JB		 681 if (large) {
682 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
683 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
684 goto nla_put_failure;
685 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
686 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
687 goto nla_put_failure;
688 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
689 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
690 goto nla_put_failure;
691 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
692 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
693 goto nla_put_failure;
570dbde1
DS		 694 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
695 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
696 goto nla_put_failure;
06f207fc
AN		 697 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
698 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
570dbde1 699 goto nla_put_failure;
ea077c1c
RL		 700 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
701 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
702 goto nla_put_failure;
703 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
704 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
705 goto nla_put_failure;
fe1abafd
JB		 706 }
707
9360ffd1
DM		 708 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
709 DBM_TO_MBM(chan->max_power)))
710 goto nla_put_failure;
5dab3b8a
LR		 711
712 return 0;
713
714 nla_put_failure:
715 return -ENOBUFS;
716}
717
55682965
JB		 718/* netlink command implementations */
719
b9454e83
JB		 720struct key_parse {
721 struct key_params p;
722 int idx;
e31b8213 723 int type;
b9454e83 724 bool def, defmgmt;
dbd2fd65 725 bool def_uni, def_multi;
b9454e83
JB		 726};
727
728static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
729{
730 struct nlattr *tb[NL80211_KEY_MAX + 1];
731 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
fceb6435 732 nl80211_key_policy, NULL);
b9454e83
JB		 733 if (err)
734 return err;
735
736 k->def = !!tb[NL80211_KEY_DEFAULT];
737 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
738
dbd2fd65
JB		 739 if (k->def) {
740 k->def_uni = true;
741 k->def_multi = true;
742 }
743 if (k->defmgmt)
744 k->def_multi = true;
745
b9454e83
JB		 746 if (tb[NL80211_KEY_IDX])
747 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
748
749 if (tb[NL80211_KEY_DATA]) {
750 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
751 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
752 }
753
754 if (tb[NL80211_KEY_SEQ]) {
755 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
756 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
757 }
758
759 if (tb[NL80211_KEY_CIPHER])
760 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
761
e31b8213
JB		 762 if (tb[NL80211_KEY_TYPE]) {
763 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
764 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
765 return -EINVAL;
766 }
767
dbd2fd65
JB		 768 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
769 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
7a087e74 770
2da8f419
JB		 771 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
772 tb[NL80211_KEY_DEFAULT_TYPES],
fceb6435 773 nl80211_key_default_policy, NULL);
dbd2fd65
JB		 774 if (err)
775 return err;
776
777 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
778 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
779 }
780
b9454e83
JB		 781 return 0;
782}
783
784static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
785{
786 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
787 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
788 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
789 }
790
791 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
792 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
793 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
794 }
795
796 if (info->attrs[NL80211_ATTR_KEY_IDX])
797 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
798
799 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
800 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
801
802 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
803 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
804
dbd2fd65
JB		 805 if (k->def) {
806 k->def_uni = true;
807 k->def_multi = true;
808 }
809 if (k->defmgmt)
810 k->def_multi = true;
811
e31b8213
JB		 812 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
813 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
814 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
815 return -EINVAL;
816 }
817
dbd2fd65
JB		 818 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
819 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
fceb6435
JB		 820 int err = nla_parse_nested(kdt,
821 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
822 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
fe52145f
JB		 823 nl80211_key_default_policy,
824 info->extack);
dbd2fd65
JB		 825 if (err)
826 return err;
827
828 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
829 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
830 }
831
b9454e83
JB		 832 return 0;
833}
834
835static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
836{
837 int err;
838
839 memset(k, 0, sizeof(*k));
840 k->idx = -1;
e31b8213 841 k->type = -1;
b9454e83
JB		 842
843 if (info->attrs[NL80211_ATTR_KEY])
844 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
845 else
846 err = nl80211_parse_key_old(info, k);
847
848 if (err)
849 return err;
850
851 if (k->def && k->defmgmt)
852 return -EINVAL;
853
dbd2fd65
JB		 854 if (k->defmgmt) {
855 if (k->def_uni || !k->def_multi)
856 return -EINVAL;
857 }
858
b9454e83
JB		 859 if (k->idx != -1) {
860 if (k->defmgmt) {
861 if (k->idx < 4 || k->idx > 5)
862 return -EINVAL;
863 } else if (k->def) {
864 if (k->idx < 0 || k->idx > 3)
865 return -EINVAL;
866 } else {
867 if (k->idx < 0 || k->idx > 5)
868 return -EINVAL;
869 }
870 }
871
872 return 0;
873}
874
fffd0934
JB		 875static struct cfg80211_cached_keys *
876nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
de7044ee 877 struct nlattr *keys, bool *no_ht)
fffd0934
JB		 878{
879 struct key_parse parse;
880 struct nlattr *key;
881 struct cfg80211_cached_keys *result;
882 int rem, err, def = 0;
f1c1f17a
JB		 883 bool have_key = false;
884
885 nla_for_each_nested(key, keys, rem) {
886 have_key = true;
887 break;
888 }
889
890 if (!have_key)
891 return NULL;
fffd0934
JB		 892
893 result = kzalloc(sizeof(*result), GFP_KERNEL);
894 if (!result)
895 return ERR_PTR(-ENOMEM);
896
897 result->def = -1;
fffd0934
JB		 898
899 nla_for_each_nested(key, keys, rem) {
900 memset(&parse, 0, sizeof(parse));
901 parse.idx = -1;
902
903 err = nl80211_parse_key_new(key, &parse);
904 if (err)
905 goto error;
906 err = -EINVAL;
907 if (!parse.p.key)
908 goto error;
42ee231c 909 if (parse.idx < 0 || parse.idx > 3)
fffd0934
JB		 910 goto error;
911 if (parse.def) {
912 if (def)
913 goto error;
914 def = 1;
915 result->def = parse.idx;
dbd2fd65
JB		 916 if (!parse.def_uni || !parse.def_multi)
917 goto error;
fffd0934
JB		 918 } else if (parse.defmgmt)
919 goto error;
920 err = cfg80211_validate_key_settings(rdev, &parse.p,
e31b8213 921 parse.idx, false, NULL);
fffd0934
JB		 922 if (err)
923 goto error;
386b1f27
JB		 924 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
925 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
926 err = -EINVAL;
927 goto error;
928 }
fffd0934
JB		 929 result->params[parse.idx].cipher = parse.p.cipher;
930 result->params[parse.idx].key_len = parse.p.key_len;
931 result->params[parse.idx].key = result->data[parse.idx];
932 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
de7044ee 933
386b1f27
JB		 934 /* must be WEP key if we got here */
935 if (no_ht)
936 *no_ht = true;
fffd0934
JB		 937 }
938
f1c1f17a
JB		 939 if (result->def < 0) {
940 err = -EINVAL;
941 goto error;
942 }
943
fffd0934
JB		 944 return result;
945 error:
946 kfree(result);
947 return ERR_PTR(err);
948}
949
950static int nl80211_key_allowed(struct wireless_dev *wdev)
951{
952 ASSERT_WDEV_LOCK(wdev);
953
fffd0934
JB		 954 switch (wdev->iftype) {
955 case NL80211_IFTYPE_AP:
956 case NL80211_IFTYPE_AP_VLAN:
074ac8df 957 case NL80211_IFTYPE_P2P_GO:
ff973af7 958 case NL80211_IFTYPE_MESH_POINT:
fffd0934
JB		 959 break;
960 case NL80211_IFTYPE_ADHOC:
fffd0934 961 case NL80211_IFTYPE_STATION:
074ac8df 962 case NL80211_IFTYPE_P2P_CLIENT:
ceca7b71 963 if (!wdev->current_bss)
fffd0934
JB		 964 return -ENOLINK;
965 break;
de4fcbad 966 case NL80211_IFTYPE_UNSPECIFIED:
6e0bd6c3 967 case NL80211_IFTYPE_OCB:
de4fcbad 968 case NL80211_IFTYPE_MONITOR:
cb3b7d87 969 case NL80211_IFTYPE_NAN:
de4fcbad
JB		 970 case NL80211_IFTYPE_P2P_DEVICE:
971 case NL80211_IFTYPE_WDS:
972 case NUM_NL80211_IFTYPES:
fffd0934
JB		 973 return -EINVAL;
974 }
975
976 return 0;
977}
978
664834de
JM		 979static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
980 struct nlattr *tb)
981{
982 struct ieee80211_channel *chan;
983
984 if (tb == NULL)
985 return NULL;
986 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
987 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
988 return NULL;
989 return chan;
990}
991
7527a782
JB		 992static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
993{
994 struct nlattr *nl_modes = nla_nest_start(msg, attr);
995 int i;
996
997 if (!nl_modes)
998 goto nla_put_failure;
999
1000 i = 0;
1001 while (ifmodes) {
9360ffd1
DM		 1002 if ((ifmodes & 1) && nla_put_flag(msg, i))
1003 goto nla_put_failure;
7527a782
JB		 1004 ifmodes >>= 1;
1005 i++;
1006 }
1007
1008 nla_nest_end(msg, nl_modes);
1009 return 0;
1010
1011nla_put_failure:
1012 return -ENOBUFS;
1013}
1014
1015static int nl80211_put_iface_combinations(struct wiphy *wiphy,
cdc89b97
JB		 1016 struct sk_buff *msg,
1017 bool large)
7527a782
JB		 1018{
1019 struct nlattr *nl_combis;
1020 int i, j;
1021
1022 nl_combis = nla_nest_start(msg,
1023 NL80211_ATTR_INTERFACE_COMBINATIONS);
1024 if (!nl_combis)
1025 goto nla_put_failure;
1026
1027 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1028 const struct ieee80211_iface_combination *c;
1029 struct nlattr *nl_combi, *nl_limits;
1030
1031 c = &wiphy->iface_combinations[i];
1032
1033 nl_combi = nla_nest_start(msg, i + 1);
1034 if (!nl_combi)
1035 goto nla_put_failure;
1036
1037 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
1038 if (!nl_limits)
1039 goto nla_put_failure;
1040
1041 for (j = 0; j < c->n_limits; j++) {
1042 struct nlattr *nl_limit;
1043
1044 nl_limit = nla_nest_start(msg, j + 1);
1045 if (!nl_limit)
1046 goto nla_put_failure;
9360ffd1
DM		 1047 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1048 c->limits[j].max))
1049 goto nla_put_failure;
7527a782
JB		 1050 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1051 c->limits[j].types))
1052 goto nla_put_failure;
1053 nla_nest_end(msg, nl_limit);
1054 }
1055
1056 nla_nest_end(msg, nl_limits);
1057
9360ffd1
DM		 1058 if (c->beacon_int_infra_match &&
1059 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1060 goto nla_put_failure;
1061 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1062 c->num_different_channels) ||
1063 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1064 c->max_interfaces))
1065 goto nla_put_failure;
cdc89b97 1066 if (large &&
8c48b50a
FF		 1067 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1068 c->radar_detect_widths) ||
1069 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1070 c->radar_detect_regions)))
cdc89b97 1071 goto nla_put_failure;
0c317a02
PK		 1072 if (c->beacon_int_min_gcd &&
1073 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1074 c->beacon_int_min_gcd))
1075 goto nla_put_failure;
7527a782
JB		 1076
1077 nla_nest_end(msg, nl_combi);
1078 }
1079
1080 nla_nest_end(msg, nl_combis);
1081
1082 return 0;
1083nla_put_failure:
1084 return -ENOBUFS;
1085}
1086
3713b4e3 1087#ifdef CONFIG_PM
b56cf720
JB		 1088static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1089 struct sk_buff *msg)
1090{
964dc9e2 1091 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
b56cf720
JB		 1092 struct nlattr *nl_tcp;
1093
1094 if (!tcp)
1095 return 0;
1096
1097 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1098 if (!nl_tcp)
1099 return -ENOBUFS;
1100
1101 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1102 tcp->data_payload_max))
1103 return -ENOBUFS;
1104
1105 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1106 tcp->data_payload_max))
1107 return -ENOBUFS;
1108
1109 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1110 return -ENOBUFS;
1111
1112 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1113 sizeof(*tcp->tok), tcp->tok))
1114 return -ENOBUFS;
1115
1116 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1117 tcp->data_interval_max))
1118 return -ENOBUFS;
1119
1120 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1121 tcp->wake_payload_max))
1122 return -ENOBUFS;
1123
1124 nla_nest_end(msg, nl_tcp);
1125 return 0;
1126}
1127
3713b4e3 1128static int nl80211_send_wowlan(struct sk_buff *msg,
1b8ec87a 1129 struct cfg80211_registered_device *rdev,
b56cf720 1130 bool large)
55682965 1131{
3713b4e3 1132 struct nlattr *nl_wowlan;
55682965 1133
1b8ec87a 1134 if (!rdev->wiphy.wowlan)
3713b4e3 1135 return 0;
55682965 1136
3713b4e3
JB		 1137 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1138 if (!nl_wowlan)
1139 return -ENOBUFS;
9360ffd1 1140
1b8ec87a 1141 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
3713b4e3 1142 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1b8ec87a 1143 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
3713b4e3 1144 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1b8ec87a 1145 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
3713b4e3 1146 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1b8ec87a 1147 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
3713b4e3 1148 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1b8ec87a 1149 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
3713b4e3 1150 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1b8ec87a 1151 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
3713b4e3 1152 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1b8ec87a 1153 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
3713b4e3 1154 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1b8ec87a 1155 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
3713b4e3
JB		 1156 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1157 return -ENOBUFS;
9360ffd1 1158
1b8ec87a 1159 if (rdev->wiphy.wowlan->n_patterns) {
50ac6607 1160 struct nl80211_pattern_support pat = {
1b8ec87a
ZG		 1161 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1162 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1163 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1164 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
3713b4e3 1165 };
9360ffd1 1166
3713b4e3
JB		 1167 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1168 sizeof(pat), &pat))
1169 return -ENOBUFS;
1170 }
9360ffd1 1171
75453ccb
LC		 1172 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1173 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1174 rdev->wiphy.wowlan->max_nd_match_sets))
1175 return -ENOBUFS;
1176
1b8ec87a 1177 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
b56cf720
JB		 1178 return -ENOBUFS;
1179
3713b4e3 1180 nla_nest_end(msg, nl_wowlan);
9360ffd1 1181
3713b4e3
JB		 1182 return 0;
1183}
1184#endif
9360ffd1 1185
be29b99a 1186static int nl80211_send_coalesce(struct sk_buff *msg,
1b8ec87a 1187 struct cfg80211_registered_device *rdev)
be29b99a
AK		 1188{
1189 struct nl80211_coalesce_rule_support rule;
1190
1b8ec87a 1191 if (!rdev->wiphy.coalesce)
be29b99a
AK		 1192 return 0;
1193
1b8ec87a
ZG		 1194 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1195 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1196 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1197 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1198 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1199 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
be29b99a
AK		 1200
1201 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1202 return -ENOBUFS;
1203
1204 return 0;
1205}
1206
3713b4e3
JB		 1207static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1208 struct ieee80211_supported_band *sband)
1209{
1210 struct nlattr *nl_rates, *nl_rate;
1211 struct ieee80211_rate *rate;
1212 int i;
87bbbe22 1213
3713b4e3
JB		 1214 /* add HT info */
1215 if (sband->ht_cap.ht_supported &&
1216 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1217 sizeof(sband->ht_cap.mcs),
1218 &sband->ht_cap.mcs) ||
1219 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1220 sband->ht_cap.cap) ||
1221 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1222 sband->ht_cap.ampdu_factor) ||
1223 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1224 sband->ht_cap.ampdu_density)))
1225 return -ENOBUFS;
afe0cbf8 1226
3713b4e3
JB		 1227 /* add VHT info */
1228 if (sband->vht_cap.vht_supported &&
1229 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1230 sizeof(sband->vht_cap.vht_mcs),
1231 &sband->vht_cap.vht_mcs) ||
1232 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1233 sband->vht_cap.cap)))
1234 return -ENOBUFS;
f59ac048 1235
3713b4e3
JB		 1236 /* add bitrates */
1237 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1238 if (!nl_rates)
1239 return -ENOBUFS;
ee688b00 1240
3713b4e3
JB		 1241 for (i = 0; i < sband->n_bitrates; i++) {
1242 nl_rate = nla_nest_start(msg, i);
1243 if (!nl_rate)
1244 return -ENOBUFS;
ee688b00 1245
3713b4e3
JB		 1246 rate = &sband->bitrates[i];
1247 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1248 rate->bitrate))
1249 return -ENOBUFS;
1250 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1251 nla_put_flag(msg,
1252 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1253 return -ENOBUFS;
ee688b00 1254
3713b4e3
JB		 1255 nla_nest_end(msg, nl_rate);
1256 }
d51626df 1257
3713b4e3 1258 nla_nest_end(msg, nl_rates);
bf0c111e 1259
3713b4e3
JB		 1260 return 0;
1261}
ee688b00 1262
3713b4e3
JB		 1263static int
1264nl80211_send_mgmt_stypes(struct sk_buff *msg,
1265 const struct ieee80211_txrx_stypes *mgmt_stypes)
1266{
1267 u16 stypes;
1268 struct nlattr *nl_ftypes, *nl_ifs;
1269 enum nl80211_iftype ift;
1270 int i;
ee688b00 1271
3713b4e3
JB		 1272 if (!mgmt_stypes)
1273 return 0;
5dab3b8a 1274
3713b4e3
JB		 1275 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1276 if (!nl_ifs)
1277 return -ENOBUFS;
e2f367f2 1278
3713b4e3
JB		 1279 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1280 nl_ftypes = nla_nest_start(msg, ift);
1281 if (!nl_ftypes)
1282 return -ENOBUFS;
1283 i = 0;
1284 stypes = mgmt_stypes[ift].tx;
1285 while (stypes) {
1286 if ((stypes & 1) &&
1287 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1288 (i << 4) | IEEE80211_FTYPE_MGMT))
1289 return -ENOBUFS;
1290 stypes >>= 1;
1291 i++;
ee688b00 1292 }
3713b4e3
JB		 1293 nla_nest_end(msg, nl_ftypes);
1294 }
ee688b00 1295
3713b4e3 1296 nla_nest_end(msg, nl_ifs);
ee688b00 1297
3713b4e3
JB		 1298 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1299 if (!nl_ifs)
1300 return -ENOBUFS;
ee688b00 1301
3713b4e3
JB		 1302 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1303 nl_ftypes = nla_nest_start(msg, ift);
1304 if (!nl_ftypes)
1305 return -ENOBUFS;
1306 i = 0;
1307 stypes = mgmt_stypes[ift].rx;
1308 while (stypes) {
1309 if ((stypes & 1) &&
1310 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1311 (i << 4) | IEEE80211_FTYPE_MGMT))
1312 return -ENOBUFS;
1313 stypes >>= 1;
1314 i++;
1315 }
1316 nla_nest_end(msg, nl_ftypes);
1317 }
1318 nla_nest_end(msg, nl_ifs);
ee688b00 1319
3713b4e3
JB		 1320 return 0;
1321}
ee688b00 1322
1794899e
JB		 1323#define CMD(op, n) \
1324 do { \
1325 if (rdev->ops->op) { \
1326 i++; \
1327 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1328 goto nla_put_failure; \
1329 } \
1330 } while (0)
1331
1332static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1333 struct sk_buff *msg)
1334{
1335 int i = 0;
1336
1337 /*
1338 * do *NOT* add anything into this function, new things need to be
1339 * advertised only to new versions of userspace that can deal with
1340 * the split (and they can't possibly care about new features...
1341 */
1342 CMD(add_virtual_intf, NEW_INTERFACE);
1343 CMD(change_virtual_intf, SET_INTERFACE);
1344 CMD(add_key, NEW_KEY);
1345 CMD(start_ap, START_AP);
1346 CMD(add_station, NEW_STATION);
1347 CMD(add_mpath, NEW_MPATH);
1348 CMD(update_mesh_config, SET_MESH_CONFIG);
1349 CMD(change_bss, SET_BSS);
1350 CMD(auth, AUTHENTICATE);
1351 CMD(assoc, ASSOCIATE);
1352 CMD(deauth, DEAUTHENTICATE);
1353 CMD(disassoc, DISASSOCIATE);
1354 CMD(join_ibss, JOIN_IBSS);
1355 CMD(join_mesh, JOIN_MESH);
1356 CMD(set_pmksa, SET_PMKSA);
1357 CMD(del_pmksa, DEL_PMKSA);
1358 CMD(flush_pmksa, FLUSH_PMKSA);
1359 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1360 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1361 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1362 CMD(mgmt_tx, FRAME);
1363 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1364 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1365 i++;
1366 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1367 goto nla_put_failure;
1368 }
1369 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1370 rdev->ops->join_mesh) {
1371 i++;
1372 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1373 goto nla_put_failure;
1374 }
1375 CMD(set_wds_peer, SET_WDS_PEER);
1376 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1377 CMD(tdls_mgmt, TDLS_MGMT);
1378 CMD(tdls_oper, TDLS_OPER);
1379 }
ca986ad9 1380 if (rdev->wiphy.max_sched_scan_reqs)
1794899e
JB		 1381 CMD(sched_scan_start, START_SCHED_SCAN);
1382 CMD(probe_client, PROBE_CLIENT);
1383 CMD(set_noack_map, SET_NOACK_MAP);
1384 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1385 i++;
1386 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1387 goto nla_put_failure;
1388 }
1389 CMD(start_p2p_device, START_P2P_DEVICE);
1390 CMD(set_mcast_rate, SET_MCAST_RATE);
1391#ifdef CONFIG_NL80211_TESTMODE
1392 CMD(testmode_cmd, TESTMODE);
1393#endif
1394
1395 if (rdev->ops->connect || rdev->ops->auth) {
1396 i++;
1397 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1398 goto nla_put_failure;
1399 }
1400
1401 if (rdev->ops->disconnect || rdev->ops->deauth) {
1402 i++;
1403 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1404 goto nla_put_failure;
1405 }
1406
1407 return i;
1408 nla_put_failure:
1409 return -ENOBUFS;
1410}
1411
86e8cf98
JB		 1412struct nl80211_dump_wiphy_state {
1413 s64 filter_wiphy;
1414 long start;
019ae3a9 1415 long split_start, band_start, chan_start, capa_start;
86e8cf98
JB		 1416 bool split;
1417};
1418
1b8ec87a 1419static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
3bb20556 1420 enum nl80211_commands cmd,
3713b4e3 1421 struct sk_buff *msg, u32 portid, u32 seq,
86e8cf98 1422 int flags, struct nl80211_dump_wiphy_state *state)
3713b4e3
JB		 1423{
1424 void *hdr;
1425 struct nlattr *nl_bands, *nl_band;
1426 struct nlattr *nl_freqs, *nl_freq;
1427 struct nlattr *nl_cmds;
57fbcce3 1428 enum nl80211_band band;
3713b4e3
JB		 1429 struct ieee80211_channel *chan;
1430 int i;
1431 const struct ieee80211_txrx_stypes *mgmt_stypes =
1b8ec87a 1432 rdev->wiphy.mgmt_stypes;
fe1abafd 1433 u32 features;
ee688b00 1434
3bb20556 1435 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3713b4e3
JB		 1436 if (!hdr)
1437 return -ENOBUFS;
ee688b00 1438
86e8cf98
JB		 1439 if (WARN_ON(!state))
1440 return -EINVAL;
ee688b00 1441
1b8ec87a 1442 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3713b4e3 1443 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1b8ec87a 1444 wiphy_name(&rdev->wiphy)) ||
3713b4e3
JB		 1445 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1446 cfg80211_rdev_list_generation))
8fdc621d
JB		 1447 goto nla_put_failure;
1448
3bb20556
JB		 1449 if (cmd != NL80211_CMD_NEW_WIPHY)
1450 goto finish;
1451
86e8cf98 1452 switch (state->split_start) {
3713b4e3
JB		 1453 case 0:
1454 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1b8ec87a 1455 rdev->wiphy.retry_short) ||
3713b4e3 1456 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1b8ec87a 1457 rdev->wiphy.retry_long) ||
3713b4e3 1458 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1b8ec87a 1459 rdev->wiphy.frag_threshold) ||
3713b4e3 1460 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1b8ec87a 1461 rdev->wiphy.rts_threshold) ||
3713b4e3 1462 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1b8ec87a 1463 rdev->wiphy.coverage_class) ||
3713b4e3 1464 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1b8ec87a 1465 rdev->wiphy.max_scan_ssids) ||
3713b4e3 1466 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1b8ec87a 1467 rdev->wiphy.max_sched_scan_ssids) ||
3713b4e3 1468 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1b8ec87a 1469 rdev->wiphy.max_scan_ie_len) ||
3713b4e3 1470 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1b8ec87a 1471 rdev->wiphy.max_sched_scan_ie_len) ||
3713b4e3 1472 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
3b06d277
AS		 1473 rdev->wiphy.max_match_sets) ||
1474 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1475 rdev->wiphy.max_sched_scan_plans) ||
1476 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1477 rdev->wiphy.max_sched_scan_plan_interval) ||
1478 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1479 rdev->wiphy.max_sched_scan_plan_iterations))
9360ffd1 1480 goto nla_put_failure;
3713b4e3 1481
1b8ec87a 1482 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
3713b4e3 1483 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
aa430da4 1484 goto nla_put_failure;
1b8ec87a 1485 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
3713b4e3
JB		 1486 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1487 goto nla_put_failure;
1b8ec87a 1488 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3713b4e3
JB		 1489 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1490 goto nla_put_failure;
1b8ec87a 1491 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
3713b4e3
JB		 1492 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1493 goto nla_put_failure;
1b8ec87a 1494 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
3713b4e3
JB		 1495 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1496 goto nla_put_failure;
1b8ec87a 1497 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
3713b4e3 1498 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
9360ffd1 1499 goto nla_put_failure;
86e8cf98
JB		 1500 state->split_start++;
1501 if (state->split)
3713b4e3
JB		 1502 break;
1503 case 1:
1504 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1b8ec87a
ZG		 1505 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1506 rdev->wiphy.cipher_suites))
3713b4e3 1507 goto nla_put_failure;
4745fc09 1508
3713b4e3 1509 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1b8ec87a 1510 rdev->wiphy.max_num_pmkids))
3713b4e3 1511 goto nla_put_failure;
b23aa676 1512
1b8ec87a 1513 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
3713b4e3 1514 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
9360ffd1 1515 goto nla_put_failure;
b23aa676 1516
3713b4e3 1517 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1b8ec87a 1518 rdev->wiphy.available_antennas_tx) ||
3713b4e3 1519 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1b8ec87a 1520 rdev->wiphy.available_antennas_rx))
9360ffd1 1521 goto nla_put_failure;
b23aa676 1522
1b8ec87a 1523 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
3713b4e3 1524 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1b8ec87a 1525 rdev->wiphy.probe_resp_offload))
3713b4e3 1526 goto nla_put_failure;
8fdc621d 1527
1b8ec87a
ZG		 1528 if ((rdev->wiphy.available_antennas_tx ||
1529 rdev->wiphy.available_antennas_rx) &&
1530 rdev->ops->get_antenna) {
3713b4e3
JB		 1531 u32 tx_ant = 0, rx_ant = 0;
1532 int res;
7a087e74 1533
1b8ec87a 1534 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
3713b4e3
JB		 1535 if (!res) {
1536 if (nla_put_u32(msg,
1537 NL80211_ATTR_WIPHY_ANTENNA_TX,
1538 tx_ant) ||
1539 nla_put_u32(msg,
1540 NL80211_ATTR_WIPHY_ANTENNA_RX,
1541 rx_ant))
1542 goto nla_put_failure;
1543 }
1544 }
a293911d 1545
86e8cf98
JB		 1546 state->split_start++;
1547 if (state->split)
3713b4e3
JB		 1548 break;
1549 case 2:
1550 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1b8ec87a 1551 rdev->wiphy.interface_modes))
3713b4e3 1552 goto nla_put_failure;
86e8cf98
JB		 1553 state->split_start++;
1554 if (state->split)
3713b4e3
JB		 1555 break;
1556 case 3:
1557 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1558 if (!nl_bands)
1559 goto nla_put_failure;
f7ca38df 1560
86e8cf98 1561 for (band = state->band_start;
57fbcce3 1562 band < NUM_NL80211_BANDS; band++) {
3713b4e3 1563 struct ieee80211_supported_band *sband;
2e161f78 1564
1b8ec87a 1565 sband = rdev->wiphy.bands[band];
2e161f78 1566
3713b4e3
JB		 1567 if (!sband)
1568 continue;
1569
1570 nl_band = nla_nest_start(msg, band);
1571 if (!nl_band)
2e161f78 1572 goto nla_put_failure;
3713b4e3 1573
86e8cf98 1574 switch (state->chan_start) {
3713b4e3
JB		 1575 case 0:
1576 if (nl80211_send_band_rateinfo(msg, sband))
9360ffd1 1577 goto nla_put_failure;
86e8cf98
JB		 1578 state->chan_start++;
1579 if (state->split)
3713b4e3
JB		 1580 break;
1581 default:
1582 /* add frequencies */
1583 nl_freqs = nla_nest_start(
1584 msg, NL80211_BAND_ATTR_FREQS);
1585 if (!nl_freqs)
1586 goto nla_put_failure;
1587
86e8cf98 1588 for (i = state->chan_start - 1;
3713b4e3
JB		 1589 i < sband->n_channels;
1590 i++) {
1591 nl_freq = nla_nest_start(msg, i);
1592 if (!nl_freq)
1593 goto nla_put_failure;
1594
1595 chan = &sband->channels[i];
1596
86e8cf98
JB		 1597 if (nl80211_msg_put_channel(
1598 msg, chan,
1599 state->split))
3713b4e3
JB		 1600 goto nla_put_failure;
1601
1602 nla_nest_end(msg, nl_freq);
86e8cf98 1603 if (state->split)
3713b4e3
JB		 1604 break;
1605 }
1606 if (i < sband->n_channels)
86e8cf98 1607 state->chan_start = i + 2;
3713b4e3 1608 else
86e8cf98 1609 state->chan_start = 0;
3713b4e3
JB		 1610 nla_nest_end(msg, nl_freqs);
1611 }
1612
1613 nla_nest_end(msg, nl_band);
1614
86e8cf98 1615 if (state->split) {
3713b4e3 1616 /* start again here */
86e8cf98 1617 if (state->chan_start)
3713b4e3
JB		 1618 band--;
1619 break;
2e161f78 1620 }
2e161f78 1621 }
3713b4e3 1622 nla_nest_end(msg, nl_bands);
2e161f78 1623
57fbcce3 1624 if (band < NUM_NL80211_BANDS)
86e8cf98 1625 state->band_start = band + 1;
3713b4e3 1626 else
86e8cf98 1627 state->band_start = 0;
74b70a4e 1628
3713b4e3 1629 /* if bands & channels are done, continue outside */
86e8cf98
JB		 1630 if (state->band_start == 0 && state->chan_start == 0)
1631 state->split_start++;
1632 if (state->split)
3713b4e3
JB		 1633 break;
1634 case 4:
1635 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1636 if (!nl_cmds)
2e161f78
JB		 1637 goto nla_put_failure;
1638
1794899e
JB		 1639 i = nl80211_add_commands_unsplit(rdev, msg);
1640 if (i < 0)
1641 goto nla_put_failure;
86e8cf98 1642 if (state->split) {
5de17984
AS		 1643 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1644 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1b8ec87a 1645 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
16ef1fe2 1646 CMD(channel_switch, CHANNEL_SWITCH);
02df00eb 1647 CMD(set_qos_map, SET_QOS_MAP);
723e73ac
JB		 1648 if (rdev->wiphy.features &
1649 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
960d01ac 1650 CMD(add_tx_ts, ADD_TX_TS);
ce0ce13a 1651 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
088e8df8 1652 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
5de17984 1653 }
3713b4e3 1654#undef CMD
ff1b6e69 1655
3713b4e3 1656 nla_nest_end(msg, nl_cmds);
86e8cf98
JB		 1657 state->split_start++;
1658 if (state->split)
3713b4e3
JB		 1659 break;
1660 case 5:
1b8ec87a
ZG		 1661 if (rdev->ops->remain_on_channel &&
1662 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
3713b4e3
JB		 1663 nla_put_u32(msg,
1664 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1b8ec87a 1665 rdev->wiphy.max_remain_on_channel_duration))
3713b4e3
JB		 1666 goto nla_put_failure;
1667
1b8ec87a 1668 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
3713b4e3
JB		 1669 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1670 goto nla_put_failure;
1671
1672 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1673 goto nla_put_failure;
86e8cf98
JB		 1674 state->split_start++;
1675 if (state->split)
3713b4e3
JB		 1676 break;
1677 case 6:
1678#ifdef CONFIG_PM
1b8ec87a 1679 if (nl80211_send_wowlan(msg, rdev, state->split))
3713b4e3 1680 goto nla_put_failure;
86e8cf98
JB		 1681 state->split_start++;
1682 if (state->split)
3713b4e3
JB		 1683 break;
1684#else
86e8cf98 1685 state->split_start++;
dfb89c56 1686#endif
3713b4e3
JB		 1687 case 7:
1688 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1b8ec87a 1689 rdev->wiphy.software_iftypes))
3713b4e3 1690 goto nla_put_failure;
ff1b6e69 1691
1b8ec87a 1692 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
86e8cf98 1693 state->split))
3713b4e3 1694 goto nla_put_failure;
7527a782 1695
86e8cf98
JB		 1696 state->split_start++;
1697 if (state->split)
3713b4e3
JB		 1698 break;
1699 case 8:
1b8ec87a 1700 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
3713b4e3 1701 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1b8ec87a 1702 rdev->wiphy.ap_sme_capa))
3713b4e3 1703 goto nla_put_failure;
7527a782 1704
1b8ec87a 1705 features = rdev->wiphy.features;
fe1abafd
JB		 1706 /*
1707 * We can only add the per-channel limit information if the
1708 * dump is split, otherwise it makes it too big. Therefore
1709 * only advertise it in that case.
1710 */
86e8cf98 1711 if (state->split)
fe1abafd
JB		 1712 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1713 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
3713b4e3 1714 goto nla_put_failure;
562a7480 1715
1b8ec87a 1716 if (rdev->wiphy.ht_capa_mod_mask &&
3713b4e3 1717 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1b8ec87a
ZG		 1718 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1719 rdev->wiphy.ht_capa_mod_mask))
3713b4e3 1720 goto nla_put_failure;
1f074bd8 1721
1b8ec87a
ZG		 1722 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1723 rdev->wiphy.max_acl_mac_addrs &&
3713b4e3 1724 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1b8ec87a 1725 rdev->wiphy.max_acl_mac_addrs))
3713b4e3 1726 goto nla_put_failure;
7e7c8926 1727
3713b4e3
JB		 1728 /*
1729 * Any information below this point is only available to
1730 * applications that can deal with it being split. This
1731 * helps ensure that newly added capabilities don't break
1732 * older tools by overrunning their buffers.
1733 *
1734 * We still increment split_start so that in the split
1735 * case we'll continue with more data in the next round,
1736 * but break unconditionally so unsplit data stops here.
1737 */
86e8cf98 1738 state->split_start++;
3713b4e3
JB		 1739 break;
1740 case 9:
1b8ec87a 1741 if (rdev->wiphy.extended_capabilities &&
fe1abafd 1742 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1b8ec87a
ZG		 1743 rdev->wiphy.extended_capabilities_len,
1744 rdev->wiphy.extended_capabilities) ||
fe1abafd 1745 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1b8ec87a
ZG		 1746 rdev->wiphy.extended_capabilities_len,
1747 rdev->wiphy.extended_capabilities_mask)))
fe1abafd 1748 goto nla_put_failure;
a50df0c4 1749
1b8ec87a 1750 if (rdev->wiphy.vht_capa_mod_mask &&
ee2aca34 1751 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1b8ec87a
ZG		 1752 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1753 rdev->wiphy.vht_capa_mod_mask))
ee2aca34
JB		 1754 goto nla_put_failure;
1755
be29b99a
AK		 1756 state->split_start++;
1757 break;
1758 case 10:
1b8ec87a 1759 if (nl80211_send_coalesce(msg, rdev))
be29b99a
AK		 1760 goto nla_put_failure;
1761
1b8ec87a 1762 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
01e0daa4
FF		 1763 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1764 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1765 goto nla_put_failure;
b43504cf 1766
1b8ec87a 1767 if (rdev->wiphy.max_ap_assoc_sta &&
b43504cf 1768 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1b8ec87a 1769 rdev->wiphy.max_ap_assoc_sta))
b43504cf
JM		 1770 goto nla_put_failure;
1771
ad7e718c
JB		 1772 state->split_start++;
1773 break;
1774 case 11:
1b8ec87a 1775 if (rdev->wiphy.n_vendor_commands) {
567ffc35
JB		 1776 const struct nl80211_vendor_cmd_info *info;
1777 struct nlattr *nested;
1778
1779 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1780 if (!nested)
1781 goto nla_put_failure;
1782
1b8ec87a
ZG		 1783 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1784 info = &rdev->wiphy.vendor_commands[i].info;
567ffc35
JB		 1785 if (nla_put(msg, i + 1, sizeof(*info), info))
1786 goto nla_put_failure;
1787 }
1788 nla_nest_end(msg, nested);
1789 }
1790
1b8ec87a 1791 if (rdev->wiphy.n_vendor_events) {
567ffc35
JB		 1792 const struct nl80211_vendor_cmd_info *info;
1793 struct nlattr *nested;
ad7e718c 1794
567ffc35
JB		 1795 nested = nla_nest_start(msg,
1796 NL80211_ATTR_VENDOR_EVENTS);
1797 if (!nested)
ad7e718c 1798 goto nla_put_failure;
567ffc35 1799
1b8ec87a
ZG		 1800 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1801 info = &rdev->wiphy.vendor_events[i];
567ffc35
JB		 1802 if (nla_put(msg, i + 1, sizeof(*info), info))
1803 goto nla_put_failure;
1804 }
1805 nla_nest_end(msg, nested);
1806 }
9a774c78
AO		 1807 state->split_start++;
1808 break;
1809 case 12:
1810 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1811 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1812 rdev->wiphy.max_num_csa_counters))
1813 goto nla_put_failure;
01e0daa4 1814
1bdd716c
AN		 1815 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
1816 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
1817 goto nla_put_failure;
1818
ca986ad9
AVS		 1819 if (rdev->wiphy.max_sched_scan_reqs &&
1820 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
1821 rdev->wiphy.max_sched_scan_reqs))
1822 goto nla_put_failure;
1823
d75bb06b
GKS		 1824 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
1825 sizeof(rdev->wiphy.ext_features),
1826 rdev->wiphy.ext_features))
1827 goto nla_put_failure;
1828
38de03d2
AS		 1829 if (rdev->wiphy.bss_select_support) {
1830 struct nlattr *nested;
1831 u32 bss_select_support = rdev->wiphy.bss_select_support;
1832
1833 nested = nla_nest_start(msg, NL80211_ATTR_BSS_SELECT);
1834 if (!nested)
1835 goto nla_put_failure;
1836
1837 i = 0;
1838 while (bss_select_support) {
1839 if ((bss_select_support & 1) &&
1840 nla_put_flag(msg, i))
1841 goto nla_put_failure;
1842 i++;
1843 bss_select_support >>= 1;
1844 }
1845 nla_nest_end(msg, nested);
1846 }
1847
019ae3a9
KV		 1848 state->split_start++;
1849 break;
1850 case 13:
1851 if (rdev->wiphy.num_iftype_ext_capab &&
1852 rdev->wiphy.iftype_ext_capab) {
1853 struct nlattr *nested_ext_capab, *nested;
1854
1855 nested = nla_nest_start(msg,
1856 NL80211_ATTR_IFTYPE_EXT_CAPA);
1857 if (!nested)
1858 goto nla_put_failure;
1859
1860 for (i = state->capa_start;
1861 i < rdev->wiphy.num_iftype_ext_capab; i++) {
1862 const struct wiphy_iftype_ext_capab *capab;
1863
1864 capab = &rdev->wiphy.iftype_ext_capab[i];
1865
1866 nested_ext_capab = nla_nest_start(msg, i);
1867 if (!nested_ext_capab ||
1868 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
1869 capab->iftype) ||
1870 nla_put(msg, NL80211_ATTR_EXT_CAPA,
1871 capab->extended_capabilities_len,
1872 capab->extended_capabilities) ||
1873 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1874 capab->extended_capabilities_len,
1875 capab->extended_capabilities_mask))
1876 goto nla_put_failure;
1877
1878 nla_nest_end(msg, nested_ext_capab);
1879 if (state->split)
1880 break;
1881 }
1882 nla_nest_end(msg, nested);
1883 if (i < rdev->wiphy.num_iftype_ext_capab) {
1884 state->capa_start = i + 1;
1885 break;
1886 }
1887 }
1888
8585989d
LC		 1889 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
1890 rdev->wiphy.nan_supported_bands))
1891 goto nla_put_failure;
1892
3713b4e3 1893 /* done */
86e8cf98 1894 state->split_start = 0;
3713b4e3
JB		 1895 break;
1896 }
3bb20556 1897 finish:
053c095a
JB		 1898 genlmsg_end(msg, hdr);
1899 return 0;
55682965
JB		 1900
1901 nla_put_failure:
bc3ed28c
TG		 1902 genlmsg_cancel(msg, hdr);
1903 return -EMSGSIZE;
55682965
JB		 1904}
1905
86e8cf98
JB		 1906static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
1907 struct netlink_callback *cb,
1908 struct nl80211_dump_wiphy_state *state)
1909{
c90c39da 1910 struct nlattr **tb = genl_family_attrbuf(&nl80211_fam);
fceb6435
JB		 1911 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb,
1912 nl80211_fam.maxattr, nl80211_policy, NULL);
86e8cf98
JB		 1913 /* ignore parse errors for backward compatibility */
1914 if (ret)
1915 return 0;
1916
1917 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1918 if (tb[NL80211_ATTR_WIPHY])
1919 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1920 if (tb[NL80211_ATTR_WDEV])
1921 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1922 if (tb[NL80211_ATTR_IFINDEX]) {
1923 struct net_device *netdev;
1924 struct cfg80211_registered_device *rdev;
1925 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1926
7f2b8562 1927 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
86e8cf98
JB		 1928 if (!netdev)
1929 return -ENODEV;
1930 if (netdev->ieee80211_ptr) {
f26cbf40 1931 rdev = wiphy_to_rdev(
86e8cf98
JB		 1932 netdev->ieee80211_ptr->wiphy);
1933 state->filter_wiphy = rdev->wiphy_idx;
1934 }
86e8cf98
JB		 1935 }
1936
1937 return 0;
1938}
1939
55682965
JB		 1940static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1941{
645e77de 1942 int idx = 0, ret;
86e8cf98 1943 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
1b8ec87a 1944 struct cfg80211_registered_device *rdev;
3a5a423b 1945
5fe231e8 1946 rtnl_lock();
86e8cf98
JB		 1947 if (!state) {
1948 state = kzalloc(sizeof(*state), GFP_KERNEL);
57ed5cd6
JL		 1949 if (!state) {
1950 rtnl_unlock();
86e8cf98 1951 return -ENOMEM;
3713b4e3 1952 }
86e8cf98
JB		 1953 state->filter_wiphy = -1;
1954 ret = nl80211_dump_wiphy_parse(skb, cb, state);
1955 if (ret) {
1956 kfree(state);
1957 rtnl_unlock();
1958 return ret;
3713b4e3 1959 }
86e8cf98 1960 cb->args[0] = (long)state;
3713b4e3
JB		 1961 }
1962
1b8ec87a
ZG		 1963 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1964 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 1965 continue;
86e8cf98 1966 if (++idx <= state->start)
55682965 1967 continue;
86e8cf98 1968 if (state->filter_wiphy != -1 &&
1b8ec87a 1969 state->filter_wiphy != rdev->wiphy_idx)
3713b4e3
JB		 1970 continue;
1971 /* attempt to fit multiple wiphy data chunks into the skb */
1972 do {
3bb20556
JB		 1973 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
1974 skb,
3713b4e3
JB		 1975 NETLINK_CB(cb->skb).portid,
1976 cb->nlh->nlmsg_seq,
86e8cf98 1977 NLM_F_MULTI, state);
3713b4e3
JB		 1978 if (ret < 0) {
1979 /*
1980 * If sending the wiphy data didn't fit (ENOBUFS
1981 * or EMSGSIZE returned), this SKB is still
1982 * empty (so it's not too big because another
1983 * wiphy dataset is already in the skb) and
1984 * we've not tried to adjust the dump allocation
1985 * yet ... then adjust the alloc size to be
1986 * bigger, and return 1 but with the empty skb.
1987 * This results in an empty message being RX'ed
1988 * in userspace, but that is ignored.
1989 *
1990 * We can then retry with the larger buffer.
1991 */
1992 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
f12cb289 1993 !skb->len && !state->split &&
3713b4e3
JB		 1994 cb->min_dump_alloc < 4096) {
1995 cb->min_dump_alloc = 4096;
f12cb289 1996 state->split_start = 0;
d98cae64 1997 rtnl_unlock();
3713b4e3
JB		 1998 return 1;
1999 }
2000 idx--;
2001 break;
645e77de 2002 }
86e8cf98 2003 } while (state->split_start > 0);
3713b4e3 2004 break;
55682965 2005 }
5fe231e8 2006 rtnl_unlock();
55682965 2007
86e8cf98 2008 state->start = idx;
55682965
JB		 2009
2010 return skb->len;
2011}
2012
86e8cf98
JB		 2013static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2014{
2015 kfree((void *)cb->args[0]);
2016 return 0;
2017}
2018
55682965
JB		 2019static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2020{
2021 struct sk_buff *msg;
1b8ec87a 2022 struct cfg80211_registered_device *rdev = info->user_ptr[0];
86e8cf98 2023 struct nl80211_dump_wiphy_state state = {};
55682965 2024
645e77de 2025 msg = nlmsg_new(4096, GFP_KERNEL);
55682965 2026 if (!msg)
4c476991 2027 return -ENOMEM;
55682965 2028
3bb20556
JB		 2029 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2030 info->snd_portid, info->snd_seq, 0,
86e8cf98 2031 &state) < 0) {
4c476991
JB		 2032 nlmsg_free(msg);
2033 return -ENOBUFS;
2034 }
55682965 2035
134e6375 2036 return genlmsg_reply(msg, info);
55682965
JB		 2037}
2038
31888487
JM		 2039static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2040 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2041 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2042 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2043 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2044 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2045};
2046
2047static int parse_txq_params(struct nlattr *tb[],
2048 struct ieee80211_txq_params *txq_params)
2049{
a3304b0a 2050 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
31888487
JM		 2051 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2052 !tb[NL80211_TXQ_ATTR_AIFS])
2053 return -EINVAL;
2054
a3304b0a 2055 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
31888487
JM		 2056 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2057 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2058 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2059 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2060
a3304b0a
JB		 2061 if (txq_params->ac >= NL80211_NUM_ACS)
2062 return -EINVAL;
2063
31888487
JM		 2064 return 0;
2065}
2066
f444de05
JB		 2067static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2068{
2069 /*
cc1d2806
JB		 2070 * You can only set the channel explicitly for WDS interfaces,
2071 * all others have their channel managed via their respective
2072 * "establish a connection" command (connect, join, ...)
2073 *
2074 * For AP/GO and mesh mode, the channel can be set with the
2075 * channel userspace API, but is only stored and passed to the
2076 * low-level driver when the AP starts or the mesh is joined.
2077 * This is for backward compatibility, userspace can also give
2078 * the channel in the start-ap or join-mesh commands instead.
f444de05
JB		 2079 *
2080 * Monitors are special as they are normally slaved to
e8c9bd5b
JB		 2081 * whatever else is going on, so they have their own special
2082 * operation to set the monitor channel if possible.
f444de05
JB		 2083 */
2084 return !wdev ||
2085 wdev->iftype == NL80211_IFTYPE_AP ||
f444de05 2086 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
074ac8df
JB		 2087 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2088 wdev->iftype == NL80211_IFTYPE_P2P_GO;
f444de05
JB		 2089}
2090
683b6d3b
JB		 2091static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2092 struct genl_info *info,
2093 struct cfg80211_chan_def *chandef)
2094{
dbeca2ea 2095 u32 control_freq;
683b6d3b
JB		 2096
2097 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
2098 return -EINVAL;
2099
2100 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
2101
2102 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
3d9d1d66
JB		 2103 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2104 chandef->center_freq1 = control_freq;
2105 chandef->center_freq2 = 0;
683b6d3b
JB		 2106
2107 /* Primary channel not allowed */
2108 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
2109 return -EINVAL;
2110
3d9d1d66
JB		 2111 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2112 enum nl80211_channel_type chantype;
2113
2114 chantype = nla_get_u32(
2115 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2116
2117 switch (chantype) {
2118 case NL80211_CHAN_NO_HT:
2119 case NL80211_CHAN_HT20:
2120 case NL80211_CHAN_HT40PLUS:
2121 case NL80211_CHAN_HT40MINUS:
2122 cfg80211_chandef_create(chandef, chandef->chan,
2123 chantype);
2124 break;
2125 default:
2126 return -EINVAL;
2127 }
2128 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2129 chandef->width =
2130 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2131 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
2132 chandef->center_freq1 =
2133 nla_get_u32(
2134 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
2135 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
2136 chandef->center_freq2 =
2137 nla_get_u32(
2138 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
2139 }
2140
9f5e8f6e 2141 if (!cfg80211_chandef_valid(chandef))
3d9d1d66
JB		 2142 return -EINVAL;
2143
9f5e8f6e
JB		 2144 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2145 IEEE80211_CHAN_DISABLED))
3d9d1d66
JB		 2146 return -EINVAL;
2147
2f301ab2
SW		 2148 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2149 chandef->width == NL80211_CHAN_WIDTH_10) &&
2150 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ))
2151 return -EINVAL;
2152
683b6d3b
JB		 2153 return 0;
2154}
2155
f444de05 2156static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
e16821bc 2157 struct net_device *dev,
f444de05
JB		 2158 struct genl_info *info)
2159{
683b6d3b 2160 struct cfg80211_chan_def chandef;
f444de05 2161 int result;
e8c9bd5b 2162 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
e16821bc 2163 struct wireless_dev *wdev = NULL;
e8c9bd5b 2164
e16821bc
JM		 2165 if (dev)
2166 wdev = dev->ieee80211_ptr;
f444de05
JB		 2167 if (!nl80211_can_set_dev_channel(wdev))
2168 return -EOPNOTSUPP;
e16821bc
JM		 2169 if (wdev)
2170 iftype = wdev->iftype;
f444de05 2171
683b6d3b
JB		 2172 result = nl80211_parse_chandef(rdev, info, &chandef);
2173 if (result)
2174 return result;
f444de05 2175
e8c9bd5b 2176 switch (iftype) {
aa430da4
JB		 2177 case NL80211_IFTYPE_AP:
2178 case NL80211_IFTYPE_P2P_GO:
923b352f
AN		 2179 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2180 iftype)) {
aa430da4
JB		 2181 result = -EINVAL;
2182 break;
2183 }
e16821bc
JM		 2184 if (wdev->beacon_interval) {
2185 if (!dev || !rdev->ops->set_ap_chanwidth ||
2186 !(rdev->wiphy.features &
2187 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2188 result = -EBUSY;
2189 break;
2190 }
2191
2192 /* Only allow dynamic channel width changes */
2193 if (chandef.chan != wdev->preset_chandef.chan) {
2194 result = -EBUSY;
2195 break;
2196 }
2197 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2198 if (result)
2199 break;
2200 }
683b6d3b 2201 wdev->preset_chandef = chandef;
aa430da4
JB		 2202 result = 0;
2203 break;
cc1d2806 2204 case NL80211_IFTYPE_MESH_POINT:
683b6d3b 2205 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
cc1d2806 2206 break;
e8c9bd5b 2207 case NL80211_IFTYPE_MONITOR:
683b6d3b 2208 result = cfg80211_set_monitor_channel(rdev, &chandef);
e8c9bd5b 2209 break;
aa430da4 2210 default:
e8c9bd5b 2211 result = -EINVAL;
f444de05 2212 }
f444de05
JB		 2213
2214 return result;
2215}
2216
2217static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2218{
4c476991
JB		 2219 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2220 struct net_device *netdev = info->user_ptr[1];
f444de05 2221
e16821bc 2222 return __nl80211_set_channel(rdev, netdev, info);
f444de05
JB		 2223}
2224
e8347eba
BJ		 2225static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2226{
43b19952
JB		 2227 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2228 struct net_device *dev = info->user_ptr[1];
2229 struct wireless_dev *wdev = dev->ieee80211_ptr;
388ac775 2230 const u8 *bssid;
e8347eba
BJ		 2231
2232 if (!info->attrs[NL80211_ATTR_MAC])
2233 return -EINVAL;
2234
43b19952
JB		 2235 if (netif_running(dev))
2236 return -EBUSY;
e8347eba 2237
43b19952
JB		 2238 if (!rdev->ops->set_wds_peer)
2239 return -EOPNOTSUPP;
e8347eba 2240
43b19952
JB		 2241 if (wdev->iftype != NL80211_IFTYPE_WDS)
2242 return -EOPNOTSUPP;
e8347eba
BJ		 2243
2244 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
e35e4d28 2245 return rdev_set_wds_peer(rdev, dev, bssid);
e8347eba
BJ		 2246}
2247
55682965
JB		 2248static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2249{
2250 struct cfg80211_registered_device *rdev;
f444de05
JB		 2251 struct net_device *netdev = NULL;
2252 struct wireless_dev *wdev;
a1e567c8 2253 int result = 0, rem_txq_params = 0;
31888487 2254 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 2255 u32 changed;
2256 u8 retry_short = 0, retry_long = 0;
2257 u32 frag_threshold = 0, rts_threshold = 0;
81077e82 2258 u8 coverage_class = 0;
55682965 2259
5fe231e8
JB		 2260 ASSERT_RTNL();
2261
f444de05
JB		 2262 /*
2263 * Try to find the wiphy and netdev. Normally this
2264 * function shouldn't need the netdev, but this is
2265 * done for backward compatibility -- previously
2266 * setting the channel was done per wiphy, but now
2267 * it is per netdev. Previous userland like hostapd
2268 * also passed a netdev to set_wiphy, so that it is
2269 * possible to let that go to the right netdev!
2270 */
4bbf4d56 2271
f444de05
JB		 2272 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2273 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2274
7f2b8562 2275 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
5fe231e8 2276 if (netdev && netdev->ieee80211_ptr)
f26cbf40 2277 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
5fe231e8 2278 else
f444de05 2279 netdev = NULL;
4bbf4d56
JB		 2280 }
2281
f444de05 2282 if (!netdev) {
878d9ec7
JB		 2283 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2284 info->attrs);
5fe231e8 2285 if (IS_ERR(rdev))
4c476991 2286 return PTR_ERR(rdev);
f444de05
JB		 2287 wdev = NULL;
2288 netdev = NULL;
2289 result = 0;
71fe96bf 2290 } else
f444de05 2291 wdev = netdev->ieee80211_ptr;
f444de05
JB		 2292
2293 /*
2294 * end workaround code, by now the rdev is available
2295 * and locked, and wdev may or may not be NULL.
2296 */
4bbf4d56
JB		 2297
2298 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 2299 result = cfg80211_dev_rename(
2300 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56 2301
4bbf4d56 2302 if (result)
7f2b8562 2303 return result;
31888487
JM		 2304
2305 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2306 struct ieee80211_txq_params txq_params;
2307 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2308
7f2b8562
YX		 2309 if (!rdev->ops->set_txq_params)
2310 return -EOPNOTSUPP;
31888487 2311
7f2b8562
YX		 2312 if (!netdev)
2313 return -EINVAL;
f70f01c2 2314
133a3ff2 2315 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7f2b8562
YX		 2316 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2317 return -EINVAL;
133a3ff2 2318
7f2b8562
YX		 2319 if (!netif_running(netdev))
2320 return -ENETDOWN;
2b5f8b0b 2321
31888487
JM		 2322 nla_for_each_nested(nl_txq_params,
2323 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2324 rem_txq_params) {
bfe2c7b1
JB		 2325 result = nla_parse_nested(tb, NL80211_TXQ_ATTR_MAX,
2326 nl_txq_params,
fe52145f
JB		 2327 txq_params_policy,
2328 info->extack);
ae811e21
JB		 2329 if (result)
2330 return result;
31888487
JM		 2331 result = parse_txq_params(tb, &txq_params);
2332 if (result)
7f2b8562 2333 return result;
31888487 2334
e35e4d28
HG		 2335 result = rdev_set_txq_params(rdev, netdev,
2336 &txq_params);
31888487 2337 if (result)
7f2b8562 2338 return result;
31888487
JM		 2339 }
2340 }
55682965 2341
72bdcf34 2342 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
e16821bc
JM		 2343 result = __nl80211_set_channel(
2344 rdev,
2345 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2346 info);
72bdcf34 2347 if (result)
7f2b8562 2348 return result;
72bdcf34
JM		 2349 }
2350
98d2ff8b 2351 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
c8442118 2352 struct wireless_dev *txp_wdev = wdev;
98d2ff8b
JO		 2353 enum nl80211_tx_power_setting type;
2354 int idx, mbm = 0;
2355
c8442118
JB		 2356 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2357 txp_wdev = NULL;
2358
7f2b8562
YX		 2359 if (!rdev->ops->set_tx_power)
2360 return -EOPNOTSUPP;
98d2ff8b
JO		 2361
2362 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2363 type = nla_get_u32(info->attrs[idx]);
2364
2365 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
7f2b8562
YX		 2366 (type != NL80211_TX_POWER_AUTOMATIC))
2367 return -EINVAL;
98d2ff8b
JO		 2368
2369 if (type != NL80211_TX_POWER_AUTOMATIC) {
2370 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2371 mbm = nla_get_u32(info->attrs[idx]);
2372 }
2373
c8442118 2374 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
98d2ff8b 2375 if (result)
7f2b8562 2376 return result;
98d2ff8b
JO		 2377 }
2378
afe0cbf8
BR		 2379 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2380 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2381 u32 tx_ant, rx_ant;
7a087e74 2382
7f531e03
BR		 2383 if ((!rdev->wiphy.available_antennas_tx &&
2384 !rdev->wiphy.available_antennas_rx) ||
7f2b8562
YX		 2385 !rdev->ops->set_antenna)
2386 return -EOPNOTSUPP;
afe0cbf8
BR		 2387
2388 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2389 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2390
a7ffac95 2391 /* reject antenna configurations which don't match the
7f531e03
BR		 2392 * available antenna masks, except for the "all" mask */
2393 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
7f2b8562
YX		 2394 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2395 return -EINVAL;
a7ffac95 2396
7f531e03
BR		 2397 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2398 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
a7ffac95 2399
e35e4d28 2400 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
afe0cbf8 2401 if (result)
7f2b8562 2402 return result;
afe0cbf8
BR		 2403 }
2404
b9a5f8ca
JM		 2405 changed = 0;
2406
2407 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2408 retry_short = nla_get_u8(
2409 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
7f2b8562
YX		 2410 if (retry_short == 0)
2411 return -EINVAL;
2412
b9a5f8ca
JM		 2413 changed |= WIPHY_PARAM_RETRY_SHORT;
2414 }
2415
2416 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2417 retry_long = nla_get_u8(
2418 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
7f2b8562
YX		 2419 if (retry_long == 0)
2420 return -EINVAL;
2421
b9a5f8ca
JM		 2422 changed |= WIPHY_PARAM_RETRY_LONG;
2423 }
2424
2425 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2426 frag_threshold = nla_get_u32(
2427 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
7f2b8562
YX		 2428 if (frag_threshold < 256)
2429 return -EINVAL;
2430
b9a5f8ca
JM		 2431 if (frag_threshold != (u32) -1) {
2432 /*
2433 * Fragments (apart from the last one) are required to
2434 * have even length. Make the fragmentation code
2435 * simpler by stripping LSB should someone try to use
2436 * odd threshold value.
2437 */
2438 frag_threshold &= ~0x1;
2439 }
2440 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2441 }
2442
2443 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2444 rts_threshold = nla_get_u32(
2445 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2446 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2447 }
2448
81077e82 2449 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3057dbfd
LB		 2450 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2451 return -EINVAL;
2452
81077e82
LT		 2453 coverage_class = nla_get_u8(
2454 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2455 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2456 }
2457
3057dbfd
LB		 2458 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2459 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2460 return -EOPNOTSUPP;
2461
2462 changed |= WIPHY_PARAM_DYN_ACK;
81077e82
LT		 2463 }
2464
b9a5f8ca
JM		 2465 if (changed) {
2466 u8 old_retry_short, old_retry_long;
2467 u32 old_frag_threshold, old_rts_threshold;
81077e82 2468 u8 old_coverage_class;
b9a5f8ca 2469
7f2b8562
YX		 2470 if (!rdev->ops->set_wiphy_params)
2471 return -EOPNOTSUPP;
b9a5f8ca
JM		 2472
2473 old_retry_short = rdev->wiphy.retry_short;
2474 old_retry_long = rdev->wiphy.retry_long;
2475 old_frag_threshold = rdev->wiphy.frag_threshold;
2476 old_rts_threshold = rdev->wiphy.rts_threshold;
81077e82 2477 old_coverage_class = rdev->wiphy.coverage_class;
b9a5f8ca
JM		 2478
2479 if (changed & WIPHY_PARAM_RETRY_SHORT)
2480 rdev->wiphy.retry_short = retry_short;
2481 if (changed & WIPHY_PARAM_RETRY_LONG)
2482 rdev->wiphy.retry_long = retry_long;
2483 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2484 rdev->wiphy.frag_threshold = frag_threshold;
2485 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2486 rdev->wiphy.rts_threshold = rts_threshold;
81077e82
LT		 2487 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2488 rdev->wiphy.coverage_class = coverage_class;
b9a5f8ca 2489
e35e4d28 2490 result = rdev_set_wiphy_params(rdev, changed);
b9a5f8ca
JM		 2491 if (result) {
2492 rdev->wiphy.retry_short = old_retry_short;
2493 rdev->wiphy.retry_long = old_retry_long;
2494 rdev->wiphy.frag_threshold = old_frag_threshold;
2495 rdev->wiphy.rts_threshold = old_rts_threshold;
81077e82 2496 rdev->wiphy.coverage_class = old_coverage_class;
9189ee31 2497 return result;
b9a5f8ca
JM		 2498 }
2499 }
7f2b8562 2500 return 0;
55682965
JB		 2501}
2502
71bbc994
JB		 2503static inline u64 wdev_id(struct wireless_dev *wdev)
2504{
2505 return (u64)wdev->identifier |
f26cbf40 2506 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
71bbc994 2507}
55682965 2508
683b6d3b 2509static int nl80211_send_chandef(struct sk_buff *msg,
d2859df5 2510 const struct cfg80211_chan_def *chandef)
683b6d3b 2511{
601555cd
JB		 2512 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2513 return -EINVAL;
3d9d1d66 2514
683b6d3b
JB		 2515 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2516 chandef->chan->center_freq))
2517 return -ENOBUFS;
3d9d1d66
JB		 2518 switch (chandef->width) {
2519 case NL80211_CHAN_WIDTH_20_NOHT:
2520 case NL80211_CHAN_WIDTH_20:
2521 case NL80211_CHAN_WIDTH_40:
2522 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2523 cfg80211_get_chandef_type(chandef)))
2524 return -ENOBUFS;
2525 break;
2526 default:
2527 break;
2528 }
2529 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2530 return -ENOBUFS;
2531 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2532 return -ENOBUFS;
2533 if (chandef->center_freq2 &&
2534 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
683b6d3b
JB		 2535 return -ENOBUFS;
2536 return 0;
2537}
2538
15e47304 2539static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
d726405a 2540 struct cfg80211_registered_device *rdev,
8f894be2 2541 struct wireless_dev *wdev, bool removal)
55682965 2542{
72fb2abc 2543 struct net_device *dev = wdev->netdev;
8f894be2 2544 u8 cmd = NL80211_CMD_NEW_INTERFACE;
55682965
JB		 2545 void *hdr;
2546
8f894be2
TB		 2547 if (removal)
2548 cmd = NL80211_CMD_DEL_INTERFACE;
2549
2550 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
55682965
JB		 2551 if (!hdr)
2552 return -1;
2553
72fb2abc
JB		 2554 if (dev &&
2555 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
98104fde 2556 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
72fb2abc
JB		 2557 goto nla_put_failure;
2558
2559 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2560 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2dad624e
ND		 2561 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
2562 NL80211_ATTR_PAD) ||
98104fde 2563 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
9360ffd1
DM		 2564 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2565 rdev->devlist_generation ^
2566 (cfg80211_rdev_list_generation << 2)))
2567 goto nla_put_failure;
f5ea9120 2568
5b7ccaf3 2569 if (rdev->ops->get_channel) {
683b6d3b
JB		 2570 int ret;
2571 struct cfg80211_chan_def chandef;
2572
2573 ret = rdev_get_channel(rdev, wdev, &chandef);
2574 if (ret == 0) {
2575 if (nl80211_send_chandef(msg, &chandef))
2576 goto nla_put_failure;
2577 }
d91df0e3
PF		 2578 }
2579
d55d0d59
RM		 2580 if (rdev->ops->get_tx_power) {
2581 int dbm, ret;
2582
2583 ret = rdev_get_tx_power(rdev, wdev, &dbm);
2584 if (ret == 0 &&
2585 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
2586 DBM_TO_MBM(dbm)))
2587 goto nla_put_failure;
2588 }
2589
b84e7a05
AQ		 2590 if (wdev->ssid_len) {
2591 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2592 goto nla_put_failure;
2593 }
2594
053c095a
JB		 2595 genlmsg_end(msg, hdr);
2596 return 0;
55682965
JB		 2597
2598 nla_put_failure:
bc3ed28c
TG		 2599 genlmsg_cancel(msg, hdr);
2600 return -EMSGSIZE;
55682965
JB		 2601}
2602
2603static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2604{
2605 int wp_idx = 0;
2606 int if_idx = 0;
2607 int wp_start = cb->args[0];
2608 int if_start = cb->args[1];
b7fb44da 2609 int filter_wiphy = -1;
f5ea9120 2610 struct cfg80211_registered_device *rdev;
55682965 2611 struct wireless_dev *wdev;
ea90e0dc 2612 int ret;
55682965 2613
5fe231e8 2614 rtnl_lock();
b7fb44da
DK		 2615 if (!cb->args[2]) {
2616 struct nl80211_dump_wiphy_state state = {
2617 .filter_wiphy = -1,
2618 };
b7fb44da
DK		 2619
2620 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
2621 if (ret)
ea90e0dc 2622 goto out_unlock;
b7fb44da
DK		 2623
2624 filter_wiphy = state.filter_wiphy;
2625
2626 /*
2627 * if filtering, set cb->args[2] to +1 since 0 is the default
2628 * value needed to determine that parsing is necessary.
2629 */
2630 if (filter_wiphy >= 0)
2631 cb->args[2] = filter_wiphy + 1;
2632 else
2633 cb->args[2] = -1;
2634 } else if (cb->args[2] > 0) {
2635 filter_wiphy = cb->args[2] - 1;
2636 }
2637
f5ea9120
JB		 2638 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2639 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2640 continue;
bba95fef
JB		 2641 if (wp_idx < wp_start) {
2642 wp_idx++;
55682965 2643 continue;
bba95fef 2644 }
b7fb44da
DK		 2645
2646 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
2647 continue;
2648
55682965
JB		 2649 if_idx = 0;
2650
53873f13 2651 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
bba95fef
JB		 2652 if (if_idx < if_start) {
2653 if_idx++;
55682965 2654 continue;
bba95fef 2655 }
15e47304 2656 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
55682965 2657 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8f894be2 2658 rdev, wdev, false) < 0) {
bba95fef
JB		 2659 goto out;
2660 }
2661 if_idx++;
55682965 2662 }
bba95fef
JB		 2663
2664 wp_idx++;
55682965 2665 }
bba95fef 2666 out:
55682965
JB		 2667 cb->args[0] = wp_idx;
2668 cb->args[1] = if_idx;
2669
ea90e0dc
JB		 2670 ret = skb->len;
2671 out_unlock:
2672 rtnl_unlock();
2673
2674 return ret;
55682965
JB		 2675}
2676
2677static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2678{
2679 struct sk_buff *msg;
1b8ec87a 2680 struct cfg80211_registered_device *rdev = info->user_ptr[0];
72fb2abc 2681 struct wireless_dev *wdev = info->user_ptr[1];
55682965 2682
fd2120ca 2683 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965 2684 if (!msg)
4c476991 2685 return -ENOMEM;
55682965 2686
15e47304 2687 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2688 rdev, wdev, false) < 0) {
4c476991
JB		 2689 nlmsg_free(msg);
2690 return -ENOBUFS;
2691 }
55682965 2692
134e6375 2693 return genlmsg_reply(msg, info);
55682965
JB		 2694}
2695
66f7ac50
MW		 2696static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2697 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2698 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2699 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2700 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2701 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
e057d3c3 2702 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
66f7ac50
MW		 2703};
2704
2705static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2706{
2707 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2708 int flag;
2709
2710 *mntrflags = 0;
2711
2712 if (!nla)
2713 return -EINVAL;
2714
fceb6435
JB		 2715 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX, nla,
2716 mntr_flags_policy, NULL))
66f7ac50
MW		 2717 return -EINVAL;
2718
2719 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2720 if (flags[flag])
2721 *mntrflags |= (1<<flag);
2722
818a986e
JB		 2723 *mntrflags |= MONITOR_FLAG_CHANGED;
2724
66f7ac50
MW		 2725 return 0;
2726}
2727
1db77596
JB		 2728static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
2729 enum nl80211_iftype type,
2730 struct genl_info *info,
2731 struct vif_params *params)
2732{
2733 bool change = false;
2734 int err;
2735
2736 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2737 if (type != NL80211_IFTYPE_MONITOR)
2738 return -EINVAL;
2739
2740 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2741 &params->flags);
2742 if (err)
2743 return err;
2744
2745 change = true;
2746 }
2747
2748 if (params->flags & MONITOR_FLAG_ACTIVE &&
2749 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2750 return -EOPNOTSUPP;
2751
2752 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
2753 const u8 *mumimo_groups;
2754 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2755
2756 if (type != NL80211_IFTYPE_MONITOR)
2757 return -EINVAL;
2758
2759 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2760 return -EOPNOTSUPP;
2761
2762 mumimo_groups =
2763 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
2764
2765 /* bits 0 and 63 are reserved and must be zero */
4954601f
JB		 2766 if ((mumimo_groups[0] & BIT(0)) ||
2767 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
1db77596
JB		 2768 return -EINVAL;
2769
2770 params->vht_mumimo_groups = mumimo_groups;
2771 change = true;
2772 }
2773
2774 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
2775 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2776
2777 if (type != NL80211_IFTYPE_MONITOR)
2778 return -EINVAL;
2779
2780 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2781 return -EOPNOTSUPP;
2782
2783 params->vht_mumimo_follow_addr =
2784 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
2785 change = true;
2786 }
2787
2788 return change ? 1 : 0;
2789}
2790
9bc383de 2791static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
ad4bb6f8
JB		 2792 struct net_device *netdev, u8 use_4addr,
2793 enum nl80211_iftype iftype)
9bc383de 2794{
ad4bb6f8 2795 if (!use_4addr) {
f350a0a8 2796 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
ad4bb6f8 2797 return -EBUSY;
9bc383de 2798 return 0;
ad4bb6f8 2799 }
9bc383de
JB		 2800
2801 switch (iftype) {
2802 case NL80211_IFTYPE_AP_VLAN:
2803 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2804 return 0;
2805 break;
2806 case NL80211_IFTYPE_STATION:
2807 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2808 return 0;
2809 break;
2810 default:
2811 break;
2812 }
2813
2814 return -EOPNOTSUPP;
2815}
2816
55682965
JB		 2817static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2818{
4c476991 2819 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2820 struct vif_params params;
e36d56b6 2821 int err;
04a773ad 2822 enum nl80211_iftype otype, ntype;
4c476991 2823 struct net_device *dev = info->user_ptr[1];
ac7f9cfa 2824 bool change = false;
55682965 2825
2ec600d6
LCC		 2826 memset(&params, 0, sizeof(params));
2827
04a773ad 2828 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 2829
723b038d 2830 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 2831 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 2832 if (otype != ntype)
ac7f9cfa 2833 change = true;
4c476991
JB		 2834 if (ntype > NL80211_IFTYPE_MAX)
2835 return -EINVAL;
723b038d
JB		 2836 }
2837
92ffe055 2838 if (info->attrs[NL80211_ATTR_MESH_ID]) {
29cbe68c
JB		 2839 struct wireless_dev *wdev = dev->ieee80211_ptr;
2840
4c476991
JB		 2841 if (ntype != NL80211_IFTYPE_MESH_POINT)
2842 return -EINVAL;
29cbe68c
JB		 2843 if (netif_running(dev))
2844 return -EBUSY;
2845
2846 wdev_lock(wdev);
2847 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2848 IEEE80211_MAX_MESH_ID_LEN);
2849 wdev->mesh_id_up_len =
2850 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2851 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2852 wdev->mesh_id_up_len);
2853 wdev_unlock(wdev);
2ec600d6
LCC		 2854 }
2855
8b787643
FF		 2856 if (info->attrs[NL80211_ATTR_4ADDR]) {
2857 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2858 change = true;
ad4bb6f8 2859 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
9bc383de 2860 if (err)
4c476991 2861 return err;
8b787643
FF		 2862 } else {
2863 params.use_4addr = -1;
2864 }
2865
1db77596
JB		 2866 err = nl80211_parse_mon_options(rdev, ntype, info, &params);
2867 if (err < 0)
2868 return err;
2869 if (err > 0)
c6e6a0c8 2870 change = true;
e057d3c3 2871
ac7f9cfa 2872 if (change)
818a986e 2873 err = cfg80211_change_iface(rdev, dev, ntype, &params);
ac7f9cfa
JB		 2874 else
2875 err = 0;
60719ffd 2876
9bc383de
JB		 2877 if (!err && params.use_4addr != -1)
2878 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2879
55682965
JB		 2880 return err;
2881}
2882
2883static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2884{
4c476991 2885 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2886 struct vif_params params;
84efbb84 2887 struct wireless_dev *wdev;
896ff063 2888 struct sk_buff *msg;
55682965
JB		 2889 int err;
2890 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2891
78f22b6a
JB		 2892 /* to avoid failing a new interface creation due to pending removal */
2893 cfg80211_destroy_ifaces(rdev);
2894
2ec600d6
LCC		 2895 memset(&params, 0, sizeof(params));
2896
55682965
JB		 2897 if (!info->attrs[NL80211_ATTR_IFNAME])
2898 return -EINVAL;
2899
2900 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2901 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2902 if (type > NL80211_IFTYPE_MAX)
2903 return -EINVAL;
2904 }
2905
79c97e97 2906 if (!rdev->ops->add_virtual_intf ||
4c476991
JB		 2907 !(rdev->wiphy.interface_modes & (1 << type)))
2908 return -EOPNOTSUPP;
55682965 2909
cb3b7d87 2910 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
e8f479b1
BG		 2911 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2912 info->attrs[NL80211_ATTR_MAC]) {
1c18f145
AS		 2913 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2914 ETH_ALEN);
2915 if (!is_valid_ether_addr(params.macaddr))
2916 return -EADDRNOTAVAIL;
2917 }
2918
9bc383de 2919 if (info->attrs[NL80211_ATTR_4ADDR]) {
8b787643 2920 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
ad4bb6f8 2921 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
9bc383de 2922 if (err)
4c476991 2923 return err;
9bc383de 2924 }
8b787643 2925
1db77596
JB		 2926 err = nl80211_parse_mon_options(rdev, type, info, &params);
2927 if (err < 0)
2928 return err;
e057d3c3 2929
a18c7192
JB		 2930 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2931 if (!msg)
2932 return -ENOMEM;
2933
e35e4d28
HG		 2934 wdev = rdev_add_virtual_intf(rdev,
2935 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
818a986e 2936 NET_NAME_USER, type, &params);
d687cbb7
RM		 2937 if (WARN_ON(!wdev)) {
2938 nlmsg_free(msg);
2939 return -EPROTO;
2940 } else if (IS_ERR(wdev)) {
1c90f9d4 2941 nlmsg_free(msg);
84efbb84 2942 return PTR_ERR(wdev);
1c90f9d4 2943 }
2ec600d6 2944
18e5ca65 2945 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
78f22b6a
JB		 2946 wdev->owner_nlportid = info->snd_portid;
2947
98104fde
JB		 2948 switch (type) {
2949 case NL80211_IFTYPE_MESH_POINT:
2950 if (!info->attrs[NL80211_ATTR_MESH_ID])
2951 break;
29cbe68c
JB		 2952 wdev_lock(wdev);
2953 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2954 IEEE80211_MAX_MESH_ID_LEN);
2955 wdev->mesh_id_up_len =
2956 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2957 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2958 wdev->mesh_id_up_len);
2959 wdev_unlock(wdev);
98104fde 2960 break;
cb3b7d87 2961 case NL80211_IFTYPE_NAN:
98104fde
JB		 2962 case NL80211_IFTYPE_P2P_DEVICE:
2963 /*
cb3b7d87 2964 * P2P Device and NAN do not have a netdev, so don't go
98104fde
JB		 2965 * through the netdev notifier and must be added here
2966 */
2967 mutex_init(&wdev->mtx);
2968 INIT_LIST_HEAD(&wdev->event_list);
2969 spin_lock_init(&wdev->event_lock);
2970 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2971 spin_lock_init(&wdev->mgmt_registrations_lock);
2972
98104fde 2973 wdev->identifier = ++rdev->wdev_id;
53873f13 2974 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
98104fde 2975 rdev->devlist_generation++;
98104fde
JB		 2976 break;
2977 default:
2978 break;
29cbe68c
JB		 2979 }
2980
15e47304 2981 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2982 rdev, wdev, false) < 0) {
1c90f9d4
JB		 2983 nlmsg_free(msg);
2984 return -ENOBUFS;
2985 }
2986
896ff063
DK		 2987 /*
2988 * For wdevs which have no associated netdev object (e.g. of type
2989 * NL80211_IFTYPE_P2P_DEVICE), emit the NEW_INTERFACE event here.
2990 * For all other types, the event will be generated from the
2991 * netdev notifier
2992 */
2993 if (!wdev->netdev)
2994 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
8f894be2 2995
1c90f9d4 2996 return genlmsg_reply(msg, info);
55682965
JB		 2997}
2998
2999static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3000{
4c476991 3001 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84efbb84 3002 struct wireless_dev *wdev = info->user_ptr[1];
55682965 3003
4c476991
JB		 3004 if (!rdev->ops->del_virtual_intf)
3005 return -EOPNOTSUPP;
55682965 3006
84efbb84
JB		 3007 /*
3008 * If we remove a wireless device without a netdev then clear
3009 * user_ptr[1] so that nl80211_post_doit won't dereference it
3010 * to check if it needs to do dev_put(). Otherwise it crashes
3011 * since the wdev has been freed, unlike with a netdev where
3012 * we need the dev_put() for the netdev to really be freed.
3013 */
3014 if (!wdev->netdev)
3015 info->user_ptr[1] = NULL;
3016
7f8ed01e 3017 return rdev_del_virtual_intf(rdev, wdev);
55682965
JB		 3018}
3019
1d9d9213
SW		 3020static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3021{
3022 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3023 struct net_device *dev = info->user_ptr[1];
3024 u16 noack_map;
3025
3026 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3027 return -EINVAL;
3028
3029 if (!rdev->ops->set_noack_map)
3030 return -EOPNOTSUPP;
3031
3032 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3033
e35e4d28 3034 return rdev_set_noack_map(rdev, dev, noack_map);
1d9d9213
SW		 3035}
3036
41ade00f
JB		 3037struct get_key_cookie {
3038 struct sk_buff *msg;
3039 int error;
b9454e83 3040 int idx;
41ade00f
JB		 3041};
3042
3043static void get_key_callback(void *c, struct key_params *params)
3044{
b9454e83 3045 struct nlattr *key;
41ade00f
JB		 3046 struct get_key_cookie *cookie = c;
3047
9360ffd1
DM		 3048 if ((params->key &&
3049 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3050 params->key_len, params->key)) ||
3051 (params->seq &&
3052 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3053 params->seq_len, params->seq)) ||
3054 (params->cipher &&
3055 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3056 params->cipher)))
3057 goto nla_put_failure;
41ade00f 3058
b9454e83
JB		 3059 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
3060 if (!key)
3061 goto nla_put_failure;
3062
9360ffd1
DM		 3063 if ((params->key &&
3064 nla_put(cookie->msg, NL80211_KEY_DATA,
3065 params->key_len, params->key)) ||
3066 (params->seq &&
3067 nla_put(cookie->msg, NL80211_KEY_SEQ,
3068 params->seq_len, params->seq)) ||
3069 (params->cipher &&
3070 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3071 params->cipher)))
3072 goto nla_put_failure;
b9454e83 3073
9360ffd1
DM		 3074 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
3075 goto nla_put_failure;
b9454e83
JB		 3076
3077 nla_nest_end(cookie->msg, key);
3078
41ade00f
JB		 3079 return;
3080 nla_put_failure:
3081 cookie->error = 1;
3082}
3083
3084static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3085{
4c476991 3086 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3087 int err;
4c476991 3088 struct net_device *dev = info->user_ptr[1];
41ade00f 3089 u8 key_idx = 0;
e31b8213
JB		 3090 const u8 *mac_addr = NULL;
3091 bool pairwise;
41ade00f
JB		 3092 struct get_key_cookie cookie = {
3093 .error = 0,
3094 };
3095 void *hdr;
3096 struct sk_buff *msg;
3097
3098 if (info->attrs[NL80211_ATTR_KEY_IDX])
3099 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3100
3cfcf6ac 3101 if (key_idx > 5)
41ade00f
JB		 3102 return -EINVAL;
3103
3104 if (info->attrs[NL80211_ATTR_MAC])
3105 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3106
e31b8213
JB		 3107 pairwise = !!mac_addr;
3108 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3109 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
7a087e74 3110
e31b8213
JB		 3111 if (kt >= NUM_NL80211_KEYTYPES)
3112 return -EINVAL;
3113 if (kt != NL80211_KEYTYPE_GROUP &&
3114 kt != NL80211_KEYTYPE_PAIRWISE)
3115 return -EINVAL;
3116 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3117 }
3118
4c476991
JB		 3119 if (!rdev->ops->get_key)
3120 return -EOPNOTSUPP;
41ade00f 3121
0fa7b391
JB		 3122 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3123 return -ENOENT;
3124
fd2120ca 3125 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 3126 if (!msg)
3127 return -ENOMEM;
41ade00f 3128
15e47304 3129 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
41ade00f 3130 NL80211_CMD_NEW_KEY);
cb35fba3 3131 if (!hdr)
9fe271af 3132 goto nla_put_failure;
41ade00f
JB		 3133
3134 cookie.msg = msg;
b9454e83 3135 cookie.idx = key_idx;
41ade00f 3136
9360ffd1
DM		 3137 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3138 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3139 goto nla_put_failure;
3140 if (mac_addr &&
3141 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3142 goto nla_put_failure;
41ade00f 3143
e35e4d28
HG		 3144 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3145 get_key_callback);
41ade00f
JB		 3146
3147 if (err)
6c95e2a2 3148 goto free_msg;
41ade00f
JB		 3149
3150 if (cookie.error)
3151 goto nla_put_failure;
3152
3153 genlmsg_end(msg, hdr);
4c476991 3154 return genlmsg_reply(msg, info);
41ade00f
JB		 3155
3156 nla_put_failure:
3157 err = -ENOBUFS;
6c95e2a2 3158 free_msg:
41ade00f 3159 nlmsg_free(msg);
41ade00f
JB		 3160 return err;
3161}
3162
3163static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3164{
4c476991 3165 struct cfg80211_registered_device *rdev = info->user_ptr[0];
b9454e83 3166 struct key_parse key;
41ade00f 3167 int err;
4c476991 3168 struct net_device *dev = info->user_ptr[1];
41ade00f 3169
b9454e83
JB		 3170 err = nl80211_parse_key(info, &key);
3171 if (err)
3172 return err;
41ade00f 3173
b9454e83 3174 if (key.idx < 0)
41ade00f
JB		 3175 return -EINVAL;
3176
b9454e83
JB		 3177 /* only support setting default key */
3178 if (!key.def && !key.defmgmt)
41ade00f
JB		 3179 return -EINVAL;
3180
dbd2fd65 3181 wdev_lock(dev->ieee80211_ptr);
3cfcf6ac 3182
dbd2fd65
JB		 3183 if (key.def) {
3184 if (!rdev->ops->set_default_key) {
3185 err = -EOPNOTSUPP;
3186 goto out;
3187 }
41ade00f 3188
dbd2fd65
JB		 3189 err = nl80211_key_allowed(dev->ieee80211_ptr);
3190 if (err)
3191 goto out;
3192
e35e4d28 3193 err = rdev_set_default_key(rdev, dev, key.idx,
dbd2fd65
JB		 3194 key.def_uni, key.def_multi);
3195
3196 if (err)
3197 goto out;
fffd0934 3198
3d23e349 3199#ifdef CONFIG_CFG80211_WEXT
dbd2fd65
JB		 3200 dev->ieee80211_ptr->wext.default_key = key.idx;
3201#endif
3202 } else {
3203 if (key.def_uni || !key.def_multi) {
3204 err = -EINVAL;
3205 goto out;
3206 }
3207
3208 if (!rdev->ops->set_default_mgmt_key) {
3209 err = -EOPNOTSUPP;
3210 goto out;
3211 }
3212
3213 err = nl80211_key_allowed(dev->ieee80211_ptr);
3214 if (err)
3215 goto out;
3216
e35e4d28 3217 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
dbd2fd65
JB		 3218 if (err)
3219 goto out;
3220
3221#ifdef CONFIG_CFG80211_WEXT
3222 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126 3223#endif
dbd2fd65
JB		 3224 }
3225
3226 out:
fffd0934 3227 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3228
41ade00f
JB		 3229 return err;
3230}
3231
3232static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3233{
4c476991 3234 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fffd0934 3235 int err;
4c476991 3236 struct net_device *dev = info->user_ptr[1];
b9454e83 3237 struct key_parse key;
e31b8213 3238 const u8 *mac_addr = NULL;
41ade00f 3239
b9454e83
JB		 3240 err = nl80211_parse_key(info, &key);
3241 if (err)
3242 return err;
41ade00f 3243
b9454e83 3244 if (!key.p.key)
41ade00f
JB		 3245 return -EINVAL;
3246
41ade00f
JB		 3247 if (info->attrs[NL80211_ATTR_MAC])
3248 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3249
e31b8213
JB		 3250 if (key.type == -1) {
3251 if (mac_addr)
3252 key.type = NL80211_KEYTYPE_PAIRWISE;
3253 else
3254 key.type = NL80211_KEYTYPE_GROUP;
3255 }
3256
3257 /* for now */
3258 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3259 key.type != NL80211_KEYTYPE_GROUP)
3260 return -EINVAL;
3261
4c476991
JB		 3262 if (!rdev->ops->add_key)
3263 return -EOPNOTSUPP;
25e47c18 3264
e31b8213
JB		 3265 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3266 key.type == NL80211_KEYTYPE_PAIRWISE,
3267 mac_addr))
4c476991 3268 return -EINVAL;
41ade00f 3269
fffd0934
JB		 3270 wdev_lock(dev->ieee80211_ptr);
3271 err = nl80211_key_allowed(dev->ieee80211_ptr);
3272 if (!err)
e35e4d28
HG		 3273 err = rdev_add_key(rdev, dev, key.idx,
3274 key.type == NL80211_KEYTYPE_PAIRWISE,
3275 mac_addr, &key.p);
fffd0934 3276 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3277
41ade00f
JB		 3278 return err;
3279}
3280
3281static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3282{
4c476991 3283 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3284 int err;
4c476991 3285 struct net_device *dev = info->user_ptr[1];
41ade00f 3286 u8 *mac_addr = NULL;
b9454e83 3287 struct key_parse key;
41ade00f 3288
b9454e83
JB		 3289 err = nl80211_parse_key(info, &key);
3290 if (err)
3291 return err;
41ade00f
JB		 3292
3293 if (info->attrs[NL80211_ATTR_MAC])
3294 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3295
e31b8213
JB		 3296 if (key.type == -1) {
3297 if (mac_addr)
3298 key.type = NL80211_KEYTYPE_PAIRWISE;
3299 else
3300 key.type = NL80211_KEYTYPE_GROUP;
3301 }
3302
3303 /* for now */
3304 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3305 key.type != NL80211_KEYTYPE_GROUP)
3306 return -EINVAL;
3307
4c476991
JB		 3308 if (!rdev->ops->del_key)
3309 return -EOPNOTSUPP;
41ade00f 3310
fffd0934
JB		 3311 wdev_lock(dev->ieee80211_ptr);
3312 err = nl80211_key_allowed(dev->ieee80211_ptr);
e31b8213 3313
0fa7b391 3314 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
e31b8213
JB		 3315 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3316 err = -ENOENT;
3317
fffd0934 3318 if (!err)
e35e4d28
HG		 3319 err = rdev_del_key(rdev, dev, key.idx,
3320 key.type == NL80211_KEYTYPE_PAIRWISE,
3321 mac_addr);
41ade00f 3322
3d23e349 3323#ifdef CONFIG_CFG80211_WEXT
08645126 3324 if (!err) {
b9454e83 3325 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 3326 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 3327 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 3328 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3329 }
3330#endif
fffd0934 3331 wdev_unlock(dev->ieee80211_ptr);
08645126 3332
41ade00f
JB		 3333 return err;
3334}
3335
77765eaf
VT		 3336/* This function returns an error or the number of nested attributes */
3337static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3338{
3339 struct nlattr *attr;
3340 int n_entries = 0, tmp;
3341
3342 nla_for_each_nested(attr, nl_attr, tmp) {
3343 if (nla_len(attr) != ETH_ALEN)
3344 return -EINVAL;
3345
3346 n_entries++;
3347 }
3348
3349 return n_entries;
3350}
3351
3352/*
3353 * This function parses ACL information and allocates memory for ACL data.
3354 * On successful return, the calling function is responsible to free the
3355 * ACL buffer returned by this function.
3356 */
3357static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3358 struct genl_info *info)
3359{
3360 enum nl80211_acl_policy acl_policy;
3361 struct nlattr *attr;
3362 struct cfg80211_acl_data *acl;
3363 int i = 0, n_entries, tmp;
3364
3365 if (!wiphy->max_acl_mac_addrs)
3366 return ERR_PTR(-EOPNOTSUPP);
3367
3368 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3369 return ERR_PTR(-EINVAL);
3370
3371 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3372 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3373 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3374 return ERR_PTR(-EINVAL);
3375
3376 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3377 return ERR_PTR(-EINVAL);
3378
3379 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3380 if (n_entries < 0)
3381 return ERR_PTR(n_entries);
3382
3383 if (n_entries > wiphy->max_acl_mac_addrs)
3384 return ERR_PTR(-ENOTSUPP);
3385
3386 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3387 GFP_KERNEL);
3388 if (!acl)
3389 return ERR_PTR(-ENOMEM);
3390
3391 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3392 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3393 i++;
3394 }
3395
3396 acl->n_acl_entries = n_entries;
3397 acl->acl_policy = acl_policy;
3398
3399 return acl;
3400}
3401
3402static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3403{
3404 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3405 struct net_device *dev = info->user_ptr[1];
3406 struct cfg80211_acl_data *acl;
3407 int err;
3408
3409 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3410 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3411 return -EOPNOTSUPP;
3412
3413 if (!dev->ieee80211_ptr->beacon_interval)
3414 return -EINVAL;
3415
3416 acl = parse_acl_data(&rdev->wiphy, info);
3417 if (IS_ERR(acl))
3418 return PTR_ERR(acl);
3419
3420 err = rdev_set_mac_acl(rdev, dev, acl);
3421
3422 kfree(acl);
3423
3424 return err;
3425}
3426
a7c7fbff
PK		 3427static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
3428 u8 *rates, u8 rates_len)
3429{
3430 u8 i;
3431 u32 mask = 0;
3432
3433 for (i = 0; i < rates_len; i++) {
3434 int rate = (rates[i] & 0x7f) * 5;
3435 int ridx;
3436
3437 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
3438 struct ieee80211_rate *srate =
3439 &sband->bitrates[ridx];
3440 if (rate == srate->bitrate) {
3441 mask |= 1 << ridx;
3442 break;
3443 }
3444 }
3445 if (ridx == sband->n_bitrates)
3446 return 0; /* rate not found */
3447 }
3448
3449 return mask;
3450}
3451
3452static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
3453 u8 *rates, u8 rates_len,
3454 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
3455{
3456 u8 i;
3457
3458 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
3459
3460 for (i = 0; i < rates_len; i++) {
3461 int ridx, rbit;
3462
3463 ridx = rates[i] / 8;
3464 rbit = BIT(rates[i] % 8);
3465
3466 /* check validity */
3467 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
3468 return false;
3469
3470 /* check availability */
3471 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
3472 mcs[ridx] |= rbit;
3473 else
3474 return false;
3475 }
3476
3477 return true;
3478}
3479
3480static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
3481{
3482 u16 mcs_mask = 0;
3483
3484 switch (vht_mcs_map) {
3485 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
3486 break;
3487 case IEEE80211_VHT_MCS_SUPPORT_0_7:
3488 mcs_mask = 0x00FF;
3489 break;
3490 case IEEE80211_VHT_MCS_SUPPORT_0_8:
3491 mcs_mask = 0x01FF;
3492 break;
3493 case IEEE80211_VHT_MCS_SUPPORT_0_9:
3494 mcs_mask = 0x03FF;
3495 break;
3496 default:
3497 break;
3498 }
3499
3500 return mcs_mask;
3501}
3502
3503static void vht_build_mcs_mask(u16 vht_mcs_map,
3504 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
3505{
3506 u8 nss;
3507
3508 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
3509 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
3510 vht_mcs_map >>= 2;
3511 }
3512}
3513
3514static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
3515 struct nl80211_txrate_vht *txrate,
3516 u16 mcs[NL80211_VHT_NSS_MAX])
3517{
3518 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3519 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
3520 u8 i;
3521
3522 if (!sband->vht_cap.vht_supported)
3523 return false;
3524
3525 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
3526
3527 /* Build vht_mcs_mask from VHT capabilities */
3528 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
3529
3530 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3531 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
3532 mcs[i] = txrate->mcs[i];
3533 else
3534 return false;
3535 }
3536
3537 return true;
3538}
3539
3540static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
3541 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
3542 .len = NL80211_MAX_SUPP_RATES },
3543 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
3544 .len = NL80211_MAX_SUPP_HT_RATES },
3545 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
3546 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
3547};
3548
3549static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
3550 struct cfg80211_bitrate_mask *mask)
3551{
3552 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
3553 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3554 int rem, i;
3555 struct nlattr *tx_rates;
3556 struct ieee80211_supported_band *sband;
3557 u16 vht_tx_mcs_map;
3558
3559 memset(mask, 0, sizeof(*mask));
3560 /* Default to all rates enabled */
3561 for (i = 0; i < NUM_NL80211_BANDS; i++) {
3562 sband = rdev->wiphy.bands[i];
3563
3564 if (!sband)
3565 continue;
3566
3567 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
3568 memcpy(mask->control[i].ht_mcs,
3569 sband->ht_cap.mcs.rx_mask,
3570 sizeof(mask->control[i].ht_mcs));
3571
3572 if (!sband->vht_cap.vht_supported)
3573 continue;
3574
3575 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3576 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
3577 }
3578
3579 /* if no rates are given set it back to the defaults */
3580 if (!info->attrs[NL80211_ATTR_TX_RATES])
3581 goto out;
3582
3583 /* The nested attribute uses enum nl80211_band as the index. This maps
3584 * directly to the enum nl80211_band values used in cfg80211.
3585 */
3586 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
3587 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
3588 enum nl80211_band band = nla_type(tx_rates);
3589 int err;
3590
3591 if (band < 0 || band >= NUM_NL80211_BANDS)
3592 return -EINVAL;
3593 sband = rdev->wiphy.bands[band];
3594 if (sband == NULL)
3595 return -EINVAL;
bfe2c7b1 3596 err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
fe52145f 3597 nl80211_txattr_policy, info->extack);
a7c7fbff
PK		 3598 if (err)
3599 return err;
3600 if (tb[NL80211_TXRATE_LEGACY]) {
3601 mask->control[band].legacy = rateset_to_mask(
3602 sband,
3603 nla_data(tb[NL80211_TXRATE_LEGACY]),
3604 nla_len(tb[NL80211_TXRATE_LEGACY]));
3605 if ((mask->control[band].legacy == 0) &&
3606 nla_len(tb[NL80211_TXRATE_LEGACY]))
3607 return -EINVAL;
3608 }
3609 if (tb[NL80211_TXRATE_HT]) {
3610 if (!ht_rateset_to_mask(
3611 sband,
3612 nla_data(tb[NL80211_TXRATE_HT]),
3613 nla_len(tb[NL80211_TXRATE_HT]),
3614 mask->control[band].ht_mcs))
3615 return -EINVAL;
3616 }
3617 if (tb[NL80211_TXRATE_VHT]) {
3618 if (!vht_set_mcs_mask(
3619 sband,
3620 nla_data(tb[NL80211_TXRATE_VHT]),
3621 mask->control[band].vht_mcs))
3622 return -EINVAL;
3623 }
3624 if (tb[NL80211_TXRATE_GI]) {
3625 mask->control[band].gi =
3626 nla_get_u8(tb[NL80211_TXRATE_GI]);
3627 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
3628 return -EINVAL;
3629 }
3630
3631 if (mask->control[band].legacy == 0) {
3632 /* don't allow empty legacy rates if HT or VHT
3633 * are not even supported.
3634 */
3635 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
3636 rdev->wiphy.bands[band]->vht_cap.vht_supported))
3637 return -EINVAL;
3638
3639 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3640 if (mask->control[band].ht_mcs[i])
3641 goto out;
3642
3643 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3644 if (mask->control[band].vht_mcs[i])
3645 goto out;
3646
3647 /* legacy and mcs rates may not be both empty */
3648 return -EINVAL;
3649 }
3650 }
3651
3652out:
3653 return 0;
3654}
3655
8564e382
JB		 3656static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
3657 enum nl80211_band band,
3658 struct cfg80211_bitrate_mask *beacon_rate)
a7c7fbff 3659{
8564e382
JB		 3660 u32 count_ht, count_vht, i;
3661 u32 rate = beacon_rate->control[band].legacy;
a7c7fbff
PK		 3662
3663 /* Allow only one rate */
3664 if (hweight32(rate) > 1)
3665 return -EINVAL;
3666
3667 count_ht = 0;
3668 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
8564e382 3669 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
a7c7fbff 3670 return -EINVAL;
8564e382 3671 } else if (beacon_rate->control[band].ht_mcs[i]) {
a7c7fbff
PK		 3672 count_ht++;
3673 if (count_ht > 1)
3674 return -EINVAL;
3675 }
3676 if (count_ht && rate)
3677 return -EINVAL;
3678 }
3679
3680 count_vht = 0;
3681 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8564e382 3682 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
a7c7fbff 3683 return -EINVAL;
8564e382 3684 } else if (beacon_rate->control[band].vht_mcs[i]) {
a7c7fbff
PK		 3685 count_vht++;
3686 if (count_vht > 1)
3687 return -EINVAL;
3688 }
3689 if (count_vht && rate)
3690 return -EINVAL;
3691 }
3692
3693 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
3694 return -EINVAL;
3695
8564e382
JB		 3696 if (rate &&
3697 !wiphy_ext_feature_isset(&rdev->wiphy,
3698 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
3699 return -EINVAL;
3700 if (count_ht &&
3701 !wiphy_ext_feature_isset(&rdev->wiphy,
3702 NL80211_EXT_FEATURE_BEACON_RATE_HT))
3703 return -EINVAL;
3704 if (count_vht &&
3705 !wiphy_ext_feature_isset(&rdev->wiphy,
3706 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
3707 return -EINVAL;
3708
a7c7fbff
PK		 3709 return 0;
3710}
3711
a1193be8 3712static int nl80211_parse_beacon(struct nlattr *attrs[],
8860020e 3713 struct cfg80211_beacon_data *bcn)
ed1b6cc7 3714{
8860020e 3715 bool haveinfo = false;
ed1b6cc7 3716
a1193be8
SW		 3717 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3718 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3719 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3720 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
f4a11bb0
JB		 3721 return -EINVAL;
3722
8860020e 3723 memset(bcn, 0, sizeof(*bcn));
ed1b6cc7 3724
a1193be8
SW		 3725 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
3726 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3727 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
8860020e
JB		 3728 if (!bcn->head_len)
3729 return -EINVAL;
3730 haveinfo = true;
ed1b6cc7
JB		 3731 }
3732
a1193be8
SW		 3733 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3734 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3735 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
8860020e 3736 haveinfo = true;
ed1b6cc7
JB		 3737 }
3738
4c476991
JB		 3739 if (!haveinfo)
3740 return -EINVAL;
3b85875a 3741
a1193be8
SW		 3742 if (attrs[NL80211_ATTR_IE]) {
3743 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3744 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
9946ecfb
JM		 3745 }
3746
a1193be8 3747 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
8860020e 3748 bcn->proberesp_ies =
a1193be8 3749 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
8860020e 3750 bcn->proberesp_ies_len =
a1193be8 3751 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
9946ecfb
JM		 3752 }
3753
a1193be8 3754 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
8860020e 3755 bcn->assocresp_ies =
a1193be8 3756 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
8860020e 3757 bcn->assocresp_ies_len =
a1193be8 3758 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
9946ecfb
JM		 3759 }
3760
a1193be8
SW		 3761 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3762 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3763 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
00f740e1
AN		 3764 }
3765
8860020e
JB		 3766 return 0;
3767}
3768
66cd794e
JB		 3769static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
3770 const u8 *rates)
3771{
3772 int i;
3773
3774 if (!rates)
3775 return;
3776
3777 for (i = 0; i < rates[1]; i++) {
3778 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
3779 params->ht_required = true;
3780 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
3781 params->vht_required = true;
3782 }
3783}
3784
3785/*
3786 * Since the nl80211 API didn't include, from the beginning, attributes about
3787 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
3788 * benefit of drivers that rebuild IEs in the firmware.
3789 */
3790static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
3791{
3792 const struct cfg80211_beacon_data *bcn = &params->beacon;
3793 size_t ies_len = bcn->beacon_ies_len;
3794 const u8 *ies = bcn->beacon_ies;
3795 const u8 *rates;
3796 const u8 *cap;
3797
3798 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
3799 nl80211_check_ap_rate_selectors(params, rates);
3800
3801 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
3802 nl80211_check_ap_rate_selectors(params, rates);
3803
3804 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
3805 if (cap && cap[1] >= sizeof(*params->ht_cap))
3806 params->ht_cap = (void *)(cap + 2);
3807 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
3808 if (cap && cap[1] >= sizeof(*params->vht_cap))
3809 params->vht_cap = (void *)(cap + 2);
3810}
3811
46c1dd0c
FF		 3812static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3813 struct cfg80211_ap_settings *params)
3814{
3815 struct wireless_dev *wdev;
3816 bool ret = false;
3817
53873f13 3818 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
46c1dd0c
FF		 3819 if (wdev->iftype != NL80211_IFTYPE_AP &&
3820 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3821 continue;
3822
683b6d3b 3823 if (!wdev->preset_chandef.chan)
46c1dd0c
FF		 3824 continue;
3825
683b6d3b 3826 params->chandef = wdev->preset_chandef;
46c1dd0c
FF		 3827 ret = true;
3828 break;
3829 }
3830
46c1dd0c
FF		 3831 return ret;
3832}
3833
e39e5b5e
JM		 3834static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3835 enum nl80211_auth_type auth_type,
3836 enum nl80211_commands cmd)
3837{
3838 if (auth_type > NL80211_AUTHTYPE_MAX)
3839 return false;
3840
3841 switch (cmd) {
3842 case NL80211_CMD_AUTHENTICATE:
3843 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3844 auth_type == NL80211_AUTHTYPE_SAE)
3845 return false;
63181060
JM		 3846 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3847 NL80211_EXT_FEATURE_FILS_STA) &&
3848 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3849 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3850 auth_type == NL80211_AUTHTYPE_FILS_PK))
3851 return false;
e39e5b5e
JM		 3852 return true;
3853 case NL80211_CMD_CONNECT:
a3caf744
VK		 3854 /* SAE not supported yet */
3855 if (auth_type == NL80211_AUTHTYPE_SAE)
3856 return false;
3857 /* FILS with SK PFS or PK not supported yet */
3858 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3859 auth_type == NL80211_AUTHTYPE_FILS_PK)
3860 return false;
3861 if (!wiphy_ext_feature_isset(
3862 &rdev->wiphy,
3863 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
3864 auth_type == NL80211_AUTHTYPE_FILS_SK)
3865 return false;
3866 return true;
e39e5b5e
JM		 3867 case NL80211_CMD_START_AP:
3868 /* SAE not supported yet */
3869 if (auth_type == NL80211_AUTHTYPE_SAE)
3870 return false;
63181060
JM		 3871 /* FILS not supported yet */
3872 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3873 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3874 auth_type == NL80211_AUTHTYPE_FILS_PK)
3875 return false;
e39e5b5e
JM		 3876 return true;
3877 default:
3878 return false;
3879 }
3880}
3881
8860020e
JB		 3882static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3883{
3884 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3885 struct net_device *dev = info->user_ptr[1];
3886 struct wireless_dev *wdev = dev->ieee80211_ptr;
3887 struct cfg80211_ap_settings params;
3888 int err;
3889
3890 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3891 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3892 return -EOPNOTSUPP;
3893
3894 if (!rdev->ops->start_ap)
3895 return -EOPNOTSUPP;
3896
3897 if (wdev->beacon_interval)
3898 return -EALREADY;
3899
3900 memset(&params, 0, sizeof(params));
3901
3902 /* these are required for START_AP */
3903 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3904 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3905 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3906 return -EINVAL;
3907
a1193be8 3908 err = nl80211_parse_beacon(info->attrs, &params.beacon);
8860020e
JB		 3909 if (err)
3910 return err;
3911
3912 params.beacon_interval =
3913 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3914 params.dtim_period =
3915 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3916
0c317a02
PK		 3917 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
3918 params.beacon_interval);
8860020e
JB		 3919 if (err)
3920 return err;
3921
3922 /*
3923 * In theory, some of these attributes should be required here
3924 * but since they were not used when the command was originally
3925 * added, keep them optional for old user space programs to let
3926 * them continue to work with drivers that do not need the
3927 * additional information -- drivers must check!
3928 */
3929 if (info->attrs[NL80211_ATTR_SSID]) {
3930 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3931 params.ssid_len =
3932 nla_len(info->attrs[NL80211_ATTR_SSID]);
3933 if (params.ssid_len == 0 ||
3934 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3935 return -EINVAL;
3936 }
3937
3938 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3939 params.hidden_ssid = nla_get_u32(
3940 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3941 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3942 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3943 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3944 return -EINVAL;
3945 }
3946
3947 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3948
3949 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3950 params.auth_type = nla_get_u32(
3951 info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 3952 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3953 NL80211_CMD_START_AP))
8860020e
JB		 3954 return -EINVAL;
3955 } else
3956 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3957
3958 err = nl80211_crypto_settings(rdev, info, &params.crypto,
3959 NL80211_MAX_NR_CIPHER_SUITES);
3960 if (err)
3961 return err;
3962
1b658f11
VT		 3963 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3964 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3965 return -EOPNOTSUPP;
3966 params.inactivity_timeout = nla_get_u16(
3967 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3968 }
3969
53cabad7
JB		 3970 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3971 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3972 return -EINVAL;
3973 params.p2p_ctwindow =
3974 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3975 if (params.p2p_ctwindow > 127)
3976 return -EINVAL;
3977 if (params.p2p_ctwindow != 0 &&
3978 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3979 return -EINVAL;
3980 }
3981
3982 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3983 u8 tmp;
3984
3985 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3986 return -EINVAL;
3987 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3988 if (tmp > 1)
3989 return -EINVAL;
3990 params.p2p_opp_ps = tmp;
3991 if (params.p2p_opp_ps != 0 &&
3992 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3993 return -EINVAL;
3994 }
3995
aa430da4 3996 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 3997 err = nl80211_parse_chandef(rdev, info, &params.chandef);
3998 if (err)
3999 return err;
4000 } else if (wdev->preset_chandef.chan) {
4001 params.chandef = wdev->preset_chandef;
46c1dd0c 4002 } else if (!nl80211_get_ap_channel(rdev, &params))
aa430da4
JB		 4003 return -EINVAL;
4004
923b352f
AN		 4005 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
4006 wdev->iftype))
aa430da4
JB		 4007 return -EINVAL;
4008
a7c7fbff
PK		 4009 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4010 err = nl80211_parse_tx_bitrate_mask(info, &params.beacon_rate);
4011 if (err)
4012 return err;
4013
8564e382
JB		 4014 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4015 &params.beacon_rate);
a7c7fbff
PK		 4016 if (err)
4017 return err;
4018 }
4019
18998c38
EP		 4020 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4021 params.smps_mode =
4022 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4023 switch (params.smps_mode) {
4024 case NL80211_SMPS_OFF:
4025 break;
4026 case NL80211_SMPS_STATIC:
4027 if (!(rdev->wiphy.features &
4028 NL80211_FEATURE_STATIC_SMPS))
4029 return -EINVAL;
4030 break;
4031 case NL80211_SMPS_DYNAMIC:
4032 if (!(rdev->wiphy.features &
4033 NL80211_FEATURE_DYNAMIC_SMPS))
4034 return -EINVAL;
4035 break;
4036 default:
4037 return -EINVAL;
4038 }
4039 } else {
4040 params.smps_mode = NL80211_SMPS_OFF;
4041 }
4042
6e8ef842
PK		 4043 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4044 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4045 return -EOPNOTSUPP;
4046
4baf6bea
OO		 4047 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4048 params.acl = parse_acl_data(&rdev->wiphy, info);
4049 if (IS_ERR(params.acl))
4050 return PTR_ERR(params.acl);
4051 }
4052
66cd794e
JB		 4053 nl80211_calculate_ap_params(&params);
4054
c56589ed 4055 wdev_lock(wdev);
e35e4d28 4056 err = rdev_start_ap(rdev, dev, &params);
46c1dd0c 4057 if (!err) {
683b6d3b 4058 wdev->preset_chandef = params.chandef;
8860020e 4059 wdev->beacon_interval = params.beacon_interval;
9e0e2961 4060 wdev->chandef = params.chandef;
06e191e2
AQ		 4061 wdev->ssid_len = params.ssid_len;
4062 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
46c1dd0c 4063 }
c56589ed 4064 wdev_unlock(wdev);
77765eaf
VT		 4065
4066 kfree(params.acl);
4067
56d1893d 4068 return err;
ed1b6cc7
JB		 4069}
4070
8860020e
JB		 4071static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4072{
4073 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4074 struct net_device *dev = info->user_ptr[1];
4075 struct wireless_dev *wdev = dev->ieee80211_ptr;
4076 struct cfg80211_beacon_data params;
4077 int err;
4078
4079 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4080 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4081 return -EOPNOTSUPP;
4082
4083 if (!rdev->ops->change_beacon)
4084 return -EOPNOTSUPP;
4085
4086 if (!wdev->beacon_interval)
4087 return -EINVAL;
4088
a1193be8 4089 err = nl80211_parse_beacon(info->attrs, &params);
8860020e
JB		 4090 if (err)
4091 return err;
4092
c56589ed
SW		 4093 wdev_lock(wdev);
4094 err = rdev_change_beacon(rdev, dev, &params);
4095 wdev_unlock(wdev);
4096
4097 return err;
8860020e
JB		 4098}
4099
4100static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
ed1b6cc7 4101{
4c476991
JB		 4102 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4103 struct net_device *dev = info->user_ptr[1];
ed1b6cc7 4104
7c8d5e03 4105 return cfg80211_stop_ap(rdev, dev, false);
ed1b6cc7
JB		 4106}
4107
5727ef1b
JB		 4108static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4109 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4110 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4111 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 4112 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
b39c48fa 4113 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
d83023da 4114 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5727ef1b
JB		 4115};
4116
eccb8e8f 4117static int parse_station_flags(struct genl_info *info,
bdd3ae3d 4118 enum nl80211_iftype iftype,
eccb8e8f 4119 struct station_parameters *params)
5727ef1b
JB		 4120{
4121 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 4122 struct nlattr *nla;
5727ef1b
JB		 4123 int flag;
4124
eccb8e8f
JB		 4125 /*
4126 * Try parsing the new attribute first so userspace
4127 * can specify both for older kernels.
4128 */
4129 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4130 if (nla) {
4131 struct nl80211_sta_flag_update *sta_flags;
4132
4133 sta_flags = nla_data(nla);
4134 params->sta_flags_mask = sta_flags->mask;
4135 params->sta_flags_set = sta_flags->set;
77ee7c89 4136 params->sta_flags_set &= params->sta_flags_mask;
eccb8e8f
JB		 4137 if ((params->sta_flags_mask |
4138 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4139 return -EINVAL;
4140 return 0;
4141 }
4142
4143 /* if present, parse the old attribute */
5727ef1b 4144
eccb8e8f 4145 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 4146 if (!nla)
4147 return 0;
4148
fceb6435 4149 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, nla,
fe52145f 4150 sta_flags_policy, info->extack))
5727ef1b
JB		 4151 return -EINVAL;
4152
bdd3ae3d
JB		 4153 /*
4154 * Only allow certain flags for interface types so that
4155 * other attributes are silently ignored. Remember that
4156 * this is backward compatibility code with old userspace
4157 * and shouldn't be hit in other cases anyway.
4158 */
4159 switch (iftype) {
4160 case NL80211_IFTYPE_AP:
4161 case NL80211_IFTYPE_AP_VLAN:
4162 case NL80211_IFTYPE_P2P_GO:
4163 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4164 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4165 BIT(NL80211_STA_FLAG_WME) |
4166 BIT(NL80211_STA_FLAG_MFP);
4167 break;
4168 case NL80211_IFTYPE_P2P_CLIENT:
4169 case NL80211_IFTYPE_STATION:
4170 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4171 BIT(NL80211_STA_FLAG_TDLS_PEER);
4172 break;
4173 case NL80211_IFTYPE_MESH_POINT:
4174 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4175 BIT(NL80211_STA_FLAG_MFP) |
4176 BIT(NL80211_STA_FLAG_AUTHORIZED);
4177 default:
4178 return -EINVAL;
4179 }
5727ef1b 4180
3383b5a6
JB		 4181 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4182 if (flags[flag]) {
eccb8e8f 4183 params->sta_flags_set |= (1<<flag);
5727ef1b 4184
3383b5a6
JB		 4185 /* no longer support new API additions in old API */
4186 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4187 return -EINVAL;
4188 }
4189 }
4190
5727ef1b
JB		 4191 return 0;
4192}
4193
c8dcfd8a
FF		 4194static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
4195 int attr)
4196{
4197 struct nlattr *rate;
8eb41c8d
VK		 4198 u32 bitrate;
4199 u16 bitrate_compat;
bbf67e45 4200 enum nl80211_rate_info rate_flg;
c8dcfd8a
FF		 4201
4202 rate = nla_nest_start(msg, attr);
4203 if (!rate)
db9c64cf 4204 return false;
c8dcfd8a
FF		 4205
4206 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4207 bitrate = cfg80211_calculate_bitrate(info);
8eb41c8d
VK		 4208 /* report 16-bit bitrate only if we can */
4209 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
db9c64cf
JB		 4210 if (bitrate > 0 &&
4211 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4212 return false;
4213 if (bitrate_compat > 0 &&
4214 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4215 return false;
4216
b51f3bee
JB		 4217 switch (info->bw) {
4218 case RATE_INFO_BW_5:
4219 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4220 break;
4221 case RATE_INFO_BW_10:
4222 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4223 break;
4224 default:
4225 WARN_ON(1);
4226 /* fall through */
4227 case RATE_INFO_BW_20:
4228 rate_flg = 0;
4229 break;
4230 case RATE_INFO_BW_40:
4231 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4232 break;
4233 case RATE_INFO_BW_80:
4234 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4235 break;
4236 case RATE_INFO_BW_160:
4237 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4238 break;
4239 }
4240
4241 if (rate_flg && nla_put_flag(msg, rate_flg))
4242 return false;
4243
db9c64cf
JB		 4244 if (info->flags & RATE_INFO_FLAGS_MCS) {
4245 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4246 return false;
db9c64cf
JB		 4247 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4248 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4249 return false;
4250 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4251 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4252 return false;
4253 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4254 return false;
db9c64cf
JB		 4255 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4256 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4257 return false;
4258 }
c8dcfd8a
FF		 4259
4260 nla_nest_end(msg, rate);
4261 return true;
c8dcfd8a
FF		 4262}
4263
119363c7
FF		 4264static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4265 int id)
4266{
4267 void *attr;
4268 int i = 0;
4269
4270 if (!mask)
4271 return true;
4272
4273 attr = nla_nest_start(msg, id);
4274 if (!attr)
4275 return false;
4276
4277 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4278 if (!(mask & BIT(i)))
4279 continue;
4280
4281 if (nla_put_u8(msg, i, signal[i]))
4282 return false;
4283 }
4284
4285 nla_nest_end(msg, attr);
4286
4287 return true;
4288}
4289
cf5ead82
JB		 4290static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4291 u32 seq, int flags,
66266b3a
JL		 4292 struct cfg80211_registered_device *rdev,
4293 struct net_device *dev,
98b62183 4294 const u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 4295{
4296 void *hdr;
f4263c98 4297 struct nlattr *sinfoattr, *bss_param;
fd5b74dc 4298
cf5ead82 4299 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
fd5b74dc
JB		 4300 if (!hdr)
4301 return -1;
4302
9360ffd1
DM		 4303 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4304 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
4305 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
4306 goto nla_put_failure;
f5ea9120 4307
2ec600d6
LCC		 4308 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
4309 if (!sinfoattr)
fd5b74dc 4310 goto nla_put_failure;
319090bf
JB		 4311
4312#define PUT_SINFO(attr, memb, type) do { \
d686b920 4313 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
739960f1 4314 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
319090bf
JB		 4315 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
4316 sinfo->memb)) \
4317 goto nla_put_failure; \
4318 } while (0)
d686b920
JB		 4319#define PUT_SINFO_U64(attr, memb) do { \
4320 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
4321 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
4322 sinfo->memb, NL80211_STA_INFO_PAD)) \
4323 goto nla_put_failure; \
4324 } while (0)
319090bf
JB		 4325
4326 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
4327 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
4328
4329 if (sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES) |
4330 BIT(NL80211_STA_INFO_RX_BYTES64)) &&
9360ffd1 4331 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
42745e03 4332 (u32)sinfo->rx_bytes))
9360ffd1 4333 goto nla_put_failure;
319090bf
JB		 4334
4335 if (sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES) |
4336 BIT(NL80211_STA_INFO_TX_BYTES64)) &&
9360ffd1 4337 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
42745e03
VK		 4338 (u32)sinfo->tx_bytes))
4339 goto nla_put_failure;
319090bf 4340
d686b920
JB		 4341 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
4342 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
319090bf
JB		 4343 PUT_SINFO(LLID, llid, u16);
4344 PUT_SINFO(PLID, plid, u16);
4345 PUT_SINFO(PLINK_STATE, plink_state, u8);
d686b920 4346 PUT_SINFO_U64(RX_DURATION, rx_duration);
319090bf 4347
66266b3a
JL		 4348 switch (rdev->wiphy.signal_type) {
4349 case CFG80211_SIGNAL_TYPE_MBM:
319090bf
JB		 4350 PUT_SINFO(SIGNAL, signal, u8);
4351 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
66266b3a
JL		 4352 break;
4353 default:
4354 break;
4355 }
319090bf 4356 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL)) {
119363c7
FF		 4357 if (!nl80211_put_signal(msg, sinfo->chains,
4358 sinfo->chain_signal,
4359 NL80211_STA_INFO_CHAIN_SIGNAL))
4360 goto nla_put_failure;
4361 }
319090bf 4362 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
119363c7
FF		 4363 if (!nl80211_put_signal(msg, sinfo->chains,
4364 sinfo->chain_signal_avg,
4365 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
4366 goto nla_put_failure;
4367 }
319090bf 4368 if (sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {
c8dcfd8a
FF		 4369 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
4370 NL80211_STA_INFO_TX_BITRATE))
4371 goto nla_put_failure;
4372 }
319090bf 4373 if (sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE)) {
c8dcfd8a
FF		 4374 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
4375 NL80211_STA_INFO_RX_BITRATE))
420e7fab 4376 goto nla_put_failure;
420e7fab 4377 }
319090bf
JB		 4378
4379 PUT_SINFO(RX_PACKETS, rx_packets, u32);
4380 PUT_SINFO(TX_PACKETS, tx_packets, u32);
4381 PUT_SINFO(TX_RETRIES, tx_retries, u32);
4382 PUT_SINFO(TX_FAILED, tx_failed, u32);
4383 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
4384 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
4385 PUT_SINFO(LOCAL_PM, local_pm, u32);
4386 PUT_SINFO(PEER_PM, peer_pm, u32);
4387 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
4388
4389 if (sinfo->filled & BIT(NL80211_STA_INFO_BSS_PARAM)) {
f4263c98
PS		 4390 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
4391 if (!bss_param)
4392 goto nla_put_failure;
4393
9360ffd1
DM		 4394 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
4395 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
4396 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
4397 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
4398 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
4399 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
4400 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
4401 sinfo->bss_param.dtim_period) ||
4402 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
4403 sinfo->bss_param.beacon_interval))
4404 goto nla_put_failure;
f4263c98
PS		 4405
4406 nla_nest_end(msg, bss_param);
4407 }
319090bf 4408 if ((sinfo->filled & BIT(NL80211_STA_INFO_STA_FLAGS)) &&
9360ffd1
DM		 4409 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
4410 sizeof(struct nl80211_sta_flag_update),
4411 &sinfo->sta_flags))
4412 goto nla_put_failure;
319090bf 4413
d686b920
JB		 4414 PUT_SINFO_U64(T_OFFSET, t_offset);
4415 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
4416 PUT_SINFO_U64(BEACON_RX, rx_beacon);
a76b1942 4417 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
319090bf
JB		 4418
4419#undef PUT_SINFO
d686b920 4420#undef PUT_SINFO_U64
6de39808
JB		 4421
4422 if (sinfo->filled & BIT(NL80211_STA_INFO_TID_STATS)) {
4423 struct nlattr *tidsattr;
4424 int tid;
4425
4426 tidsattr = nla_nest_start(msg, NL80211_STA_INFO_TID_STATS);
4427 if (!tidsattr)
4428 goto nla_put_failure;
4429
4430 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
4431 struct cfg80211_tid_stats *tidstats;
4432 struct nlattr *tidattr;
4433
4434 tidstats = &sinfo->pertid[tid];
4435
4436 if (!tidstats->filled)
4437 continue;
4438
4439 tidattr = nla_nest_start(msg, tid + 1);
4440 if (!tidattr)
4441 goto nla_put_failure;
4442
d686b920 4443#define PUT_TIDVAL_U64(attr, memb) do { \
6de39808 4444 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
d686b920
JB		 4445 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
4446 tidstats->memb, NL80211_TID_STATS_PAD)) \
6de39808
JB		 4447 goto nla_put_failure; \
4448 } while (0)
4449
d686b920
JB		 4450 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
4451 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
4452 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
4453 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
6de39808 4454
d686b920 4455#undef PUT_TIDVAL_U64
6de39808
JB		 4456 nla_nest_end(msg, tidattr);
4457 }
4458
4459 nla_nest_end(msg, tidsattr);
4460 }
4461
2ec600d6 4462 nla_nest_end(msg, sinfoattr);
fd5b74dc 4463
319090bf 4464 if (sinfo->assoc_req_ies_len &&
9360ffd1
DM		 4465 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
4466 sinfo->assoc_req_ies))
4467 goto nla_put_failure;
50d3dfb7 4468
053c095a
JB		 4469 genlmsg_end(msg, hdr);
4470 return 0;
fd5b74dc
JB		 4471
4472 nla_put_failure:
bc3ed28c
TG		 4473 genlmsg_cancel(msg, hdr);
4474 return -EMSGSIZE;
fd5b74dc
JB		 4475}
4476
2ec600d6 4477static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 4478 struct netlink_callback *cb)
2ec600d6 4479{
2ec600d6 4480 struct station_info sinfo;
1b8ec87a 4481 struct cfg80211_registered_device *rdev;
97990a06 4482 struct wireless_dev *wdev;
2ec600d6 4483 u8 mac_addr[ETH_ALEN];
97990a06 4484 int sta_idx = cb->args[2];
2ec600d6 4485 int err;
2ec600d6 4486
ea90e0dc 4487 rtnl_lock();
1b8ec87a 4488 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 4489 if (err)
ea90e0dc 4490 goto out_err;
bba95fef 4491
97990a06
JB		 4492 if (!wdev->netdev) {
4493 err = -EINVAL;
4494 goto out_err;
4495 }
4496
1b8ec87a 4497 if (!rdev->ops->dump_station) {
eec60b03 4498 err = -EOPNOTSUPP;
bba95fef
JB		 4499 goto out_err;
4500 }
4501
bba95fef 4502 while (1) {
f612cedf 4503 memset(&sinfo, 0, sizeof(sinfo));
1b8ec87a 4504 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
e35e4d28 4505 mac_addr, &sinfo);
bba95fef
JB		 4506 if (err == -ENOENT)
4507 break;
4508 if (err)
3b85875a 4509 goto out_err;
bba95fef 4510
cf5ead82 4511 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
15e47304 4512 NETLINK_CB(cb->skb).portid,
bba95fef 4513 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1b8ec87a 4514 rdev, wdev->netdev, mac_addr,
bba95fef
JB		 4515 &sinfo) < 0)
4516 goto out;
4517
4518 sta_idx++;
4519 }
4520
bba95fef 4521 out:
97990a06 4522 cb->args[2] = sta_idx;
bba95fef 4523 err = skb->len;
bba95fef 4524 out_err:
ea90e0dc 4525 rtnl_unlock();
bba95fef
JB		 4526
4527 return err;
2ec600d6 4528}
fd5b74dc 4529
5727ef1b
JB		 4530static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
4531{
4c476991
JB		 4532 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4533 struct net_device *dev = info->user_ptr[1];
2ec600d6 4534 struct station_info sinfo;
fd5b74dc
JB		 4535 struct sk_buff *msg;
4536 u8 *mac_addr = NULL;
4c476991 4537 int err;
fd5b74dc 4538
2ec600d6 4539 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 4540
4541 if (!info->attrs[NL80211_ATTR_MAC])
4542 return -EINVAL;
4543
4544 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4545
4c476991
JB		 4546 if (!rdev->ops->get_station)
4547 return -EOPNOTSUPP;
3b85875a 4548
e35e4d28 4549 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
fd5b74dc 4550 if (err)
4c476991 4551 return err;
2ec600d6 4552
fd2120ca 4553 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc 4554 if (!msg)
4c476991 4555 return -ENOMEM;
fd5b74dc 4556
cf5ead82
JB		 4557 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
4558 info->snd_portid, info->snd_seq, 0,
66266b3a 4559 rdev, dev, mac_addr, &sinfo) < 0) {
4c476991
JB		 4560 nlmsg_free(msg);
4561 return -ENOBUFS;
4562 }
3b85875a 4563
4c476991 4564 return genlmsg_reply(msg, info);
5727ef1b
JB		 4565}
4566
77ee7c89
JB		 4567int cfg80211_check_station_change(struct wiphy *wiphy,
4568 struct station_parameters *params,
4569 enum cfg80211_station_type statype)
4570{
e4208427
AB		 4571 if (params->listen_interval != -1 &&
4572 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89 4573 return -EINVAL;
e4208427 4574
17b94247
AB		 4575 if (params->support_p2p_ps != -1 &&
4576 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
4577 return -EINVAL;
4578
c72e1140 4579 if (params->aid &&
e4208427
AB		 4580 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
4581 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89
JB		 4582 return -EINVAL;
4583
4584 /* When you run into this, adjust the code below for the new flag */
4585 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4586
4587 switch (statype) {
eef941e6
TP		 4588 case CFG80211_STA_MESH_PEER_KERNEL:
4589 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 4590 /*
4591 * No ignoring the TDLS flag here -- the userspace mesh
4592 * code doesn't have the bug of including TDLS in the
4593 * mask everywhere.
4594 */
4595 if (params->sta_flags_mask &
4596 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4597 BIT(NL80211_STA_FLAG_MFP) |
4598 BIT(NL80211_STA_FLAG_AUTHORIZED)))
4599 return -EINVAL;
4600 break;
4601 case CFG80211_STA_TDLS_PEER_SETUP:
4602 case CFG80211_STA_TDLS_PEER_ACTIVE:
4603 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4604 return -EINVAL;
4605 /* ignore since it can't change */
4606 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4607 break;
4608 default:
4609 /* disallow mesh-specific things */
4610 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
4611 return -EINVAL;
4612 if (params->local_pm)
4613 return -EINVAL;
4614 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4615 return -EINVAL;
4616 }
4617
4618 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4619 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
4620 /* TDLS can't be set, ... */
4621 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4622 return -EINVAL;
4623 /*
4624 * ... but don't bother the driver with it. This works around
4625 * a hostapd/wpa_supplicant issue -- it always includes the
4626 * TLDS_PEER flag in the mask even for AP mode.
4627 */
4628 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4629 }
4630
47edb11b
AB		 4631 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4632 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4633 /* reject other things that can't change */
4634 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
4635 return -EINVAL;
4636 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
4637 return -EINVAL;
4638 if (params->supported_rates)
4639 return -EINVAL;
4640 if (params->ext_capab || params->ht_capa || params->vht_capa)
4641 return -EINVAL;
4642 }
4643
47edb11b
AB		 4644 if (statype != CFG80211_STA_AP_CLIENT &&
4645 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4646 if (params->vlan)
4647 return -EINVAL;
4648 }
4649
4650 switch (statype) {
4651 case CFG80211_STA_AP_MLME_CLIENT:
4652 /* Use this only for authorizing/unauthorizing a station */
4653 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4654 return -EOPNOTSUPP;
4655 break;
4656 case CFG80211_STA_AP_CLIENT:
47edb11b 4657 case CFG80211_STA_AP_CLIENT_UNASSOC:
77ee7c89
JB		 4658 /* accept only the listed bits */
4659 if (params->sta_flags_mask &
4660 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4661 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4662 BIT(NL80211_STA_FLAG_ASSOCIATED) |
4663 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4664 BIT(NL80211_STA_FLAG_WME) |
4665 BIT(NL80211_STA_FLAG_MFP)))
4666 return -EINVAL;
4667
4668 /* but authenticated/associated only if driver handles it */
4669 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4670 params->sta_flags_mask &
4671 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4672 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4673 return -EINVAL;
4674 break;
4675 case CFG80211_STA_IBSS:
4676 case CFG80211_STA_AP_STA:
4677 /* reject any changes other than AUTHORIZED */
4678 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
4679 return -EINVAL;
4680 break;
4681 case CFG80211_STA_TDLS_PEER_SETUP:
4682 /* reject any changes other than AUTHORIZED or WME */
4683 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4684 BIT(NL80211_STA_FLAG_WME)))
4685 return -EINVAL;
4686 /* force (at least) rates when authorizing */
4687 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
4688 !params->supported_rates)
4689 return -EINVAL;
4690 break;
4691 case CFG80211_STA_TDLS_PEER_ACTIVE:
4692 /* reject any changes */
4693 return -EINVAL;
eef941e6 4694 case CFG80211_STA_MESH_PEER_KERNEL:
77ee7c89
JB		 4695 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4696 return -EINVAL;
4697 break;
eef941e6 4698 case CFG80211_STA_MESH_PEER_USER:
42925040
CYY		 4699 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
4700 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
77ee7c89
JB		 4701 return -EINVAL;
4702 break;
4703 }
4704
06f7c88c
BL		 4705 /*
4706 * Older kernel versions ignored this attribute entirely, so don't
4707 * reject attempts to update it but mark it as unused instead so the
4708 * driver won't look at the data.
4709 */
4710 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
4711 statype != CFG80211_STA_TDLS_PEER_SETUP)
4712 params->opmode_notif_used = false;
4713
77ee7c89
JB		 4714 return 0;
4715}
4716EXPORT_SYMBOL(cfg80211_check_station_change);
4717
5727ef1b 4718/*
c258d2de 4719 * Get vlan interface making sure it is running and on the right wiphy.
5727ef1b 4720 */
80b99899
JB		 4721static struct net_device *get_vlan(struct genl_info *info,
4722 struct cfg80211_registered_device *rdev)
5727ef1b 4723{
463d0183 4724 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
80b99899
JB		 4725 struct net_device *v;
4726 int ret;
4727
4728 if (!vlanattr)
4729 return NULL;
4730
4731 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4732 if (!v)
4733 return ERR_PTR(-ENODEV);
4734
4735 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4736 ret = -EINVAL;
4737 goto error;
5727ef1b 4738 }
80b99899 4739
77ee7c89
JB		 4740 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4741 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4742 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4743 ret = -EINVAL;
4744 goto error;
4745 }
4746
80b99899
JB		 4747 if (!netif_running(v)) {
4748 ret = -ENETDOWN;
4749 goto error;
4750 }
4751
4752 return v;
4753 error:
4754 dev_put(v);
4755 return ERR_PTR(ret);
5727ef1b
JB		 4756}
4757
94e860f1
JB		 4758static const struct nla_policy
4759nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
df881293
JM		 4760 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4761 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4762};
4763
ff276691
JB		 4764static int nl80211_parse_sta_wme(struct genl_info *info,
4765 struct station_parameters *params)
df881293 4766{
df881293
JM		 4767 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4768 struct nlattr *nla;
4769 int err;
4770
df881293
JM		 4771 /* parse WME attributes if present */
4772 if (!info->attrs[NL80211_ATTR_STA_WME])
4773 return 0;
4774
4775 nla = info->attrs[NL80211_ATTR_STA_WME];
4776 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
fe52145f 4777 nl80211_sta_wme_policy, info->extack);
df881293
JM		 4778 if (err)
4779 return err;
4780
4781 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4782 params->uapsd_queues = nla_get_u8(
4783 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4784 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4785 return -EINVAL;
4786
4787 if (tb[NL80211_STA_WME_MAX_SP])
4788 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4789
4790 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4791 return -EINVAL;
4792
4793 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4794
4795 return 0;
4796}
4797
c01fc9ad
SD		 4798static int nl80211_parse_sta_channel_info(struct genl_info *info,
4799 struct station_parameters *params)
4800{
4801 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4802 params->supported_channels =
4803 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4804 params->supported_channels_len =
4805 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4806 /*
4807 * Need to include at least one (first channel, number of
4808 * channels) tuple for each subband, and must have proper
4809 * tuples for the rest of the data as well.
4810 */
4811 if (params->supported_channels_len < 2)
4812 return -EINVAL;
4813 if (params->supported_channels_len % 2)
4814 return -EINVAL;
4815 }
4816
4817 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4818 params->supported_oper_classes =
4819 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4820 params->supported_oper_classes_len =
4821 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4822 /*
4823 * The value of the Length field of the Supported Operating
4824 * Classes element is between 2 and 253.
4825 */
4826 if (params->supported_oper_classes_len < 2 ||
4827 params->supported_oper_classes_len > 253)
4828 return -EINVAL;
4829 }
4830 return 0;
4831}
4832
ff276691
JB		 4833static int nl80211_set_station_tdls(struct genl_info *info,
4834 struct station_parameters *params)
4835{
c01fc9ad 4836 int err;
ff276691 4837 /* Dummy STA entry gets updated once the peer capabilities are known */
5e4b6f56
JM		 4838 if (info->attrs[NL80211_ATTR_PEER_AID])
4839 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
ff276691
JB		 4840 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4841 params->ht_capa =
4842 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4843 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4844 params->vht_capa =
4845 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4846
c01fc9ad
SD		 4847 err = nl80211_parse_sta_channel_info(info, params);
4848 if (err)
4849 return err;
4850
ff276691
JB		 4851 return nl80211_parse_sta_wme(info, params);
4852}
4853
5727ef1b
JB		 4854static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4855{
4c476991 4856 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4857 struct net_device *dev = info->user_ptr[1];
5727ef1b 4858 struct station_parameters params;
77ee7c89
JB		 4859 u8 *mac_addr;
4860 int err;
5727ef1b
JB		 4861
4862 memset(&params, 0, sizeof(params));
4863
77ee7c89
JB		 4864 if (!rdev->ops->change_station)
4865 return -EOPNOTSUPP;
4866
e4208427
AB		 4867 /*
4868 * AID and listen_interval properties can be set only for unassociated
4869 * station. Include these parameters here and will check them in
4870 * cfg80211_check_station_change().
4871 */
a9bc31e4
AB		 4872 if (info->attrs[NL80211_ATTR_STA_AID])
4873 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
e4208427
AB		 4874
4875 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4876 params.listen_interval =
4877 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
4878 else
4879 params.listen_interval = -1;
5727ef1b 4880
17b94247
AB		 4881 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
4882 u8 tmp;
4883
4884 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
4885 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
4886 return -EINVAL;
4887
4888 params.support_p2p_ps = tmp;
4889 } else {
4890 params.support_p2p_ps = -1;
4891 }
4892
5727ef1b
JB		 4893 if (!info->attrs[NL80211_ATTR_MAC])
4894 return -EINVAL;
4895
4896 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4897
4898 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4899 params.supported_rates =
4900 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4901 params.supported_rates_len =
4902 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4903 }
4904
9d62a986
JM		 4905 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4906 params.capability =
4907 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4908 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4909 }
4910
4911 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4912 params.ext_capab =
4913 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4914 params.ext_capab_len =
4915 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4916 }
4917
bdd3ae3d 4918 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 4919 return -EINVAL;
4920
f8bacc21 4921 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
2ec600d6 4922 params.plink_action =
f8bacc21
JB		 4923 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4924 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4925 return -EINVAL;
4926 }
2ec600d6 4927
f8bacc21 4928 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
9c3990aa 4929 params.plink_state =
f8bacc21
JB		 4930 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
4931 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
4932 return -EINVAL;
7d27a0ba
MH		 4933 if (info->attrs[NL80211_ATTR_MESH_PEER_AID]) {
4934 params.peer_aid = nla_get_u16(
4935 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
4936 if (params.peer_aid > IEEE80211_MAX_AID)
4937 return -EINVAL;
4938 }
f8bacc21
JB		 4939 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
4940 }
9c3990aa 4941
3b1c5a53
MP		 4942 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
4943 enum nl80211_mesh_power_mode pm = nla_get_u32(
4944 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
4945
4946 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
4947 pm > NL80211_MESH_POWER_MAX)
4948 return -EINVAL;
4949
4950 params.local_pm = pm;
4951 }
4952
06f7c88c
BL		 4953 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
4954 params.opmode_notif_used = true;
4955 params.opmode_notif =
4956 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
4957 }
4958
77ee7c89
JB		 4959 /* Include parameters for TDLS peer (will check later) */
4960 err = nl80211_set_station_tdls(info, &params);
4961 if (err)
4962 return err;
4963
4964 params.vlan = get_vlan(info, rdev);
4965 if (IS_ERR(params.vlan))
4966 return PTR_ERR(params.vlan);
4967
a97f4424
JB		 4968 switch (dev->ieee80211_ptr->iftype) {
4969 case NL80211_IFTYPE_AP:
4970 case NL80211_IFTYPE_AP_VLAN:
074ac8df 4971 case NL80211_IFTYPE_P2P_GO:
074ac8df 4972 case NL80211_IFTYPE_P2P_CLIENT:
a97f4424 4973 case NL80211_IFTYPE_STATION:
267335d6 4974 case NL80211_IFTYPE_ADHOC:
a97f4424 4975 case NL80211_IFTYPE_MESH_POINT:
a97f4424
JB		 4976 break;
4977 default:
77ee7c89
JB		 4978 err = -EOPNOTSUPP;
4979 goto out_put_vlan;
034d655e
JB		 4980 }
4981
77ee7c89 4982 /* driver will call cfg80211_check_station_change() */
e35e4d28 4983 err = rdev_change_station(rdev, dev, mac_addr, &params);
5727ef1b 4984
77ee7c89 4985 out_put_vlan:
5727ef1b
JB		 4986 if (params.vlan)
4987 dev_put(params.vlan);
3b85875a 4988
5727ef1b
JB		 4989 return err;
4990}
4991
4992static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
4993{
4c476991 4994 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5727ef1b 4995 int err;
4c476991 4996 struct net_device *dev = info->user_ptr[1];
5727ef1b
JB		 4997 struct station_parameters params;
4998 u8 *mac_addr = NULL;
bda95eb1
JB		 4999 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5000 BIT(NL80211_STA_FLAG_ASSOCIATED);
5727ef1b
JB		 5001
5002 memset(&params, 0, sizeof(params));
5003
984c311b
JB		 5004 if (!rdev->ops->add_station)
5005 return -EOPNOTSUPP;
5006
5727ef1b
JB		 5007 if (!info->attrs[NL80211_ATTR_MAC])
5008 return -EINVAL;
5009
5727ef1b
JB		 5010 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5011 return -EINVAL;
5012
5013 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5014 return -EINVAL;
5015
5e4b6f56
JM		 5016 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5017 !info->attrs[NL80211_ATTR_PEER_AID])
0e956c13
TLSC		 5018 return -EINVAL;
5019
5727ef1b
JB		 5020 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5021 params.supported_rates =
5022 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5023 params.supported_rates_len =
5024 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5025 params.listen_interval =
5026 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 5027
17b94247
AB		 5028 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5029 u8 tmp;
5030
5031 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5032 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
5033 return -EINVAL;
5034
5035 params.support_p2p_ps = tmp;
5036 } else {
5037 /*
5038 * if not specified, assume it's supported for P2P GO interface,
5039 * and is NOT supported for AP interface
5040 */
5041 params.support_p2p_ps =
5042 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5043 }
5044
3d124ea2 5045 if (info->attrs[NL80211_ATTR_PEER_AID])
5e4b6f56 5046 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
3d124ea2
JM		 5047 else
5048 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
0e956c13
TLSC		 5049 if (!params.aid || params.aid > IEEE80211_MAX_AID)
5050 return -EINVAL;
51b50fbe 5051
9d62a986
JM		 5052 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5053 params.capability =
5054 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5055 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5056 }
5057
5058 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5059 params.ext_capab =
5060 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5061 params.ext_capab_len =
5062 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5063 }
5064
36aedc90
JM		 5065 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5066 params.ht_capa =
5067 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 5068
f461be3e
MP		 5069 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5070 params.vht_capa =
5071 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5072
60f4a7b1
MK		 5073 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5074 params.opmode_notif_used = true;
5075 params.opmode_notif =
5076 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5077 }
5078
f8bacc21 5079 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
96b78dff 5080 params.plink_action =
f8bacc21
JB		 5081 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5082 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
5083 return -EINVAL;
5084 }
96b78dff 5085
c01fc9ad
SD		 5086 err = nl80211_parse_sta_channel_info(info, &params);
5087 if (err)
5088 return err;
5089
ff276691
JB		 5090 err = nl80211_parse_sta_wme(info, &params);
5091 if (err)
5092 return err;
bdd90d5e 5093
bdd3ae3d 5094 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 5095 return -EINVAL;
5096
496fcc29
JB		 5097 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5098 * as userspace might just pass through the capabilities from the IEs
5099 * directly, rather than enforcing this restriction and returning an
5100 * error in this case.
5101 */
5102 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5103 params.ht_capa = NULL;
5104 params.vht_capa = NULL;
5105 }
5106
77ee7c89
JB		 5107 /* When you run into this, adjust the code below for the new flag */
5108 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5109
bdd90d5e
JB		 5110 switch (dev->ieee80211_ptr->iftype) {
5111 case NL80211_IFTYPE_AP:
5112 case NL80211_IFTYPE_AP_VLAN:
5113 case NL80211_IFTYPE_P2P_GO:
984c311b
JB		 5114 /* ignore WME attributes if iface/sta is not capable */
5115 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5116 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5117 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
c75786c9 5118
bdd90d5e 5119 /* TDLS peers cannot be added */
3d124ea2
JM		 5120 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5121 info->attrs[NL80211_ATTR_PEER_AID])
4319e193 5122 return -EINVAL;
bdd90d5e
JB		 5123 /* but don't bother the driver with it */
5124 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3b9ce80c 5125
d582cffb
JB		 5126 /* allow authenticated/associated only if driver handles it */
5127 if (!(rdev->wiphy.features &
5128 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
bda95eb1 5129 params.sta_flags_mask & auth_assoc)
d582cffb
JB		 5130 return -EINVAL;
5131
bda95eb1
JB		 5132 /* Older userspace, or userspace wanting to be compatible with
5133 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5134 * and assoc flags in the mask, but assumes the station will be
5135 * added as associated anyway since this was the required driver
5136 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5137 * introduced.
5138 * In order to not bother drivers with this quirk in the API
5139 * set the flags in both the mask and set for new stations in
5140 * this case.
5141 */
5142 if (!(params.sta_flags_mask & auth_assoc)) {
5143 params.sta_flags_mask |= auth_assoc;
5144 params.sta_flags_set |= auth_assoc;
5145 }
5146
bdd90d5e
JB		 5147 /* must be last in here for error handling */
5148 params.vlan = get_vlan(info, rdev);
5149 if (IS_ERR(params.vlan))
5150 return PTR_ERR(params.vlan);
5151 break;
5152 case NL80211_IFTYPE_MESH_POINT:
984c311b
JB		 5153 /* ignore uAPSD data */
5154 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5155
d582cffb
JB		 5156 /* associated is disallowed */
5157 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5158 return -EINVAL;
bdd90d5e 5159 /* TDLS peers cannot be added */
3d124ea2
JM		 5160 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5161 info->attrs[NL80211_ATTR_PEER_AID])
bdd90d5e
JB		 5162 return -EINVAL;
5163 break;
5164 case NL80211_IFTYPE_STATION:
93d08f0b 5165 case NL80211_IFTYPE_P2P_CLIENT:
984c311b
JB		 5166 /* ignore uAPSD data */
5167 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5168
77ee7c89
JB		 5169 /* these are disallowed */
5170 if (params.sta_flags_mask &
5171 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5172 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
d582cffb 5173 return -EINVAL;
bdd90d5e
JB		 5174 /* Only TDLS peers can be added */
5175 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5176 return -EINVAL;
5177 /* Can only add if TDLS ... */
5178 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5179 return -EOPNOTSUPP;
5180 /* ... with external setup is supported */
5181 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5182 return -EOPNOTSUPP;
77ee7c89
JB		 5183 /*
5184 * Older wpa_supplicant versions always mark the TDLS peer
5185 * as authorized, but it shouldn't yet be.
5186 */
5187 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
bdd90d5e
JB		 5188 break;
5189 default:
5190 return -EOPNOTSUPP;
c75786c9
EP		 5191 }
5192
bdd90d5e 5193 /* be aware of params.vlan when changing code here */
5727ef1b 5194
e35e4d28 5195 err = rdev_add_station(rdev, dev, mac_addr, &params);
5727ef1b 5196
5727ef1b
JB		 5197 if (params.vlan)
5198 dev_put(params.vlan);
5727ef1b
JB		 5199 return err;
5200}
5201
5202static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5203{
4c476991
JB		 5204 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5205 struct net_device *dev = info->user_ptr[1];
89c771e5
JM		 5206 struct station_del_parameters params;
5207
5208 memset(&params, 0, sizeof(params));
5727ef1b
JB		 5209
5210 if (info->attrs[NL80211_ATTR_MAC])
89c771e5 5211 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5727ef1b 5212
e80cf853 5213 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
d5d9de02 5214 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
074ac8df 5215 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4c476991
JB		 5216 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5217 return -EINVAL;
5727ef1b 5218
4c476991
JB		 5219 if (!rdev->ops->del_station)
5220 return -EOPNOTSUPP;
3b85875a 5221
98856866
JM		 5222 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
5223 params.subtype =
5224 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
5225 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
5226 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
5227 return -EINVAL;
5228 } else {
5229 /* Default to Deauthentication frame */
5230 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
5231 }
5232
5233 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
5234 params.reason_code =
5235 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5236 if (params.reason_code == 0)
5237 return -EINVAL; /* 0 is reserved */
5238 } else {
5239 /* Default to reason code 2 */
5240 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
5241 }
5242
89c771e5 5243 return rdev_del_station(rdev, dev, &params);
5727ef1b
JB		 5244}
5245
15e47304 5246static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
2ec600d6
LCC		 5247 int flags, struct net_device *dev,
5248 u8 *dst, u8 *next_hop,
5249 struct mpath_info *pinfo)
5250{
5251 void *hdr;
5252 struct nlattr *pinfoattr;
5253
1ef4c850 5254 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
2ec600d6
LCC		 5255 if (!hdr)
5256 return -1;
5257
9360ffd1
DM		 5258 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5259 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
5260 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
5261 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
5262 goto nla_put_failure;
f5ea9120 5263
2ec600d6
LCC		 5264 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
5265 if (!pinfoattr)
5266 goto nla_put_failure;
9360ffd1
DM		 5267 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
5268 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
5269 pinfo->frame_qlen))
5270 goto nla_put_failure;
5271 if (((pinfo->filled & MPATH_INFO_SN) &&
5272 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
5273 ((pinfo->filled & MPATH_INFO_METRIC) &&
5274 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
5275 pinfo->metric)) ||
5276 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
5277 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
5278 pinfo->exptime)) ||
5279 ((pinfo->filled & MPATH_INFO_FLAGS) &&
5280 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
5281 pinfo->flags)) ||
5282 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
5283 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
5284 pinfo->discovery_timeout)) ||
5285 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
5286 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
5287 pinfo->discovery_retries)))
5288 goto nla_put_failure;
2ec600d6
LCC		 5289
5290 nla_nest_end(msg, pinfoattr);
5291
053c095a
JB		 5292 genlmsg_end(msg, hdr);
5293 return 0;
2ec600d6
LCC		 5294
5295 nla_put_failure:
bc3ed28c
TG		 5296 genlmsg_cancel(msg, hdr);
5297 return -EMSGSIZE;
2ec600d6
LCC		 5298}
5299
5300static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 5301 struct netlink_callback *cb)
2ec600d6 5302{
2ec600d6 5303 struct mpath_info pinfo;
1b8ec87a 5304 struct cfg80211_registered_device *rdev;
97990a06 5305 struct wireless_dev *wdev;
2ec600d6
LCC		 5306 u8 dst[ETH_ALEN];
5307 u8 next_hop[ETH_ALEN];
97990a06 5308 int path_idx = cb->args[2];
2ec600d6 5309 int err;
2ec600d6 5310
ea90e0dc 5311 rtnl_lock();
1b8ec87a 5312 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 5313 if (err)
ea90e0dc 5314 goto out_err;
bba95fef 5315
1b8ec87a 5316 if (!rdev->ops->dump_mpath) {
eec60b03 5317 err = -EOPNOTSUPP;
bba95fef
JB		 5318 goto out_err;
5319 }
5320
97990a06 5321 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
eec60b03 5322 err = -EOPNOTSUPP;
0448b5fc 5323 goto out_err;
eec60b03
JM		 5324 }
5325
bba95fef 5326 while (1) {
1b8ec87a 5327 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
97990a06 5328 next_hop, &pinfo);
bba95fef 5329 if (err == -ENOENT)
2ec600d6 5330 break;
bba95fef 5331 if (err)
3b85875a 5332 goto out_err;
2ec600d6 5333
15e47304 5334 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
bba95fef 5335 cb->nlh->nlmsg_seq, NLM_F_MULTI,
97990a06 5336 wdev->netdev, dst, next_hop,
bba95fef
JB		 5337 &pinfo) < 0)
5338 goto out;
2ec600d6 5339
bba95fef 5340 path_idx++;
2ec600d6 5341 }
2ec600d6 5342
bba95fef 5343 out:
97990a06 5344 cb->args[2] = path_idx;
bba95fef 5345 err = skb->len;
bba95fef 5346 out_err:
ea90e0dc 5347 rtnl_unlock();
bba95fef 5348 return err;
2ec600d6
LCC		 5349}
5350
5351static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
5352{
4c476991 5353 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 5354 int err;
4c476991 5355 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5356 struct mpath_info pinfo;
5357 struct sk_buff *msg;
5358 u8 *dst = NULL;
5359 u8 next_hop[ETH_ALEN];
5360
5361 memset(&pinfo, 0, sizeof(pinfo));
5362
5363 if (!info->attrs[NL80211_ATTR_MAC])
5364 return -EINVAL;
5365
5366 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5367
4c476991
JB		 5368 if (!rdev->ops->get_mpath)
5369 return -EOPNOTSUPP;
2ec600d6 5370
4c476991
JB		 5371 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5372 return -EOPNOTSUPP;
eec60b03 5373
e35e4d28 5374 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
2ec600d6 5375 if (err)
4c476991 5376 return err;
2ec600d6 5377
fd2120ca 5378 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6 5379 if (!msg)
4c476991 5380 return -ENOMEM;
2ec600d6 5381
15e47304 5382 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4c476991
JB		 5383 dev, dst, next_hop, &pinfo) < 0) {
5384 nlmsg_free(msg);
5385 return -ENOBUFS;
5386 }
3b85875a 5387
4c476991 5388 return genlmsg_reply(msg, info);
2ec600d6
LCC		 5389}
5390
5391static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
5392{
4c476991
JB		 5393 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5394 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5395 u8 *dst = NULL;
5396 u8 *next_hop = NULL;
5397
5398 if (!info->attrs[NL80211_ATTR_MAC])
5399 return -EINVAL;
5400
5401 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5402 return -EINVAL;
5403
5404 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5405 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5406
4c476991
JB		 5407 if (!rdev->ops->change_mpath)
5408 return -EOPNOTSUPP;
35a8efe1 5409
4c476991
JB		 5410 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5411 return -EOPNOTSUPP;
2ec600d6 5412
e35e4d28 5413 return rdev_change_mpath(rdev, dev, dst, next_hop);
2ec600d6 5414}
4c476991 5415
2ec600d6
LCC		 5416static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
5417{
4c476991
JB		 5418 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5419 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5420 u8 *dst = NULL;
5421 u8 *next_hop = NULL;
5422
5423 if (!info->attrs[NL80211_ATTR_MAC])
5424 return -EINVAL;
5425
5426 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5427 return -EINVAL;
5428
5429 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5430 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5431
4c476991
JB		 5432 if (!rdev->ops->add_mpath)
5433 return -EOPNOTSUPP;
35a8efe1 5434
4c476991
JB		 5435 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5436 return -EOPNOTSUPP;
2ec600d6 5437
e35e4d28 5438 return rdev_add_mpath(rdev, dev, dst, next_hop);
2ec600d6
LCC		 5439}
5440
5441static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
5442{
4c476991
JB		 5443 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5444 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5445 u8 *dst = NULL;
5446
5447 if (info->attrs[NL80211_ATTR_MAC])
5448 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5449
4c476991
JB		 5450 if (!rdev->ops->del_mpath)
5451 return -EOPNOTSUPP;
3b85875a 5452
e35e4d28 5453 return rdev_del_mpath(rdev, dev, dst);
2ec600d6
LCC		 5454}
5455
66be7d2b
HR		 5456static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
5457{
5458 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5459 int err;
5460 struct net_device *dev = info->user_ptr[1];
5461 struct mpath_info pinfo;
5462 struct sk_buff *msg;
5463 u8 *dst = NULL;
5464 u8 mpp[ETH_ALEN];
5465
5466 memset(&pinfo, 0, sizeof(pinfo));
5467
5468 if (!info->attrs[NL80211_ATTR_MAC])
5469 return -EINVAL;
5470
5471 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5472
5473 if (!rdev->ops->get_mpp)
5474 return -EOPNOTSUPP;
5475
5476 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5477 return -EOPNOTSUPP;
5478
5479 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
5480 if (err)
5481 return err;
5482
5483 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5484 if (!msg)
5485 return -ENOMEM;
5486
5487 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
5488 dev, dst, mpp, &pinfo) < 0) {
5489 nlmsg_free(msg);
5490 return -ENOBUFS;
5491 }
5492
5493 return genlmsg_reply(msg, info);
5494}
5495
5496static int nl80211_dump_mpp(struct sk_buff *skb,
5497 struct netlink_callback *cb)
5498{
5499 struct mpath_info pinfo;
5500 struct cfg80211_registered_device *rdev;
5501 struct wireless_dev *wdev;
5502 u8 dst[ETH_ALEN];
5503 u8 mpp[ETH_ALEN];
5504 int path_idx = cb->args[2];
5505 int err;
5506
ea90e0dc 5507 rtnl_lock();
66be7d2b
HR		 5508 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5509 if (err)
ea90e0dc 5510 goto out_err;
66be7d2b
HR		 5511
5512 if (!rdev->ops->dump_mpp) {
5513 err = -EOPNOTSUPP;
5514 goto out_err;
5515 }
5516
5517 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
5518 err = -EOPNOTSUPP;
5519 goto out_err;
5520 }
5521
5522 while (1) {
5523 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
5524 mpp, &pinfo);
5525 if (err == -ENOENT)
5526 break;
5527 if (err)
5528 goto out_err;
5529
5530 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
5531 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5532 wdev->netdev, dst, mpp,
5533 &pinfo) < 0)
5534 goto out;
5535
5536 path_idx++;
5537 }
5538
5539 out:
5540 cb->args[2] = path_idx;
5541 err = skb->len;
5542 out_err:
ea90e0dc 5543 rtnl_unlock();
66be7d2b
HR		 5544 return err;
5545}
5546
9f1ba906
JM		 5547static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
5548{
4c476991
JB		 5549 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5550 struct net_device *dev = info->user_ptr[1];
c56589ed 5551 struct wireless_dev *wdev = dev->ieee80211_ptr;
9f1ba906 5552 struct bss_parameters params;
c56589ed 5553 int err;
9f1ba906
JM		 5554
5555 memset(&params, 0, sizeof(params));
5556 /* default to not changing parameters */
5557 params.use_cts_prot = -1;
5558 params.use_short_preamble = -1;
5559 params.use_short_slot_time = -1;
fd8aaaf3 5560 params.ap_isolate = -1;
50b12f59 5561 params.ht_opmode = -1;
53cabad7
JB		 5562 params.p2p_ctwindow = -1;
5563 params.p2p_opp_ps = -1;
9f1ba906
JM		 5564
5565 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
5566 params.use_cts_prot =
5567 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
5568 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
5569 params.use_short_preamble =
5570 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
5571 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
5572 params.use_short_slot_time =
5573 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 5574 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5575 params.basic_rates =
5576 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5577 params.basic_rates_len =
5578 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5579 }
fd8aaaf3
FF		 5580 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
5581 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
50b12f59
HS		 5582 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
5583 params.ht_opmode =
5584 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9f1ba906 5585
53cabad7
JB		 5586 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
5587 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5588 return -EINVAL;
5589 params.p2p_ctwindow =
5590 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
5591 if (params.p2p_ctwindow < 0)
5592 return -EINVAL;
5593 if (params.p2p_ctwindow != 0 &&
5594 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
5595 return -EINVAL;
5596 }
5597
5598 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
5599 u8 tmp;
5600
5601 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5602 return -EINVAL;
5603 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
5604 if (tmp > 1)
5605 return -EINVAL;
5606 params.p2p_opp_ps = tmp;
5607 if (params.p2p_opp_ps &&
5608 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
5609 return -EINVAL;
5610 }
5611
4c476991
JB		 5612 if (!rdev->ops->change_bss)
5613 return -EOPNOTSUPP;
9f1ba906 5614
074ac8df 5615 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4c476991
JB		 5616 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5617 return -EOPNOTSUPP;
3b85875a 5618
c56589ed
SW		 5619 wdev_lock(wdev);
5620 err = rdev_change_bss(rdev, dev, &params);
5621 wdev_unlock(wdev);
5622
5623 return err;
9f1ba906
JM		 5624}
5625
b2e1b302
LR		 5626static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
5627{
b2e1b302 5628 char *data = NULL;
05050753 5629 bool is_indoor;
57b5ce07 5630 enum nl80211_user_reg_hint_type user_reg_hint_type;
05050753
I		 5631 u32 owner_nlportid;
5632
80778f18
LR		 5633 /*
5634 * You should only get this when cfg80211 hasn't yet initialized
5635 * completely when built-in to the kernel right between the time
5636 * window between nl80211_init() and regulatory_init(), if that is
5637 * even possible.
5638 */
458f4f9e 5639 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
fe33eb39 5640 return -EINPROGRESS;
80778f18 5641
57b5ce07
LR		 5642 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
5643 user_reg_hint_type =
5644 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
5645 else
5646 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
5647
5648 switch (user_reg_hint_type) {
5649 case NL80211_USER_REG_HINT_USER:
5650 case NL80211_USER_REG_HINT_CELL_BASE:
52616f2b
IP		 5651 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5652 return -EINVAL;
5653
5654 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5655 return regulatory_hint_user(data, user_reg_hint_type);
5656 case NL80211_USER_REG_HINT_INDOOR:
05050753
I		 5657 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
5658 owner_nlportid = info->snd_portid;
5659 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
5660 } else {
5661 owner_nlportid = 0;
5662 is_indoor = true;
5663 }
5664
5665 return regulatory_hint_indoor(is_indoor, owner_nlportid);
57b5ce07
LR		 5666 default:
5667 return -EINVAL;
5668 }
b2e1b302
LR		 5669}
5670
24bdd9f4 5671static int nl80211_get_mesh_config(struct sk_buff *skb,
29cbe68c 5672 struct genl_info *info)
93da9cc1 5673{
4c476991 5674 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 5675 struct net_device *dev = info->user_ptr[1];
29cbe68c
JB		 5676 struct wireless_dev *wdev = dev->ieee80211_ptr;
5677 struct mesh_config cur_params;
5678 int err = 0;
93da9cc1 5679 void *hdr;
5680 struct nlattr *pinfoattr;
5681 struct sk_buff *msg;
5682
29cbe68c
JB		 5683 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5684 return -EOPNOTSUPP;
5685
24bdd9f4 5686 if (!rdev->ops->get_mesh_config)
4c476991 5687 return -EOPNOTSUPP;
f3f92586 5688
29cbe68c
JB		 5689 wdev_lock(wdev);
5690 /* If not connected, get default parameters */
5691 if (!wdev->mesh_id_len)
5692 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
5693 else
e35e4d28 5694 err = rdev_get_mesh_config(rdev, dev, &cur_params);
29cbe68c
JB		 5695 wdev_unlock(wdev);
5696
93da9cc1 5697 if (err)
4c476991 5698 return err;
93da9cc1 5699
5700 /* Draw up a netlink message to send back */
fd2120ca 5701 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 5702 if (!msg)
5703 return -ENOMEM;
15e47304 5704 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
24bdd9f4 5705 NL80211_CMD_GET_MESH_CONFIG);
93da9cc1 5706 if (!hdr)
efe1cf0c 5707 goto out;
24bdd9f4 5708 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
93da9cc1 5709 if (!pinfoattr)
5710 goto nla_put_failure;
9360ffd1
DM		 5711 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5712 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
5713 cur_params.dot11MeshRetryTimeout) ||
5714 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5715 cur_params.dot11MeshConfirmTimeout) ||
5716 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
5717 cur_params.dot11MeshHoldingTimeout) ||
5718 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
5719 cur_params.dot11MeshMaxPeerLinks) ||
5720 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
5721 cur_params.dot11MeshMaxRetries) ||
5722 nla_put_u8(msg, NL80211_MESHCONF_TTL,
5723 cur_params.dot11MeshTTL) ||
5724 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
5725 cur_params.element_ttl) ||
5726 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5727 cur_params.auto_open_plinks) ||
7eab0f64
JL		 5728 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5729 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
9360ffd1
DM		 5730 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5731 cur_params.dot11MeshHWMPmaxPREQretries) ||
5732 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
5733 cur_params.path_refresh_time) ||
5734 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5735 cur_params.min_discovery_timeout) ||
5736 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5737 cur_params.dot11MeshHWMPactivePathTimeout) ||
5738 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
5739 cur_params.dot11MeshHWMPpreqMinInterval) ||
5740 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
5741 cur_params.dot11MeshHWMPperrMinInterval) ||
5742 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5743 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
5744 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
5745 cur_params.dot11MeshHWMPRootMode) ||
5746 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5747 cur_params.dot11MeshHWMPRannInterval) ||
5748 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5749 cur_params.dot11MeshGateAnnouncementProtocol) ||
5750 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
5751 cur_params.dot11MeshForwarding) ||
335d5349 5752 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
70c33eaa
AN		 5753 cur_params.rssi_threshold) ||
5754 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5755 cur_params.ht_opmode) ||
5756 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5757 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
5758 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5759 cur_params.dot11MeshHWMProotInterval) ||
5760 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3b1c5a53
MP		 5761 cur_params.dot11MeshHWMPconfirmationInterval) ||
5762 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5763 cur_params.power_mode) ||
5764 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8e7c0538
CT		 5765 cur_params.dot11MeshAwakeWindowDuration) ||
5766 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5767 cur_params.plink_timeout))
9360ffd1 5768 goto nla_put_failure;
93da9cc1 5769 nla_nest_end(msg, pinfoattr);
5770 genlmsg_end(msg, hdr);
4c476991 5771 return genlmsg_reply(msg, info);
93da9cc1 5772
3b85875a 5773 nla_put_failure:
93da9cc1 5774 genlmsg_cancel(msg, hdr);
efe1cf0c 5775 out:
d080e275 5776 nlmsg_free(msg);
4c476991 5777 return -ENOBUFS;
93da9cc1 5778}
5779
b54452b0 5780static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
93da9cc1 5781 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5782 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5783 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5784 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5785 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5786 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
45904f21 5787 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
93da9cc1 5788 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
d299a1f2 5789 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
93da9cc1 5790 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5791 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5792 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5793 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5794 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
dca7e943 5795 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
93da9cc1 5796 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
699403db 5797 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
0507e159 5798 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
16dd7267 5799 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
94f90656 5800 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
a4f606ea
CYY		 5801 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5802 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
ac1073a6
CYY		 5803 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5804 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
728b19e5 5805 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3b1c5a53
MP		 5806 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5807 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8e7c0538 5808 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
93da9cc1 5809};
5810
c80d545d
JC		 5811static const struct nla_policy
5812 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
d299a1f2 5813 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
c80d545d
JC		 5814 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5815 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
15d5dda6 5816 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6e16d90b 5817 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
bb2798d4 5818 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
581a8b0f 5819 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
a4f606ea 5820 .len = IEEE80211_MAX_DATA_LEN },
b130e5ce 5821 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
c80d545d
JC		 5822};
5823
f151d9db
AB		 5824static int nl80211_check_bool(const struct nlattr *nla, u8 min, u8 max, bool *out)
5825{
5826 u8 val = nla_get_u8(nla);
5827 if (val < min || val > max)
5828 return -EINVAL;
5829 *out = val;
5830 return 0;
5831}
5832
5833static int nl80211_check_u8(const struct nlattr *nla, u8 min, u8 max, u8 *out)
5834{
5835 u8 val = nla_get_u8(nla);
5836 if (val < min || val > max)
5837 return -EINVAL;
5838 *out = val;
5839 return 0;
5840}
5841
5842static int nl80211_check_u16(const struct nlattr *nla, u16 min, u16 max, u16 *out)
5843{
5844 u16 val = nla_get_u16(nla);
5845 if (val < min || val > max)
5846 return -EINVAL;
5847 *out = val;
5848 return 0;
5849}
5850
5851static int nl80211_check_u32(const struct nlattr *nla, u32 min, u32 max, u32 *out)
5852{
5853 u32 val = nla_get_u32(nla);
5854 if (val < min || val > max)
5855 return -EINVAL;
5856 *out = val;
5857 return 0;
5858}
5859
5860static int nl80211_check_s32(const struct nlattr *nla, s32 min, s32 max, s32 *out)
5861{
5862 s32 val = nla_get_s32(nla);
5863 if (val < min || val > max)
5864 return -EINVAL;
5865 *out = val;
5866 return 0;
5867}
5868
ff9a71af
JB		 5869static int nl80211_check_power_mode(const struct nlattr *nla,
5870 enum nl80211_mesh_power_mode min,
5871 enum nl80211_mesh_power_mode max,
5872 enum nl80211_mesh_power_mode *out)
5873{
5874 u32 val = nla_get_u32(nla);
5875 if (val < min || val > max)
5876 return -EINVAL;
5877 *out = val;
5878 return 0;
5879}
5880
24bdd9f4 5881static int nl80211_parse_mesh_config(struct genl_info *info,
bd90fdcc
JB		 5882 struct mesh_config *cfg,
5883 u32 *mask_out)
93da9cc1 5884{
93da9cc1 5885 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
bd90fdcc 5886 u32 mask = 0;
9757235f 5887 u16 ht_opmode;
93da9cc1 5888
ea54fba2
MP		 5889#define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5890do { \
5891 if (tb[attr]) { \
f151d9db 5892 if (fn(tb[attr], min, max, &cfg->param)) \
ea54fba2 5893 return -EINVAL; \
ea54fba2
MP		 5894 mask |= (1 << (attr - 1)); \
5895 } \
5896} while (0)
bd90fdcc 5897
24bdd9f4 5898 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
93da9cc1 5899 return -EINVAL;
5900 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
24bdd9f4 5901 info->attrs[NL80211_ATTR_MESH_CONFIG],
fe52145f 5902 nl80211_meshconf_params_policy, info->extack))
93da9cc1 5903 return -EINVAL;
5904
93da9cc1 5905 /* This makes sure that there aren't more than 32 mesh config
5906 * parameters (otherwise our bitfield scheme would not work.) */
5907 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
5908
5909 /* Fill in the params struct */
ea54fba2 5910 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
a4f606ea 5911 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
f151d9db 5912 nl80211_check_u16);
ea54fba2 5913 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
a4f606ea 5914 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
f151d9db 5915 nl80211_check_u16);
ea54fba2 5916 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
a4f606ea 5917 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
f151d9db 5918 nl80211_check_u16);
ea54fba2 5919 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
a4f606ea 5920 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
f151d9db 5921 nl80211_check_u16);
ea54fba2 5922 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
a4f606ea 5923 mask, NL80211_MESHCONF_MAX_RETRIES,
f151d9db 5924 nl80211_check_u8);
ea54fba2 5925 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
f151d9db 5926 mask, NL80211_MESHCONF_TTL, nl80211_check_u8);
ea54fba2 5927 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
a4f606ea 5928 mask, NL80211_MESHCONF_ELEMENT_TTL,
f151d9db 5929 nl80211_check_u8);
ea54fba2 5930 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
a4f606ea 5931 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
f151d9db 5932 nl80211_check_bool);
ea54fba2
MP		 5933 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
5934 1, 255, mask,
a4f606ea 5935 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
f151d9db 5936 nl80211_check_u32);
ea54fba2 5937 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
a4f606ea 5938 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
f151d9db 5939 nl80211_check_u8);
ea54fba2 5940 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
a4f606ea 5941 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
f151d9db 5942 nl80211_check_u32);
ea54fba2 5943 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
a4f606ea 5944 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
f151d9db 5945 nl80211_check_u16);
ea54fba2
MP		 5946 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
5947 1, 65535, mask,
a4f606ea 5948 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
f151d9db 5949 nl80211_check_u32);
93da9cc1 5950 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
ea54fba2
MP		 5951 1, 65535, mask,
5952 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
f151d9db 5953 nl80211_check_u16);
dca7e943 5954 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
ea54fba2
MP		 5955 1, 65535, mask,
5956 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
f151d9db 5957 nl80211_check_u16);
93da9cc1 5958 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5959 dot11MeshHWMPnetDiameterTraversalTime,
5960 1, 65535, mask,
a4f606ea 5961 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
f151d9db 5962 nl80211_check_u16);
ea54fba2
MP		 5963 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
5964 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
f151d9db 5965 nl80211_check_u8);
ea54fba2
MP		 5966 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
5967 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
f151d9db 5968 nl80211_check_u16);
63c5723b 5969 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5970 dot11MeshGateAnnouncementProtocol, 0, 1,
5971 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
f151d9db 5972 nl80211_check_bool);
ea54fba2 5973 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
a4f606ea 5974 mask, NL80211_MESHCONF_FORWARDING,
f151d9db 5975 nl80211_check_bool);
83374fe9 5976 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
a4f606ea 5977 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
f151d9db 5978 nl80211_check_s32);
9757235f
MH		 5979 /*
5980 * Check HT operation mode based on
5981 * IEEE 802.11 2012 8.4.2.59 HT Operation element.
5982 */
5983 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
5984 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
5985
5986 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
5987 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
5988 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
5989 return -EINVAL;
5990
5991 if ((ht_opmode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
5992 (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
5993 return -EINVAL;
5994
5995 switch (ht_opmode & IEEE80211_HT_OP_MODE_PROTECTION) {
5996 case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
5997 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
5998 if (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT)
5999 return -EINVAL;
6000 break;
6001 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
6002 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
6003 if (!(ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6004 return -EINVAL;
6005 break;
6006 }
6007 cfg->ht_opmode = ht_opmode;
fd551bac 6008 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
9757235f 6009 }
ac1073a6 6010 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
ea54fba2 6011 1, 65535, mask,
ac1073a6 6012 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
f151d9db 6013 nl80211_check_u32);
ea54fba2 6014 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
ac1073a6 6015 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
f151d9db 6016 nl80211_check_u16);
728b19e5 6017 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6018 dot11MeshHWMPconfirmationInterval,
6019 1, 65535, mask,
728b19e5 6020 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
f151d9db 6021 nl80211_check_u16);
3b1c5a53
MP		 6022 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
6023 NL80211_MESH_POWER_ACTIVE,
6024 NL80211_MESH_POWER_MAX,
6025 mask, NL80211_MESHCONF_POWER_MODE,
ff9a71af 6026 nl80211_check_power_mode);
3b1c5a53
MP		 6027 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
6028 0, 65535, mask,
f151d9db 6029 NL80211_MESHCONF_AWAKE_WINDOW, nl80211_check_u16);
31f909a2 6030 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 0, 0xffffffff,
8e7c0538 6031 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
f151d9db 6032 nl80211_check_u32);
bd90fdcc
JB		 6033 if (mask_out)
6034 *mask_out = mask;
c80d545d 6035
bd90fdcc
JB		 6036 return 0;
6037
6038#undef FILL_IN_MESH_PARAM_IF_SET
6039}
6040
c80d545d
JC		 6041static int nl80211_parse_mesh_setup(struct genl_info *info,
6042 struct mesh_setup *setup)
6043{
bb2798d4 6044 struct cfg80211_registered_device *rdev = info->user_ptr[0];
c80d545d
JC		 6045 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6046
6047 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6048 return -EINVAL;
6049 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
6050 info->attrs[NL80211_ATTR_MESH_SETUP],
fe52145f 6051 nl80211_mesh_setup_params_policy, info->extack))
c80d545d
JC		 6052 return -EINVAL;
6053
d299a1f2
JC		 6054 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6055 setup->sync_method =
6056 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6057 IEEE80211_SYNC_METHOD_VENDOR :
6058 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6059
c80d545d
JC		 6060 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6061 setup->path_sel_proto =
6062 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6063 IEEE80211_PATH_PROTOCOL_VENDOR :
6064 IEEE80211_PATH_PROTOCOL_HWMP;
6065
6066 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6067 setup->path_metric =
6068 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6069 IEEE80211_PATH_METRIC_VENDOR :
6070 IEEE80211_PATH_METRIC_AIRTIME;
6071
581a8b0f 6072 if (tb[NL80211_MESH_SETUP_IE]) {
c80d545d 6073 struct nlattr *ieattr =
581a8b0f 6074 tb[NL80211_MESH_SETUP_IE];
c80d545d
JC		 6075 if (!is_valid_ie_attr(ieattr))
6076 return -EINVAL;
581a8b0f
JC		 6077 setup->ie = nla_data(ieattr);
6078 setup->ie_len = nla_len(ieattr);
c80d545d 6079 }
bb2798d4
TP		 6080 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6081 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6082 return -EINVAL;
6083 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
b130e5ce
JC		 6084 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6085 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
bb2798d4
TP		 6086 if (setup->is_secure)
6087 setup->user_mpm = true;
c80d545d 6088
6e16d90b
CT		 6089 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6090 if (!setup->user_mpm)
6091 return -EINVAL;
6092 setup->auth_id =
6093 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6094 }
6095
c80d545d
JC		 6096 return 0;
6097}
6098
24bdd9f4 6099static int nl80211_update_mesh_config(struct sk_buff *skb,
29cbe68c 6100 struct genl_info *info)
bd90fdcc
JB		 6101{
6102 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6103 struct net_device *dev = info->user_ptr[1];
29cbe68c 6104 struct wireless_dev *wdev = dev->ieee80211_ptr;
bd90fdcc
JB		 6105 struct mesh_config cfg;
6106 u32 mask;
6107 int err;
6108
29cbe68c
JB		 6109 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6110 return -EOPNOTSUPP;
6111
24bdd9f4 6112 if (!rdev->ops->update_mesh_config)
bd90fdcc
JB		 6113 return -EOPNOTSUPP;
6114
24bdd9f4 6115 err = nl80211_parse_mesh_config(info, &cfg, &mask);
bd90fdcc
JB		 6116 if (err)
6117 return err;
6118
29cbe68c
JB		 6119 wdev_lock(wdev);
6120 if (!wdev->mesh_id_len)
6121 err = -ENOLINK;
6122
6123 if (!err)
e35e4d28 6124 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
29cbe68c
JB		 6125
6126 wdev_unlock(wdev);
6127
6128 return err;
93da9cc1 6129}
6130
ad30ca2c
AN		 6131static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6132 struct sk_buff *msg)
f130347c 6133{
f130347c
LR		 6134 struct nlattr *nl_reg_rules;
6135 unsigned int i;
f130347c 6136
458f4f9e
JB		 6137 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6138 (regdom->dfs_region &&
6139 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
ad30ca2c 6140 goto nla_put_failure;
458f4f9e 6141
f130347c
LR		 6142 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
6143 if (!nl_reg_rules)
ad30ca2c 6144 goto nla_put_failure;
f130347c 6145
458f4f9e 6146 for (i = 0; i < regdom->n_reg_rules; i++) {
f130347c
LR		 6147 struct nlattr *nl_reg_rule;
6148 const struct ieee80211_reg_rule *reg_rule;
6149 const struct ieee80211_freq_range *freq_range;
6150 const struct ieee80211_power_rule *power_rule;
97524820 6151 unsigned int max_bandwidth_khz;
f130347c 6152
458f4f9e 6153 reg_rule = &regdom->reg_rules[i];
f130347c
LR		 6154 freq_range = &reg_rule->freq_range;
6155 power_rule = &reg_rule->power_rule;
6156
6157 nl_reg_rule = nla_nest_start(msg, i);
6158 if (!nl_reg_rule)
ad30ca2c 6159 goto nla_put_failure;
f130347c 6160
97524820
JD		 6161 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6162 if (!max_bandwidth_khz)
6163 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6164 reg_rule);
6165
9360ffd1
DM		 6166 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6167 reg_rule->flags) ||
6168 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6169 freq_range->start_freq_khz) ||
6170 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6171 freq_range->end_freq_khz) ||
6172 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
97524820 6173 max_bandwidth_khz) ||
9360ffd1
DM		 6174 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6175 power_rule->max_antenna_gain) ||
6176 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
089027e5
JD		 6177 power_rule->max_eirp) ||
6178 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6179 reg_rule->dfs_cac_ms))
ad30ca2c 6180 goto nla_put_failure;
f130347c
LR		 6181
6182 nla_nest_end(msg, nl_reg_rule);
6183 }
6184
6185 nla_nest_end(msg, nl_reg_rules);
ad30ca2c
AN		 6186 return 0;
6187
6188nla_put_failure:
6189 return -EMSGSIZE;
6190}
6191
6192static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6193{
6194 const struct ieee80211_regdomain *regdom = NULL;
6195 struct cfg80211_registered_device *rdev;
6196 struct wiphy *wiphy = NULL;
6197 struct sk_buff *msg;
6198 void *hdr;
6199
6200 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6201 if (!msg)
6202 return -ENOBUFS;
6203
6204 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6205 NL80211_CMD_GET_REG);
6206 if (!hdr)
6207 goto put_failure;
6208
6209 if (info->attrs[NL80211_ATTR_WIPHY]) {
1bdd716c
AN		 6210 bool self_managed;
6211
ad30ca2c
AN		 6212 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6213 if (IS_ERR(rdev)) {
6214 nlmsg_free(msg);
6215 return PTR_ERR(rdev);
6216 }
6217
6218 wiphy = &rdev->wiphy;
1bdd716c
AN		 6219 self_managed = wiphy->regulatory_flags &
6220 REGULATORY_WIPHY_SELF_MANAGED;
ad30ca2c
AN		 6221 regdom = get_wiphy_regdom(wiphy);
6222
1bdd716c
AN		 6223 /* a self-managed-reg device must have a private regdom */
6224 if (WARN_ON(!regdom && self_managed)) {
6225 nlmsg_free(msg);
6226 return -EINVAL;
6227 }
6228
ad30ca2c
AN		 6229 if (regdom &&
6230 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6231 goto nla_put_failure;
6232 }
6233
6234 if (!wiphy && reg_last_request_cell_base() &&
6235 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6236 NL80211_USER_REG_HINT_CELL_BASE))
6237 goto nla_put_failure;
6238
6239 rcu_read_lock();
6240
6241 if (!regdom)
6242 regdom = rcu_dereference(cfg80211_regdomain);
6243
6244 if (nl80211_put_regdom(regdom, msg))
6245 goto nla_put_failure_rcu;
6246
6247 rcu_read_unlock();
f130347c
LR		 6248
6249 genlmsg_end(msg, hdr);
5fe231e8 6250 return genlmsg_reply(msg, info);
f130347c 6251
458f4f9e
JB		 6252nla_put_failure_rcu:
6253 rcu_read_unlock();
f130347c
LR		 6254nla_put_failure:
6255 genlmsg_cancel(msg, hdr);
efe1cf0c 6256put_failure:
d080e275 6257 nlmsg_free(msg);
5fe231e8 6258 return -EMSGSIZE;
f130347c
LR		 6259}
6260
ad30ca2c
AN		 6261static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6262 u32 seq, int flags, struct wiphy *wiphy,
6263 const struct ieee80211_regdomain *regdom)
6264{
6265 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6266 NL80211_CMD_GET_REG);
6267
6268 if (!hdr)
6269 return -1;
6270
6271 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
6272
6273 if (nl80211_put_regdom(regdom, msg))
6274 goto nla_put_failure;
6275
6276 if (!wiphy && reg_last_request_cell_base() &&
6277 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6278 NL80211_USER_REG_HINT_CELL_BASE))
6279 goto nla_put_failure;
6280
6281 if (wiphy &&
6282 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6283 goto nla_put_failure;
6284
1bdd716c
AN		 6285 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
6286 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
6287 goto nla_put_failure;
6288
053c095a
JB		 6289 genlmsg_end(msg, hdr);
6290 return 0;
ad30ca2c
AN		 6291
6292nla_put_failure:
6293 genlmsg_cancel(msg, hdr);
6294 return -EMSGSIZE;
6295}
6296
6297static int nl80211_get_reg_dump(struct sk_buff *skb,
6298 struct netlink_callback *cb)
6299{
6300 const struct ieee80211_regdomain *regdom = NULL;
6301 struct cfg80211_registered_device *rdev;
6302 int err, reg_idx, start = cb->args[2];
6303
6304 rtnl_lock();
6305
6306 if (cfg80211_regdomain && start == 0) {
6307 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6308 NLM_F_MULTI, NULL,
6309 rtnl_dereference(cfg80211_regdomain));
6310 if (err < 0)
6311 goto out_err;
6312 }
6313
6314 /* the global regdom is idx 0 */
6315 reg_idx = 1;
6316 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
6317 regdom = get_wiphy_regdom(&rdev->wiphy);
6318 if (!regdom)
6319 continue;
6320
6321 if (++reg_idx <= start)
6322 continue;
6323
6324 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6325 NLM_F_MULTI, &rdev->wiphy, regdom);
6326 if (err < 0) {
6327 reg_idx--;
6328 break;
6329 }
6330 }
6331
6332 cb->args[2] = reg_idx;
6333 err = skb->len;
6334out_err:
6335 rtnl_unlock();
6336 return err;
6337}
6338
b6863036
JB		 6339#ifdef CONFIG_CFG80211_CRDA_SUPPORT
6340static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
6341 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6342 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6343 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6344 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6345 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6346 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6347 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
6348};
6349
6350static int parse_reg_rule(struct nlattr *tb[],
6351 struct ieee80211_reg_rule *reg_rule)
6352{
6353 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
6354 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
6355
6356 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
6357 return -EINVAL;
6358 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
6359 return -EINVAL;
6360 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
6361 return -EINVAL;
6362 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
6363 return -EINVAL;
6364 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
6365 return -EINVAL;
6366
6367 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
6368
6369 freq_range->start_freq_khz =
6370 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
6371 freq_range->end_freq_khz =
6372 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
6373 freq_range->max_bandwidth_khz =
6374 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
6375
6376 power_rule->max_eirp =
6377 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
6378
6379 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
6380 power_rule->max_antenna_gain =
6381 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
6382
6383 if (tb[NL80211_ATTR_DFS_CAC_TIME])
6384 reg_rule->dfs_cac_ms =
6385 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
6386
6387 return 0;
6388}
6389
b2e1b302
LR		 6390static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
6391{
6392 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
6393 struct nlattr *nl_reg_rule;
ea372c54
JB		 6394 char *alpha2;
6395 int rem_reg_rules, r;
b2e1b302 6396 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4c7d3982 6397 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
ea372c54 6398 struct ieee80211_regdomain *rd;
b2e1b302
LR		 6399
6400 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6401 return -EINVAL;
6402
6403 if (!info->attrs[NL80211_ATTR_REG_RULES])
6404 return -EINVAL;
6405
6406 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6407
8b60b078
LR		 6408 if (info->attrs[NL80211_ATTR_DFS_REGION])
6409 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
6410
b2e1b302 6411 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6412 rem_reg_rules) {
b2e1b302
LR		 6413 num_rules++;
6414 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 6415 return -EINVAL;
b2e1b302
LR		 6416 }
6417
e438768f
LR		 6418 if (!reg_is_valid_request(alpha2))
6419 return -EINVAL;
6420
b2e1b302 6421 size_of_regd = sizeof(struct ieee80211_regdomain) +
1a919318 6422 num_rules * sizeof(struct ieee80211_reg_rule);
b2e1b302
LR		 6423
6424 rd = kzalloc(size_of_regd, GFP_KERNEL);
6913b49a
JB		 6425 if (!rd)
6426 return -ENOMEM;
b2e1b302
LR		 6427
6428 rd->n_reg_rules = num_rules;
6429 rd->alpha2[0] = alpha2[0];
6430 rd->alpha2[1] = alpha2[1];
6431
8b60b078
LR		 6432 /*
6433 * Disable DFS master mode if the DFS region was
6434 * not supported or known on this kernel.
6435 */
6436 if (reg_supported_dfs_region(dfs_region))
6437 rd->dfs_region = dfs_region;
6438
b2e1b302 6439 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6440 rem_reg_rules) {
bfe2c7b1 6441 r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
fe52145f
JB		 6442 nl_reg_rule, reg_rule_policy,
6443 info->extack);
ae811e21
JB		 6444 if (r)
6445 goto bad_reg;
b2e1b302
LR		 6446 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
6447 if (r)
6448 goto bad_reg;
6449
6450 rule_idx++;
6451
d0e18f83
LR		 6452 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
6453 r = -EINVAL;
b2e1b302 6454 goto bad_reg;
d0e18f83 6455 }
b2e1b302
LR		 6456 }
6457
06627990
JB		 6458 /* set_regdom takes ownership of rd */
6459 return set_regdom(rd, REGD_SOURCE_CRDA);
d2372b31 6460 bad_reg:
b2e1b302 6461 kfree(rd);
d0e18f83 6462 return r;
b2e1b302 6463}
b6863036 6464#endif /* CONFIG_CFG80211_CRDA_SUPPORT */
b2e1b302 6465
83f5e2cf
JB		 6466static int validate_scan_freqs(struct nlattr *freqs)
6467{
6468 struct nlattr *attr1, *attr2;
6469 int n_channels = 0, tmp1, tmp2;
6470
6471 nla_for_each_nested(attr1, freqs, tmp1) {
6472 n_channels++;
6473 /*
6474 * Some hardware has a limited channel list for
6475 * scanning, and it is pretty much nonsensical
6476 * to scan for a channel twice, so disallow that
6477 * and don't require drivers to check that the
6478 * channel list they get isn't longer than what
6479 * they can scan, as long as they can scan all
6480 * the channels they registered at once.
6481 */
6482 nla_for_each_nested(attr2, freqs, tmp2)
6483 if (attr1 != attr2 &&
6484 nla_get_u32(attr1) == nla_get_u32(attr2))
6485 return 0;
6486 }
6487
6488 return n_channels;
6489}
6490
57fbcce3 6491static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
38de03d2 6492{
57fbcce3 6493 return b < NUM_NL80211_BANDS && wiphy->bands[b];
38de03d2
AS		 6494}
6495
6496static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
6497 struct cfg80211_bss_selection *bss_select)
6498{
6499 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
6500 struct nlattr *nest;
6501 int err;
6502 bool found = false;
6503 int i;
6504
6505 /* only process one nested attribute */
6506 nest = nla_data(nla);
6507 if (!nla_ok(nest, nla_len(nest)))
6508 return -EINVAL;
6509
bfe2c7b1 6510 err = nla_parse_nested(attr, NL80211_BSS_SELECT_ATTR_MAX, nest,
fceb6435 6511 nl80211_bss_select_policy, NULL);
38de03d2
AS		 6512 if (err)
6513 return err;
6514
6515 /* only one attribute may be given */
6516 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
6517 if (attr[i]) {
6518 if (found)
6519 return -EINVAL;
6520 found = true;
6521 }
6522 }
6523
6524 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
6525
6526 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
6527 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
6528
6529 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
6530 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
6531 bss_select->param.band_pref =
6532 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
6533 if (!is_band_valid(wiphy, bss_select->param.band_pref))
6534 return -EINVAL;
6535 }
6536
6537 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
6538 struct nl80211_bss_select_rssi_adjust *adj_param;
6539
6540 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
6541 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
6542 bss_select->param.adjust.band = adj_param->band;
6543 bss_select->param.adjust.delta = adj_param->delta;
6544 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
6545 return -EINVAL;
6546 }
6547
6548 /* user-space did not provide behaviour attribute */
6549 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
6550 return -EINVAL;
6551
6552 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
6553 return -EINVAL;
6554
6555 return 0;
6556}
6557
ad2b26ab
JB		 6558static int nl80211_parse_random_mac(struct nlattr **attrs,
6559 u8 *mac_addr, u8 *mac_addr_mask)
6560{
6561 int i;
6562
6563 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
d2beae10
JP		 6564 eth_zero_addr(mac_addr);
6565 eth_zero_addr(mac_addr_mask);
ad2b26ab
JB		 6566 mac_addr[0] = 0x2;
6567 mac_addr_mask[0] = 0x3;
6568
6569 return 0;
6570 }
6571
6572 /* need both or none */
6573 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
6574 return -EINVAL;
6575
6576 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
6577 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
6578
6579 /* don't allow or configure an mcast address */
6580 if (!is_multicast_ether_addr(mac_addr_mask) ||
6581 is_multicast_ether_addr(mac_addr))
6582 return -EINVAL;
6583
6584 /*
6585 * allow users to pass a MAC address that has bits set outside
6586 * of the mask, but don't bother drivers with having to deal
6587 * with such bits
6588 */
6589 for (i = 0; i < ETH_ALEN; i++)
6590 mac_addr[i] &= mac_addr_mask[i];
6591
6592 return 0;
6593}
6594
34373d12
VT		 6595static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
6596{
6597 ASSERT_WDEV_LOCK(wdev);
6598
6599 if (!cfg80211_beaconing_iface_active(wdev))
6600 return true;
6601
6602 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
6603 return true;
6604
6605 return regulatory_pre_cac_allowed(wdev->wiphy);
6606}
6607
2a519311
JB		 6608static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
6609{
4c476991 6610 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd014284 6611 struct wireless_dev *wdev = info->user_ptr[1];
2a519311 6612 struct cfg80211_scan_request *request;
2a519311
JB		 6613 struct nlattr *attr;
6614 struct wiphy *wiphy;
83f5e2cf 6615 int err, tmp, n_ssids = 0, n_channels, i;
70692ad2 6616 size_t ie_len;
2a519311 6617
f4a11bb0
JB		 6618 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6619 return -EINVAL;
6620
79c97e97 6621 wiphy = &rdev->wiphy;
2a519311 6622
cb3b7d87
AB		 6623 if (wdev->iftype == NL80211_IFTYPE_NAN)
6624 return -EOPNOTSUPP;
6625
4c476991
JB		 6626 if (!rdev->ops->scan)
6627 return -EOPNOTSUPP;
2a519311 6628
f9d15d16 6629 if (rdev->scan_req || rdev->scan_msg) {
f9f47529
JB		 6630 err = -EBUSY;
6631 goto unlock;
6632 }
2a519311
JB		 6633
6634 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 6635 n_channels = validate_scan_freqs(
6636 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
f9f47529
JB		 6637 if (!n_channels) {
6638 err = -EINVAL;
6639 goto unlock;
6640 }
2a519311 6641 } else {
bdfbec2d 6642 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311
JB		 6643 }
6644
6645 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
6646 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
6647 n_ssids++;
6648
f9f47529
JB		 6649 if (n_ssids > wiphy->max_scan_ssids) {
6650 err = -EINVAL;
6651 goto unlock;
6652 }
2a519311 6653
70692ad2
JM		 6654 if (info->attrs[NL80211_ATTR_IE])
6655 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6656 else
6657 ie_len = 0;
6658
f9f47529
JB		 6659 if (ie_len > wiphy->max_scan_ie_len) {
6660 err = -EINVAL;
6661 goto unlock;
6662 }
18a83659 6663
2a519311 6664 request = kzalloc(sizeof(*request)
a2cd43c5
LC		 6665 + sizeof(*request->ssids) * n_ssids
6666 + sizeof(*request->channels) * n_channels
70692ad2 6667 + ie_len, GFP_KERNEL);
f9f47529
JB		 6668 if (!request) {
6669 err = -ENOMEM;
6670 goto unlock;
6671 }
2a519311 6672
2a519311 6673 if (n_ssids)
5ba63533 6674 request->ssids = (void *)&request->channels[n_channels];
2a519311 6675 request->n_ssids = n_ssids;
70692ad2 6676 if (ie_len) {
13874e4b 6677 if (n_ssids)
70692ad2
JM		 6678 request->ie = (void *)(request->ssids + n_ssids);
6679 else
6680 request->ie = (void *)(request->channels + n_channels);
6681 }
2a519311 6682
584991dc 6683 i = 0;
2a519311
JB		 6684 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
6685 /* user specified, bail out if channel not found */
2a519311 6686 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
584991dc
JB		 6687 struct ieee80211_channel *chan;
6688
6689 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
6690
6691 if (!chan) {
2a519311
JB		 6692 err = -EINVAL;
6693 goto out_free;
6694 }
584991dc
JB		 6695
6696 /* ignore disabled channels */
6697 if (chan->flags & IEEE80211_CHAN_DISABLED)
6698 continue;
6699
6700 request->channels[i] = chan;
2a519311
JB		 6701 i++;
6702 }
6703 } else {
57fbcce3 6704 enum nl80211_band band;
34850ab2 6705
2a519311 6706 /* all channels */
57fbcce3 6707 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2a519311 6708 int j;
7a087e74 6709
2a519311
JB		 6710 if (!wiphy->bands[band])
6711 continue;
6712 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dc
JB		 6713 struct ieee80211_channel *chan;
6714
6715 chan = &wiphy->bands[band]->channels[j];
6716
6717 if (chan->flags & IEEE80211_CHAN_DISABLED)
6718 continue;
6719
6720 request->channels[i] = chan;
2a519311
JB		 6721 i++;
6722 }
6723 }
6724 }
6725
584991dc
JB		 6726 if (!i) {
6727 err = -EINVAL;
6728 goto out_free;
6729 }
6730
6731 request->n_channels = i;
6732
34373d12
VT		 6733 wdev_lock(wdev);
6734 if (!cfg80211_off_channel_oper_allowed(wdev)) {
6735 struct ieee80211_channel *chan;
6736
6737 if (request->n_channels != 1) {
6738 wdev_unlock(wdev);
6739 err = -EBUSY;
6740 goto out_free;
6741 }
6742
6743 chan = request->channels[0];
6744 if (chan->center_freq != wdev->chandef.chan->center_freq) {
6745 wdev_unlock(wdev);
6746 err = -EBUSY;
6747 goto out_free;
6748 }
6749 }
6750 wdev_unlock(wdev);
6751
2a519311 6752 i = 0;
13874e4b 6753 if (n_ssids) {
2a519311 6754 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d 6755 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311
JB		 6756 err = -EINVAL;
6757 goto out_free;
6758 }
57a27e1d 6759 request->ssids[i].ssid_len = nla_len(attr);
2a519311 6760 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2a519311
JB		 6761 i++;
6762 }
6763 }
6764
70692ad2
JM		 6765 if (info->attrs[NL80211_ATTR_IE]) {
6766 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 6767 memcpy((void *)request->ie,
6768 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 6769 request->ie_len);
6770 }
6771
57fbcce3 6772 for (i = 0; i < NUM_NL80211_BANDS; i++)
a401d2bb
JB		 6773 if (wiphy->bands[i])
6774 request->rates[i] =
6775 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab2
JB		 6776
6777 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
6778 nla_for_each_nested(attr,
6779 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
6780 tmp) {
57fbcce3 6781 enum nl80211_band band = nla_type(attr);
34850ab2 6782
57fbcce3 6783 if (band < 0 || band >= NUM_NL80211_BANDS) {
34850ab2
JB		 6784 err = -EINVAL;
6785 goto out_free;
6786 }
1b09cd82
FF		 6787
6788 if (!wiphy->bands[band])
6789 continue;
6790
34850ab2
JB		 6791 err = ieee80211_get_ratemask(wiphy->bands[band],
6792 nla_data(attr),
6793 nla_len(attr),
6794 &request->rates[band]);
6795 if (err)
6796 goto out_free;
6797 }
6798 }
6799
1d76250b
AS		 6800 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
6801 if (!wiphy_ext_feature_isset(wiphy,
6802 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
6803 err = -EOPNOTSUPP;
6804 goto out_free;
6805 }
6806
6807 request->duration =
6808 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
6809 request->duration_mandatory =
6810 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
6811 }
6812
46856bbf 6813 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771
SL		 6814 request->flags = nla_get_u32(
6815 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 6816 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
6817 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 6818 err = -EOPNOTSUPP;
6819 goto out_free;
6820 }
ad2b26ab
JB		 6821
6822 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6823 if (!(wiphy->features &
6824 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)) {
6825 err = -EOPNOTSUPP;
6826 goto out_free;
6827 }
6828
6829 if (wdev->current_bss) {
6830 err = -EOPNOTSUPP;
6831 goto out_free;
6832 }
6833
6834 err = nl80211_parse_random_mac(info->attrs,
6835 request->mac_addr,
6836 request->mac_addr_mask);
6837 if (err)
6838 goto out_free;
6839 }
46856bbf 6840 }
ed473771 6841
e9f935e3
RM		 6842 request->no_cck =
6843 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
6844
2fa436b3
VK		 6845 /* Initial implementation used NL80211_ATTR_MAC to set the specific
6846 * BSSID to scan for. This was problematic because that same attribute
6847 * was already used for another purpose (local random MAC address). The
6848 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
6849 * compatibility with older userspace components, also use the
6850 * NL80211_ATTR_MAC value here if it can be determined to be used for
6851 * the specific BSSID use case instead of the random MAC address
6852 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
6853 */
6854 if (info->attrs[NL80211_ATTR_BSSID])
6855 memcpy(request->bssid,
6856 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
6857 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
6858 info->attrs[NL80211_ATTR_MAC])
818965d3
JM		 6859 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
6860 ETH_ALEN);
6861 else
6862 eth_broadcast_addr(request->bssid);
6863
fd014284 6864 request->wdev = wdev;
79c97e97 6865 request->wiphy = &rdev->wiphy;
15d6030b 6866 request->scan_start = jiffies;
2a519311 6867
79c97e97 6868 rdev->scan_req = request;
e35e4d28 6869 err = rdev_scan(rdev, request);
2a519311 6870
463d0183 6871 if (!err) {
fd014284
JB		 6872 nl80211_send_scan_start(rdev, wdev);
6873 if (wdev->netdev)
6874 dev_hold(wdev->netdev);
4c476991 6875 } else {
2a519311 6876 out_free:
79c97e97 6877 rdev->scan_req = NULL;
2a519311
JB		 6878 kfree(request);
6879 }
3b85875a 6880
f9f47529 6881 unlock:
2a519311
JB		 6882 return err;
6883}
6884
91d3ab46
VK		 6885static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
6886{
6887 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6888 struct wireless_dev *wdev = info->user_ptr[1];
6889
6890 if (!rdev->ops->abort_scan)
6891 return -EOPNOTSUPP;
6892
6893 if (rdev->scan_msg)
6894 return 0;
6895
6896 if (!rdev->scan_req)
6897 return -ENOENT;
6898
6899 rdev_abort_scan(rdev, wdev);
6900 return 0;
6901}
6902
3b06d277
AS		 6903static int
6904nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
6905 struct cfg80211_sched_scan_request *request,
6906 struct nlattr **attrs)
6907{
6908 int tmp, err, i = 0;
6909 struct nlattr *attr;
6910
6911 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
6912 u32 interval;
6913
6914 /*
6915 * If scan plans are not specified,
5a88de53 6916 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
3b06d277
AS		 6917 * case one scan plan will be set with the specified scan
6918 * interval and infinite number of iterations.
6919 */
3b06d277
AS		 6920 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
6921 if (!interval)
6922 return -EINVAL;
6923
6924 request->scan_plans[0].interval =
6925 DIV_ROUND_UP(interval, MSEC_PER_SEC);
6926 if (!request->scan_plans[0].interval)
6927 return -EINVAL;
6928
6929 if (request->scan_plans[0].interval >
6930 wiphy->max_sched_scan_plan_interval)
6931 request->scan_plans[0].interval =
6932 wiphy->max_sched_scan_plan_interval;
6933
6934 return 0;
6935 }
6936
6937 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
6938 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
6939
6940 if (WARN_ON(i >= n_plans))
6941 return -EINVAL;
6942
bfe2c7b1 6943 err = nla_parse_nested(plan, NL80211_SCHED_SCAN_PLAN_MAX,
fceb6435 6944 attr, nl80211_plan_policy, NULL);
3b06d277
AS		 6945 if (err)
6946 return err;
6947
6948 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
6949 return -EINVAL;
6950
6951 request->scan_plans[i].interval =
6952 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
6953 if (!request->scan_plans[i].interval ||
6954 request->scan_plans[i].interval >
6955 wiphy->max_sched_scan_plan_interval)
6956 return -EINVAL;
6957
6958 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
6959 request->scan_plans[i].iterations =
6960 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
6961 if (!request->scan_plans[i].iterations ||
6962 (request->scan_plans[i].iterations >
6963 wiphy->max_sched_scan_plan_iterations))
6964 return -EINVAL;
6965 } else if (i < n_plans - 1) {
6966 /*
6967 * All scan plans but the last one must specify
6968 * a finite number of iterations
6969 */
6970 return -EINVAL;
6971 }
6972
6973 i++;
6974 }
6975
6976 /*
6977 * The last scan plan must not specify the number of
6978 * iterations, it is supposed to run infinitely
6979 */
6980 if (request->scan_plans[n_plans - 1].iterations)
6981 return -EINVAL;
6982
6983 return 0;
6984}
6985
256da02d 6986static struct cfg80211_sched_scan_request *
ad2b26ab 6987nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
aad1e812 6988 struct nlattr **attrs, int max_match_sets)
807f8a8c
LC		 6989{
6990 struct cfg80211_sched_scan_request *request;
807f8a8c 6991 struct nlattr *attr;
3b06d277 6992 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
57fbcce3 6993 enum nl80211_band band;
807f8a8c 6994 size_t ie_len;
a1f1c21c 6995 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
ea73cbce 6996 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
807f8a8c 6997
256da02d
LC		 6998 if (!is_valid_ie_attr(attrs[NL80211_ATTR_IE]))
6999 return ERR_PTR(-EINVAL);
807f8a8c 7000
256da02d 7001 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c 7002 n_channels = validate_scan_freqs(
256da02d 7003 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
807f8a8c 7004 if (!n_channels)
256da02d 7005 return ERR_PTR(-EINVAL);
807f8a8c 7006 } else {
bdfbec2d 7007 n_channels = ieee80211_get_num_supported_channels(wiphy);
807f8a8c
LC		 7008 }
7009
256da02d
LC		 7010 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7011 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c
LC		 7012 tmp)
7013 n_ssids++;
7014
93b6aa69 7015 if (n_ssids > wiphy->max_sched_scan_ssids)
256da02d 7016 return ERR_PTR(-EINVAL);
807f8a8c 7017
ea73cbce
JB		 7018 /*
7019 * First, count the number of 'real' matchsets. Due to an issue with
7020 * the old implementation, matchsets containing only the RSSI attribute
7021 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7022 * RSSI for all matchsets, rather than their own matchset for reporting
7023 * all APs with a strong RSSI. This is needed to be compatible with
7024 * older userspace that treated a matchset with only the RSSI as the
7025 * global RSSI for all other matchsets - if there are other matchsets.
7026 */
256da02d 7027 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7028 nla_for_each_nested(attr,
256da02d 7029 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
ea73cbce
JB		 7030 tmp) {
7031 struct nlattr *rssi;
7032
bfe2c7b1
JB		 7033 err = nla_parse_nested(tb,
7034 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7035 attr, nl80211_match_policy,
7036 NULL);
ea73cbce 7037 if (err)
256da02d 7038 return ERR_PTR(err);
3007e352
AVS		 7039
7040 /* SSID and BSSID are mutually exclusive */
7041 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
7042 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
7043 return ERR_PTR(-EINVAL);
7044
ea73cbce 7045 /* add other standalone attributes here */
3007e352
AVS		 7046 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
7047 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
ea73cbce
JB		 7048 n_match_sets++;
7049 continue;
7050 }
7051 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7052 if (rssi)
7053 default_match_rssi = nla_get_s32(rssi);
7054 }
7055 }
7056
7057 /* However, if there's no other matchset, add the RSSI one */
7058 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7059 n_match_sets = 1;
a1f1c21c 7060
aad1e812 7061 if (n_match_sets > max_match_sets)
256da02d 7062 return ERR_PTR(-EINVAL);
a1f1c21c 7063
256da02d
LC		 7064 if (attrs[NL80211_ATTR_IE])
7065 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
807f8a8c
LC		 7066 else
7067 ie_len = 0;
7068
5a865bad 7069 if (ie_len > wiphy->max_sched_scan_ie_len)
256da02d 7070 return ERR_PTR(-EINVAL);
c10841ca 7071
3b06d277
AS		 7072 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7073 /*
7074 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7075 * each scan plan already specifies its own interval
7076 */
7077 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7078 return ERR_PTR(-EINVAL);
7079
7080 nla_for_each_nested(attr,
7081 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7082 n_plans++;
7083 } else {
7084 /*
7085 * The scan interval attribute is kept for backward
7086 * compatibility. If no scan plans are specified and sched scan
7087 * interval is specified, one scan plan will be set with this
7088 * scan interval and infinite number of iterations.
7089 */
7090 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7091 return ERR_PTR(-EINVAL);
7092
7093 n_plans = 1;
7094 }
7095
7096 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7097 return ERR_PTR(-EINVAL);
7098
bf95ecdb 7099 if (!wiphy_ext_feature_isset(
7100 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7101 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7102 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7103 return ERR_PTR(-EINVAL);
7104
807f8a8c 7105 request = kzalloc(sizeof(*request)
a2cd43c5 7106 + sizeof(*request->ssids) * n_ssids
a1f1c21c 7107 + sizeof(*request->match_sets) * n_match_sets
3b06d277 7108 + sizeof(*request->scan_plans) * n_plans
a2cd43c5 7109 + sizeof(*request->channels) * n_channels
807f8a8c 7110 + ie_len, GFP_KERNEL);
256da02d
LC		 7111 if (!request)
7112 return ERR_PTR(-ENOMEM);
807f8a8c
LC		 7113
7114 if (n_ssids)
7115 request->ssids = (void *)&request->channels[n_channels];
7116 request->n_ssids = n_ssids;
7117 if (ie_len) {
13874e4b 7118 if (n_ssids)
807f8a8c
LC		 7119 request->ie = (void *)(request->ssids + n_ssids);
7120 else
7121 request->ie = (void *)(request->channels + n_channels);
7122 }
7123
a1f1c21c
LC		 7124 if (n_match_sets) {
7125 if (request->ie)
7126 request->match_sets = (void *)(request->ie + ie_len);
13874e4b 7127 else if (n_ssids)
a1f1c21c
LC		 7128 request->match_sets =
7129 (void *)(request->ssids + n_ssids);
7130 else
7131 request->match_sets =
7132 (void *)(request->channels + n_channels);
7133 }
7134 request->n_match_sets = n_match_sets;
7135
3b06d277
AS		 7136 if (n_match_sets)
7137 request->scan_plans = (void *)(request->match_sets +
7138 n_match_sets);
7139 else if (request->ie)
7140 request->scan_plans = (void *)(request->ie + ie_len);
7141 else if (n_ssids)
7142 request->scan_plans = (void *)(request->ssids + n_ssids);
7143 else
7144 request->scan_plans = (void *)(request->channels + n_channels);
7145
7146 request->n_scan_plans = n_plans;
7147
807f8a8c 7148 i = 0;
256da02d 7149 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c
LC		 7150 /* user specified, bail out if channel not found */
7151 nla_for_each_nested(attr,
256da02d 7152 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
807f8a8c
LC		 7153 tmp) {
7154 struct ieee80211_channel *chan;
7155
7156 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7157
7158 if (!chan) {
7159 err = -EINVAL;
7160 goto out_free;
7161 }
7162
7163 /* ignore disabled channels */
7164 if (chan->flags & IEEE80211_CHAN_DISABLED)
7165 continue;
7166
7167 request->channels[i] = chan;
7168 i++;
7169 }
7170 } else {
7171 /* all channels */
57fbcce3 7172 for (band = 0; band < NUM_NL80211_BANDS; band++) {
807f8a8c 7173 int j;
7a087e74 7174
807f8a8c
LC		 7175 if (!wiphy->bands[band])
7176 continue;
7177 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7178 struct ieee80211_channel *chan;
7179
7180 chan = &wiphy->bands[band]->channels[j];
7181
7182 if (chan->flags & IEEE80211_CHAN_DISABLED)
7183 continue;
7184
7185 request->channels[i] = chan;
7186 i++;
7187 }
7188 }
7189 }
7190
7191 if (!i) {
7192 err = -EINVAL;
7193 goto out_free;
7194 }
7195
7196 request->n_channels = i;
7197
7198 i = 0;
13874e4b 7199 if (n_ssids) {
256da02d 7200 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c 7201 tmp) {
57a27e1d 7202 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
807f8a8c
LC		 7203 err = -EINVAL;
7204 goto out_free;
7205 }
57a27e1d 7206 request->ssids[i].ssid_len = nla_len(attr);
807f8a8c
LC		 7207 memcpy(request->ssids[i].ssid, nla_data(attr),
7208 nla_len(attr));
807f8a8c
LC		 7209 i++;
7210 }
7211 }
7212
a1f1c21c 7213 i = 0;
256da02d 7214 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7215 nla_for_each_nested(attr,
256da02d 7216 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
a1f1c21c 7217 tmp) {
3007e352 7218 struct nlattr *ssid, *bssid, *rssi;
a1f1c21c 7219
bfe2c7b1
JB		 7220 err = nla_parse_nested(tb,
7221 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7222 attr, nl80211_match_policy,
7223 NULL);
ae811e21
JB		 7224 if (err)
7225 goto out_free;
4a4ab0d7 7226 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
3007e352
AVS		 7227 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
7228 if (ssid || bssid) {
ea73cbce
JB		 7229 if (WARN_ON(i >= n_match_sets)) {
7230 /* this indicates a programming error,
7231 * the loop above should have verified
7232 * things properly
7233 */
7234 err = -EINVAL;
7235 goto out_free;
7236 }
7237
3007e352
AVS		 7238 if (ssid) {
7239 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
7240 err = -EINVAL;
7241 goto out_free;
7242 }
7243 memcpy(request->match_sets[i].ssid.ssid,
7244 nla_data(ssid), nla_len(ssid));
7245 request->match_sets[i].ssid.ssid_len =
7246 nla_len(ssid);
7247 }
7248 if (bssid) {
7249 if (nla_len(bssid) != ETH_ALEN) {
7250 err = -EINVAL;
7251 goto out_free;
7252 }
7253 memcpy(request->match_sets[i].bssid,
7254 nla_data(bssid), ETH_ALEN);
a1f1c21c 7255 }
3007e352 7256
56ab364f 7257 /* special attribute - old implementation w/a */
ea73cbce
JB		 7258 request->match_sets[i].rssi_thold =
7259 default_match_rssi;
7260 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7261 if (rssi)
7262 request->match_sets[i].rssi_thold =
7263 nla_get_s32(rssi);
a1f1c21c
LC		 7264 }
7265 i++;
7266 }
ea73cbce
JB		 7267
7268 /* there was no other matchset, so the RSSI one is alone */
f89f46cf 7269 if (i == 0 && n_match_sets)
ea73cbce
JB		 7270 request->match_sets[0].rssi_thold = default_match_rssi;
7271
7272 request->min_rssi_thold = INT_MAX;
7273 for (i = 0; i < n_match_sets; i++)
7274 request->min_rssi_thold =
7275 min(request->match_sets[i].rssi_thold,
7276 request->min_rssi_thold);
7277 } else {
7278 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
a1f1c21c
LC		 7279 }
7280
9900e484
JB		 7281 if (ie_len) {
7282 request->ie_len = ie_len;
807f8a8c 7283 memcpy((void *)request->ie,
256da02d 7284 nla_data(attrs[NL80211_ATTR_IE]),
807f8a8c
LC		 7285 request->ie_len);
7286 }
7287
256da02d 7288 if (attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771 7289 request->flags = nla_get_u32(
256da02d 7290 attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 7291 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7292 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 7293 err = -EOPNOTSUPP;
7294 goto out_free;
7295 }
ad2b26ab
JB		 7296
7297 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7298 u32 flg = NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
7299
7300 if (!wdev) /* must be net-detect */
7301 flg = NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7302
7303 if (!(wiphy->features & flg)) {
7304 err = -EOPNOTSUPP;
7305 goto out_free;
7306 }
7307
7308 if (wdev && wdev->current_bss) {
7309 err = -EOPNOTSUPP;
7310 goto out_free;
7311 }
7312
7313 err = nl80211_parse_random_mac(attrs, request->mac_addr,
7314 request->mac_addr_mask);
7315 if (err)
7316 goto out_free;
7317 }
46856bbf 7318 }
ed473771 7319
9c748934
LC		 7320 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
7321 request->delay =
7322 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
7323
bf95ecdb 7324 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
7325 request->relative_rssi = nla_get_s8(
7326 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
7327 request->relative_rssi_set = true;
7328 }
7329
7330 if (request->relative_rssi_set &&
7331 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
7332 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
7333
7334 rssi_adjust = nla_data(
7335 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
7336 request->rssi_adjust.band = rssi_adjust->band;
7337 request->rssi_adjust.delta = rssi_adjust->delta;
7338 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
7339 err = -EINVAL;
7340 goto out_free;
7341 }
7342 }
7343
3b06d277
AS		 7344 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
7345 if (err)
7346 goto out_free;
7347
15d6030b 7348 request->scan_start = jiffies;
807f8a8c 7349
256da02d 7350 return request;
807f8a8c
LC		 7351
7352out_free:
7353 kfree(request);
256da02d
LC		 7354 return ERR_PTR(err);
7355}
7356
7357static int nl80211_start_sched_scan(struct sk_buff *skb,
7358 struct genl_info *info)
7359{
7360 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7361 struct net_device *dev = info->user_ptr[1];
ad2b26ab 7362 struct wireless_dev *wdev = dev->ieee80211_ptr;
31a60ed1 7363 struct cfg80211_sched_scan_request *sched_scan_req;
ca986ad9 7364 bool want_multi;
256da02d
LC		 7365 int err;
7366
ca986ad9 7367 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
256da02d
LC		 7368 return -EOPNOTSUPP;
7369
ca986ad9
AVS		 7370 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
7371 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
7372 if (err)
7373 return err;
256da02d 7374
31a60ed1 7375 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
aad1e812
AVS		 7376 info->attrs,
7377 rdev->wiphy.max_match_sets);
31a60ed1
JR		 7378
7379 err = PTR_ERR_OR_ZERO(sched_scan_req);
256da02d
LC		 7380 if (err)
7381 goto out_err;
7382
ca986ad9
AVS		 7383 /* leave request id zero for legacy request
7384 * or if driver does not support multi-scheduled scan
7385 */
7386 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) {
7387 while (!sched_scan_req->reqid)
7388 sched_scan_req->reqid = rdev->wiphy.cookie_counter++;
7389 }
7390
31a60ed1 7391 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
256da02d
LC		 7392 if (err)
7393 goto out_free;
7394
31a60ed1
JR		 7395 sched_scan_req->dev = dev;
7396 sched_scan_req->wiphy = &rdev->wiphy;
7397
93a1e86c
JR		 7398 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
7399 sched_scan_req->owner_nlportid = info->snd_portid;
7400
ca986ad9 7401 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
256da02d 7402
96b08fd6 7403 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
256da02d
LC		 7404 return 0;
7405
7406out_free:
31a60ed1 7407 kfree(sched_scan_req);
256da02d 7408out_err:
807f8a8c
LC		 7409 return err;
7410}
7411
7412static int nl80211_stop_sched_scan(struct sk_buff *skb,
7413 struct genl_info *info)
7414{
ca986ad9 7415 struct cfg80211_sched_scan_request *req;
807f8a8c 7416 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ca986ad9 7417 u64 cookie;
807f8a8c 7418
ca986ad9 7419 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
807f8a8c
LC		 7420 return -EOPNOTSUPP;
7421
ca986ad9
AVS		 7422 if (info->attrs[NL80211_ATTR_COOKIE]) {
7423 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7424 return __cfg80211_stop_sched_scan(rdev, cookie, false);
7425 }
7426
7427 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
7428 struct cfg80211_sched_scan_request,
7429 list);
7430 if (!req || req->reqid ||
7431 (req->owner_nlportid &&
7432 req->owner_nlportid != info->snd_portid))
7433 return -ENOENT;
7434
7435 return cfg80211_stop_sched_scan_req(rdev, req, false);
807f8a8c
LC		 7436}
7437
04f39047
SW		 7438static int nl80211_start_radar_detection(struct sk_buff *skb,
7439 struct genl_info *info)
7440{
7441 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7442 struct net_device *dev = info->user_ptr[1];
7443 struct wireless_dev *wdev = dev->ieee80211_ptr;
7444 struct cfg80211_chan_def chandef;
55f7435c 7445 enum nl80211_dfs_regions dfs_region;
31559f35 7446 unsigned int cac_time_ms;
04f39047
SW		 7447 int err;
7448
55f7435c
LR		 7449 dfs_region = reg_get_dfs_region(wdev->wiphy);
7450 if (dfs_region == NL80211_DFS_UNSET)
7451 return -EINVAL;
7452
04f39047
SW		 7453 err = nl80211_parse_chandef(rdev, info, &chandef);
7454 if (err)
7455 return err;
7456
ff311bc1
SW		 7457 if (netif_carrier_ok(dev))
7458 return -EBUSY;
7459
04f39047
SW		 7460 if (wdev->cac_started)
7461 return -EBUSY;
7462
2beb6dab 7463 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
00ec75fc 7464 wdev->iftype);
04f39047
SW		 7465 if (err < 0)
7466 return err;
7467
7468 if (err == 0)
7469 return -EINVAL;
7470
fe7c3a1f 7471 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
04f39047
SW		 7472 return -EINVAL;
7473
7474 if (!rdev->ops->start_radar_detection)
7475 return -EOPNOTSUPP;
7476
31559f35
JD		 7477 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
7478 if (WARN_ON(!cac_time_ms))
7479 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
7480
a1056b1b 7481 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
04f39047 7482 if (!err) {
9e0e2961 7483 wdev->chandef = chandef;
04f39047
SW		 7484 wdev->cac_started = true;
7485 wdev->cac_start_time = jiffies;
31559f35 7486 wdev->cac_time_ms = cac_time_ms;
04f39047 7487 }
04f39047
SW		 7488 return err;
7489}
7490
16ef1fe2
SW		 7491static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
7492{
7493 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7494 struct net_device *dev = info->user_ptr[1];
7495 struct wireless_dev *wdev = dev->ieee80211_ptr;
7496 struct cfg80211_csa_settings params;
7497 /* csa_attrs is defined static to avoid waste of stack size - this
7498 * function is called under RTNL lock, so this should not be a problem.
7499 */
7500 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
16ef1fe2 7501 int err;
ee4bc9e7 7502 bool need_new_beacon = false;
9a774c78 7503 int len, i;
252e07ca 7504 u32 cs_count;
16ef1fe2
SW		 7505
7506 if (!rdev->ops->channel_switch ||
7507 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
7508 return -EOPNOTSUPP;
7509
ee4bc9e7
SW		 7510 switch (dev->ieee80211_ptr->iftype) {
7511 case NL80211_IFTYPE_AP:
7512 case NL80211_IFTYPE_P2P_GO:
7513 need_new_beacon = true;
7514
7515 /* useless if AP is not running */
7516 if (!wdev->beacon_interval)
1ff79dfa 7517 return -ENOTCONN;
ee4bc9e7
SW		 7518 break;
7519 case NL80211_IFTYPE_ADHOC:
1ff79dfa
JB		 7520 if (!wdev->ssid_len)
7521 return -ENOTCONN;
7522 break;
c6da674a 7523 case NL80211_IFTYPE_MESH_POINT:
1ff79dfa
JB		 7524 if (!wdev->mesh_id_len)
7525 return -ENOTCONN;
ee4bc9e7
SW		 7526 break;
7527 default:
16ef1fe2 7528 return -EOPNOTSUPP;
ee4bc9e7 7529 }
16ef1fe2
SW		 7530
7531 memset(&params, 0, sizeof(params));
7532
7533 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7534 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
7535 return -EINVAL;
7536
7537 /* only important for AP, IBSS and mesh create IEs internally */
d0a361a5 7538 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
16ef1fe2
SW		 7539 return -EINVAL;
7540
252e07ca
LC		 7541 /* Even though the attribute is u32, the specification says
7542 * u8, so let's make sure we don't overflow.
7543 */
7544 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
7545 if (cs_count > 255)
7546 return -EINVAL;
7547
7548 params.count = cs_count;
16ef1fe2 7549
ee4bc9e7
SW		 7550 if (!need_new_beacon)
7551 goto skip_beacons;
7552
16ef1fe2
SW		 7553 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
7554 if (err)
7555 return err;
7556
7557 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
7558 info->attrs[NL80211_ATTR_CSA_IES],
fe52145f 7559 nl80211_policy, info->extack);
16ef1fe2
SW		 7560 if (err)
7561 return err;
7562
7563 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
7564 if (err)
7565 return err;
7566
7567 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
7568 return -EINVAL;
7569
9a774c78
AO		 7570 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7571 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7572 return -EINVAL;
7573
9a774c78
AO		 7574 params.n_counter_offsets_beacon = len / sizeof(u16);
7575 if (rdev->wiphy.max_num_csa_counters &&
7576 (params.n_counter_offsets_beacon >
7577 rdev->wiphy.max_num_csa_counters))
16ef1fe2
SW		 7578 return -EINVAL;
7579
9a774c78
AO		 7580 params.counter_offsets_beacon =
7581 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7582
7583 /* sanity checks - counters should fit and be the same */
7584 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
7585 u16 offset = params.counter_offsets_beacon[i];
7586
7587 if (offset >= params.beacon_csa.tail_len)
7588 return -EINVAL;
7589
7590 if (params.beacon_csa.tail[offset] != params.count)
7591 return -EINVAL;
7592 }
7593
16ef1fe2 7594 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
9a774c78
AO		 7595 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7596 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7597 return -EINVAL;
7598
9a774c78
AO		 7599 params.n_counter_offsets_presp = len / sizeof(u16);
7600 if (rdev->wiphy.max_num_csa_counters &&
ad5987b4 7601 (params.n_counter_offsets_presp >
9a774c78 7602 rdev->wiphy.max_num_csa_counters))
16ef1fe2 7603 return -EINVAL;
9a774c78
AO		 7604
7605 params.counter_offsets_presp =
7606 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7607
7608 /* sanity checks - counters should fit and be the same */
7609 for (i = 0; i < params.n_counter_offsets_presp; i++) {
7610 u16 offset = params.counter_offsets_presp[i];
7611
7612 if (offset >= params.beacon_csa.probe_resp_len)
7613 return -EINVAL;
7614
7615 if (params.beacon_csa.probe_resp[offset] !=
7616 params.count)
7617 return -EINVAL;
7618 }
16ef1fe2
SW		 7619 }
7620
ee4bc9e7 7621skip_beacons:
16ef1fe2
SW		 7622 err = nl80211_parse_chandef(rdev, info, &params.chandef);
7623 if (err)
7624 return err;
7625
923b352f
AN		 7626 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
7627 wdev->iftype))
16ef1fe2
SW		 7628 return -EINVAL;
7629
2beb6dab
LC		 7630 err = cfg80211_chandef_dfs_required(wdev->wiphy,
7631 &params.chandef,
7632 wdev->iftype);
7633 if (err < 0)
7634 return err;
7635
dcc6c2f5 7636 if (err > 0)
2beb6dab 7637 params.radar_required = true;
16ef1fe2 7638
16ef1fe2
SW		 7639 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
7640 params.block_tx = true;
7641
c56589ed
SW		 7642 wdev_lock(wdev);
7643 err = rdev_channel_switch(rdev, dev, &params);
7644 wdev_unlock(wdev);
7645
7646 return err;
16ef1fe2
SW		 7647}
7648
9720bb3a
JB		 7649static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
7650 u32 seq, int flags,
2a519311 7651 struct cfg80211_registered_device *rdev,
48ab905d
JB		 7652 struct wireless_dev *wdev,
7653 struct cfg80211_internal_bss *intbss)
2a519311 7654{
48ab905d 7655 struct cfg80211_bss *res = &intbss->pub;
9caf0364 7656 const struct cfg80211_bss_ies *ies;
2a519311
JB		 7657 void *hdr;
7658 struct nlattr *bss;
48ab905d
JB		 7659
7660 ASSERT_WDEV_LOCK(wdev);
2a519311 7661
15e47304 7662 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
2a519311
JB		 7663 NL80211_CMD_NEW_SCAN_RESULTS);
7664 if (!hdr)
7665 return -1;
7666
9720bb3a
JB		 7667 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
7668
97990a06
JB		 7669 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
7670 goto nla_put_failure;
7671 if (wdev->netdev &&
9360ffd1
DM		 7672 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
7673 goto nla_put_failure;
2dad624e
ND		 7674 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
7675 NL80211_ATTR_PAD))
97990a06 7676 goto nla_put_failure;
2a519311
JB		 7677
7678 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
7679 if (!bss)
7680 goto nla_put_failure;
9360ffd1 7681 if ((!is_zero_ether_addr(res->bssid) &&
9caf0364 7682 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9360ffd1 7683 goto nla_put_failure;
9caf0364
JB		 7684
7685 rcu_read_lock();
0e227084
JB		 7686 /* indicate whether we have probe response data or not */
7687 if (rcu_access_pointer(res->proberesp_ies) &&
7688 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
7689 goto fail_unlock_rcu;
7690
7691 /* this pointer prefers to be pointed to probe response data
7692 * but is always valid
7693 */
9caf0364 7694 ies = rcu_dereference(res->ies);
8cef2c9d 7695 if (ies) {
2dad624e
ND		 7696 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
7697 NL80211_BSS_PAD))
8cef2c9d 7698 goto fail_unlock_rcu;
8cef2c9d
JB		 7699 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
7700 ies->len, ies->data))
7701 goto fail_unlock_rcu;
9caf0364 7702 }
0e227084
JB		 7703
7704 /* and this pointer is always (unless driver didn't know) beacon data */
9caf0364 7705 ies = rcu_dereference(res->beacon_ies);
0e227084 7706 if (ies && ies->from_beacon) {
2dad624e
ND		 7707 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
7708 NL80211_BSS_PAD))
8cef2c9d
JB		 7709 goto fail_unlock_rcu;
7710 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
7711 ies->len, ies->data))
7712 goto fail_unlock_rcu;
9caf0364
JB		 7713 }
7714 rcu_read_unlock();
7715
9360ffd1
DM		 7716 if (res->beacon_interval &&
7717 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
7718 goto nla_put_failure;
7719 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
7720 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
dcd6eac1 7721 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9360ffd1
DM		 7722 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
7723 jiffies_to_msecs(jiffies - intbss->ts)))
7724 goto nla_put_failure;
2a519311 7725
1d76250b
AS		 7726 if (intbss->parent_tsf &&
7727 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
7728 intbss->parent_tsf, NL80211_BSS_PAD) ||
7729 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
7730 intbss->parent_bssid)))
7731 goto nla_put_failure;
7732
6e19bc4b 7733 if (intbss->ts_boottime &&
2dad624e
ND		 7734 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
7735 intbss->ts_boottime, NL80211_BSS_PAD))
6e19bc4b
DS		 7736 goto nla_put_failure;
7737
77965c97 7738 switch (rdev->wiphy.signal_type) {
2a519311 7739 case CFG80211_SIGNAL_TYPE_MBM:
9360ffd1
DM		 7740 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
7741 goto nla_put_failure;
2a519311
JB		 7742 break;
7743 case CFG80211_SIGNAL_TYPE_UNSPEC:
9360ffd1
DM		 7744 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
7745 goto nla_put_failure;
2a519311
JB		 7746 break;
7747 default:
7748 break;
7749 }
7750
48ab905d 7751 switch (wdev->iftype) {
074ac8df 7752 case NL80211_IFTYPE_P2P_CLIENT:
48ab905d 7753 case NL80211_IFTYPE_STATION:
9360ffd1
DM		 7754 if (intbss == wdev->current_bss &&
7755 nla_put_u32(msg, NL80211_BSS_STATUS,
7756 NL80211_BSS_STATUS_ASSOCIATED))
7757 goto nla_put_failure;
48ab905d
JB		 7758 break;
7759 case NL80211_IFTYPE_ADHOC:
9360ffd1
DM		 7760 if (intbss == wdev->current_bss &&
7761 nla_put_u32(msg, NL80211_BSS_STATUS,
7762 NL80211_BSS_STATUS_IBSS_JOINED))
7763 goto nla_put_failure;
48ab905d
JB		 7764 break;
7765 default:
7766 break;
7767 }
7768
2a519311
JB		 7769 nla_nest_end(msg, bss);
7770
053c095a
JB		 7771 genlmsg_end(msg, hdr);
7772 return 0;
2a519311 7773
8cef2c9d
JB		 7774 fail_unlock_rcu:
7775 rcu_read_unlock();
2a519311
JB		 7776 nla_put_failure:
7777 genlmsg_cancel(msg, hdr);
7778 return -EMSGSIZE;
7779}
7780
97990a06 7781static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
2a519311 7782{
48ab905d 7783 struct cfg80211_registered_device *rdev;
2a519311 7784 struct cfg80211_internal_bss *scan;
48ab905d 7785 struct wireless_dev *wdev;
97990a06 7786 int start = cb->args[2], idx = 0;
2a519311
JB		 7787 int err;
7788
ea90e0dc 7789 rtnl_lock();
97990a06 7790 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
ea90e0dc
JB		 7791 if (err) {
7792 rtnl_unlock();
67748893 7793 return err;
ea90e0dc 7794 }
2a519311 7795
48ab905d
JB		 7796 wdev_lock(wdev);
7797 spin_lock_bh(&rdev->bss_lock);
7798 cfg80211_bss_expire(rdev);
7799
9720bb3a
JB		 7800 cb->seq = rdev->bss_generation;
7801
48ab905d 7802 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 7803 if (++idx <= start)
7804 continue;
9720bb3a 7805 if (nl80211_send_bss(skb, cb,
2a519311 7806 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 7807 rdev, wdev, scan) < 0) {
2a519311 7808 idx--;
67748893 7809 break;
2a519311
JB		 7810 }
7811 }
7812
48ab905d
JB		 7813 spin_unlock_bh(&rdev->bss_lock);
7814 wdev_unlock(wdev);
2a519311 7815
97990a06 7816 cb->args[2] = idx;
ea90e0dc 7817 rtnl_unlock();
2a519311 7818
67748893 7819 return skb->len;
2a519311
JB		 7820}
7821
15e47304 7822static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
11f78ac3
JB		 7823 int flags, struct net_device *dev,
7824 bool allow_radio_stats,
7825 struct survey_info *survey)
61fa713c
HS		 7826{
7827 void *hdr;
7828 struct nlattr *infoattr;
7829
11f78ac3
JB		 7830 /* skip radio stats if userspace didn't request them */
7831 if (!survey->channel && !allow_radio_stats)
7832 return 0;
7833
15e47304 7834 hdr = nl80211hdr_put(msg, portid, seq, flags,
61fa713c
HS		 7835 NL80211_CMD_NEW_SURVEY_RESULTS);
7836 if (!hdr)
7837 return -ENOMEM;
7838
9360ffd1
DM		 7839 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
7840 goto nla_put_failure;
61fa713c
HS		 7841
7842 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
7843 if (!infoattr)
7844 goto nla_put_failure;
7845
11f78ac3
JB		 7846 if (survey->channel &&
7847 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9360ffd1
DM		 7848 survey->channel->center_freq))
7849 goto nla_put_failure;
7850
7851 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
7852 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
7853 goto nla_put_failure;
7854 if ((survey->filled & SURVEY_INFO_IN_USE) &&
7855 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
7856 goto nla_put_failure;
4ed20beb 7857 if ((survey->filled & SURVEY_INFO_TIME) &&
2dad624e
ND		 7858 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
7859 survey->time, NL80211_SURVEY_INFO_PAD))
9360ffd1 7860 goto nla_put_failure;
4ed20beb 7861 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
2dad624e
ND		 7862 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
7863 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7864 goto nla_put_failure;
4ed20beb 7865 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
2dad624e
ND		 7866 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
7867 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7868 goto nla_put_failure;
4ed20beb 7869 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
2dad624e
ND		 7870 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
7871 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7872 goto nla_put_failure;
4ed20beb 7873 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
2dad624e
ND		 7874 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
7875 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7876 goto nla_put_failure;
052536ab 7877 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
2dad624e
ND		 7878 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
7879 survey->time_scan, NL80211_SURVEY_INFO_PAD))
052536ab 7880 goto nla_put_failure;
61fa713c
HS		 7881
7882 nla_nest_end(msg, infoattr);
7883
053c095a
JB		 7884 genlmsg_end(msg, hdr);
7885 return 0;
61fa713c
HS		 7886
7887 nla_put_failure:
7888 genlmsg_cancel(msg, hdr);
7889 return -EMSGSIZE;
7890}
7891
11f78ac3 7892static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
61fa713c 7893{
c90c39da 7894 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
61fa713c 7895 struct survey_info survey;
1b8ec87a 7896 struct cfg80211_registered_device *rdev;
97990a06
JB		 7897 struct wireless_dev *wdev;
7898 int survey_idx = cb->args[2];
61fa713c 7899 int res;
11f78ac3 7900 bool radio_stats;
61fa713c 7901
ea90e0dc 7902 rtnl_lock();
1b8ec87a 7903 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 7904 if (res)
ea90e0dc 7905 goto out_err;
61fa713c 7906
11f78ac3 7907 /* prepare_wdev_dump parsed the attributes */
c90c39da 7908 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
11f78ac3 7909
97990a06
JB		 7910 if (!wdev->netdev) {
7911 res = -EINVAL;
7912 goto out_err;
7913 }
7914
1b8ec87a 7915 if (!rdev->ops->dump_survey) {
61fa713c
HS		 7916 res = -EOPNOTSUPP;
7917 goto out_err;
7918 }
7919
7920 while (1) {
1b8ec87a 7921 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
61fa713c
HS		 7922 if (res == -ENOENT)
7923 break;
7924 if (res)
7925 goto out_err;
7926
11f78ac3
JB		 7927 /* don't send disabled channels, but do send non-channel data */
7928 if (survey.channel &&
7929 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
180cdc79
LR		 7930 survey_idx++;
7931 continue;
7932 }
7933
61fa713c 7934 if (nl80211_send_survey(skb,
15e47304 7935 NETLINK_CB(cb->skb).portid,
61fa713c 7936 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11f78ac3 7937 wdev->netdev, radio_stats, &survey) < 0)
61fa713c
HS		 7938 goto out;
7939 survey_idx++;
7940 }
7941
7942 out:
97990a06 7943 cb->args[2] = survey_idx;
61fa713c
HS		 7944 res = skb->len;
7945 out_err:
ea90e0dc 7946 rtnl_unlock();
61fa713c
HS		 7947 return res;
7948}
7949
b23aa676
SO		 7950static bool nl80211_valid_wpa_versions(u32 wpa_versions)
7951{
7952 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
7953 NL80211_WPA_VERSION_2));
7954}
7955
636a5d36
JM		 7956static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
7957{
4c476991
JB		 7958 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7959 struct net_device *dev = info->user_ptr[1];
19957bb3 7960 struct ieee80211_channel *chan;
11b6b5a4
JM		 7961 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
7962 int err, ssid_len, ie_len = 0, auth_data_len = 0;
19957bb3 7963 enum nl80211_auth_type auth_type;
fffd0934 7964 struct key_parse key;
d5cdfacb 7965 bool local_state_change;
636a5d36 7966
f4a11bb0
JB		 7967 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7968 return -EINVAL;
7969
7970 if (!info->attrs[NL80211_ATTR_MAC])
7971 return -EINVAL;
7972
1778092e
JM		 7973 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
7974 return -EINVAL;
7975
19957bb3
JB		 7976 if (!info->attrs[NL80211_ATTR_SSID])
7977 return -EINVAL;
7978
7979 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
7980 return -EINVAL;
7981
fffd0934
JB		 7982 err = nl80211_parse_key(info, &key);
7983 if (err)
7984 return err;
7985
7986 if (key.idx >= 0) {
e31b8213
JB		 7987 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
7988 return -EINVAL;
fffd0934
JB		 7989 if (!key.p.key || !key.p.key_len)
7990 return -EINVAL;
7991 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
7992 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
7993 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
7994 key.p.key_len != WLAN_KEY_LEN_WEP104))
7995 return -EINVAL;
b6b5555b 7996 if (key.idx > 3)
fffd0934
JB		 7997 return -EINVAL;
7998 } else {
7999 key.p.key_len = 0;
8000 key.p.key = NULL;
8001 }
8002
afea0b7a
JB		 8003 if (key.idx >= 0) {
8004 int i;
8005 bool ok = false;
7a087e74 8006
afea0b7a
JB		 8007 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
8008 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
8009 ok = true;
8010 break;
8011 }
8012 }
4c476991
JB		 8013 if (!ok)
8014 return -EINVAL;
afea0b7a
JB		 8015 }
8016
4c476991
JB		 8017 if (!rdev->ops->auth)
8018 return -EOPNOTSUPP;
636a5d36 8019
074ac8df 8020 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8021 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8022 return -EOPNOTSUPP;
eec60b03 8023
19957bb3 8024 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
664834de
JM		 8025 chan = nl80211_get_valid_chan(&rdev->wiphy,
8026 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8027 if (!chan)
4c476991 8028 return -EINVAL;
636a5d36 8029
19957bb3
JB		 8030 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8031 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8032
8033 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8034 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8035 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8036 }
8037
19957bb3 8038 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e 8039 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
4c476991 8040 return -EINVAL;
636a5d36 8041
63181060
JM		 8042 if ((auth_type == NL80211_AUTHTYPE_SAE ||
8043 auth_type == NL80211_AUTHTYPE_FILS_SK ||
8044 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
8045 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
11b6b5a4 8046 !info->attrs[NL80211_ATTR_AUTH_DATA])
e39e5b5e
JM		 8047 return -EINVAL;
8048
11b6b5a4 8049 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
63181060
JM		 8050 if (auth_type != NL80211_AUTHTYPE_SAE &&
8051 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8052 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8053 auth_type != NL80211_AUTHTYPE_FILS_PK)
e39e5b5e 8054 return -EINVAL;
11b6b5a4
JM		 8055 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8056 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
e39e5b5e 8057 /* need to include at least Auth Transaction and Status Code */
11b6b5a4 8058 if (auth_data_len < 4)
e39e5b5e
JM		 8059 return -EINVAL;
8060 }
8061
d5cdfacb
JM		 8062 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8063
95de817b
JB		 8064 /*
8065 * Since we no longer track auth state, ignore
8066 * requests to only change local state.
8067 */
8068 if (local_state_change)
8069 return 0;
8070
91bf9b26
JB		 8071 wdev_lock(dev->ieee80211_ptr);
8072 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8073 ssid, ssid_len, ie, ie_len,
8074 key.p.key, key.p.key_len, key.idx,
11b6b5a4 8075 auth_data, auth_data_len);
91bf9b26
JB		 8076 wdev_unlock(dev->ieee80211_ptr);
8077 return err;
636a5d36
JM		 8078}
8079
c0692b8f
JB		 8080static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8081 struct genl_info *info,
3dc27d25
JB		 8082 struct cfg80211_crypto_settings *settings,
8083 int cipher_limit)
b23aa676 8084{
c0b2bbd8
JB		 8085 memset(settings, 0, sizeof(*settings));
8086
b23aa676
SO		 8087 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
8088
c0692b8f
JB		 8089 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
8090 u16 proto;
7a087e74 8091
c0692b8f
JB		 8092 proto = nla_get_u16(
8093 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
8094 settings->control_port_ethertype = cpu_to_be16(proto);
8095 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
8096 proto != ETH_P_PAE)
8097 return -EINVAL;
8098 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
8099 settings->control_port_no_encrypt = true;
8100 } else
8101 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
8102
b23aa676
SO		 8103 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
8104 void *data;
8105 int len, i;
8106
8107 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8108 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8109 settings->n_ciphers_pairwise = len / sizeof(u32);
8110
8111 if (len % sizeof(u32))
8112 return -EINVAL;
8113
3dc27d25 8114 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 8115 return -EINVAL;
8116
8117 memcpy(settings->ciphers_pairwise, data, len);
8118
8119 for (i = 0; i < settings->n_ciphers_pairwise; i++)
38ba3c57
JM		 8120 if (!cfg80211_supported_cipher_suite(
8121 &rdev->wiphy,
b23aa676
SO		 8122 settings->ciphers_pairwise[i]))
8123 return -EINVAL;
8124 }
8125
8126 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
8127 settings->cipher_group =
8128 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
38ba3c57
JM		 8129 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
8130 settings->cipher_group))
b23aa676
SO		 8131 return -EINVAL;
8132 }
8133
8134 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
8135 settings->wpa_versions =
8136 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
8137 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
8138 return -EINVAL;
8139 }
8140
8141 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
8142 void *data;
6d30240e 8143 int len;
b23aa676
SO		 8144
8145 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
8146 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
8147 settings->n_akm_suites = len / sizeof(u32);
8148
8149 if (len % sizeof(u32))
8150 return -EINVAL;
8151
1b9ca027
JM		 8152 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
8153 return -EINVAL;
8154
b23aa676 8155 memcpy(settings->akm_suites, data, len);
b23aa676
SO		 8156 }
8157
8158 return 0;
8159}
8160
636a5d36
JM		 8161static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
8162{
4c476991
JB		 8163 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8164 struct net_device *dev = info->user_ptr[1];
f444de05 8165 struct ieee80211_channel *chan;
f62fab73
JB		 8166 struct cfg80211_assoc_request req = {};
8167 const u8 *bssid, *ssid;
8168 int err, ssid_len = 0;
636a5d36 8169
f4a11bb0
JB		 8170 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8171 return -EINVAL;
8172
8173 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 8174 !info->attrs[NL80211_ATTR_SSID] ||
8175 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 8176 return -EINVAL;
8177
4c476991
JB		 8178 if (!rdev->ops->assoc)
8179 return -EOPNOTSUPP;
636a5d36 8180
074ac8df 8181 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8182 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8183 return -EOPNOTSUPP;
eec60b03 8184
19957bb3 8185 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8186
664834de
JM		 8187 chan = nl80211_get_valid_chan(&rdev->wiphy,
8188 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8189 if (!chan)
4c476991 8190 return -EINVAL;
636a5d36 8191
19957bb3
JB		 8192 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8193 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8194
8195 if (info->attrs[NL80211_ATTR_IE]) {
f62fab73
JB		 8196 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8197 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8198 }
8199
dc6382ce 8200 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 8201 enum nl80211_mfp mfp =
dc6382ce 8202 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 8203 if (mfp == NL80211_MFP_REQUIRED)
f62fab73 8204 req.use_mfp = true;
4c476991
JB		 8205 else if (mfp != NL80211_MFP_NO)
8206 return -EINVAL;
dc6382ce
JM		 8207 }
8208
3e5d7649 8209 if (info->attrs[NL80211_ATTR_PREV_BSSID])
f62fab73 8210 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3e5d7649 8211
7e7c8926 8212 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
f62fab73 8213 req.flags |= ASSOC_REQ_DISABLE_HT;
7e7c8926
BG		 8214
8215 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
f62fab73
JB		 8216 memcpy(&req.ht_capa_mask,
8217 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8218 sizeof(req.ht_capa_mask));
7e7c8926
BG		 8219
8220 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
f62fab73 8221 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7e7c8926 8222 return -EINVAL;
f62fab73
JB		 8223 memcpy(&req.ht_capa,
8224 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8225 sizeof(req.ht_capa));
7e7c8926
BG		 8226 }
8227
ee2aca34 8228 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
f62fab73 8229 req.flags |= ASSOC_REQ_DISABLE_VHT;
ee2aca34
JB		 8230
8231 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
f62fab73
JB		 8232 memcpy(&req.vht_capa_mask,
8233 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8234 sizeof(req.vht_capa_mask));
ee2aca34
JB		 8235
8236 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
f62fab73 8237 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
ee2aca34 8238 return -EINVAL;
f62fab73
JB		 8239 memcpy(&req.vht_capa,
8240 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8241 sizeof(req.vht_capa));
ee2aca34
JB		 8242 }
8243
bab5ab7d 8244 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8245 if (!((rdev->wiphy.features &
8246 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8247 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8248 !wiphy_ext_feature_isset(&rdev->wiphy,
8249 NL80211_EXT_FEATURE_RRM))
bab5ab7d
AK		 8250 return -EINVAL;
8251 req.flags |= ASSOC_REQ_USE_RRM;
8252 }
8253
348bd456
JM		 8254 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
8255 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
8256 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
8257 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
8258 return -EINVAL;
8259 req.fils_nonces =
8260 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
8261 }
8262
f62fab73 8263 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
91bf9b26
JB		 8264 if (!err) {
8265 wdev_lock(dev->ieee80211_ptr);
bd2522b1 8266
f62fab73
JB		 8267 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
8268 ssid, ssid_len, &req);
bd2522b1
AZ		 8269
8270 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8271 dev->ieee80211_ptr->conn_owner_nlportid =
8272 info->snd_portid;
8273 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8274 bssid, ETH_ALEN);
8275 }
8276
91bf9b26
JB		 8277 wdev_unlock(dev->ieee80211_ptr);
8278 }
636a5d36 8279
636a5d36
JM		 8280 return err;
8281}
8282
8283static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
8284{
4c476991
JB		 8285 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8286 struct net_device *dev = info->user_ptr[1];
19957bb3 8287 const u8 *ie = NULL, *bssid;
91bf9b26 8288 int ie_len = 0, err;
19957bb3 8289 u16 reason_code;
d5cdfacb 8290 bool local_state_change;
636a5d36 8291
f4a11bb0
JB		 8292 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8293 return -EINVAL;
8294
8295 if (!info->attrs[NL80211_ATTR_MAC])
8296 return -EINVAL;
8297
8298 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8299 return -EINVAL;
8300
4c476991
JB		 8301 if (!rdev->ops->deauth)
8302 return -EOPNOTSUPP;
636a5d36 8303
074ac8df 8304 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8305 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8306 return -EOPNOTSUPP;
eec60b03 8307
19957bb3 8308 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8309
19957bb3
JB		 8310 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8311 if (reason_code == 0) {
f4a11bb0 8312 /* Reason Code 0 is reserved */
4c476991 8313 return -EINVAL;
255e737e 8314 }
636a5d36
JM		 8315
8316 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8317 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8318 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8319 }
8320
d5cdfacb
JM		 8321 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8322
91bf9b26
JB		 8323 wdev_lock(dev->ieee80211_ptr);
8324 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
8325 local_state_change);
8326 wdev_unlock(dev->ieee80211_ptr);
8327 return err;
636a5d36
JM		 8328}
8329
8330static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
8331{
4c476991
JB		 8332 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8333 struct net_device *dev = info->user_ptr[1];
19957bb3 8334 const u8 *ie = NULL, *bssid;
91bf9b26 8335 int ie_len = 0, err;
19957bb3 8336 u16 reason_code;
d5cdfacb 8337 bool local_state_change;
636a5d36 8338
f4a11bb0
JB		 8339 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8340 return -EINVAL;
8341
8342 if (!info->attrs[NL80211_ATTR_MAC])
8343 return -EINVAL;
8344
8345 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8346 return -EINVAL;
8347
4c476991
JB		 8348 if (!rdev->ops->disassoc)
8349 return -EOPNOTSUPP;
636a5d36 8350
074ac8df 8351 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8352 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8353 return -EOPNOTSUPP;
eec60b03 8354
19957bb3 8355 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8356
19957bb3
JB		 8357 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8358 if (reason_code == 0) {
f4a11bb0 8359 /* Reason Code 0 is reserved */
4c476991 8360 return -EINVAL;
255e737e 8361 }
636a5d36
JM		 8362
8363 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8364 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8365 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8366 }
8367
d5cdfacb
JM		 8368 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8369
91bf9b26
JB		 8370 wdev_lock(dev->ieee80211_ptr);
8371 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
8372 local_state_change);
8373 wdev_unlock(dev->ieee80211_ptr);
8374 return err;
636a5d36
JM		 8375}
8376
dd5b4cc7
FF		 8377static bool
8378nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
57fbcce3 8379 int mcast_rate[NUM_NL80211_BANDS],
dd5b4cc7
FF		 8380 int rateval)
8381{
8382 struct wiphy *wiphy = &rdev->wiphy;
8383 bool found = false;
8384 int band, i;
8385
57fbcce3 8386 for (band = 0; band < NUM_NL80211_BANDS; band++) {
dd5b4cc7
FF		 8387 struct ieee80211_supported_band *sband;
8388
8389 sband = wiphy->bands[band];
8390 if (!sband)
8391 continue;
8392
8393 for (i = 0; i < sband->n_bitrates; i++) {
8394 if (sband->bitrates[i].bitrate == rateval) {
8395 mcast_rate[band] = i + 1;
8396 found = true;
8397 break;
8398 }
8399 }
8400 }
8401
8402 return found;
8403}
8404
04a773ad
JB		 8405static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
8406{
4c476991
JB		 8407 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8408 struct net_device *dev = info->user_ptr[1];
04a773ad
JB		 8409 struct cfg80211_ibss_params ibss;
8410 struct wiphy *wiphy;
fffd0934 8411 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 8412 int err;
8413
8e30bc55
JB		 8414 memset(&ibss, 0, sizeof(ibss));
8415
04a773ad
JB		 8416 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8417 return -EINVAL;
8418
683b6d3b 8419 if (!info->attrs[NL80211_ATTR_SSID] ||
04a773ad
JB		 8420 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8421 return -EINVAL;
8422
8e30bc55
JB		 8423 ibss.beacon_interval = 100;
8424
12d20fc9 8425 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
8e30bc55
JB		 8426 ibss.beacon_interval =
8427 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 8428
0c317a02
PK		 8429 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
8430 ibss.beacon_interval);
12d20fc9
PK		 8431 if (err)
8432 return err;
8e30bc55 8433
4c476991
JB		 8434 if (!rdev->ops->join_ibss)
8435 return -EOPNOTSUPP;
04a773ad 8436
4c476991
JB		 8437 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8438 return -EOPNOTSUPP;
04a773ad 8439
79c97e97 8440 wiphy = &rdev->wiphy;
04a773ad 8441
39193498 8442 if (info->attrs[NL80211_ATTR_MAC]) {
04a773ad 8443 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
39193498
JB		 8444
8445 if (!is_valid_ether_addr(ibss.bssid))
8446 return -EINVAL;
8447 }
04a773ad
JB		 8448 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8449 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8450
8451 if (info->attrs[NL80211_ATTR_IE]) {
8452 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8453 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8454 }
8455
683b6d3b
JB		 8456 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
8457 if (err)
8458 return err;
04a773ad 8459
174e0cd2
IP		 8460 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
8461 NL80211_IFTYPE_ADHOC))
54858ee5
AS		 8462 return -EINVAL;
8463
2f301ab2 8464 switch (ibss.chandef.width) {
bf372645
SW		 8465 case NL80211_CHAN_WIDTH_5:
8466 case NL80211_CHAN_WIDTH_10:
2f301ab2
SW		 8467 case NL80211_CHAN_WIDTH_20_NOHT:
8468 break;
8469 case NL80211_CHAN_WIDTH_20:
8470 case NL80211_CHAN_WIDTH_40:
ffc11991
JD		 8471 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8472 return -EINVAL;
8473 break;
8474 case NL80211_CHAN_WIDTH_80:
8475 case NL80211_CHAN_WIDTH_80P80:
8476 case NL80211_CHAN_WIDTH_160:
8477 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8478 return -EINVAL;
8479 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8480 NL80211_EXT_FEATURE_VHT_IBSS))
8481 return -EINVAL;
8482 break;
2f301ab2 8483 default:
c04d6150 8484 return -EINVAL;
2f301ab2 8485 }
db9c64cf 8486
04a773ad 8487 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 8488 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
8489
fbd2c8dc
TP		 8490 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8491 u8 *rates =
8492 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8493 int n_rates =
8494 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8495 struct ieee80211_supported_band *sband =
683b6d3b 8496 wiphy->bands[ibss.chandef.chan->band];
fbd2c8dc 8497
34850ab2
JB		 8498 err = ieee80211_get_ratemask(sband, rates, n_rates,
8499 &ibss.basic_rates);
8500 if (err)
8501 return err;
fbd2c8dc 8502 }
dd5b4cc7 8503
803768f5
SW		 8504 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8505 memcpy(&ibss.ht_capa_mask,
8506 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8507 sizeof(ibss.ht_capa_mask));
8508
8509 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
8510 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8511 return -EINVAL;
8512 memcpy(&ibss.ht_capa,
8513 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8514 sizeof(ibss.ht_capa));
8515 }
8516
dd5b4cc7
FF		 8517 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8518 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
8519 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8520 return -EINVAL;
fbd2c8dc 8521
4c476991 8522 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
de7044ee
SM		 8523 bool no_ht = false;
8524
4c476991 8525 connkeys = nl80211_parse_connkeys(rdev,
de7044ee
SM		 8526 info->attrs[NL80211_ATTR_KEYS],
8527 &no_ht);
4c476991
JB		 8528 if (IS_ERR(connkeys))
8529 return PTR_ERR(connkeys);
de7044ee 8530
3d9d1d66
JB		 8531 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
8532 no_ht) {
5e950a78 8533 kzfree(connkeys);
de7044ee
SM		 8534 return -EINVAL;
8535 }
4c476991 8536 }
04a773ad 8537
267335d6
AQ		 8538 ibss.control_port =
8539 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
8540
5336fa88
SW		 8541 ibss.userspace_handles_dfs =
8542 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
8543
4c476991 8544 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
fffd0934 8545 if (err)
b47f610b 8546 kzfree(connkeys);
04a773ad
JB		 8547 return err;
8548}
8549
8550static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
8551{
4c476991
JB		 8552 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8553 struct net_device *dev = info->user_ptr[1];
04a773ad 8554
4c476991
JB		 8555 if (!rdev->ops->leave_ibss)
8556 return -EOPNOTSUPP;
04a773ad 8557
4c476991
JB		 8558 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8559 return -EOPNOTSUPP;
04a773ad 8560
4c476991 8561 return cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 8562}
8563
f4e583c8
AQ		 8564static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
8565{
8566 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8567 struct net_device *dev = info->user_ptr[1];
57fbcce3 8568 int mcast_rate[NUM_NL80211_BANDS];
f4e583c8
AQ		 8569 u32 nla_rate;
8570 int err;
8571
8572 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
876dc930
BVB		 8573 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
8574 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
f4e583c8
AQ		 8575 return -EOPNOTSUPP;
8576
8577 if (!rdev->ops->set_mcast_rate)
8578 return -EOPNOTSUPP;
8579
8580 memset(mcast_rate, 0, sizeof(mcast_rate));
8581
8582 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
8583 return -EINVAL;
8584
8585 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
8586 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
8587 return -EINVAL;
8588
a1056b1b 8589 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
f4e583c8
AQ		 8590
8591 return err;
8592}
8593
ad7e718c
JB		 8594static struct sk_buff *
8595__cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
6c09e791
AK		 8596 struct wireless_dev *wdev, int approxlen,
8597 u32 portid, u32 seq, enum nl80211_commands cmd,
567ffc35
JB		 8598 enum nl80211_attrs attr,
8599 const struct nl80211_vendor_cmd_info *info,
8600 gfp_t gfp)
ad7e718c
JB		 8601{
8602 struct sk_buff *skb;
8603 void *hdr;
8604 struct nlattr *data;
8605
8606 skb = nlmsg_new(approxlen + 100, gfp);
8607 if (!skb)
8608 return NULL;
8609
8610 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
8611 if (!hdr) {
8612 kfree_skb(skb);
8613 return NULL;
8614 }
8615
8616 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
8617 goto nla_put_failure;
567ffc35
JB		 8618
8619 if (info) {
8620 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
8621 info->vendor_id))
8622 goto nla_put_failure;
8623 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
8624 info->subcmd))
8625 goto nla_put_failure;
8626 }
8627
6c09e791 8628 if (wdev) {
2dad624e
ND		 8629 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
8630 wdev_id(wdev), NL80211_ATTR_PAD))
6c09e791
AK		 8631 goto nla_put_failure;
8632 if (wdev->netdev &&
8633 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
8634 wdev->netdev->ifindex))
8635 goto nla_put_failure;
8636 }
8637
ad7e718c 8638 data = nla_nest_start(skb, attr);
76e1fb4b
JB		 8639 if (!data)
8640 goto nla_put_failure;
ad7e718c
JB		 8641
8642 ((void **)skb->cb)[0] = rdev;
8643 ((void **)skb->cb)[1] = hdr;
8644 ((void **)skb->cb)[2] = data;
8645
8646 return skb;
8647
8648 nla_put_failure:
8649 kfree_skb(skb);
8650 return NULL;
8651}
f4e583c8 8652
e03ad6ea 8653struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
6c09e791 8654 struct wireless_dev *wdev,
e03ad6ea
JB		 8655 enum nl80211_commands cmd,
8656 enum nl80211_attrs attr,
8657 int vendor_event_idx,
8658 int approxlen, gfp_t gfp)
8659{
f26cbf40 8660 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
e03ad6ea
JB		 8661 const struct nl80211_vendor_cmd_info *info;
8662
8663 switch (cmd) {
8664 case NL80211_CMD_TESTMODE:
8665 if (WARN_ON(vendor_event_idx != -1))
8666 return NULL;
8667 info = NULL;
8668 break;
8669 case NL80211_CMD_VENDOR:
8670 if (WARN_ON(vendor_event_idx < 0 ||
8671 vendor_event_idx >= wiphy->n_vendor_events))
8672 return NULL;
8673 info = &wiphy->vendor_events[vendor_event_idx];
8674 break;
8675 default:
8676 WARN_ON(1);
8677 return NULL;
8678 }
8679
6c09e791 8680 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, 0, 0,
e03ad6ea
JB		 8681 cmd, attr, info, gfp);
8682}
8683EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
8684
8685void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
8686{
8687 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
8688 void *hdr = ((void **)skb->cb)[1];
8689 struct nlattr *data = ((void **)skb->cb)[2];
8690 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
8691
bd8c78e7
JB		 8692 /* clear CB data for netlink core to own from now on */
8693 memset(skb->cb, 0, sizeof(skb->cb));
8694
e03ad6ea
JB		 8695 nla_nest_end(skb, data);
8696 genlmsg_end(skb, hdr);
8697
8698 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
8699 mcgrp = NL80211_MCGRP_VENDOR;
8700
8701 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
8702 mcgrp, gfp);
8703}
8704EXPORT_SYMBOL(__cfg80211_send_event_skb);
8705
aff89a9b 8706#ifdef CONFIG_NL80211_TESTMODE
aff89a9b
JB		 8707static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
8708{
4c476991 8709 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fc73f11f
DS		 8710 struct wireless_dev *wdev =
8711 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
aff89a9b
JB		 8712 int err;
8713
fc73f11f
DS		 8714 if (!rdev->ops->testmode_cmd)
8715 return -EOPNOTSUPP;
8716
8717 if (IS_ERR(wdev)) {
8718 err = PTR_ERR(wdev);
8719 if (err != -EINVAL)
8720 return err;
8721 wdev = NULL;
8722 } else if (wdev->wiphy != &rdev->wiphy) {
8723 return -EINVAL;
8724 }
8725
aff89a9b
JB		 8726 if (!info->attrs[NL80211_ATTR_TESTDATA])
8727 return -EINVAL;
8728
ad7e718c 8729 rdev->cur_cmd_info = info;
fc73f11f 8730 err = rdev_testmode_cmd(rdev, wdev,
aff89a9b
JB		 8731 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
8732 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
ad7e718c 8733 rdev->cur_cmd_info = NULL;
aff89a9b 8734
aff89a9b
JB		 8735 return err;
8736}
8737
71063f0e
WYG		 8738static int nl80211_testmode_dump(struct sk_buff *skb,
8739 struct netlink_callback *cb)
8740{
00918d33 8741 struct cfg80211_registered_device *rdev;
71063f0e
WYG		 8742 int err;
8743 long phy_idx;
8744 void *data = NULL;
8745 int data_len = 0;
8746
5fe231e8
JB		 8747 rtnl_lock();
8748
71063f0e
WYG		 8749 if (cb->args[0]) {
8750 /*
8751 * 0 is a valid index, but not valid for args[0],
8752 * so we need to offset by 1.
8753 */
8754 phy_idx = cb->args[0] - 1;
a4956dca
LC		 8755
8756 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
8757 if (!rdev) {
8758 err = -ENOENT;
8759 goto out_err;
8760 }
71063f0e 8761 } else {
c90c39da
JB		 8762 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
8763
71063f0e 8764 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
fceb6435
JB		 8765 attrbuf, nl80211_fam.maxattr,
8766 nl80211_policy, NULL);
71063f0e 8767 if (err)
5fe231e8 8768 goto out_err;
00918d33 8769
c90c39da 8770 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
2bd7e35d 8771 if (IS_ERR(rdev)) {
5fe231e8
JB		 8772 err = PTR_ERR(rdev);
8773 goto out_err;
00918d33 8774 }
2bd7e35d 8775 phy_idx = rdev->wiphy_idx;
2bd7e35d 8776
c90c39da
JB		 8777 if (attrbuf[NL80211_ATTR_TESTDATA])
8778 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
71063f0e
WYG		 8779 }
8780
8781 if (cb->args[1]) {
8782 data = nla_data((void *)cb->args[1]);
8783 data_len = nla_len((void *)cb->args[1]);
8784 }
8785
00918d33 8786 if (!rdev->ops->testmode_dump) {
71063f0e
WYG		 8787 err = -EOPNOTSUPP;
8788 goto out_err;
8789 }
8790
8791 while (1) {
15e47304 8792 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
71063f0e
WYG		 8793 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8794 NL80211_CMD_TESTMODE);
8795 struct nlattr *tmdata;
8796
cb35fba3
DC		 8797 if (!hdr)
8798 break;
8799
9360ffd1 8800 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
71063f0e
WYG		 8801 genlmsg_cancel(skb, hdr);
8802 break;
8803 }
8804
8805 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
8806 if (!tmdata) {
8807 genlmsg_cancel(skb, hdr);
8808 break;
8809 }
e35e4d28 8810 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
71063f0e
WYG		 8811 nla_nest_end(skb, tmdata);
8812
8813 if (err == -ENOBUFS || err == -ENOENT) {
8814 genlmsg_cancel(skb, hdr);
8815 break;
8816 } else if (err) {
8817 genlmsg_cancel(skb, hdr);
8818 goto out_err;
8819 }
8820
8821 genlmsg_end(skb, hdr);
8822 }
8823
8824 err = skb->len;
8825 /* see above */
8826 cb->args[0] = phy_idx + 1;
8827 out_err:
5fe231e8 8828 rtnl_unlock();
71063f0e
WYG		 8829 return err;
8830}
aff89a9b
JB		 8831#endif
8832
b23aa676
SO		 8833static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
8834{
4c476991
JB		 8835 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8836 struct net_device *dev = info->user_ptr[1];
b23aa676
SO		 8837 struct cfg80211_connect_params connect;
8838 struct wiphy *wiphy;
fffd0934 8839 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 8840 int err;
8841
8842 memset(&connect, 0, sizeof(connect));
8843
8844 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8845 return -EINVAL;
8846
8847 if (!info->attrs[NL80211_ATTR_SSID] ||
8848 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8849 return -EINVAL;
8850
8851 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
8852 connect.auth_type =
8853 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 8854 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
8855 NL80211_CMD_CONNECT))
b23aa676
SO		 8856 return -EINVAL;
8857 } else
8858 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
8859
8860 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
8861
c0692b8f 8862 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
3dc27d25 8863 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 8864 if (err)
8865 return err;
b23aa676 8866
074ac8df 8867 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8868 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8869 return -EOPNOTSUPP;
b23aa676 8870
79c97e97 8871 wiphy = &rdev->wiphy;
b23aa676 8872
4486ea98
BS		 8873 connect.bg_scan_period = -1;
8874 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
8875 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
8876 connect.bg_scan_period =
8877 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
8878 }
8879
b23aa676
SO		 8880 if (info->attrs[NL80211_ATTR_MAC])
8881 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1df4a510
JM		 8882 else if (info->attrs[NL80211_ATTR_MAC_HINT])
8883 connect.bssid_hint =
8884 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
b23aa676
SO		 8885 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8886 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8887
8888 if (info->attrs[NL80211_ATTR_IE]) {
8889 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8890 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8891 }
8892
cee00a95
JM		 8893 if (info->attrs[NL80211_ATTR_USE_MFP]) {
8894 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
8895 if (connect.mfp != NL80211_MFP_REQUIRED &&
8896 connect.mfp != NL80211_MFP_NO)
8897 return -EINVAL;
8898 } else {
8899 connect.mfp = NL80211_MFP_NO;
8900 }
8901
ba6fbacf
JM		 8902 if (info->attrs[NL80211_ATTR_PREV_BSSID])
8903 connect.prev_bssid =
8904 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
8905
b23aa676 8906 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
664834de
JM		 8907 connect.channel = nl80211_get_valid_chan(
8908 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8909 if (!connect.channel)
1df4a510
JM		 8910 return -EINVAL;
8911 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
664834de
JM		 8912 connect.channel_hint = nl80211_get_valid_chan(
8913 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
8914 if (!connect.channel_hint)
4c476991 8915 return -EINVAL;
b23aa676
SO		 8916 }
8917
fffd0934
JB		 8918 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
8919 connkeys = nl80211_parse_connkeys(rdev,
de7044ee 8920 info->attrs[NL80211_ATTR_KEYS], NULL);
4c476991
JB		 8921 if (IS_ERR(connkeys))
8922 return PTR_ERR(connkeys);
fffd0934
JB		 8923 }
8924
7e7c8926
BG		 8925 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
8926 connect.flags |= ASSOC_REQ_DISABLE_HT;
8927
8928 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8929 memcpy(&connect.ht_capa_mask,
8930 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8931 sizeof(connect.ht_capa_mask));
8932
8933 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
b4e4f47e 8934 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
b47f610b 8935 kzfree(connkeys);
7e7c8926 8936 return -EINVAL;
b4e4f47e 8937 }
7e7c8926
BG		 8938 memcpy(&connect.ht_capa,
8939 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8940 sizeof(connect.ht_capa));
8941 }
8942
ee2aca34
JB		 8943 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
8944 connect.flags |= ASSOC_REQ_DISABLE_VHT;
8945
8946 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
8947 memcpy(&connect.vht_capa_mask,
8948 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8949 sizeof(connect.vht_capa_mask));
8950
8951 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
8952 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
b47f610b 8953 kzfree(connkeys);
ee2aca34
JB		 8954 return -EINVAL;
8955 }
8956 memcpy(&connect.vht_capa,
8957 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8958 sizeof(connect.vht_capa));
8959 }
8960
bab5ab7d 8961 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8962 if (!((rdev->wiphy.features &
8963 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8964 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8965 !wiphy_ext_feature_isset(&rdev->wiphy,
8966 NL80211_EXT_FEATURE_RRM)) {
707554b4 8967 kzfree(connkeys);
bab5ab7d 8968 return -EINVAL;
707554b4 8969 }
bab5ab7d
AK		 8970 connect.flags |= ASSOC_REQ_USE_RRM;
8971 }
8972
34d50519 8973 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
57fbcce3 8974 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
34d50519
LD		 8975 kzfree(connkeys);
8976 return -EOPNOTSUPP;
8977 }
8978
38de03d2
AS		 8979 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
8980 /* bss selection makes no sense if bssid is set */
8981 if (connect.bssid) {
8982 kzfree(connkeys);
8983 return -EINVAL;
8984 }
8985
8986 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
8987 wiphy, &connect.bss_select);
8988 if (err) {
8989 kzfree(connkeys);
8990 return err;
8991 }
8992 }
8993
a3caf744
VK		 8994 if (wiphy_ext_feature_isset(&rdev->wiphy,
8995 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
8996 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
8997 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
8998 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
8999 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9000 connect.fils_erp_username =
9001 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9002 connect.fils_erp_username_len =
9003 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9004 connect.fils_erp_realm =
9005 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9006 connect.fils_erp_realm_len =
9007 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9008 connect.fils_erp_next_seq_num =
9009 nla_get_u16(
9010 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9011 connect.fils_erp_rrk =
9012 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9013 connect.fils_erp_rrk_len =
9014 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9015 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9016 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9017 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9018 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9019 kzfree(connkeys);
9020 return -EINVAL;
9021 }
9022
83739b03 9023 wdev_lock(dev->ieee80211_ptr);
bd2522b1 9024
4ce2bd9c
JM		 9025 err = cfg80211_connect(rdev, dev, &connect, connkeys,
9026 connect.prev_bssid);
fffd0934 9027 if (err)
b47f610b 9028 kzfree(connkeys);
bd2522b1
AZ		 9029
9030 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9031 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9032 if (connect.bssid)
9033 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9034 connect.bssid, ETH_ALEN);
9035 else
9036 memset(dev->ieee80211_ptr->disconnect_bssid,
9037 0, ETH_ALEN);
9038 }
9039
9040 wdev_unlock(dev->ieee80211_ptr);
9041
b23aa676
SO		 9042 return err;
9043}
9044
088e8df8 9045static int nl80211_update_connect_params(struct sk_buff *skb,
9046 struct genl_info *info)
9047{
9048 struct cfg80211_connect_params connect = {};
9049 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9050 struct net_device *dev = info->user_ptr[1];
9051 struct wireless_dev *wdev = dev->ieee80211_ptr;
9052 u32 changed = 0;
9053 int ret;
9054
9055 if (!rdev->ops->update_connect_params)
9056 return -EOPNOTSUPP;
9057
9058 if (info->attrs[NL80211_ATTR_IE]) {
9059 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9060 return -EINVAL;
9061 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9062 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9063 changed |= UPDATE_ASSOC_IES;
9064 }
9065
9066 wdev_lock(dev->ieee80211_ptr);
9067 if (!wdev->current_bss)
9068 ret = -ENOLINK;
9069 else
9070 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
9071 wdev_unlock(dev->ieee80211_ptr);
9072
9073 return ret;
9074}
9075
b23aa676
SO		 9076static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
9077{
4c476991
JB		 9078 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9079 struct net_device *dev = info->user_ptr[1];
b23aa676 9080 u16 reason;
83739b03 9081 int ret;
b23aa676
SO		 9082
9083 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9084 reason = WLAN_REASON_DEAUTH_LEAVING;
9085 else
9086 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9087
9088 if (reason == 0)
9089 return -EINVAL;
9090
074ac8df 9091 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9092 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9093 return -EOPNOTSUPP;
b23aa676 9094
83739b03
JB		 9095 wdev_lock(dev->ieee80211_ptr);
9096 ret = cfg80211_disconnect(rdev, dev, reason, true);
9097 wdev_unlock(dev->ieee80211_ptr);
9098 return ret;
b23aa676
SO		 9099}
9100
463d0183
JB		 9101static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
9102{
4c476991 9103 struct cfg80211_registered_device *rdev = info->user_ptr[0];
463d0183
JB		 9104 struct net *net;
9105 int err;
463d0183 9106
4b681c82
VK		 9107 if (info->attrs[NL80211_ATTR_PID]) {
9108 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
9109
9110 net = get_net_ns_by_pid(pid);
9111 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
9112 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
463d0183 9113
4b681c82
VK		 9114 net = get_net_ns_by_fd(fd);
9115 } else {
9116 return -EINVAL;
9117 }
463d0183 9118
4c476991
JB		 9119 if (IS_ERR(net))
9120 return PTR_ERR(net);
463d0183
JB		 9121
9122 err = 0;
9123
9124 /* check if anything to do */
4c476991
JB		 9125 if (!net_eq(wiphy_net(&rdev->wiphy), net))
9126 err = cfg80211_switch_netns(rdev, net);
463d0183 9127
463d0183 9128 put_net(net);
463d0183
JB		 9129 return err;
9130}
9131
67fbb16b
SO		 9132static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
9133{
4c476991 9134 struct cfg80211_registered_device *rdev = info->user_ptr[0];
67fbb16b
SO		 9135 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
9136 struct cfg80211_pmksa *pmksa) = NULL;
4c476991 9137 struct net_device *dev = info->user_ptr[1];
67fbb16b
SO		 9138 struct cfg80211_pmksa pmksa;
9139
9140 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
9141
67fbb16b
SO		 9142 if (!info->attrs[NL80211_ATTR_PMKID])
9143 return -EINVAL;
9144
67fbb16b 9145 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
a3caf744
VK		 9146
9147 if (info->attrs[NL80211_ATTR_MAC]) {
9148 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9149 } else if (info->attrs[NL80211_ATTR_SSID] &&
9150 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
9151 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
9152 info->attrs[NL80211_ATTR_PMK])) {
9153 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9154 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9155 pmksa.cache_id =
9156 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
9157 } else {
9158 return -EINVAL;
9159 }
9160 if (info->attrs[NL80211_ATTR_PMK]) {
9161 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9162 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
9163 }
67fbb16b 9164
074ac8df 9165 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9166 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9167 return -EOPNOTSUPP;
67fbb16b
SO		 9168
9169 switch (info->genlhdr->cmd) {
9170 case NL80211_CMD_SET_PMKSA:
9171 rdev_ops = rdev->ops->set_pmksa;
9172 break;
9173 case NL80211_CMD_DEL_PMKSA:
9174 rdev_ops = rdev->ops->del_pmksa;
9175 break;
9176 default:
9177 WARN_ON(1);
9178 break;
9179 }
9180
4c476991
JB		 9181 if (!rdev_ops)
9182 return -EOPNOTSUPP;
67fbb16b 9183
4c476991 9184 return rdev_ops(&rdev->wiphy, dev, &pmksa);
67fbb16b
SO		 9185}
9186
9187static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
9188{
4c476991
JB		 9189 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9190 struct net_device *dev = info->user_ptr[1];
67fbb16b 9191
074ac8df 9192 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9193 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9194 return -EOPNOTSUPP;
67fbb16b 9195
4c476991
JB		 9196 if (!rdev->ops->flush_pmksa)
9197 return -EOPNOTSUPP;
67fbb16b 9198
e35e4d28 9199 return rdev_flush_pmksa(rdev, dev);
67fbb16b
SO		 9200}
9201
109086ce
AN		 9202static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
9203{
9204 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9205 struct net_device *dev = info->user_ptr[1];
9206 u8 action_code, dialog_token;
df942e7b 9207 u32 peer_capability = 0;
109086ce
AN		 9208 u16 status_code;
9209 u8 *peer;
31fa97c5 9210 bool initiator;
109086ce
AN		 9211
9212 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9213 !rdev->ops->tdls_mgmt)
9214 return -EOPNOTSUPP;
9215
9216 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
9217 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
9218 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
9219 !info->attrs[NL80211_ATTR_IE] ||
9220 !info->attrs[NL80211_ATTR_MAC])
9221 return -EINVAL;
9222
9223 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9224 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
9225 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
9226 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
31fa97c5 9227 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
df942e7b
SDU		 9228 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
9229 peer_capability =
9230 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
109086ce 9231
e35e4d28 9232 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
df942e7b 9233 dialog_token, status_code, peer_capability,
31fa97c5 9234 initiator,
e35e4d28
HG		 9235 nla_data(info->attrs[NL80211_ATTR_IE]),
9236 nla_len(info->attrs[NL80211_ATTR_IE]));
109086ce
AN		 9237}
9238
9239static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
9240{
9241 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9242 struct net_device *dev = info->user_ptr[1];
9243 enum nl80211_tdls_operation operation;
9244 u8 *peer;
9245
9246 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9247 !rdev->ops->tdls_oper)
9248 return -EOPNOTSUPP;
9249
9250 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
9251 !info->attrs[NL80211_ATTR_MAC])
9252 return -EINVAL;
9253
9254 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
9255 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9256
e35e4d28 9257 return rdev_tdls_oper(rdev, dev, peer, operation);
109086ce
AN		 9258}
9259
9588bbd5
JM		 9260static int nl80211_remain_on_channel(struct sk_buff *skb,
9261 struct genl_info *info)
9262{
4c476991 9263 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9264 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9265 struct cfg80211_chan_def chandef;
34373d12 9266 const struct cfg80211_chan_def *compat_chandef;
9588bbd5
JM		 9267 struct sk_buff *msg;
9268 void *hdr;
9269 u64 cookie;
683b6d3b 9270 u32 duration;
9588bbd5
JM		 9271 int err;
9272
9273 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9274 !info->attrs[NL80211_ATTR_DURATION])
9275 return -EINVAL;
9276
9277 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
9278
ebf348fc
JB		 9279 if (!rdev->ops->remain_on_channel ||
9280 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
9281 return -EOPNOTSUPP;
9282
9588bbd5 9283 /*
ebf348fc
JB		 9284 * We should be on that channel for at least a minimum amount of
9285 * time (10ms) but no longer than the driver supports.
9588bbd5 9286 */
ebf348fc 9287 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
a293911d 9288 duration > rdev->wiphy.max_remain_on_channel_duration)
9588bbd5
JM		 9289 return -EINVAL;
9290
683b6d3b
JB		 9291 err = nl80211_parse_chandef(rdev, info, &chandef);
9292 if (err)
9293 return err;
9588bbd5 9294
34373d12
VT		 9295 wdev_lock(wdev);
9296 if (!cfg80211_off_channel_oper_allowed(wdev) &&
9297 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
9298 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
9299 &chandef);
9300 if (compat_chandef != &chandef) {
9301 wdev_unlock(wdev);
9302 return -EBUSY;
9303 }
9304 }
9305 wdev_unlock(wdev);
9306
9588bbd5 9307 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9308 if (!msg)
9309 return -ENOMEM;
9588bbd5 9310
15e47304 9311 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9588bbd5 9312 NL80211_CMD_REMAIN_ON_CHANNEL);
cb35fba3
DC		 9313 if (!hdr) {
9314 err = -ENOBUFS;
9588bbd5
JM		 9315 goto free_msg;
9316 }
9317
683b6d3b
JB		 9318 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
9319 duration, &cookie);
9588bbd5
JM		 9320
9321 if (err)
9322 goto free_msg;
9323
2dad624e
ND		 9324 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9325 NL80211_ATTR_PAD))
9360ffd1 9326 goto nla_put_failure;
9588bbd5
JM		 9327
9328 genlmsg_end(msg, hdr);
4c476991
JB		 9329
9330 return genlmsg_reply(msg, info);
9588bbd5
JM		 9331
9332 nla_put_failure:
9333 err = -ENOBUFS;
9334 free_msg:
9335 nlmsg_free(msg);
9588bbd5
JM		 9336 return err;
9337}
9338
9339static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
9340 struct genl_info *info)
9341{
4c476991 9342 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9343 struct wireless_dev *wdev = info->user_ptr[1];
9588bbd5 9344 u64 cookie;
9588bbd5
JM		 9345
9346 if (!info->attrs[NL80211_ATTR_COOKIE])
9347 return -EINVAL;
9348
4c476991
JB		 9349 if (!rdev->ops->cancel_remain_on_channel)
9350 return -EOPNOTSUPP;
9588bbd5 9351
9588bbd5
JM		 9352 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9353
e35e4d28 9354 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
9588bbd5
JM		 9355}
9356
13ae75b1
JM		 9357static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
9358 struct genl_info *info)
9359{
13ae75b1 9360 struct cfg80211_bitrate_mask mask;
a7c7fbff 9361 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9362 struct net_device *dev = info->user_ptr[1];
a7c7fbff 9363 int err;
13ae75b1 9364
4c476991
JB		 9365 if (!rdev->ops->set_bitrate_mask)
9366 return -EOPNOTSUPP;
13ae75b1 9367
a7c7fbff
PK		 9368 err = nl80211_parse_tx_bitrate_mask(info, &mask);
9369 if (err)
9370 return err;
13ae75b1 9371
e35e4d28 9372 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
13ae75b1
JM		 9373}
9374
2e161f78 9375static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9376{
4c476991 9377 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9378 struct wireless_dev *wdev = info->user_ptr[1];
2e161f78 9379 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
026331c4
JM		 9380
9381 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
9382 return -EINVAL;
9383
2e161f78
JB		 9384 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
9385 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
026331c4 9386
71bbc994
JB		 9387 switch (wdev->iftype) {
9388 case NL80211_IFTYPE_STATION:
9389 case NL80211_IFTYPE_ADHOC:
9390 case NL80211_IFTYPE_P2P_CLIENT:
9391 case NL80211_IFTYPE_AP:
9392 case NL80211_IFTYPE_AP_VLAN:
9393 case NL80211_IFTYPE_MESH_POINT:
9394 case NL80211_IFTYPE_P2P_GO:
98104fde 9395 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9396 break;
cb3b7d87 9397 case NL80211_IFTYPE_NAN:
71bbc994 9398 default:
4c476991 9399 return -EOPNOTSUPP;
71bbc994 9400 }
026331c4
JM		 9401
9402 /* not much point in registering if we can't reply */
4c476991
JB		 9403 if (!rdev->ops->mgmt_tx)
9404 return -EOPNOTSUPP;
026331c4 9405
15e47304 9406 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
026331c4
JM		 9407 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
9408 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
026331c4
JM		 9409}
9410
2e161f78 9411static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9412{
4c476991 9413 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9414 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9415 struct cfg80211_chan_def chandef;
026331c4 9416 int err;
d64d373f 9417 void *hdr = NULL;
026331c4 9418 u64 cookie;
e247bd90 9419 struct sk_buff *msg = NULL;
b176e629
AO		 9420 struct cfg80211_mgmt_tx_params params = {
9421 .dont_wait_for_ack =
9422 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
9423 };
026331c4 9424
683b6d3b 9425 if (!info->attrs[NL80211_ATTR_FRAME])
026331c4
JM		 9426 return -EINVAL;
9427
4c476991
JB		 9428 if (!rdev->ops->mgmt_tx)
9429 return -EOPNOTSUPP;
026331c4 9430
71bbc994 9431 switch (wdev->iftype) {
ea141b75
AQ		 9432 case NL80211_IFTYPE_P2P_DEVICE:
9433 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9434 return -EINVAL;
71bbc994
JB		 9435 case NL80211_IFTYPE_STATION:
9436 case NL80211_IFTYPE_ADHOC:
9437 case NL80211_IFTYPE_P2P_CLIENT:
9438 case NL80211_IFTYPE_AP:
9439 case NL80211_IFTYPE_AP_VLAN:
9440 case NL80211_IFTYPE_MESH_POINT:
9441 case NL80211_IFTYPE_P2P_GO:
9442 break;
cb3b7d87 9443 case NL80211_IFTYPE_NAN:
71bbc994 9444 default:
4c476991 9445 return -EOPNOTSUPP;
71bbc994 9446 }
026331c4 9447
f7ca38df 9448 if (info->attrs[NL80211_ATTR_DURATION]) {
7c4ef712 9449 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
f7ca38df 9450 return -EINVAL;
b176e629 9451 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
ebf348fc
JB		 9452
9453 /*
9454 * We should wait on the channel for at least a minimum amount
9455 * of time (10ms) but no longer than the driver supports.
9456 */
b176e629
AO		 9457 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
9458 params.wait > rdev->wiphy.max_remain_on_channel_duration)
ebf348fc 9459 return -EINVAL;
f7ca38df
JB		 9460 }
9461
b176e629 9462 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
f7ca38df 9463
b176e629 9464 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7c4ef712
JB		 9465 return -EINVAL;
9466
b176e629 9467 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3 9468
ea141b75
AQ		 9469 /* get the channel if any has been specified, otherwise pass NULL to
9470 * the driver. The latter will use the current one
9471 */
9472 chandef.chan = NULL;
9473 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9474 err = nl80211_parse_chandef(rdev, info, &chandef);
9475 if (err)
9476 return err;
9477 }
9478
b176e629 9479 if (!chandef.chan && params.offchan)
ea141b75 9480 return -EINVAL;
026331c4 9481
34373d12
VT		 9482 wdev_lock(wdev);
9483 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
9484 wdev_unlock(wdev);
9485 return -EBUSY;
9486 }
9487 wdev_unlock(wdev);
9488
34d22ce2
AO		 9489 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
9490 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
9491
9492 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
9493 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9494 int i;
9495
9496 if (len % sizeof(u16))
9497 return -EINVAL;
9498
9499 params.n_csa_offsets = len / sizeof(u16);
9500 params.csa_offsets =
9501 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9502
9503 /* check that all the offsets fit the frame */
9504 for (i = 0; i < params.n_csa_offsets; i++) {
9505 if (params.csa_offsets[i] >= params.len)
9506 return -EINVAL;
9507 }
9508 }
9509
b176e629 9510 if (!params.dont_wait_for_ack) {
e247bd90
JB		 9511 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9512 if (!msg)
9513 return -ENOMEM;
026331c4 9514
15e47304 9515 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
e247bd90 9516 NL80211_CMD_FRAME);
cb35fba3
DC		 9517 if (!hdr) {
9518 err = -ENOBUFS;
e247bd90
JB		 9519 goto free_msg;
9520 }
026331c4 9521 }
e247bd90 9522
b176e629
AO		 9523 params.chan = chandef.chan;
9524 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
026331c4
JM		 9525 if (err)
9526 goto free_msg;
9527
e247bd90 9528 if (msg) {
2dad624e
ND		 9529 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9530 NL80211_ATTR_PAD))
9360ffd1 9531 goto nla_put_failure;
026331c4 9532
e247bd90
JB		 9533 genlmsg_end(msg, hdr);
9534 return genlmsg_reply(msg, info);
9535 }
9536
9537 return 0;
026331c4
JM		 9538
9539 nla_put_failure:
9540 err = -ENOBUFS;
9541 free_msg:
9542 nlmsg_free(msg);
026331c4
JM		 9543 return err;
9544}
9545
f7ca38df
JB		 9546static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
9547{
9548 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9549 struct wireless_dev *wdev = info->user_ptr[1];
f7ca38df
JB		 9550 u64 cookie;
9551
9552 if (!info->attrs[NL80211_ATTR_COOKIE])
9553 return -EINVAL;
9554
9555 if (!rdev->ops->mgmt_tx_cancel_wait)
9556 return -EOPNOTSUPP;
9557
71bbc994
JB		 9558 switch (wdev->iftype) {
9559 case NL80211_IFTYPE_STATION:
9560 case NL80211_IFTYPE_ADHOC:
9561 case NL80211_IFTYPE_P2P_CLIENT:
9562 case NL80211_IFTYPE_AP:
9563 case NL80211_IFTYPE_AP_VLAN:
9564 case NL80211_IFTYPE_P2P_GO:
98104fde 9565 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9566 break;
cb3b7d87 9567 case NL80211_IFTYPE_NAN:
71bbc994 9568 default:
f7ca38df 9569 return -EOPNOTSUPP;
71bbc994 9570 }
f7ca38df
JB		 9571
9572 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9573
e35e4d28 9574 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
f7ca38df
JB		 9575}
9576
ffb9eb3d
KV		 9577static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
9578{
4c476991 9579 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d 9580 struct wireless_dev *wdev;
4c476991 9581 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9582 u8 ps_state;
9583 bool state;
9584 int err;
9585
4c476991
JB		 9586 if (!info->attrs[NL80211_ATTR_PS_STATE])
9587 return -EINVAL;
ffb9eb3d
KV		 9588
9589 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
9590
4c476991
JB		 9591 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
9592 return -EINVAL;
ffb9eb3d
KV		 9593
9594 wdev = dev->ieee80211_ptr;
9595
4c476991
JB		 9596 if (!rdev->ops->set_power_mgmt)
9597 return -EOPNOTSUPP;
ffb9eb3d
KV		 9598
9599 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
9600
9601 if (state == wdev->ps)
4c476991 9602 return 0;
ffb9eb3d 9603
e35e4d28 9604 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
4c476991
JB		 9605 if (!err)
9606 wdev->ps = state;
ffb9eb3d
KV		 9607 return err;
9608}
9609
9610static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
9611{
4c476991 9612 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d
KV		 9613 enum nl80211_ps_state ps_state;
9614 struct wireless_dev *wdev;
4c476991 9615 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9616 struct sk_buff *msg;
9617 void *hdr;
9618 int err;
9619
ffb9eb3d
KV		 9620 wdev = dev->ieee80211_ptr;
9621
4c476991
JB		 9622 if (!rdev->ops->set_power_mgmt)
9623 return -EOPNOTSUPP;
ffb9eb3d
KV		 9624
9625 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9626 if (!msg)
9627 return -ENOMEM;
ffb9eb3d 9628
15e47304 9629 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ffb9eb3d
KV		 9630 NL80211_CMD_GET_POWER_SAVE);
9631 if (!hdr) {
4c476991 9632 err = -ENOBUFS;
ffb9eb3d
KV		 9633 goto free_msg;
9634 }
9635
9636 if (wdev->ps)
9637 ps_state = NL80211_PS_ENABLED;
9638 else
9639 ps_state = NL80211_PS_DISABLED;
9640
9360ffd1
DM		 9641 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
9642 goto nla_put_failure;
ffb9eb3d
KV		 9643
9644 genlmsg_end(msg, hdr);
4c476991 9645 return genlmsg_reply(msg, info);
ffb9eb3d 9646
4c476991 9647 nla_put_failure:
ffb9eb3d 9648 err = -ENOBUFS;
4c476991 9649 free_msg:
ffb9eb3d 9650 nlmsg_free(msg);
ffb9eb3d
KV		 9651 return err;
9652}
9653
94e860f1
JB		 9654static const struct nla_policy
9655nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
4a4b8169 9656 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
d6dc1a38
JO		 9657 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
9658 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
84f10708
TP		 9659 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
9660 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
9661 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
bee427b8 9662 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
d6dc1a38
JO		 9663};
9664
84f10708 9665static int nl80211_set_cqm_txe(struct genl_info *info,
d9d8b019 9666 u32 rate, u32 pkts, u32 intvl)
84f10708
TP		 9667{
9668 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84f10708 9669 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9670 struct wireless_dev *wdev = dev->ieee80211_ptr;
84f10708 9671
d9d8b019 9672 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
84f10708
TP		 9673 return -EINVAL;
9674
84f10708
TP		 9675 if (!rdev->ops->set_cqm_txe_config)
9676 return -EOPNOTSUPP;
9677
9678 if (wdev->iftype != NL80211_IFTYPE_STATION &&
9679 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9680 return -EOPNOTSUPP;
9681
e35e4d28 9682 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
84f10708
TP		 9683}
9684
4a4b8169
AZ		 9685static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
9686 struct net_device *dev)
9687{
9688 struct wireless_dev *wdev = dev->ieee80211_ptr;
9689 s32 last, low, high;
9690 u32 hyst;
9691 int i, n;
9692 int err;
9693
9694 /* RSSI reporting disabled? */
9695 if (!wdev->cqm_config)
9696 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
9697
9698 /*
9699 * Obtain current RSSI value if possible, if not and no RSSI threshold
9700 * event has been received yet, we should receive an event after a
9701 * connection is established and enough beacons received to calculate
9702 * the average.
9703 */
9704 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
9705 rdev->ops->get_station) {
9706 struct station_info sinfo;
9707 u8 *mac_addr;
9708
9709 mac_addr = wdev->current_bss->pub.bssid;
9710
9711 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
9712 if (err)
9713 return err;
9714
9715 if (sinfo.filled & BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
9716 wdev->cqm_config->last_rssi_event_value =
9717 (s8) sinfo.rx_beacon_signal_avg;
9718 }
9719
9720 last = wdev->cqm_config->last_rssi_event_value;
9721 hyst = wdev->cqm_config->rssi_hyst;
9722 n = wdev->cqm_config->n_rssi_thresholds;
9723
9724 for (i = 0; i < n; i++)
9725 if (last < wdev->cqm_config->rssi_thresholds[i])
9726 break;
9727
9728 low = i > 0 ?
9729 (wdev->cqm_config->rssi_thresholds[i - 1] - hyst) : S32_MIN;
9730 high = i < n ?
9731 (wdev->cqm_config->rssi_thresholds[i] + hyst - 1) : S32_MAX;
9732
9733 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
9734}
9735
d6dc1a38 9736static int nl80211_set_cqm_rssi(struct genl_info *info,
4a4b8169
AZ		 9737 const s32 *thresholds, int n_thresholds,
9738 u32 hysteresis)
d6dc1a38 9739{
4c476991 9740 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9741 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9742 struct wireless_dev *wdev = dev->ieee80211_ptr;
4a4b8169
AZ		 9743 int i, err;
9744 s32 prev = S32_MIN;
d6dc1a38 9745
4a4b8169
AZ		 9746 /* Check all values negative and sorted */
9747 for (i = 0; i < n_thresholds; i++) {
9748 if (thresholds[i] > 0 || thresholds[i] <= prev)
9749 return -EINVAL;
d6dc1a38 9750
4a4b8169
AZ		 9751 prev = thresholds[i];
9752 }
d6dc1a38 9753
074ac8df 9754 if (wdev->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9755 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9756 return -EOPNOTSUPP;
d6dc1a38 9757
4a4b8169
AZ		 9758 wdev_lock(wdev);
9759 cfg80211_cqm_config_free(wdev);
9760 wdev_unlock(wdev);
9761
9762 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
9763 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
9764 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
9765
9766 return rdev_set_cqm_rssi_config(rdev, dev,
9767 thresholds[0], hysteresis);
9768 }
9769
9770 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9771 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
9772 return -EOPNOTSUPP;
9773
9774 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
9775 n_thresholds = 0;
9776
9777 wdev_lock(wdev);
9778 if (n_thresholds) {
9779 struct cfg80211_cqm_config *cqm_config;
9780
9781 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
9782 n_thresholds * sizeof(s32), GFP_KERNEL);
9783 if (!cqm_config) {
9784 err = -ENOMEM;
9785 goto unlock;
9786 }
9787
9788 cqm_config->rssi_hyst = hysteresis;
9789 cqm_config->n_rssi_thresholds = n_thresholds;
9790 memcpy(cqm_config->rssi_thresholds, thresholds,
9791 n_thresholds * sizeof(s32));
9792
9793 wdev->cqm_config = cqm_config;
9794 }
9795
9796 err = cfg80211_cqm_rssi_update(rdev, dev);
9797
9798unlock:
9799 wdev_unlock(wdev);
9800
9801 return err;
d6dc1a38
JO		 9802}
9803
9804static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
9805{
9806 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
9807 struct nlattr *cqm;
9808 int err;
9809
9810 cqm = info->attrs[NL80211_ATTR_CQM];
1da5fcc8
JB		 9811 if (!cqm)
9812 return -EINVAL;
d6dc1a38
JO		 9813
9814 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
fe52145f 9815 nl80211_attr_cqm_policy, info->extack);
d6dc1a38 9816 if (err)
1da5fcc8 9817 return err;
d6dc1a38
JO		 9818
9819 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
9820 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
4a4b8169
AZ		 9821 const s32 *thresholds =
9822 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
9823 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
1da5fcc8 9824 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
d6dc1a38 9825
4a4b8169
AZ		 9826 if (len % 4)
9827 return -EINVAL;
9828
9829 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
9830 hysteresis);
1da5fcc8
JB		 9831 }
9832
9833 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
9834 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
9835 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
9836 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
9837 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
9838 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
9839
9840 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
9841 }
9842
9843 return -EINVAL;
d6dc1a38
JO		 9844}
9845
6e0bd6c3
RL		 9846static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
9847{
9848 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9849 struct net_device *dev = info->user_ptr[1];
9850 struct ocb_setup setup = {};
9851 int err;
9852
9853 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9854 if (err)
9855 return err;
9856
9857 return cfg80211_join_ocb(rdev, dev, &setup);
9858}
9859
9860static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
9861{
9862 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9863 struct net_device *dev = info->user_ptr[1];
9864
9865 return cfg80211_leave_ocb(rdev, dev);
9866}
9867
29cbe68c
JB		 9868static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
9869{
9870 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9871 struct net_device *dev = info->user_ptr[1];
9872 struct mesh_config cfg;
c80d545d 9873 struct mesh_setup setup;
29cbe68c
JB		 9874 int err;
9875
9876 /* start with default */
9877 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
c80d545d 9878 memcpy(&setup, &default_mesh_setup, sizeof(setup));
29cbe68c 9879
24bdd9f4 9880 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
29cbe68c 9881 /* and parse parameters if given */
24bdd9f4 9882 err = nl80211_parse_mesh_config(info, &cfg, NULL);
29cbe68c
JB		 9883 if (err)
9884 return err;
9885 }
9886
9887 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
9888 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
9889 return -EINVAL;
9890
c80d545d
JC		 9891 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
9892 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
9893
4bb62344
CYY		 9894 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9895 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
9896 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9897 return -EINVAL;
9898
9bdbf04d
MP		 9899 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
9900 setup.beacon_interval =
9901 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 9902
0c317a02
PK		 9903 err = cfg80211_validate_beacon_int(rdev,
9904 NL80211_IFTYPE_MESH_POINT,
9905 setup.beacon_interval);
12d20fc9
PK		 9906 if (err)
9907 return err;
9bdbf04d
MP		 9908 }
9909
9910 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
9911 setup.dtim_period =
9912 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
9913 if (setup.dtim_period < 1 || setup.dtim_period > 100)
9914 return -EINVAL;
9915 }
9916
c80d545d
JC		 9917 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
9918 /* parse additional setup parameters if given */
9919 err = nl80211_parse_mesh_setup(info, &setup);
9920 if (err)
9921 return err;
9922 }
9923
d37bb18a
TP		 9924 if (setup.user_mpm)
9925 cfg.auto_open_plinks = false;
9926
cc1d2806 9927 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 9928 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9929 if (err)
9930 return err;
cc1d2806
JB		 9931 } else {
9932 /* cfg80211_join_mesh() will sort it out */
683b6d3b 9933 setup.chandef.chan = NULL;
cc1d2806
JB		 9934 }
9935
ffb3cf30
AN		 9936 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9937 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9938 int n_rates =
9939 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9940 struct ieee80211_supported_band *sband;
9941
9942 if (!setup.chandef.chan)
9943 return -EINVAL;
9944
9945 sband = rdev->wiphy.bands[setup.chandef.chan->band];
9946
9947 err = ieee80211_get_ratemask(sband, rates, n_rates,
9948 &setup.basic_rates);
9949 if (err)
9950 return err;
9951 }
9952
8564e382
JB		 9953 if (info->attrs[NL80211_ATTR_TX_RATES]) {
9954 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
9955 if (err)
9956 return err;
9957
9958 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
9959 &setup.beacon_rate);
9960 if (err)
9961 return err;
9962 }
9963
c80d545d 9964 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
29cbe68c
JB		 9965}
9966
9967static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
9968{
9969 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9970 struct net_device *dev = info->user_ptr[1];
9971
9972 return cfg80211_leave_mesh(rdev, dev);
9973}
9974
dfb89c56 9975#ifdef CONFIG_PM
bb92d199
AK		 9976static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
9977 struct cfg80211_registered_device *rdev)
9978{
6abb9cb9 9979 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
bb92d199
AK		 9980 struct nlattr *nl_pats, *nl_pat;
9981 int i, pat_len;
9982
6abb9cb9 9983 if (!wowlan->n_patterns)
bb92d199
AK		 9984 return 0;
9985
9986 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
9987 if (!nl_pats)
9988 return -ENOBUFS;
9989
6abb9cb9 9990 for (i = 0; i < wowlan->n_patterns; i++) {
bb92d199
AK		 9991 nl_pat = nla_nest_start(msg, i + 1);
9992 if (!nl_pat)
9993 return -ENOBUFS;
6abb9cb9 9994 pat_len = wowlan->patterns[i].pattern_len;
50ac6607 9995 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
6abb9cb9 9996 wowlan->patterns[i].mask) ||
50ac6607
AK		 9997 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
9998 wowlan->patterns[i].pattern) ||
9999 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
6abb9cb9 10000 wowlan->patterns[i].pkt_offset))
bb92d199
AK		 10001 return -ENOBUFS;
10002 nla_nest_end(msg, nl_pat);
10003 }
10004 nla_nest_end(msg, nl_pats);
10005
10006 return 0;
10007}
10008
2a0e047e
JB		 10009static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
10010 struct cfg80211_wowlan_tcp *tcp)
10011{
10012 struct nlattr *nl_tcp;
10013
10014 if (!tcp)
10015 return 0;
10016
10017 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
10018 if (!nl_tcp)
10019 return -ENOBUFS;
10020
930345ea
JB		 10021 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
10022 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
2a0e047e
JB		 10023 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
10024 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
10025 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
10026 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
10027 tcp->payload_len, tcp->payload) ||
10028 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
10029 tcp->data_interval) ||
10030 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
10031 tcp->wake_len, tcp->wake_data) ||
10032 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
10033 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
10034 return -ENOBUFS;
10035
10036 if (tcp->payload_seq.len &&
10037 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
10038 sizeof(tcp->payload_seq), &tcp->payload_seq))
10039 return -ENOBUFS;
10040
10041 if (tcp->payload_tok.len &&
10042 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
10043 sizeof(tcp->payload_tok) + tcp->tokens_size,
10044 &tcp->payload_tok))
10045 return -ENOBUFS;
10046
e248ad30
JB		 10047 nla_nest_end(msg, nl_tcp);
10048
2a0e047e
JB		 10049 return 0;
10050}
10051
75453ccb
LC		 10052static int nl80211_send_wowlan_nd(struct sk_buff *msg,
10053 struct cfg80211_sched_scan_request *req)
10054{
3b06d277 10055 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
75453ccb
LC		 10056 int i;
10057
10058 if (!req)
10059 return 0;
10060
10061 nd = nla_nest_start(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
10062 if (!nd)
10063 return -ENOBUFS;
10064
3b06d277
AS		 10065 if (req->n_scan_plans == 1 &&
10066 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
10067 req->scan_plans[0].interval * 1000))
75453ccb
LC		 10068 return -ENOBUFS;
10069
21fea567
LC		 10070 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
10071 return -ENOBUFS;
10072
bf95ecdb 10073 if (req->relative_rssi_set) {
10074 struct nl80211_bss_select_rssi_adjust rssi_adjust;
10075
10076 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
10077 req->relative_rssi))
10078 return -ENOBUFS;
10079
10080 rssi_adjust.band = req->rssi_adjust.band;
10081 rssi_adjust.delta = req->rssi_adjust.delta;
10082 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
10083 sizeof(rssi_adjust), &rssi_adjust))
10084 return -ENOBUFS;
10085 }
10086
75453ccb
LC		 10087 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10088 if (!freqs)
10089 return -ENOBUFS;
10090
53b18980
JB		 10091 for (i = 0; i < req->n_channels; i++) {
10092 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10093 return -ENOBUFS;
10094 }
75453ccb
LC		 10095
10096 nla_nest_end(msg, freqs);
10097
10098 if (req->n_match_sets) {
10099 matches = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
76e1fb4b
JB		 10100 if (!matches)
10101 return -ENOBUFS;
10102
75453ccb
LC		 10103 for (i = 0; i < req->n_match_sets; i++) {
10104 match = nla_nest_start(msg, i);
76e1fb4b
JB		 10105 if (!match)
10106 return -ENOBUFS;
10107
53b18980
JB		 10108 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
10109 req->match_sets[i].ssid.ssid_len,
10110 req->match_sets[i].ssid.ssid))
10111 return -ENOBUFS;
75453ccb
LC		 10112 nla_nest_end(msg, match);
10113 }
10114 nla_nest_end(msg, matches);
10115 }
10116
3b06d277
AS		 10117 scan_plans = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
10118 if (!scan_plans)
10119 return -ENOBUFS;
10120
10121 for (i = 0; i < req->n_scan_plans; i++) {
10122 scan_plan = nla_nest_start(msg, i + 1);
76e1fb4b
JB		 10123 if (!scan_plan)
10124 return -ENOBUFS;
10125
3b06d277
AS		 10126 if (!scan_plan ||
10127 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
10128 req->scan_plans[i].interval) ||
10129 (req->scan_plans[i].iterations &&
10130 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
10131 req->scan_plans[i].iterations)))
10132 return -ENOBUFS;
10133 nla_nest_end(msg, scan_plan);
10134 }
10135 nla_nest_end(msg, scan_plans);
10136
75453ccb
LC		 10137 nla_nest_end(msg, nd);
10138
10139 return 0;
10140}
10141
ff1b6e69
JB		 10142static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
10143{
10144 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10145 struct sk_buff *msg;
10146 void *hdr;
2a0e047e 10147 u32 size = NLMSG_DEFAULT_SIZE;
ff1b6e69 10148
964dc9e2 10149 if (!rdev->wiphy.wowlan)
ff1b6e69
JB		 10150 return -EOPNOTSUPP;
10151
6abb9cb9 10152 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
2a0e047e 10153 /* adjust size to have room for all the data */
6abb9cb9
JB		 10154 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
10155 rdev->wiphy.wowlan_config->tcp->payload_len +
10156 rdev->wiphy.wowlan_config->tcp->wake_len +
10157 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
2a0e047e
JB		 10158 }
10159
10160 msg = nlmsg_new(size, GFP_KERNEL);
ff1b6e69
JB		 10161 if (!msg)
10162 return -ENOMEM;
10163
15e47304 10164 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ff1b6e69
JB		 10165 NL80211_CMD_GET_WOWLAN);
10166 if (!hdr)
10167 goto nla_put_failure;
10168
6abb9cb9 10169 if (rdev->wiphy.wowlan_config) {
ff1b6e69
JB		 10170 struct nlattr *nl_wowlan;
10171
10172 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10173 if (!nl_wowlan)
10174 goto nla_put_failure;
10175
6abb9cb9 10176 if ((rdev->wiphy.wowlan_config->any &&
9360ffd1 10177 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6abb9cb9 10178 (rdev->wiphy.wowlan_config->disconnect &&
9360ffd1 10179 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6abb9cb9 10180 (rdev->wiphy.wowlan_config->magic_pkt &&
9360ffd1 10181 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6abb9cb9 10182 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
9360ffd1 10183 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6abb9cb9 10184 (rdev->wiphy.wowlan_config->eap_identity_req &&
9360ffd1 10185 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6abb9cb9 10186 (rdev->wiphy.wowlan_config->four_way_handshake &&
9360ffd1 10187 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6abb9cb9 10188 (rdev->wiphy.wowlan_config->rfkill_release &&
9360ffd1
DM		 10189 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
10190 goto nla_put_failure;
2a0e047e 10191
bb92d199
AK		 10192 if (nl80211_send_wowlan_patterns(msg, rdev))
10193 goto nla_put_failure;
2a0e047e 10194
6abb9cb9
JB		 10195 if (nl80211_send_wowlan_tcp(msg,
10196 rdev->wiphy.wowlan_config->tcp))
2a0e047e 10197 goto nla_put_failure;
75453ccb
LC		 10198
10199 if (nl80211_send_wowlan_nd(
10200 msg,
10201 rdev->wiphy.wowlan_config->nd_config))
10202 goto nla_put_failure;
2a0e047e 10203
ff1b6e69
JB		 10204 nla_nest_end(msg, nl_wowlan);
10205 }
10206
10207 genlmsg_end(msg, hdr);
10208 return genlmsg_reply(msg, info);
10209
10210nla_put_failure:
10211 nlmsg_free(msg);
10212 return -ENOBUFS;
10213}
10214
2a0e047e
JB		 10215static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
10216 struct nlattr *attr,
10217 struct cfg80211_wowlan *trig)
10218{
10219 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
10220 struct cfg80211_wowlan_tcp *cfg;
10221 struct nl80211_wowlan_tcp_data_token *tok = NULL;
10222 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
10223 u32 size;
10224 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
10225 int err, port;
10226
964dc9e2 10227 if (!rdev->wiphy.wowlan->tcp)
2a0e047e
JB		 10228 return -EINVAL;
10229
bfe2c7b1 10230 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TCP, attr,
fceb6435 10231 nl80211_wowlan_tcp_policy, NULL);
2a0e047e
JB		 10232 if (err)
10233 return err;
10234
10235 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
10236 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
10237 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
10238 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
10239 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
10240 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
10241 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
10242 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
10243 return -EINVAL;
10244
10245 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
964dc9e2 10246 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
2a0e047e
JB		 10247 return -EINVAL;
10248
10249 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
964dc9e2 10250 rdev->wiphy.wowlan->tcp->data_interval_max ||
723d568a 10251 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
2a0e047e
JB		 10252 return -EINVAL;
10253
10254 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
964dc9e2 10255 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
2a0e047e
JB		 10256 return -EINVAL;
10257
10258 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
10259 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
10260 return -EINVAL;
10261
10262 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
10263 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10264
10265 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10266 tokens_size = tokln - sizeof(*tok);
10267
10268 if (!tok->len || tokens_size % tok->len)
10269 return -EINVAL;
964dc9e2 10270 if (!rdev->wiphy.wowlan->tcp->tok)
2a0e047e 10271 return -EINVAL;
964dc9e2 10272 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
2a0e047e 10273 return -EINVAL;
964dc9e2 10274 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
2a0e047e 10275 return -EINVAL;
964dc9e2 10276 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
2a0e047e
JB		 10277 return -EINVAL;
10278 if (tok->offset + tok->len > data_size)
10279 return -EINVAL;
10280 }
10281
10282 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
10283 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
964dc9e2 10284 if (!rdev->wiphy.wowlan->tcp->seq)
2a0e047e
JB		 10285 return -EINVAL;
10286 if (seq->len == 0 || seq->len > 4)
10287 return -EINVAL;
10288 if (seq->len + seq->offset > data_size)
10289 return -EINVAL;
10290 }
10291
10292 size = sizeof(*cfg);
10293 size += data_size;
10294 size += wake_size + wake_mask_size;
10295 size += tokens_size;
10296
10297 cfg = kzalloc(size, GFP_KERNEL);
10298 if (!cfg)
10299 return -ENOMEM;
67b61f6c
JB		 10300 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
10301 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
2a0e047e
JB		 10302 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
10303 ETH_ALEN);
10304 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
10305 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
10306 else
10307 port = 0;
10308#ifdef CONFIG_INET
10309 /* allocate a socket and port for it and use it */
10310 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
10311 IPPROTO_TCP, &cfg->sock, 1);
10312 if (err) {
10313 kfree(cfg);
10314 return err;
10315 }
10316 if (inet_csk_get_port(cfg->sock->sk, port)) {
10317 sock_release(cfg->sock);
10318 kfree(cfg);
10319 return -EADDRINUSE;
10320 }
10321 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
10322#else
10323 if (!port) {
10324 kfree(cfg);
10325 return -EINVAL;
10326 }
10327 cfg->src_port = port;
10328#endif
10329
10330 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
10331 cfg->payload_len = data_size;
10332 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
10333 memcpy((void *)cfg->payload,
10334 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
10335 data_size);
10336 if (seq)
10337 cfg->payload_seq = *seq;
10338 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
10339 cfg->wake_len = wake_size;
10340 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
10341 memcpy((void *)cfg->wake_data,
10342 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
10343 wake_size);
10344 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
10345 data_size + wake_size;
10346 memcpy((void *)cfg->wake_mask,
10347 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
10348 wake_mask_size);
10349 if (tok) {
10350 cfg->tokens_size = tokens_size;
10351 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
10352 }
10353
10354 trig->tcp = cfg;
10355
10356 return 0;
10357}
10358
8cd4d456
LC		 10359static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
10360 const struct wiphy_wowlan_support *wowlan,
10361 struct nlattr *attr,
10362 struct cfg80211_wowlan *trig)
10363{
10364 struct nlattr **tb;
10365 int err;
10366
10367 tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL);
10368 if (!tb)
10369 return -ENOMEM;
10370
10371 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
10372 err = -EOPNOTSUPP;
10373 goto out;
10374 }
10375
fceb6435
JB		 10376 err = nla_parse_nested(tb, NL80211_ATTR_MAX, attr, nl80211_policy,
10377 NULL);
8cd4d456
LC		 10378 if (err)
10379 goto out;
10380
aad1e812
AVS		 10381 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
10382 wowlan->max_nd_match_sets);
8cd4d456
LC		 10383 err = PTR_ERR_OR_ZERO(trig->nd_config);
10384 if (err)
10385 trig->nd_config = NULL;
10386
10387out:
10388 kfree(tb);
10389 return err;
10390}
10391
ff1b6e69
JB		 10392static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
10393{
10394 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10395 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
ff1b6e69 10396 struct cfg80211_wowlan new_triggers = {};
ae33bd81 10397 struct cfg80211_wowlan *ntrig;
964dc9e2 10398 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
ff1b6e69 10399 int err, i;
6abb9cb9 10400 bool prev_enabled = rdev->wiphy.wowlan_config;
98fc4386 10401 bool regular = false;
ff1b6e69 10402
964dc9e2 10403 if (!wowlan)
ff1b6e69
JB		 10404 return -EOPNOTSUPP;
10405
ae33bd81
JB		 10406 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
10407 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10408 rdev->wiphy.wowlan_config = NULL;
ae33bd81
JB		 10409 goto set_wakeup;
10410 }
ff1b6e69 10411
bfe2c7b1
JB		 10412 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
10413 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
fe52145f 10414 nl80211_wowlan_policy, info->extack);
ff1b6e69
JB		 10415 if (err)
10416 return err;
10417
10418 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
10419 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
10420 return -EINVAL;
10421 new_triggers.any = true;
10422 }
10423
10424 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
10425 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
10426 return -EINVAL;
10427 new_triggers.disconnect = true;
98fc4386 10428 regular = true;
ff1b6e69
JB		 10429 }
10430
10431 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
10432 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
10433 return -EINVAL;
10434 new_triggers.magic_pkt = true;
98fc4386 10435 regular = true;
ff1b6e69
JB		 10436 }
10437
77dbbb13
JB		 10438 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
10439 return -EINVAL;
10440
10441 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
10442 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
10443 return -EINVAL;
10444 new_triggers.gtk_rekey_failure = true;
98fc4386 10445 regular = true;
77dbbb13
JB		 10446 }
10447
10448 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
10449 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
10450 return -EINVAL;
10451 new_triggers.eap_identity_req = true;
98fc4386 10452 regular = true;
77dbbb13
JB		 10453 }
10454
10455 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
10456 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
10457 return -EINVAL;
10458 new_triggers.four_way_handshake = true;
98fc4386 10459 regular = true;
77dbbb13
JB		 10460 }
10461
10462 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
10463 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
10464 return -EINVAL;
10465 new_triggers.rfkill_release = true;
98fc4386 10466 regular = true;
77dbbb13
JB		 10467 }
10468
ff1b6e69
JB		 10469 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
10470 struct nlattr *pat;
10471 int n_patterns = 0;
bb92d199 10472 int rem, pat_len, mask_len, pkt_offset;
50ac6607 10473 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
ff1b6e69 10474
98fc4386
JB		 10475 regular = true;
10476
ff1b6e69
JB		 10477 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10478 rem)
10479 n_patterns++;
10480 if (n_patterns > wowlan->n_patterns)
10481 return -EINVAL;
10482
10483 new_triggers.patterns = kcalloc(n_patterns,
10484 sizeof(new_triggers.patterns[0]),
10485 GFP_KERNEL);
10486 if (!new_triggers.patterns)
10487 return -ENOMEM;
10488
10489 new_triggers.n_patterns = n_patterns;
10490 i = 0;
10491
10492 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10493 rem) {
922bd80f
JB		 10494 u8 *mask_pat;
10495
bfe2c7b1 10496 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
fe52145f 10497 NULL, info->extack);
ff1b6e69 10498 err = -EINVAL;
50ac6607
AK		 10499 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10500 !pat_tb[NL80211_PKTPAT_PATTERN])
ff1b6e69 10501 goto error;
50ac6607 10502 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
ff1b6e69 10503 mask_len = DIV_ROUND_UP(pat_len, 8);
50ac6607 10504 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
ff1b6e69
JB		 10505 goto error;
10506 if (pat_len > wowlan->pattern_max_len ||
10507 pat_len < wowlan->pattern_min_len)
10508 goto error;
10509
50ac6607 10510 if (!pat_tb[NL80211_PKTPAT_OFFSET])
bb92d199
AK		 10511 pkt_offset = 0;
10512 else
10513 pkt_offset = nla_get_u32(
50ac6607 10514 pat_tb[NL80211_PKTPAT_OFFSET]);
bb92d199
AK		 10515 if (pkt_offset > wowlan->max_pkt_offset)
10516 goto error;
10517 new_triggers.patterns[i].pkt_offset = pkt_offset;
10518
922bd80f
JB		 10519 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10520 if (!mask_pat) {
ff1b6e69
JB		 10521 err = -ENOMEM;
10522 goto error;
10523 }
922bd80f
JB		 10524 new_triggers.patterns[i].mask = mask_pat;
10525 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
ff1b6e69 10526 mask_len);
922bd80f
JB		 10527 mask_pat += mask_len;
10528 new_triggers.patterns[i].pattern = mask_pat;
ff1b6e69 10529 new_triggers.patterns[i].pattern_len = pat_len;
922bd80f 10530 memcpy(mask_pat,
50ac6607 10531 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
ff1b6e69
JB		 10532 pat_len);
10533 i++;
10534 }
10535 }
10536
2a0e047e 10537 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
98fc4386 10538 regular = true;
2a0e047e
JB		 10539 err = nl80211_parse_wowlan_tcp(
10540 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
10541 &new_triggers);
10542 if (err)
10543 goto error;
10544 }
10545
8cd4d456 10546 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
98fc4386 10547 regular = true;
8cd4d456
LC		 10548 err = nl80211_parse_wowlan_nd(
10549 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
10550 &new_triggers);
10551 if (err)
10552 goto error;
10553 }
10554
98fc4386
JB		 10555 /* The 'any' trigger means the device continues operating more or less
10556 * as in its normal operation mode and wakes up the host on most of the
10557 * normal interrupts (like packet RX, ...)
10558 * It therefore makes little sense to combine with the more constrained
10559 * wakeup trigger modes.
10560 */
10561 if (new_triggers.any && regular) {
10562 err = -EINVAL;
10563 goto error;
10564 }
10565
ae33bd81
JB		 10566 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
10567 if (!ntrig) {
10568 err = -ENOMEM;
10569 goto error;
ff1b6e69 10570 }
ae33bd81 10571 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10572 rdev->wiphy.wowlan_config = ntrig;
ff1b6e69 10573
ae33bd81 10574 set_wakeup:
6abb9cb9
JB		 10575 if (rdev->ops->set_wakeup &&
10576 prev_enabled != !!rdev->wiphy.wowlan_config)
10577 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
6d52563f 10578
ff1b6e69
JB		 10579 return 0;
10580 error:
10581 for (i = 0; i < new_triggers.n_patterns; i++)
10582 kfree(new_triggers.patterns[i].mask);
10583 kfree(new_triggers.patterns);
2a0e047e
JB		 10584 if (new_triggers.tcp && new_triggers.tcp->sock)
10585 sock_release(new_triggers.tcp->sock);
10586 kfree(new_triggers.tcp);
e5dbe070 10587 kfree(new_triggers.nd_config);
ff1b6e69
JB		 10588 return err;
10589}
dfb89c56 10590#endif
ff1b6e69 10591
be29b99a
AK		 10592static int nl80211_send_coalesce_rules(struct sk_buff *msg,
10593 struct cfg80211_registered_device *rdev)
10594{
10595 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
10596 int i, j, pat_len;
10597 struct cfg80211_coalesce_rules *rule;
10598
10599 if (!rdev->coalesce->n_rules)
10600 return 0;
10601
10602 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
10603 if (!nl_rules)
10604 return -ENOBUFS;
10605
10606 for (i = 0; i < rdev->coalesce->n_rules; i++) {
10607 nl_rule = nla_nest_start(msg, i + 1);
10608 if (!nl_rule)
10609 return -ENOBUFS;
10610
10611 rule = &rdev->coalesce->rules[i];
10612 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
10613 rule->delay))
10614 return -ENOBUFS;
10615
10616 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
10617 rule->condition))
10618 return -ENOBUFS;
10619
10620 nl_pats = nla_nest_start(msg,
10621 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
10622 if (!nl_pats)
10623 return -ENOBUFS;
10624
10625 for (j = 0; j < rule->n_patterns; j++) {
10626 nl_pat = nla_nest_start(msg, j + 1);
10627 if (!nl_pat)
10628 return -ENOBUFS;
10629 pat_len = rule->patterns[j].pattern_len;
10630 if (nla_put(msg, NL80211_PKTPAT_MASK,
10631 DIV_ROUND_UP(pat_len, 8),
10632 rule->patterns[j].mask) ||
10633 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10634 rule->patterns[j].pattern) ||
10635 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
10636 rule->patterns[j].pkt_offset))
10637 return -ENOBUFS;
10638 nla_nest_end(msg, nl_pat);
10639 }
10640 nla_nest_end(msg, nl_pats);
10641 nla_nest_end(msg, nl_rule);
10642 }
10643 nla_nest_end(msg, nl_rules);
10644
10645 return 0;
10646}
10647
10648static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
10649{
10650 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10651 struct sk_buff *msg;
10652 void *hdr;
10653
10654 if (!rdev->wiphy.coalesce)
10655 return -EOPNOTSUPP;
10656
10657 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10658 if (!msg)
10659 return -ENOMEM;
10660
10661 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10662 NL80211_CMD_GET_COALESCE);
10663 if (!hdr)
10664 goto nla_put_failure;
10665
10666 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
10667 goto nla_put_failure;
10668
10669 genlmsg_end(msg, hdr);
10670 return genlmsg_reply(msg, info);
10671
10672nla_put_failure:
10673 nlmsg_free(msg);
10674 return -ENOBUFS;
10675}
10676
10677void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
10678{
10679 struct cfg80211_coalesce *coalesce = rdev->coalesce;
10680 int i, j;
10681 struct cfg80211_coalesce_rules *rule;
10682
10683 if (!coalesce)
10684 return;
10685
10686 for (i = 0; i < coalesce->n_rules; i++) {
10687 rule = &coalesce->rules[i];
10688 for (j = 0; j < rule->n_patterns; j++)
10689 kfree(rule->patterns[j].mask);
10690 kfree(rule->patterns);
10691 }
10692 kfree(coalesce->rules);
10693 kfree(coalesce);
10694 rdev->coalesce = NULL;
10695}
10696
10697static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
10698 struct nlattr *rule,
10699 struct cfg80211_coalesce_rules *new_rule)
10700{
10701 int err, i;
10702 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10703 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
10704 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
10705 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
10706
bfe2c7b1 10707 err = nla_parse_nested(tb, NL80211_ATTR_COALESCE_RULE_MAX, rule,
fceb6435 10708 nl80211_coalesce_policy, NULL);
be29b99a
AK		 10709 if (err)
10710 return err;
10711
10712 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
10713 new_rule->delay =
10714 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
10715 if (new_rule->delay > coalesce->max_delay)
10716 return -EINVAL;
10717
10718 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
10719 new_rule->condition =
10720 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
10721 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
10722 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
10723 return -EINVAL;
10724
10725 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
10726 return -EINVAL;
10727
10728 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10729 rem)
10730 n_patterns++;
10731 if (n_patterns > coalesce->n_patterns)
10732 return -EINVAL;
10733
10734 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
10735 GFP_KERNEL);
10736 if (!new_rule->patterns)
10737 return -ENOMEM;
10738
10739 new_rule->n_patterns = n_patterns;
10740 i = 0;
10741
10742 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10743 rem) {
922bd80f
JB		 10744 u8 *mask_pat;
10745
fceb6435 10746 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat, NULL, NULL);
be29b99a
AK		 10747 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10748 !pat_tb[NL80211_PKTPAT_PATTERN])
10749 return -EINVAL;
10750 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
10751 mask_len = DIV_ROUND_UP(pat_len, 8);
10752 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
10753 return -EINVAL;
10754 if (pat_len > coalesce->pattern_max_len ||
10755 pat_len < coalesce->pattern_min_len)
10756 return -EINVAL;
10757
10758 if (!pat_tb[NL80211_PKTPAT_OFFSET])
10759 pkt_offset = 0;
10760 else
10761 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
10762 if (pkt_offset > coalesce->max_pkt_offset)
10763 return -EINVAL;
10764 new_rule->patterns[i].pkt_offset = pkt_offset;
10765
922bd80f
JB		 10766 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10767 if (!mask_pat)
be29b99a 10768 return -ENOMEM;
922bd80f
JB		 10769
10770 new_rule->patterns[i].mask = mask_pat;
10771 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
10772 mask_len);
10773
10774 mask_pat += mask_len;
10775 new_rule->patterns[i].pattern = mask_pat;
be29b99a 10776 new_rule->patterns[i].pattern_len = pat_len;
922bd80f
JB		 10777 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
10778 pat_len);
be29b99a
AK		 10779 i++;
10780 }
10781
10782 return 0;
10783}
10784
10785static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
10786{
10787 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10788 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10789 struct cfg80211_coalesce new_coalesce = {};
10790 struct cfg80211_coalesce *n_coalesce;
10791 int err, rem_rule, n_rules = 0, i, j;
10792 struct nlattr *rule;
10793 struct cfg80211_coalesce_rules *tmp_rule;
10794
10795 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
10796 return -EOPNOTSUPP;
10797
10798 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
10799 cfg80211_rdev_free_coalesce(rdev);
a1056b1b 10800 rdev_set_coalesce(rdev, NULL);
be29b99a
AK		 10801 return 0;
10802 }
10803
10804 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10805 rem_rule)
10806 n_rules++;
10807 if (n_rules > coalesce->n_rules)
10808 return -EINVAL;
10809
10810 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
10811 GFP_KERNEL);
10812 if (!new_coalesce.rules)
10813 return -ENOMEM;
10814
10815 new_coalesce.n_rules = n_rules;
10816 i = 0;
10817
10818 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10819 rem_rule) {
10820 err = nl80211_parse_coalesce_rule(rdev, rule,
10821 &new_coalesce.rules[i]);
10822 if (err)
10823 goto error;
10824
10825 i++;
10826 }
10827
a1056b1b 10828 err = rdev_set_coalesce(rdev, &new_coalesce);
be29b99a
AK		 10829 if (err)
10830 goto error;
10831
10832 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
10833 if (!n_coalesce) {
10834 err = -ENOMEM;
10835 goto error;
10836 }
10837 cfg80211_rdev_free_coalesce(rdev);
10838 rdev->coalesce = n_coalesce;
10839
10840 return 0;
10841error:
10842 for (i = 0; i < new_coalesce.n_rules; i++) {
10843 tmp_rule = &new_coalesce.rules[i];
10844 for (j = 0; j < tmp_rule->n_patterns; j++)
10845 kfree(tmp_rule->patterns[j].mask);
10846 kfree(tmp_rule->patterns);
10847 }
10848 kfree(new_coalesce.rules);
10849
10850 return err;
10851}
10852
e5497d76
JB		 10853static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
10854{
10855 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10856 struct net_device *dev = info->user_ptr[1];
10857 struct wireless_dev *wdev = dev->ieee80211_ptr;
10858 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
10859 struct cfg80211_gtk_rekey_data rekey_data;
10860 int err;
10861
10862 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
10863 return -EINVAL;
10864
bfe2c7b1
JB		 10865 err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
10866 info->attrs[NL80211_ATTR_REKEY_DATA],
fe52145f 10867 nl80211_rekey_policy, info->extack);
e5497d76
JB		 10868 if (err)
10869 return err;
10870
10871 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
10872 return -ERANGE;
10873 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
10874 return -ERANGE;
10875 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
10876 return -ERANGE;
10877
78f686ca
JB		 10878 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
10879 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
10880 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
e5497d76
JB		 10881
10882 wdev_lock(wdev);
10883 if (!wdev->current_bss) {
10884 err = -ENOTCONN;
10885 goto out;
10886 }
10887
10888 if (!rdev->ops->set_rekey_data) {
10889 err = -EOPNOTSUPP;
10890 goto out;
10891 }
10892
e35e4d28 10893 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
e5497d76
JB		 10894 out:
10895 wdev_unlock(wdev);
10896 return err;
10897}
10898
28946da7
JB		 10899static int nl80211_register_unexpected_frame(struct sk_buff *skb,
10900 struct genl_info *info)
10901{
10902 struct net_device *dev = info->user_ptr[1];
10903 struct wireless_dev *wdev = dev->ieee80211_ptr;
10904
10905 if (wdev->iftype != NL80211_IFTYPE_AP &&
10906 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10907 return -EINVAL;
10908
15e47304 10909 if (wdev->ap_unexpected_nlportid)
28946da7
JB		 10910 return -EBUSY;
10911
15e47304 10912 wdev->ap_unexpected_nlportid = info->snd_portid;
28946da7
JB		 10913 return 0;
10914}
10915
7f6cf311
JB		 10916static int nl80211_probe_client(struct sk_buff *skb,
10917 struct genl_info *info)
10918{
10919 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10920 struct net_device *dev = info->user_ptr[1];
10921 struct wireless_dev *wdev = dev->ieee80211_ptr;
10922 struct sk_buff *msg;
10923 void *hdr;
10924 const u8 *addr;
10925 u64 cookie;
10926 int err;
10927
10928 if (wdev->iftype != NL80211_IFTYPE_AP &&
10929 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10930 return -EOPNOTSUPP;
10931
10932 if (!info->attrs[NL80211_ATTR_MAC])
10933 return -EINVAL;
10934
10935 if (!rdev->ops->probe_client)
10936 return -EOPNOTSUPP;
10937
10938 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10939 if (!msg)
10940 return -ENOMEM;
10941
15e47304 10942 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7f6cf311 10943 NL80211_CMD_PROBE_CLIENT);
cb35fba3
DC		 10944 if (!hdr) {
10945 err = -ENOBUFS;
7f6cf311
JB		 10946 goto free_msg;
10947 }
10948
10949 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
10950
e35e4d28 10951 err = rdev_probe_client(rdev, dev, addr, &cookie);
7f6cf311
JB		 10952 if (err)
10953 goto free_msg;
10954
2dad624e
ND		 10955 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10956 NL80211_ATTR_PAD))
9360ffd1 10957 goto nla_put_failure;
7f6cf311
JB		 10958
10959 genlmsg_end(msg, hdr);
10960
10961 return genlmsg_reply(msg, info);
10962
10963 nla_put_failure:
10964 err = -ENOBUFS;
10965 free_msg:
10966 nlmsg_free(msg);
10967 return err;
10968}
10969
5e760230
JB		 10970static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
10971{
10972 struct cfg80211_registered_device *rdev = info->user_ptr[0];
37c73b5f
BG		 10973 struct cfg80211_beacon_registration *reg, *nreg;
10974 int rv;
5e760230
JB		 10975
10976 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
10977 return -EOPNOTSUPP;
10978
37c73b5f
BG		 10979 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
10980 if (!nreg)
10981 return -ENOMEM;
10982
10983 /* First, check if already registered. */
10984 spin_lock_bh(&rdev->beacon_registrations_lock);
10985 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
10986 if (reg->nlportid == info->snd_portid) {
10987 rv = -EALREADY;
10988 goto out_err;
10989 }
10990 }
10991 /* Add it to the list */
10992 nreg->nlportid = info->snd_portid;
10993 list_add(&nreg->list, &rdev->beacon_registrations);
5e760230 10994
37c73b5f 10995 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 10996
10997 return 0;
37c73b5f
BG		 10998out_err:
10999 spin_unlock_bh(&rdev->beacon_registrations_lock);
11000 kfree(nreg);
11001 return rv;
5e760230
JB		 11002}
11003
98104fde
JB		 11004static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
11005{
11006 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11007 struct wireless_dev *wdev = info->user_ptr[1];
11008 int err;
11009
11010 if (!rdev->ops->start_p2p_device)
11011 return -EOPNOTSUPP;
11012
11013 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11014 return -EOPNOTSUPP;
11015
73c7da3d 11016 if (wdev_running(wdev))
98104fde
JB		 11017 return 0;
11018
b6a55015
LC		 11019 if (rfkill_blocked(rdev->rfkill))
11020 return -ERFKILL;
98104fde 11021
eeb126e9 11022 err = rdev_start_p2p_device(rdev, wdev);
98104fde
JB		 11023 if (err)
11024 return err;
11025
73c7da3d 11026 wdev->is_running = true;
98104fde 11027 rdev->opencount++;
98104fde
JB		 11028
11029 return 0;
11030}
11031
11032static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
11033{
11034 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11035 struct wireless_dev *wdev = info->user_ptr[1];
11036
11037 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11038 return -EOPNOTSUPP;
11039
11040 if (!rdev->ops->stop_p2p_device)
11041 return -EOPNOTSUPP;
11042
f9f47529 11043 cfg80211_stop_p2p_device(rdev, wdev);
98104fde
JB		 11044
11045 return 0;
11046}
11047
cb3b7d87
AB		 11048static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
11049{
11050 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11051 struct wireless_dev *wdev = info->user_ptr[1];
11052 struct cfg80211_nan_conf conf = {};
11053 int err;
11054
11055 if (wdev->iftype != NL80211_IFTYPE_NAN)
11056 return -EOPNOTSUPP;
11057
eeb04a96 11058 if (wdev_running(wdev))
cb3b7d87
AB		 11059 return -EEXIST;
11060
11061 if (rfkill_blocked(rdev->rfkill))
11062 return -ERFKILL;
11063
11064 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
11065 return -EINVAL;
11066
cb3b7d87
AB		 11067 conf.master_pref =
11068 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11069 if (!conf.master_pref)
11070 return -EINVAL;
11071
8585989d
LC		 11072 if (info->attrs[NL80211_ATTR_BANDS]) {
11073 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11074
11075 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11076 return -EOPNOTSUPP;
11077
11078 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11079 return -EINVAL;
11080
11081 conf.bands = bands;
11082 }
cb3b7d87
AB		 11083
11084 err = rdev_start_nan(rdev, wdev, &conf);
11085 if (err)
11086 return err;
11087
73c7da3d 11088 wdev->is_running = true;
cb3b7d87
AB		 11089 rdev->opencount++;
11090
11091 return 0;
11092}
11093
11094static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
11095{
11096 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11097 struct wireless_dev *wdev = info->user_ptr[1];
11098
11099 if (wdev->iftype != NL80211_IFTYPE_NAN)
11100 return -EOPNOTSUPP;
11101
11102 cfg80211_stop_nan(rdev, wdev);
11103
11104 return 0;
11105}
11106
a442b761
AB		 11107static int validate_nan_filter(struct nlattr *filter_attr)
11108{
11109 struct nlattr *attr;
11110 int len = 0, n_entries = 0, rem;
11111
11112 nla_for_each_nested(attr, filter_attr, rem) {
11113 len += nla_len(attr);
11114 n_entries++;
11115 }
11116
11117 if (len >= U8_MAX)
11118 return -EINVAL;
11119
11120 return n_entries;
11121}
11122
11123static int handle_nan_filter(struct nlattr *attr_filter,
11124 struct cfg80211_nan_func *func,
11125 bool tx)
11126{
11127 struct nlattr *attr;
11128 int n_entries, rem, i;
11129 struct cfg80211_nan_func_filter *filter;
11130
11131 n_entries = validate_nan_filter(attr_filter);
11132 if (n_entries < 0)
11133 return n_entries;
11134
11135 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
11136
11137 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
11138 if (!filter)
11139 return -ENOMEM;
11140
11141 i = 0;
11142 nla_for_each_nested(attr, attr_filter, rem) {
b15ca182 11143 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
a442b761
AB		 11144 filter[i].len = nla_len(attr);
11145 i++;
11146 }
11147 if (tx) {
11148 func->num_tx_filters = n_entries;
11149 func->tx_filters = filter;
11150 } else {
11151 func->num_rx_filters = n_entries;
11152 func->rx_filters = filter;
11153 }
11154
11155 return 0;
11156}
11157
11158static int nl80211_nan_add_func(struct sk_buff *skb,
11159 struct genl_info *info)
11160{
11161 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11162 struct wireless_dev *wdev = info->user_ptr[1];
11163 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
11164 struct cfg80211_nan_func *func;
11165 struct sk_buff *msg = NULL;
11166 void *hdr = NULL;
11167 int err = 0;
11168
11169 if (wdev->iftype != NL80211_IFTYPE_NAN)
11170 return -EOPNOTSUPP;
11171
73c7da3d 11172 if (!wdev_running(wdev))
a442b761
AB		 11173 return -ENOTCONN;
11174
11175 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
11176 return -EINVAL;
11177
11178 if (wdev->owner_nlportid &&
11179 wdev->owner_nlportid != info->snd_portid)
11180 return -ENOTCONN;
11181
bfe2c7b1
JB		 11182 err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
11183 info->attrs[NL80211_ATTR_NAN_FUNC],
fe52145f 11184 nl80211_nan_func_policy, info->extack);
a442b761
AB		 11185 if (err)
11186 return err;
11187
11188 func = kzalloc(sizeof(*func), GFP_KERNEL);
11189 if (!func)
11190 return -ENOMEM;
11191
11192 func->cookie = wdev->wiphy->cookie_counter++;
11193
11194 if (!tb[NL80211_NAN_FUNC_TYPE] ||
11195 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
11196 err = -EINVAL;
11197 goto out;
11198 }
11199
11200
11201 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
11202
11203 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
11204 err = -EINVAL;
11205 goto out;
11206 }
11207
11208 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
11209 sizeof(func->service_id));
11210
11211 func->close_range =
11212 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
11213
11214 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
11215 func->serv_spec_info_len =
11216 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
11217 func->serv_spec_info =
11218 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
11219 func->serv_spec_info_len,
11220 GFP_KERNEL);
11221 if (!func->serv_spec_info) {
11222 err = -ENOMEM;
11223 goto out;
11224 }
11225 }
11226
11227 if (tb[NL80211_NAN_FUNC_TTL])
11228 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
11229
11230 switch (func->type) {
11231 case NL80211_NAN_FUNC_PUBLISH:
11232 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
11233 err = -EINVAL;
11234 goto out;
11235 }
11236
11237 func->publish_type =
11238 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
11239 func->publish_bcast =
11240 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
11241
11242 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
11243 func->publish_bcast) {
11244 err = -EINVAL;
11245 goto out;
11246 }
11247 break;
11248 case NL80211_NAN_FUNC_SUBSCRIBE:
11249 func->subscribe_active =
11250 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
11251 break;
11252 case NL80211_NAN_FUNC_FOLLOW_UP:
11253 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
11254 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]) {
11255 err = -EINVAL;
11256 goto out;
11257 }
11258
11259 func->followup_id =
11260 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
11261 func->followup_reqid =
11262 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
11263 memcpy(func->followup_dest.addr,
11264 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
11265 sizeof(func->followup_dest.addr));
11266 if (func->ttl) {
11267 err = -EINVAL;
11268 goto out;
11269 }
11270 break;
11271 default:
11272 err = -EINVAL;
11273 goto out;
11274 }
11275
11276 if (tb[NL80211_NAN_FUNC_SRF]) {
11277 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
11278
bfe2c7b1
JB		 11279 err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
11280 tb[NL80211_NAN_FUNC_SRF],
fe52145f 11281 nl80211_nan_srf_policy, info->extack);
a442b761
AB		 11282 if (err)
11283 goto out;
11284
11285 func->srf_include =
11286 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
11287
11288 if (srf_tb[NL80211_NAN_SRF_BF]) {
11289 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
11290 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
11291 err = -EINVAL;
11292 goto out;
11293 }
11294
11295 func->srf_bf_len =
11296 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
11297 func->srf_bf =
11298 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
11299 func->srf_bf_len, GFP_KERNEL);
11300 if (!func->srf_bf) {
11301 err = -ENOMEM;
11302 goto out;
11303 }
11304
11305 func->srf_bf_idx =
11306 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
11307 } else {
11308 struct nlattr *attr, *mac_attr =
11309 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
11310 int n_entries, rem, i = 0;
11311
11312 if (!mac_attr) {
11313 err = -EINVAL;
11314 goto out;
11315 }
11316
11317 n_entries = validate_acl_mac_addrs(mac_attr);
11318 if (n_entries <= 0) {
11319 err = -EINVAL;
11320 goto out;
11321 }
11322
11323 func->srf_num_macs = n_entries;
11324 func->srf_macs =
11325 kzalloc(sizeof(*func->srf_macs) * n_entries,
11326 GFP_KERNEL);
11327 if (!func->srf_macs) {
11328 err = -ENOMEM;
11329 goto out;
11330 }
11331
11332 nla_for_each_nested(attr, mac_attr, rem)
11333 memcpy(func->srf_macs[i++].addr, nla_data(attr),
11334 sizeof(*func->srf_macs));
11335 }
11336 }
11337
11338 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
11339 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
11340 func, true);
11341 if (err)
11342 goto out;
11343 }
11344
11345 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
11346 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
11347 func, false);
11348 if (err)
11349 goto out;
11350 }
11351
11352 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11353 if (!msg) {
11354 err = -ENOMEM;
11355 goto out;
11356 }
11357
11358 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11359 NL80211_CMD_ADD_NAN_FUNCTION);
11360 /* This can't really happen - we just allocated 4KB */
11361 if (WARN_ON(!hdr)) {
11362 err = -ENOMEM;
11363 goto out;
11364 }
11365
11366 err = rdev_add_nan_func(rdev, wdev, func);
11367out:
11368 if (err < 0) {
11369 cfg80211_free_nan_func(func);
11370 nlmsg_free(msg);
11371 return err;
11372 }
11373
11374 /* propagate the instance id and cookie to userspace */
11375 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
11376 NL80211_ATTR_PAD))
11377 goto nla_put_failure;
11378
11379 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11380 if (!func_attr)
11381 goto nla_put_failure;
11382
11383 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
11384 func->instance_id))
11385 goto nla_put_failure;
11386
11387 nla_nest_end(msg, func_attr);
11388
11389 genlmsg_end(msg, hdr);
11390 return genlmsg_reply(msg, info);
11391
11392nla_put_failure:
11393 nlmsg_free(msg);
11394 return -ENOBUFS;
11395}
11396
11397static int nl80211_nan_del_func(struct sk_buff *skb,
11398 struct genl_info *info)
11399{
11400 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11401 struct wireless_dev *wdev = info->user_ptr[1];
11402 u64 cookie;
11403
11404 if (wdev->iftype != NL80211_IFTYPE_NAN)
11405 return -EOPNOTSUPP;
11406
73c7da3d 11407 if (!wdev_running(wdev))
a442b761
AB		 11408 return -ENOTCONN;
11409
11410 if (!info->attrs[NL80211_ATTR_COOKIE])
11411 return -EINVAL;
11412
11413 if (wdev->owner_nlportid &&
11414 wdev->owner_nlportid != info->snd_portid)
11415 return -ENOTCONN;
11416
11417 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11418
11419 rdev_del_nan_func(rdev, wdev, cookie);
11420
11421 return 0;
11422}
11423
a5a9dcf2
AB		 11424static int nl80211_nan_change_config(struct sk_buff *skb,
11425 struct genl_info *info)
11426{
11427 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11428 struct wireless_dev *wdev = info->user_ptr[1];
11429 struct cfg80211_nan_conf conf = {};
11430 u32 changed = 0;
11431
11432 if (wdev->iftype != NL80211_IFTYPE_NAN)
11433 return -EOPNOTSUPP;
11434
73c7da3d 11435 if (!wdev_running(wdev))
a5a9dcf2
AB		 11436 return -ENOTCONN;
11437
11438 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
11439 conf.master_pref =
11440 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11441 if (conf.master_pref <= 1 || conf.master_pref == 255)
11442 return -EINVAL;
11443
11444 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
11445 }
11446
8585989d
LC		 11447 if (info->attrs[NL80211_ATTR_BANDS]) {
11448 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11449
11450 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11451 return -EOPNOTSUPP;
11452
11453 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11454 return -EINVAL;
11455
11456 conf.bands = bands;
11457 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
a5a9dcf2
AB		 11458 }
11459
11460 if (!changed)
11461 return -EINVAL;
11462
11463 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
11464}
11465
50bcd31d
AB		 11466void cfg80211_nan_match(struct wireless_dev *wdev,
11467 struct cfg80211_nan_match_params *match, gfp_t gfp)
11468{
11469 struct wiphy *wiphy = wdev->wiphy;
11470 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11471 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
11472 struct sk_buff *msg;
11473 void *hdr;
11474
11475 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
11476 return;
11477
11478 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11479 if (!msg)
11480 return;
11481
11482 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
11483 if (!hdr) {
11484 nlmsg_free(msg);
11485 return;
11486 }
11487
11488 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11489 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11490 wdev->netdev->ifindex)) ||
11491 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11492 NL80211_ATTR_PAD))
11493 goto nla_put_failure;
11494
11495 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
11496 NL80211_ATTR_PAD) ||
11497 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
11498 goto nla_put_failure;
11499
11500 match_attr = nla_nest_start(msg, NL80211_ATTR_NAN_MATCH);
11501 if (!match_attr)
11502 goto nla_put_failure;
11503
11504 local_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_LOCAL);
11505 if (!local_func_attr)
11506 goto nla_put_failure;
11507
11508 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
11509 goto nla_put_failure;
11510
11511 nla_nest_end(msg, local_func_attr);
11512
11513 peer_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_PEER);
11514 if (!peer_func_attr)
11515 goto nla_put_failure;
11516
11517 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
11518 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
11519 goto nla_put_failure;
11520
11521 if (match->info && match->info_len &&
11522 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
11523 match->info))
11524 goto nla_put_failure;
11525
11526 nla_nest_end(msg, peer_func_attr);
11527 nla_nest_end(msg, match_attr);
11528 genlmsg_end(msg, hdr);
11529
11530 if (!wdev->owner_nlportid)
11531 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11532 msg, 0, NL80211_MCGRP_NAN, gfp);
11533 else
11534 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11535 wdev->owner_nlportid);
11536
11537 return;
11538
11539nla_put_failure:
11540 nlmsg_free(msg);
11541}
11542EXPORT_SYMBOL(cfg80211_nan_match);
11543
368e5a7b
AB		 11544void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
11545 u8 inst_id,
11546 enum nl80211_nan_func_term_reason reason,
11547 u64 cookie, gfp_t gfp)
11548{
11549 struct wiphy *wiphy = wdev->wiphy;
11550 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11551 struct sk_buff *msg;
11552 struct nlattr *func_attr;
11553 void *hdr;
11554
11555 if (WARN_ON(!inst_id))
11556 return;
11557
11558 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11559 if (!msg)
11560 return;
11561
11562 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
11563 if (!hdr) {
11564 nlmsg_free(msg);
11565 return;
11566 }
11567
11568 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11569 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11570 wdev->netdev->ifindex)) ||
11571 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11572 NL80211_ATTR_PAD))
11573 goto nla_put_failure;
11574
11575 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11576 NL80211_ATTR_PAD))
11577 goto nla_put_failure;
11578
11579 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11580 if (!func_attr)
11581 goto nla_put_failure;
11582
11583 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
11584 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
11585 goto nla_put_failure;
11586
11587 nla_nest_end(msg, func_attr);
11588 genlmsg_end(msg, hdr);
11589
11590 if (!wdev->owner_nlportid)
11591 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11592 msg, 0, NL80211_MCGRP_NAN, gfp);
11593 else
11594 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11595 wdev->owner_nlportid);
11596
11597 return;
11598
11599nla_put_failure:
11600 nlmsg_free(msg);
11601}
11602EXPORT_SYMBOL(cfg80211_nan_func_terminated);
11603
3713b4e3
JB		 11604static int nl80211_get_protocol_features(struct sk_buff *skb,
11605 struct genl_info *info)
11606{
11607 void *hdr;
11608 struct sk_buff *msg;
11609
11610 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11611 if (!msg)
11612 return -ENOMEM;
11613
11614 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11615 NL80211_CMD_GET_PROTOCOL_FEATURES);
11616 if (!hdr)
11617 goto nla_put_failure;
11618
11619 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
11620 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
11621 goto nla_put_failure;
11622
11623 genlmsg_end(msg, hdr);
11624 return genlmsg_reply(msg, info);
11625
11626 nla_put_failure:
11627 kfree_skb(msg);
11628 return -ENOBUFS;
11629}
11630
355199e0
JM		 11631static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
11632{
11633 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11634 struct cfg80211_update_ft_ies_params ft_params;
11635 struct net_device *dev = info->user_ptr[1];
11636
11637 if (!rdev->ops->update_ft_ies)
11638 return -EOPNOTSUPP;
11639
11640 if (!info->attrs[NL80211_ATTR_MDID] ||
11641 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
11642 return -EINVAL;
11643
11644 memset(&ft_params, 0, sizeof(ft_params));
11645 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
11646 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11647 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11648
11649 return rdev_update_ft_ies(rdev, dev, &ft_params);
11650}
11651
5de17984
AS		 11652static int nl80211_crit_protocol_start(struct sk_buff *skb,
11653 struct genl_info *info)
11654{
11655 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11656 struct wireless_dev *wdev = info->user_ptr[1];
11657 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
11658 u16 duration;
11659 int ret;
11660
11661 if (!rdev->ops->crit_proto_start)
11662 return -EOPNOTSUPP;
11663
11664 if (WARN_ON(!rdev->ops->crit_proto_stop))
11665 return -EINVAL;
11666
11667 if (rdev->crit_proto_nlportid)
11668 return -EBUSY;
11669
11670 /* determine protocol if provided */
11671 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
11672 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
11673
11674 if (proto >= NUM_NL80211_CRIT_PROTO)
11675 return -EINVAL;
11676
11677 /* timeout must be provided */
11678 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
11679 return -EINVAL;
11680
11681 duration =
11682 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
11683
11684 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
11685 return -ERANGE;
11686
11687 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
11688 if (!ret)
11689 rdev->crit_proto_nlportid = info->snd_portid;
11690
11691 return ret;
11692}
11693
11694static int nl80211_crit_protocol_stop(struct sk_buff *skb,
11695 struct genl_info *info)
11696{
11697 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11698 struct wireless_dev *wdev = info->user_ptr[1];
11699
11700 if (!rdev->ops->crit_proto_stop)
11701 return -EOPNOTSUPP;
11702
11703 if (rdev->crit_proto_nlportid) {
11704 rdev->crit_proto_nlportid = 0;
11705 rdev_crit_proto_stop(rdev, wdev);
11706 }
11707 return 0;
11708}
11709
ad7e718c
JB		 11710static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
11711{
11712 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11713 struct wireless_dev *wdev =
11714 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
11715 int i, err;
11716 u32 vid, subcmd;
11717
11718 if (!rdev->wiphy.vendor_commands)
11719 return -EOPNOTSUPP;
11720
11721 if (IS_ERR(wdev)) {
11722 err = PTR_ERR(wdev);
11723 if (err != -EINVAL)
11724 return err;
11725 wdev = NULL;
11726 } else if (wdev->wiphy != &rdev->wiphy) {
11727 return -EINVAL;
11728 }
11729
11730 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
11731 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
11732 return -EINVAL;
11733
11734 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
11735 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
11736 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
11737 const struct wiphy_vendor_command *vcmd;
11738 void *data = NULL;
11739 int len = 0;
11740
11741 vcmd = &rdev->wiphy.vendor_commands[i];
11742
11743 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11744 continue;
11745
11746 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11747 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
11748 if (!wdev)
11749 return -EINVAL;
11750 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
11751 !wdev->netdev)
11752 return -EINVAL;
11753
11754 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
73c7da3d 11755 if (!wdev_running(wdev))
ad7e718c
JB		 11756 return -ENETDOWN;
11757 }
7bdbe400
JB		 11758
11759 if (!vcmd->doit)
11760 return -EOPNOTSUPP;
ad7e718c
JB		 11761 } else {
11762 wdev = NULL;
11763 }
11764
11765 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
11766 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11767 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11768 }
11769
11770 rdev->cur_cmd_info = info;
11771 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
11772 data, len);
11773 rdev->cur_cmd_info = NULL;
11774 return err;
11775 }
11776
11777 return -EOPNOTSUPP;
11778}
11779
7bdbe400
JB		 11780static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
11781 struct netlink_callback *cb,
11782 struct cfg80211_registered_device **rdev,
11783 struct wireless_dev **wdev)
11784{
c90c39da 11785 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
7bdbe400
JB		 11786 u32 vid, subcmd;
11787 unsigned int i;
11788 int vcmd_idx = -1;
11789 int err;
11790 void *data = NULL;
11791 unsigned int data_len = 0;
11792
7bdbe400
JB		 11793 if (cb->args[0]) {
11794 /* subtract the 1 again here */
11795 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
11796 struct wireless_dev *tmp;
11797
ea90e0dc
JB		 11798 if (!wiphy)
11799 return -ENODEV;
7bdbe400
JB		 11800 *rdev = wiphy_to_rdev(wiphy);
11801 *wdev = NULL;
11802
11803 if (cb->args[1]) {
53873f13 11804 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
7bdbe400
JB		 11805 if (tmp->identifier == cb->args[1] - 1) {
11806 *wdev = tmp;
11807 break;
11808 }
11809 }
11810 }
11811
11812 /* keep rtnl locked in successful case */
11813 return 0;
11814 }
11815
fceb6435
JB		 11816 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, attrbuf,
11817 nl80211_fam.maxattr, nl80211_policy, NULL);
7bdbe400 11818 if (err)
ea90e0dc 11819 return err;
7bdbe400 11820
c90c39da 11821 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
ea90e0dc
JB		 11822 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD])
11823 return -EINVAL;
7bdbe400 11824
c90c39da 11825 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
7bdbe400
JB		 11826 if (IS_ERR(*wdev))
11827 *wdev = NULL;
11828
c90c39da 11829 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
ea90e0dc
JB		 11830 if (IS_ERR(*rdev))
11831 return PTR_ERR(*rdev);
7bdbe400 11832
c90c39da
JB		 11833 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
11834 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
7bdbe400
JB		 11835
11836 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
11837 const struct wiphy_vendor_command *vcmd;
11838
11839 vcmd = &(*rdev)->wiphy.vendor_commands[i];
11840
11841 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11842 continue;
11843
ea90e0dc
JB		 11844 if (!vcmd->dumpit)
11845 return -EOPNOTSUPP;
7bdbe400
JB		 11846
11847 vcmd_idx = i;
11848 break;
11849 }
11850
ea90e0dc
JB		 11851 if (vcmd_idx < 0)
11852 return -EOPNOTSUPP;
7bdbe400 11853
c90c39da
JB		 11854 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
11855 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
11856 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
7bdbe400
JB		 11857 }
11858
11859 /* 0 is the first index - add 1 to parse only once */
11860 cb->args[0] = (*rdev)->wiphy_idx + 1;
11861 /* add 1 to know if it was NULL */
11862 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
11863 cb->args[2] = vcmd_idx;
11864 cb->args[3] = (unsigned long)data;
11865 cb->args[4] = data_len;
11866
11867 /* keep rtnl locked in successful case */
11868 return 0;
7bdbe400
JB		 11869}
11870
11871static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
11872 struct netlink_callback *cb)
11873{
11874 struct cfg80211_registered_device *rdev;
11875 struct wireless_dev *wdev;
11876 unsigned int vcmd_idx;
11877 const struct wiphy_vendor_command *vcmd;
11878 void *data;
11879 int data_len;
11880 int err;
11881 struct nlattr *vendor_data;
11882
ea90e0dc 11883 rtnl_lock();
7bdbe400
JB		 11884 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
11885 if (err)
ea90e0dc 11886 goto out;
7bdbe400
JB		 11887
11888 vcmd_idx = cb->args[2];
11889 data = (void *)cb->args[3];
11890 data_len = cb->args[4];
11891 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
11892
11893 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11894 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
ea90e0dc
JB		 11895 if (!wdev) {
11896 err = -EINVAL;
11897 goto out;
11898 }
7bdbe400 11899 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
ea90e0dc
JB		 11900 !wdev->netdev) {
11901 err = -EINVAL;
11902 goto out;
11903 }
7bdbe400
JB		 11904
11905 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
ea90e0dc
JB		 11906 if (!wdev_running(wdev)) {
11907 err = -ENETDOWN;
11908 goto out;
11909 }
7bdbe400
JB		 11910 }
11911 }
11912
11913 while (1) {
11914 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
11915 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11916 NL80211_CMD_VENDOR);
11917 if (!hdr)
11918 break;
11919
11920 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 11921 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
11922 wdev_id(wdev),
11923 NL80211_ATTR_PAD))) {
7bdbe400
JB		 11924 genlmsg_cancel(skb, hdr);
11925 break;
11926 }
11927
11928 vendor_data = nla_nest_start(skb, NL80211_ATTR_VENDOR_DATA);
11929 if (!vendor_data) {
11930 genlmsg_cancel(skb, hdr);
11931 break;
11932 }
11933
11934 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
11935 (unsigned long *)&cb->args[5]);
11936 nla_nest_end(skb, vendor_data);
11937
11938 if (err == -ENOBUFS || err == -ENOENT) {
11939 genlmsg_cancel(skb, hdr);
11940 break;
11941 } else if (err) {
11942 genlmsg_cancel(skb, hdr);
11943 goto out;
11944 }
11945
11946 genlmsg_end(skb, hdr);
11947 }
11948
11949 err = skb->len;
11950 out:
11951 rtnl_unlock();
11952 return err;
11953}
11954
ad7e718c
JB		 11955struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
11956 enum nl80211_commands cmd,
11957 enum nl80211_attrs attr,
11958 int approxlen)
11959{
f26cbf40 11960 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ad7e718c
JB		 11961
11962 if (WARN_ON(!rdev->cur_cmd_info))
11963 return NULL;
11964
6c09e791 11965 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
ad7e718c
JB		 11966 rdev->cur_cmd_info->snd_portid,
11967 rdev->cur_cmd_info->snd_seq,
567ffc35 11968 cmd, attr, NULL, GFP_KERNEL);
ad7e718c
JB		 11969}
11970EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
11971
11972int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
11973{
11974 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
11975 void *hdr = ((void **)skb->cb)[1];
11976 struct nlattr *data = ((void **)skb->cb)[2];
11977
bd8c78e7
JB		 11978 /* clear CB data for netlink core to own from now on */
11979 memset(skb->cb, 0, sizeof(skb->cb));
11980
ad7e718c
JB		 11981 if (WARN_ON(!rdev->cur_cmd_info)) {
11982 kfree_skb(skb);
11983 return -EINVAL;
11984 }
11985
11986 nla_nest_end(skb, data);
11987 genlmsg_end(skb, hdr);
11988 return genlmsg_reply(skb, rdev->cur_cmd_info);
11989}
11990EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
11991
fa9ffc74
KP		 11992static int nl80211_set_qos_map(struct sk_buff *skb,
11993 struct genl_info *info)
11994{
11995 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11996 struct cfg80211_qos_map *qos_map = NULL;
11997 struct net_device *dev = info->user_ptr[1];
11998 u8 *pos, len, num_des, des_len, des;
11999 int ret;
12000
12001 if (!rdev->ops->set_qos_map)
12002 return -EOPNOTSUPP;
12003
12004 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
12005 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
12006 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
12007
12008 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
12009 len > IEEE80211_QOS_MAP_LEN_MAX)
12010 return -EINVAL;
12011
12012 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
12013 if (!qos_map)
12014 return -ENOMEM;
12015
12016 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
12017 if (num_des) {
12018 des_len = num_des *
12019 sizeof(struct cfg80211_dscp_exception);
12020 memcpy(qos_map->dscp_exception, pos, des_len);
12021 qos_map->num_des = num_des;
12022 for (des = 0; des < num_des; des++) {
12023 if (qos_map->dscp_exception[des].up > 7) {
12024 kfree(qos_map);
12025 return -EINVAL;
12026 }
12027 }
12028 pos += des_len;
12029 }
12030 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
12031 }
12032
12033 wdev_lock(dev->ieee80211_ptr);
12034 ret = nl80211_key_allowed(dev->ieee80211_ptr);
12035 if (!ret)
12036 ret = rdev_set_qos_map(rdev, dev, qos_map);
12037 wdev_unlock(dev->ieee80211_ptr);
12038
12039 kfree(qos_map);
12040 return ret;
12041}
12042
960d01ac
JB		 12043static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
12044{
12045 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12046 struct net_device *dev = info->user_ptr[1];
12047 struct wireless_dev *wdev = dev->ieee80211_ptr;
12048 const u8 *peer;
12049 u8 tsid, up;
12050 u16 admitted_time = 0;
12051 int err;
12052
723e73ac 12053 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
960d01ac
JB		 12054 return -EOPNOTSUPP;
12055
12056 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
12057 !info->attrs[NL80211_ATTR_USER_PRIO])
12058 return -EINVAL;
12059
12060 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12061 if (tsid >= IEEE80211_NUM_TIDS)
12062 return -EINVAL;
12063
12064 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
12065 if (up >= IEEE80211_NUM_UPS)
12066 return -EINVAL;
12067
12068 /* WMM uses TIDs 0-7 even for TSPEC */
723e73ac 12069 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
960d01ac 12070 /* TODO: handle 802.11 TSPEC/admission control
723e73ac
JB		 12071 * need more attributes for that (e.g. BA session requirement);
12072 * change the WMM adminssion test above to allow both then
960d01ac
JB		 12073 */
12074 return -EINVAL;
12075 }
12076
12077 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12078
12079 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
12080 admitted_time =
12081 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
12082 if (!admitted_time)
12083 return -EINVAL;
12084 }
12085
12086 wdev_lock(wdev);
12087 switch (wdev->iftype) {
12088 case NL80211_IFTYPE_STATION:
12089 case NL80211_IFTYPE_P2P_CLIENT:
12090 if (wdev->current_bss)
12091 break;
12092 err = -ENOTCONN;
12093 goto out;
12094 default:
12095 err = -EOPNOTSUPP;
12096 goto out;
12097 }
12098
12099 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
12100
12101 out:
12102 wdev_unlock(wdev);
12103 return err;
12104}
12105
12106static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
12107{
12108 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12109 struct net_device *dev = info->user_ptr[1];
12110 struct wireless_dev *wdev = dev->ieee80211_ptr;
12111 const u8 *peer;
12112 u8 tsid;
12113 int err;
12114
12115 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
12116 return -EINVAL;
12117
12118 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12119 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12120
12121 wdev_lock(wdev);
12122 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
12123 wdev_unlock(wdev);
12124
12125 return err;
12126}
12127
1057d35e
AN		 12128static int nl80211_tdls_channel_switch(struct sk_buff *skb,
12129 struct genl_info *info)
12130{
12131 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12132 struct net_device *dev = info->user_ptr[1];
12133 struct wireless_dev *wdev = dev->ieee80211_ptr;
12134 struct cfg80211_chan_def chandef = {};
12135 const u8 *addr;
12136 u8 oper_class;
12137 int err;
12138
12139 if (!rdev->ops->tdls_channel_switch ||
12140 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12141 return -EOPNOTSUPP;
12142
12143 switch (dev->ieee80211_ptr->iftype) {
12144 case NL80211_IFTYPE_STATION:
12145 case NL80211_IFTYPE_P2P_CLIENT:
12146 break;
12147 default:
12148 return -EOPNOTSUPP;
12149 }
12150
12151 if (!info->attrs[NL80211_ATTR_MAC] ||
12152 !info->attrs[NL80211_ATTR_OPER_CLASS])
12153 return -EINVAL;
12154
12155 err = nl80211_parse_chandef(rdev, info, &chandef);
12156 if (err)
12157 return err;
12158
12159 /*
12160 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
12161 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
12162 * specification is not defined for them.
12163 */
57fbcce3 12164 if (chandef.chan->band == NL80211_BAND_2GHZ &&
1057d35e
AN		 12165 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
12166 chandef.width != NL80211_CHAN_WIDTH_20)
12167 return -EINVAL;
12168
12169 /* we will be active on the TDLS link */
923b352f
AN		 12170 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
12171 wdev->iftype))
1057d35e
AN		 12172 return -EINVAL;
12173
12174 /* don't allow switching to DFS channels */
12175 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
12176 return -EINVAL;
12177
12178 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12179 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
12180
12181 wdev_lock(wdev);
12182 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
12183 wdev_unlock(wdev);
12184
12185 return err;
12186}
12187
12188static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
12189 struct genl_info *info)
12190{
12191 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12192 struct net_device *dev = info->user_ptr[1];
12193 struct wireless_dev *wdev = dev->ieee80211_ptr;
12194 const u8 *addr;
12195
12196 if (!rdev->ops->tdls_channel_switch ||
12197 !rdev->ops->tdls_cancel_channel_switch ||
12198 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12199 return -EOPNOTSUPP;
12200
12201 switch (dev->ieee80211_ptr->iftype) {
12202 case NL80211_IFTYPE_STATION:
12203 case NL80211_IFTYPE_P2P_CLIENT:
12204 break;
12205 default:
12206 return -EOPNOTSUPP;
12207 }
12208
12209 if (!info->attrs[NL80211_ATTR_MAC])
12210 return -EINVAL;
12211
12212 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12213
12214 wdev_lock(wdev);
12215 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
12216 wdev_unlock(wdev);
12217
12218 return 0;
12219}
12220
ce0ce13a
MB		 12221static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
12222 struct genl_info *info)
12223{
12224 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12225 struct net_device *dev = info->user_ptr[1];
12226 struct wireless_dev *wdev = dev->ieee80211_ptr;
12227 const struct nlattr *nla;
12228 bool enabled;
12229
ce0ce13a
MB		 12230 if (!rdev->ops->set_multicast_to_unicast)
12231 return -EOPNOTSUPP;
12232
12233 if (wdev->iftype != NL80211_IFTYPE_AP &&
12234 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12235 return -EOPNOTSUPP;
12236
12237 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
12238 enabled = nla_get_flag(nla);
12239
12240 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
12241}
12242
4c476991
JB		 12243#define NL80211_FLAG_NEED_WIPHY 0x01
12244#define NL80211_FLAG_NEED_NETDEV 0x02
12245#define NL80211_FLAG_NEED_RTNL 0x04
41265714
JB		 12246#define NL80211_FLAG_CHECK_NETDEV_UP 0x08
12247#define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
12248 NL80211_FLAG_CHECK_NETDEV_UP)
1bf614ef 12249#define NL80211_FLAG_NEED_WDEV 0x10
98104fde 12250/* If a netdev is associated, it must be UP, P2P must be started */
1bf614ef
JB		 12251#define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
12252 NL80211_FLAG_CHECK_NETDEV_UP)
5393b917 12253#define NL80211_FLAG_CLEAR_SKB 0x20
4c476991 12254
f84f771d 12255static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12256 struct genl_info *info)
12257{
12258 struct cfg80211_registered_device *rdev;
89a54e48 12259 struct wireless_dev *wdev;
4c476991 12260 struct net_device *dev;
4c476991
JB		 12261 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
12262
12263 if (rtnl)
12264 rtnl_lock();
12265
12266 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
4f7eff10 12267 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
4c476991
JB		 12268 if (IS_ERR(rdev)) {
12269 if (rtnl)
12270 rtnl_unlock();
12271 return PTR_ERR(rdev);
12272 }
12273 info->user_ptr[0] = rdev;
1bf614ef
JB		 12274 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
12275 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
5fe231e8
JB		 12276 ASSERT_RTNL();
12277
89a54e48
JB		 12278 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
12279 info->attrs);
12280 if (IS_ERR(wdev)) {
4c476991
JB		 12281 if (rtnl)
12282 rtnl_unlock();
89a54e48 12283 return PTR_ERR(wdev);
4c476991 12284 }
89a54e48 12285
89a54e48 12286 dev = wdev->netdev;
f26cbf40 12287 rdev = wiphy_to_rdev(wdev->wiphy);
89a54e48 12288
1bf614ef
JB		 12289 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
12290 if (!dev) {
1bf614ef
JB		 12291 if (rtnl)
12292 rtnl_unlock();
12293 return -EINVAL;
12294 }
12295
12296 info->user_ptr[1] = dev;
12297 } else {
12298 info->user_ptr[1] = wdev;
41265714 12299 }
1bf614ef 12300
73c7da3d
AVS		 12301 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
12302 !wdev_running(wdev)) {
12303 if (rtnl)
12304 rtnl_unlock();
12305 return -ENETDOWN;
12306 }
1bf614ef 12307
73c7da3d 12308 if (dev)
1bf614ef 12309 dev_hold(dev);
89a54e48 12310
4c476991 12311 info->user_ptr[0] = rdev;
4c476991
JB		 12312 }
12313
12314 return 0;
12315}
12316
f84f771d 12317static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12318 struct genl_info *info)
12319{
1bf614ef
JB		 12320 if (info->user_ptr[1]) {
12321 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
12322 struct wireless_dev *wdev = info->user_ptr[1];
12323
12324 if (wdev->netdev)
12325 dev_put(wdev->netdev);
12326 } else {
12327 dev_put(info->user_ptr[1]);
12328 }
12329 }
5393b917 12330
4c476991
JB		 12331 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
12332 rtnl_unlock();
5393b917
JB		 12333
12334 /* If needed, clear the netlink message payload from the SKB
12335 * as it might contain key data that shouldn't stick around on
12336 * the heap after the SKB is freed. The netlink message header
12337 * is still needed for further processing, so leave it intact.
12338 */
12339 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
12340 struct nlmsghdr *nlh = nlmsg_hdr(skb);
12341
12342 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
12343 }
4c476991
JB		 12344}
12345
4534de83 12346static const struct genl_ops nl80211_ops[] = {
55682965
JB		 12347 {
12348 .cmd = NL80211_CMD_GET_WIPHY,
12349 .doit = nl80211_get_wiphy,
12350 .dumpit = nl80211_dump_wiphy,
86e8cf98 12351 .done = nl80211_dump_wiphy_done,
55682965
JB		 12352 .policy = nl80211_policy,
12353 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12354 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12355 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12356 },
12357 {
12358 .cmd = NL80211_CMD_SET_WIPHY,
12359 .doit = nl80211_set_wiphy,
12360 .policy = nl80211_policy,
5617c6cd 12361 .flags = GENL_UNS_ADMIN_PERM,
4c476991 12362 .internal_flags = NL80211_FLAG_NEED_RTNL,
55682965
JB		 12363 },
12364 {
12365 .cmd = NL80211_CMD_GET_INTERFACE,
12366 .doit = nl80211_get_interface,
12367 .dumpit = nl80211_dump_interface,
12368 .policy = nl80211_policy,
12369 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12370 .internal_flags = NL80211_FLAG_NEED_WDEV |
12371 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12372 },
12373 {
12374 .cmd = NL80211_CMD_SET_INTERFACE,
12375 .doit = nl80211_set_interface,
12376 .policy = nl80211_policy,
5617c6cd 12377 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12378 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12379 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12380 },
12381 {
12382 .cmd = NL80211_CMD_NEW_INTERFACE,
12383 .doit = nl80211_new_interface,
12384 .policy = nl80211_policy,
5617c6cd 12385 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12386 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12387 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12388 },
12389 {
12390 .cmd = NL80211_CMD_DEL_INTERFACE,
12391 .doit = nl80211_del_interface,
12392 .policy = nl80211_policy,
5617c6cd 12393 .flags = GENL_UNS_ADMIN_PERM,
84efbb84 12394 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12395 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12396 },
12397 {
12398 .cmd = NL80211_CMD_GET_KEY,
12399 .doit = nl80211_get_key,
12400 .policy = nl80211_policy,
5617c6cd 12401 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12402 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12403 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12404 },
12405 {
12406 .cmd = NL80211_CMD_SET_KEY,
12407 .doit = nl80211_set_key,
12408 .policy = nl80211_policy,
5617c6cd 12409 .flags = GENL_UNS_ADMIN_PERM,
41265714 12410 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12411 NL80211_FLAG_NEED_RTNL |
12412 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12413 },
12414 {
12415 .cmd = NL80211_CMD_NEW_KEY,
12416 .doit = nl80211_new_key,
12417 .policy = nl80211_policy,
5617c6cd 12418 .flags = GENL_UNS_ADMIN_PERM,
41265714 12419 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12420 NL80211_FLAG_NEED_RTNL |
12421 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12422 },
12423 {
12424 .cmd = NL80211_CMD_DEL_KEY,
12425 .doit = nl80211_del_key,
12426 .policy = nl80211_policy,
5617c6cd 12427 .flags = GENL_UNS_ADMIN_PERM,
41265714 12428 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12429 NL80211_FLAG_NEED_RTNL,
55682965 12430 },
ed1b6cc7
JB		 12431 {
12432 .cmd = NL80211_CMD_SET_BEACON,
12433 .policy = nl80211_policy,
5617c6cd 12434 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12435 .doit = nl80211_set_beacon,
2b5f8b0b 12436 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12437 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12438 },
12439 {
8860020e 12440 .cmd = NL80211_CMD_START_AP,
ed1b6cc7 12441 .policy = nl80211_policy,
5617c6cd 12442 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12443 .doit = nl80211_start_ap,
2b5f8b0b 12444 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12445 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12446 },
12447 {
8860020e 12448 .cmd = NL80211_CMD_STOP_AP,
ed1b6cc7 12449 .policy = nl80211_policy,
5617c6cd 12450 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12451 .doit = nl80211_stop_ap,
2b5f8b0b 12452 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12453 NL80211_FLAG_NEED_RTNL,
ed1b6cc7 12454 },
5727ef1b
JB		 12455 {
12456 .cmd = NL80211_CMD_GET_STATION,
12457 .doit = nl80211_get_station,
2ec600d6 12458 .dumpit = nl80211_dump_station,
5727ef1b 12459 .policy = nl80211_policy,
4c476991
JB		 12460 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12461 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12462 },
12463 {
12464 .cmd = NL80211_CMD_SET_STATION,
12465 .doit = nl80211_set_station,
12466 .policy = nl80211_policy,
5617c6cd 12467 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12468 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12469 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12470 },
12471 {
12472 .cmd = NL80211_CMD_NEW_STATION,
12473 .doit = nl80211_new_station,
12474 .policy = nl80211_policy,
5617c6cd 12475 .flags = GENL_UNS_ADMIN_PERM,
41265714 12476 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12477 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12478 },
12479 {
12480 .cmd = NL80211_CMD_DEL_STATION,
12481 .doit = nl80211_del_station,
12482 .policy = nl80211_policy,
5617c6cd 12483 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12484 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12485 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12486 },
12487 {
12488 .cmd = NL80211_CMD_GET_MPATH,
12489 .doit = nl80211_get_mpath,
12490 .dumpit = nl80211_dump_mpath,
12491 .policy = nl80211_policy,
5617c6cd 12492 .flags = GENL_UNS_ADMIN_PERM,
41265714 12493 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12494 NL80211_FLAG_NEED_RTNL,
2ec600d6 12495 },
66be7d2b
HR		 12496 {
12497 .cmd = NL80211_CMD_GET_MPP,
12498 .doit = nl80211_get_mpp,
12499 .dumpit = nl80211_dump_mpp,
12500 .policy = nl80211_policy,
5617c6cd 12501 .flags = GENL_UNS_ADMIN_PERM,
66be7d2b
HR		 12502 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12503 NL80211_FLAG_NEED_RTNL,
12504 },
2ec600d6
LCC		 12505 {
12506 .cmd = NL80211_CMD_SET_MPATH,
12507 .doit = nl80211_set_mpath,
12508 .policy = nl80211_policy,
5617c6cd 12509 .flags = GENL_UNS_ADMIN_PERM,
41265714 12510 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12511 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12512 },
12513 {
12514 .cmd = NL80211_CMD_NEW_MPATH,
12515 .doit = nl80211_new_mpath,
12516 .policy = nl80211_policy,
5617c6cd 12517 .flags = GENL_UNS_ADMIN_PERM,
41265714 12518 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12519 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12520 },
12521 {
12522 .cmd = NL80211_CMD_DEL_MPATH,
12523 .doit = nl80211_del_mpath,
12524 .policy = nl80211_policy,
5617c6cd 12525 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12526 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12527 NL80211_FLAG_NEED_RTNL,
9f1ba906
JM		 12528 },
12529 {
12530 .cmd = NL80211_CMD_SET_BSS,
12531 .doit = nl80211_set_bss,
12532 .policy = nl80211_policy,
5617c6cd 12533 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12534 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12535 NL80211_FLAG_NEED_RTNL,
b2e1b302 12536 },
f130347c
LR		 12537 {
12538 .cmd = NL80211_CMD_GET_REG,
ad30ca2c
AN		 12539 .doit = nl80211_get_reg_do,
12540 .dumpit = nl80211_get_reg_dump,
f130347c 12541 .policy = nl80211_policy,
5fe231e8 12542 .internal_flags = NL80211_FLAG_NEED_RTNL,
f130347c
LR		 12543 /* can be retrieved by unprivileged users */
12544 },
b6863036 12545#ifdef CONFIG_CFG80211_CRDA_SUPPORT
b2e1b302
LR		 12546 {
12547 .cmd = NL80211_CMD_SET_REG,
12548 .doit = nl80211_set_reg,
12549 .policy = nl80211_policy,
12550 .flags = GENL_ADMIN_PERM,
5fe231e8 12551 .internal_flags = NL80211_FLAG_NEED_RTNL,
b2e1b302 12552 },
b6863036 12553#endif
b2e1b302
LR		 12554 {
12555 .cmd = NL80211_CMD_REQ_SET_REG,
12556 .doit = nl80211_req_set_reg,
12557 .policy = nl80211_policy,
93da9cc1 12558 .flags = GENL_ADMIN_PERM,
12559 },
12560 {
24bdd9f4
JC		 12561 .cmd = NL80211_CMD_GET_MESH_CONFIG,
12562 .doit = nl80211_get_mesh_config,
93da9cc1 12563 .policy = nl80211_policy,
12564 /* can be retrieved by unprivileged users */
2b5f8b0b 12565 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12566 NL80211_FLAG_NEED_RTNL,
93da9cc1 12567 },
12568 {
24bdd9f4
JC		 12569 .cmd = NL80211_CMD_SET_MESH_CONFIG,
12570 .doit = nl80211_update_mesh_config,
93da9cc1 12571 .policy = nl80211_policy,
5617c6cd 12572 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c 12573 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12574 NL80211_FLAG_NEED_RTNL,
9aed3cc1 12575 },
2a519311
JB		 12576 {
12577 .cmd = NL80211_CMD_TRIGGER_SCAN,
12578 .doit = nl80211_trigger_scan,
12579 .policy = nl80211_policy,
5617c6cd 12580 .flags = GENL_UNS_ADMIN_PERM,
fd014284 12581 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12582 NL80211_FLAG_NEED_RTNL,
2a519311 12583 },
91d3ab46
VK		 12584 {
12585 .cmd = NL80211_CMD_ABORT_SCAN,
12586 .doit = nl80211_abort_scan,
12587 .policy = nl80211_policy,
5617c6cd 12588 .flags = GENL_UNS_ADMIN_PERM,
91d3ab46
VK		 12589 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12590 NL80211_FLAG_NEED_RTNL,
12591 },
2a519311
JB		 12592 {
12593 .cmd = NL80211_CMD_GET_SCAN,
12594 .policy = nl80211_policy,
12595 .dumpit = nl80211_dump_scan,
12596 },
807f8a8c
LC		 12597 {
12598 .cmd = NL80211_CMD_START_SCHED_SCAN,
12599 .doit = nl80211_start_sched_scan,
12600 .policy = nl80211_policy,
5617c6cd 12601 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12602 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12603 NL80211_FLAG_NEED_RTNL,
12604 },
12605 {
12606 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
12607 .doit = nl80211_stop_sched_scan,
12608 .policy = nl80211_policy,
5617c6cd 12609 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12610 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12611 NL80211_FLAG_NEED_RTNL,
12612 },
636a5d36
JM		 12613 {
12614 .cmd = NL80211_CMD_AUTHENTICATE,
12615 .doit = nl80211_authenticate,
12616 .policy = nl80211_policy,
5617c6cd 12617 .flags = GENL_UNS_ADMIN_PERM,
41265714 12618 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12619 NL80211_FLAG_NEED_RTNL |
12620 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 12621 },
12622 {
12623 .cmd = NL80211_CMD_ASSOCIATE,
12624 .doit = nl80211_associate,
12625 .policy = nl80211_policy,
5617c6cd 12626 .flags = GENL_UNS_ADMIN_PERM,
41265714 12627 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12628 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12629 },
12630 {
12631 .cmd = NL80211_CMD_DEAUTHENTICATE,
12632 .doit = nl80211_deauthenticate,
12633 .policy = nl80211_policy,
5617c6cd 12634 .flags = GENL_UNS_ADMIN_PERM,
41265714 12635 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12636 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12637 },
12638 {
12639 .cmd = NL80211_CMD_DISASSOCIATE,
12640 .doit = nl80211_disassociate,
12641 .policy = nl80211_policy,
5617c6cd 12642 .flags = GENL_UNS_ADMIN_PERM,
41265714 12643 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12644 NL80211_FLAG_NEED_RTNL,
636a5d36 12645 },
04a773ad
JB		 12646 {
12647 .cmd = NL80211_CMD_JOIN_IBSS,
12648 .doit = nl80211_join_ibss,
12649 .policy = nl80211_policy,
5617c6cd 12650 .flags = GENL_UNS_ADMIN_PERM,
41265714 12651 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12652 NL80211_FLAG_NEED_RTNL,
04a773ad
JB		 12653 },
12654 {
12655 .cmd = NL80211_CMD_LEAVE_IBSS,
12656 .doit = nl80211_leave_ibss,
12657 .policy = nl80211_policy,
5617c6cd 12658 .flags = GENL_UNS_ADMIN_PERM,
41265714 12659 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12660 NL80211_FLAG_NEED_RTNL,
04a773ad 12661 },
aff89a9b
JB		 12662#ifdef CONFIG_NL80211_TESTMODE
12663 {
12664 .cmd = NL80211_CMD_TESTMODE,
12665 .doit = nl80211_testmode_do,
71063f0e 12666 .dumpit = nl80211_testmode_dump,
aff89a9b 12667 .policy = nl80211_policy,
5617c6cd 12668 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12669 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12670 NL80211_FLAG_NEED_RTNL,
aff89a9b
JB		 12671 },
12672#endif
b23aa676
SO		 12673 {
12674 .cmd = NL80211_CMD_CONNECT,
12675 .doit = nl80211_connect,
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,
b23aa676 12680 },
088e8df8 12681 {
12682 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
12683 .doit = nl80211_update_connect_params,
12684 .policy = nl80211_policy,
12685 .flags = GENL_ADMIN_PERM,
12686 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12687 NL80211_FLAG_NEED_RTNL,
12688 },
b23aa676
SO		 12689 {
12690 .cmd = NL80211_CMD_DISCONNECT,
12691 .doit = nl80211_disconnect,
12692 .policy = nl80211_policy,
5617c6cd 12693 .flags = GENL_UNS_ADMIN_PERM,
41265714 12694 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12695 NL80211_FLAG_NEED_RTNL,
b23aa676 12696 },
463d0183
JB		 12697 {
12698 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
12699 .doit = nl80211_wiphy_netns,
12700 .policy = nl80211_policy,
5617c6cd 12701 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12702 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12703 NL80211_FLAG_NEED_RTNL,
463d0183 12704 },
61fa713c
HS		 12705 {
12706 .cmd = NL80211_CMD_GET_SURVEY,
12707 .policy = nl80211_policy,
12708 .dumpit = nl80211_dump_survey,
12709 },
67fbb16b
SO		 12710 {
12711 .cmd = NL80211_CMD_SET_PMKSA,
12712 .doit = nl80211_setdel_pmksa,
12713 .policy = nl80211_policy,
5617c6cd 12714 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12715 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12716 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12717 },
12718 {
12719 .cmd = NL80211_CMD_DEL_PMKSA,
12720 .doit = nl80211_setdel_pmksa,
12721 .policy = nl80211_policy,
5617c6cd 12722 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12723 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12724 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12725 },
12726 {
12727 .cmd = NL80211_CMD_FLUSH_PMKSA,
12728 .doit = nl80211_flush_pmksa,
12729 .policy = nl80211_policy,
5617c6cd 12730 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12731 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12732 NL80211_FLAG_NEED_RTNL,
67fbb16b 12733 },
9588bbd5
JM		 12734 {
12735 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
12736 .doit = nl80211_remain_on_channel,
12737 .policy = nl80211_policy,
5617c6cd 12738 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12739 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12740 NL80211_FLAG_NEED_RTNL,
9588bbd5
JM		 12741 },
12742 {
12743 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
12744 .doit = nl80211_cancel_remain_on_channel,
12745 .policy = nl80211_policy,
5617c6cd 12746 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12747 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12748 NL80211_FLAG_NEED_RTNL,
9588bbd5 12749 },
13ae75b1
JM		 12750 {
12751 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
12752 .doit = nl80211_set_tx_bitrate_mask,
12753 .policy = nl80211_policy,
5617c6cd 12754 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12755 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12756 NL80211_FLAG_NEED_RTNL,
13ae75b1 12757 },
026331c4 12758 {
2e161f78
JB		 12759 .cmd = NL80211_CMD_REGISTER_FRAME,
12760 .doit = nl80211_register_mgmt,
026331c4 12761 .policy = nl80211_policy,
5617c6cd 12762 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12763 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12764 NL80211_FLAG_NEED_RTNL,
026331c4
JM		 12765 },
12766 {
2e161f78
JB		 12767 .cmd = NL80211_CMD_FRAME,
12768 .doit = nl80211_tx_mgmt,
026331c4 12769 .policy = nl80211_policy,
5617c6cd 12770 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12771 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
f7ca38df
JB		 12772 NL80211_FLAG_NEED_RTNL,
12773 },
12774 {
12775 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
12776 .doit = nl80211_tx_mgmt_cancel_wait,
12777 .policy = nl80211_policy,
5617c6cd 12778 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12779 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12780 NL80211_FLAG_NEED_RTNL,
026331c4 12781 },
ffb9eb3d
KV		 12782 {
12783 .cmd = NL80211_CMD_SET_POWER_SAVE,
12784 .doit = nl80211_set_power_save,
12785 .policy = nl80211_policy,
5617c6cd 12786 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12787 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12788 NL80211_FLAG_NEED_RTNL,
ffb9eb3d
KV		 12789 },
12790 {
12791 .cmd = NL80211_CMD_GET_POWER_SAVE,
12792 .doit = nl80211_get_power_save,
12793 .policy = nl80211_policy,
12794 /* can be retrieved by unprivileged users */
4c476991
JB		 12795 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12796 NL80211_FLAG_NEED_RTNL,
ffb9eb3d 12797 },
d6dc1a38
JO		 12798 {
12799 .cmd = NL80211_CMD_SET_CQM,
12800 .doit = nl80211_set_cqm,
12801 .policy = nl80211_policy,
5617c6cd 12802 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12803 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12804 NL80211_FLAG_NEED_RTNL,
d6dc1a38 12805 },
f444de05
JB		 12806 {
12807 .cmd = NL80211_CMD_SET_CHANNEL,
12808 .doit = nl80211_set_channel,
12809 .policy = nl80211_policy,
5617c6cd 12810 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12811 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12812 NL80211_FLAG_NEED_RTNL,
f444de05 12813 },
e8347eba
BJ		 12814 {
12815 .cmd = NL80211_CMD_SET_WDS_PEER,
12816 .doit = nl80211_set_wds_peer,
12817 .policy = nl80211_policy,
5617c6cd 12818 .flags = GENL_UNS_ADMIN_PERM,
43b19952
JB		 12819 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12820 NL80211_FLAG_NEED_RTNL,
e8347eba 12821 },
29cbe68c
JB		 12822 {
12823 .cmd = NL80211_CMD_JOIN_MESH,
12824 .doit = nl80211_join_mesh,
12825 .policy = nl80211_policy,
5617c6cd 12826 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12827 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12828 NL80211_FLAG_NEED_RTNL,
12829 },
12830 {
12831 .cmd = NL80211_CMD_LEAVE_MESH,
12832 .doit = nl80211_leave_mesh,
12833 .policy = nl80211_policy,
5617c6cd 12834 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12835 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12836 NL80211_FLAG_NEED_RTNL,
12837 },
6e0bd6c3
RL		 12838 {
12839 .cmd = NL80211_CMD_JOIN_OCB,
12840 .doit = nl80211_join_ocb,
12841 .policy = nl80211_policy,
5617c6cd 12842 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12843 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12844 NL80211_FLAG_NEED_RTNL,
12845 },
12846 {
12847 .cmd = NL80211_CMD_LEAVE_OCB,
12848 .doit = nl80211_leave_ocb,
12849 .policy = nl80211_policy,
5617c6cd 12850 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12851 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12852 NL80211_FLAG_NEED_RTNL,
12853 },
dfb89c56 12854#ifdef CONFIG_PM
ff1b6e69
JB		 12855 {
12856 .cmd = NL80211_CMD_GET_WOWLAN,
12857 .doit = nl80211_get_wowlan,
12858 .policy = nl80211_policy,
12859 /* can be retrieved by unprivileged users */
12860 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12861 NL80211_FLAG_NEED_RTNL,
12862 },
12863 {
12864 .cmd = NL80211_CMD_SET_WOWLAN,
12865 .doit = nl80211_set_wowlan,
12866 .policy = nl80211_policy,
5617c6cd 12867 .flags = GENL_UNS_ADMIN_PERM,
ff1b6e69
JB		 12868 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12869 NL80211_FLAG_NEED_RTNL,
12870 },
dfb89c56 12871#endif
e5497d76
JB		 12872 {
12873 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
12874 .doit = nl80211_set_rekey_data,
12875 .policy = nl80211_policy,
5617c6cd 12876 .flags = GENL_UNS_ADMIN_PERM,
e5497d76 12877 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12878 NL80211_FLAG_NEED_RTNL |
12879 NL80211_FLAG_CLEAR_SKB,
e5497d76 12880 },
109086ce
AN		 12881 {
12882 .cmd = NL80211_CMD_TDLS_MGMT,
12883 .doit = nl80211_tdls_mgmt,
12884 .policy = nl80211_policy,
5617c6cd 12885 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 12886 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12887 NL80211_FLAG_NEED_RTNL,
12888 },
12889 {
12890 .cmd = NL80211_CMD_TDLS_OPER,
12891 .doit = nl80211_tdls_oper,
12892 .policy = nl80211_policy,
5617c6cd 12893 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 12894 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12895 NL80211_FLAG_NEED_RTNL,
12896 },
28946da7
JB		 12897 {
12898 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
12899 .doit = nl80211_register_unexpected_frame,
12900 .policy = nl80211_policy,
5617c6cd 12901 .flags = GENL_UNS_ADMIN_PERM,
28946da7
JB		 12902 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12903 NL80211_FLAG_NEED_RTNL,
12904 },
7f6cf311
JB		 12905 {
12906 .cmd = NL80211_CMD_PROBE_CLIENT,
12907 .doit = nl80211_probe_client,
12908 .policy = nl80211_policy,
5617c6cd 12909 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12910 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7f6cf311
JB		 12911 NL80211_FLAG_NEED_RTNL,
12912 },
5e760230
JB		 12913 {
12914 .cmd = NL80211_CMD_REGISTER_BEACONS,
12915 .doit = nl80211_register_beacons,
12916 .policy = nl80211_policy,
5617c6cd 12917 .flags = GENL_UNS_ADMIN_PERM,
5e760230
JB		 12918 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12919 NL80211_FLAG_NEED_RTNL,
12920 },
1d9d9213
SW		 12921 {
12922 .cmd = NL80211_CMD_SET_NOACK_MAP,
12923 .doit = nl80211_set_noack_map,
12924 .policy = nl80211_policy,
5617c6cd 12925 .flags = GENL_UNS_ADMIN_PERM,
1d9d9213
SW		 12926 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12927 NL80211_FLAG_NEED_RTNL,
12928 },
98104fde
JB		 12929 {
12930 .cmd = NL80211_CMD_START_P2P_DEVICE,
12931 .doit = nl80211_start_p2p_device,
12932 .policy = nl80211_policy,
5617c6cd 12933 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 12934 .internal_flags = NL80211_FLAG_NEED_WDEV |
12935 NL80211_FLAG_NEED_RTNL,
12936 },
12937 {
12938 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
12939 .doit = nl80211_stop_p2p_device,
12940 .policy = nl80211_policy,
5617c6cd 12941 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 12942 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12943 NL80211_FLAG_NEED_RTNL,
cb3b7d87
AB		 12944 },
12945 {
12946 .cmd = NL80211_CMD_START_NAN,
12947 .doit = nl80211_start_nan,
12948 .policy = nl80211_policy,
12949 .flags = GENL_ADMIN_PERM,
12950 .internal_flags = NL80211_FLAG_NEED_WDEV |
12951 NL80211_FLAG_NEED_RTNL,
12952 },
12953 {
12954 .cmd = NL80211_CMD_STOP_NAN,
12955 .doit = nl80211_stop_nan,
12956 .policy = nl80211_policy,
12957 .flags = GENL_ADMIN_PERM,
12958 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12959 NL80211_FLAG_NEED_RTNL,
a442b761
AB		 12960 },
12961 {
12962 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
12963 .doit = nl80211_nan_add_func,
12964 .policy = nl80211_policy,
12965 .flags = GENL_ADMIN_PERM,
12966 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12967 NL80211_FLAG_NEED_RTNL,
12968 },
12969 {
12970 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
12971 .doit = nl80211_nan_del_func,
12972 .policy = nl80211_policy,
12973 .flags = GENL_ADMIN_PERM,
12974 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12975 NL80211_FLAG_NEED_RTNL,
a5a9dcf2
AB		 12976 },
12977 {
12978 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
12979 .doit = nl80211_nan_change_config,
12980 .policy = nl80211_policy,
12981 .flags = GENL_ADMIN_PERM,
12982 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12983 NL80211_FLAG_NEED_RTNL,
98104fde 12984 },
f4e583c8
AQ		 12985 {
12986 .cmd = NL80211_CMD_SET_MCAST_RATE,
12987 .doit = nl80211_set_mcast_rate,
77765eaf 12988 .policy = nl80211_policy,
5617c6cd 12989 .flags = GENL_UNS_ADMIN_PERM,
77765eaf
VT		 12990 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12991 NL80211_FLAG_NEED_RTNL,
12992 },
12993 {
12994 .cmd = NL80211_CMD_SET_MAC_ACL,
12995 .doit = nl80211_set_mac_acl,
f4e583c8 12996 .policy = nl80211_policy,
5617c6cd 12997 .flags = GENL_UNS_ADMIN_PERM,
f4e583c8
AQ		 12998 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12999 NL80211_FLAG_NEED_RTNL,
13000 },
04f39047
SW		 13001 {
13002 .cmd = NL80211_CMD_RADAR_DETECT,
13003 .doit = nl80211_start_radar_detection,
13004 .policy = nl80211_policy,
5617c6cd 13005 .flags = GENL_UNS_ADMIN_PERM,
04f39047
SW		 13006 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13007 NL80211_FLAG_NEED_RTNL,
13008 },
3713b4e3
JB		 13009 {
13010 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
13011 .doit = nl80211_get_protocol_features,
13012 .policy = nl80211_policy,
13013 },
355199e0
JM		 13014 {
13015 .cmd = NL80211_CMD_UPDATE_FT_IES,
13016 .doit = nl80211_update_ft_ies,
13017 .policy = nl80211_policy,
5617c6cd 13018 .flags = GENL_UNS_ADMIN_PERM,
355199e0
JM		 13019 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13020 NL80211_FLAG_NEED_RTNL,
13021 },
5de17984
AS		 13022 {
13023 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
13024 .doit = nl80211_crit_protocol_start,
13025 .policy = nl80211_policy,
5617c6cd 13026 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13027 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13028 NL80211_FLAG_NEED_RTNL,
13029 },
13030 {
13031 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
13032 .doit = nl80211_crit_protocol_stop,
13033 .policy = nl80211_policy,
5617c6cd 13034 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13035 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13036 NL80211_FLAG_NEED_RTNL,
be29b99a
AK		 13037 },
13038 {
13039 .cmd = NL80211_CMD_GET_COALESCE,
13040 .doit = nl80211_get_coalesce,
13041 .policy = nl80211_policy,
13042 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13043 NL80211_FLAG_NEED_RTNL,
13044 },
13045 {
13046 .cmd = NL80211_CMD_SET_COALESCE,
13047 .doit = nl80211_set_coalesce,
13048 .policy = nl80211_policy,
5617c6cd 13049 .flags = GENL_UNS_ADMIN_PERM,
be29b99a
AK		 13050 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13051 NL80211_FLAG_NEED_RTNL,
16ef1fe2
SW		 13052 },
13053 {
13054 .cmd = NL80211_CMD_CHANNEL_SWITCH,
13055 .doit = nl80211_channel_switch,
13056 .policy = nl80211_policy,
5617c6cd 13057 .flags = GENL_UNS_ADMIN_PERM,
16ef1fe2
SW		 13058 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13059 NL80211_FLAG_NEED_RTNL,
13060 },
ad7e718c
JB		 13061 {
13062 .cmd = NL80211_CMD_VENDOR,
13063 .doit = nl80211_vendor_cmd,
7bdbe400 13064 .dumpit = nl80211_vendor_cmd_dump,
ad7e718c 13065 .policy = nl80211_policy,
5617c6cd 13066 .flags = GENL_UNS_ADMIN_PERM,
ad7e718c
JB		 13067 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13068 NL80211_FLAG_NEED_RTNL,
13069 },
fa9ffc74
KP		 13070 {
13071 .cmd = NL80211_CMD_SET_QOS_MAP,
13072 .doit = nl80211_set_qos_map,
13073 .policy = nl80211_policy,
5617c6cd 13074 .flags = GENL_UNS_ADMIN_PERM,
fa9ffc74
KP		 13075 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13076 NL80211_FLAG_NEED_RTNL,
13077 },
960d01ac
JB		 13078 {
13079 .cmd = NL80211_CMD_ADD_TX_TS,
13080 .doit = nl80211_add_tx_ts,
13081 .policy = nl80211_policy,
5617c6cd 13082 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13083 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13084 NL80211_FLAG_NEED_RTNL,
13085 },
13086 {
13087 .cmd = NL80211_CMD_DEL_TX_TS,
13088 .doit = nl80211_del_tx_ts,
13089 .policy = nl80211_policy,
5617c6cd 13090 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13091 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13092 NL80211_FLAG_NEED_RTNL,
13093 },
1057d35e
AN		 13094 {
13095 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
13096 .doit = nl80211_tdls_channel_switch,
13097 .policy = nl80211_policy,
5617c6cd 13098 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13099 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13100 NL80211_FLAG_NEED_RTNL,
13101 },
13102 {
13103 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
13104 .doit = nl80211_tdls_cancel_channel_switch,
13105 .policy = nl80211_policy,
5617c6cd 13106 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13107 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13108 NL80211_FLAG_NEED_RTNL,
13109 },
ce0ce13a
MB		 13110 {
13111 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
13112 .doit = nl80211_set_multicast_to_unicast,
13113 .policy = nl80211_policy,
13114 .flags = GENL_UNS_ADMIN_PERM,
13115 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13116 NL80211_FLAG_NEED_RTNL,
13117 },
55682965 13118};
9588bbd5 13119
56989f6d 13120static struct genl_family nl80211_fam __ro_after_init = {
489111e5
JB		 13121 .name = NL80211_GENL_NAME, /* have users key off the name instead */
13122 .hdrsize = 0, /* no private header */
13123 .version = 1, /* no particular meaning now */
13124 .maxattr = NL80211_ATTR_MAX,
13125 .netnsok = true,
13126 .pre_doit = nl80211_pre_doit,
13127 .post_doit = nl80211_post_doit,
13128 .module = THIS_MODULE,
13129 .ops = nl80211_ops,
13130 .n_ops = ARRAY_SIZE(nl80211_ops),
13131 .mcgrps = nl80211_mcgrps,
13132 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
13133};
13134
55682965
JB		 13135/* notification functions */
13136
3bb20556
JB		 13137void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
13138 enum nl80211_commands cmd)
55682965
JB		 13139{
13140 struct sk_buff *msg;
86e8cf98 13141 struct nl80211_dump_wiphy_state state = {};
55682965 13142
3bb20556
JB		 13143 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
13144 cmd != NL80211_CMD_DEL_WIPHY);
13145
fd2120ca 13146 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 13147 if (!msg)
13148 return;
13149
3bb20556 13150 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
55682965
JB		 13151 nlmsg_free(msg);
13152 return;
13153 }
13154
68eb5503 13155 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13156 NL80211_MCGRP_CONFIG, GFP_KERNEL);
55682965
JB		 13157}
13158
896ff063
DK		 13159void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
13160 struct wireless_dev *wdev,
13161 enum nl80211_commands cmd)
13162{
13163 struct sk_buff *msg;
13164
13165 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
13166 cmd != NL80211_CMD_DEL_INTERFACE);
13167
13168 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13169 if (!msg)
13170 return;
13171
13172 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev,
13173 cmd == NL80211_CMD_DEL_INTERFACE) < 0) {
13174 nlmsg_free(msg);
13175 return;
13176 }
13177
13178 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
13179 NL80211_MCGRP_CONFIG, GFP_KERNEL);
13180}
13181
362a415d
JB		 13182static int nl80211_add_scan_req(struct sk_buff *msg,
13183 struct cfg80211_registered_device *rdev)
13184{
13185 struct cfg80211_scan_request *req = rdev->scan_req;
13186 struct nlattr *nest;
13187 int i;
13188
13189 if (WARN_ON(!req))
13190 return 0;
13191
13192 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
13193 if (!nest)
13194 goto nla_put_failure;
9360ffd1
DM		 13195 for (i = 0; i < req->n_ssids; i++) {
13196 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
13197 goto nla_put_failure;
13198 }
362a415d
JB		 13199 nla_nest_end(msg, nest);
13200
13201 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
13202 if (!nest)
13203 goto nla_put_failure;
9360ffd1
DM		 13204 for (i = 0; i < req->n_channels; i++) {
13205 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
13206 goto nla_put_failure;
13207 }
362a415d
JB		 13208 nla_nest_end(msg, nest);
13209
9360ffd1
DM		 13210 if (req->ie &&
13211 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
13212 goto nla_put_failure;
362a415d 13213
ae917c9f
JB		 13214 if (req->flags &&
13215 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
13216 goto nla_put_failure;
ed473771 13217
1d76250b
AS		 13218 if (req->info.scan_start_tsf &&
13219 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
13220 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
13221 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
13222 req->info.tsf_bssid)))
13223 goto nla_put_failure;
13224
362a415d
JB		 13225 return 0;
13226 nla_put_failure:
13227 return -ENOBUFS;
13228}
13229
505a2e88 13230static int nl80211_prep_scan_msg(struct sk_buff *msg,
a538e2d5 13231 struct cfg80211_registered_device *rdev,
fd014284 13232 struct wireless_dev *wdev,
15e47304 13233 u32 portid, u32 seq, int flags,
a538e2d5 13234 u32 cmd)
2a519311
JB		 13235{
13236 void *hdr;
13237
15e47304 13238 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2a519311
JB		 13239 if (!hdr)
13240 return -1;
13241
9360ffd1 13242 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
fd014284
JB		 13243 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13244 wdev->netdev->ifindex)) ||
2dad624e
ND		 13245 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13246 NL80211_ATTR_PAD))
9360ffd1 13247 goto nla_put_failure;
2a519311 13248
362a415d
JB		 13249 /* ignore errors and send incomplete event anyway */
13250 nl80211_add_scan_req(msg, rdev);
2a519311 13251
053c095a
JB		 13252 genlmsg_end(msg, hdr);
13253 return 0;
2a519311
JB		 13254
13255 nla_put_failure:
13256 genlmsg_cancel(msg, hdr);
13257 return -EMSGSIZE;
13258}
13259
807f8a8c 13260static int
505a2e88 13261nl80211_prep_sched_scan_msg(struct sk_buff *msg,
96b08fd6 13262 struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13263{
13264 void *hdr;
13265
96b08fd6 13266 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
807f8a8c
LC		 13267 if (!hdr)
13268 return -1;
13269
96b08fd6
AVS		 13270 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
13271 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
13272 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
13273 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
13274 NL80211_ATTR_PAD))
9360ffd1 13275 goto nla_put_failure;
807f8a8c 13276
053c095a
JB		 13277 genlmsg_end(msg, hdr);
13278 return 0;
807f8a8c
LC		 13279
13280 nla_put_failure:
13281 genlmsg_cancel(msg, hdr);
13282 return -EMSGSIZE;
13283}
13284
a538e2d5 13285void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
fd014284 13286 struct wireless_dev *wdev)
a538e2d5
JB		 13287{
13288 struct sk_buff *msg;
13289
58050fce 13290 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
a538e2d5
JB		 13291 if (!msg)
13292 return;
13293
505a2e88 13294 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
a538e2d5
JB		 13295 NL80211_CMD_TRIGGER_SCAN) < 0) {
13296 nlmsg_free(msg);
13297 return;
13298 }
13299
68eb5503 13300 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13301 NL80211_MCGRP_SCAN, GFP_KERNEL);
a538e2d5
JB		 13302}
13303
f9d15d16
JB		 13304struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
13305 struct wireless_dev *wdev, bool aborted)
2a519311
JB		 13306{
13307 struct sk_buff *msg;
13308
fd2120ca 13309 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311 13310 if (!msg)
f9d15d16 13311 return NULL;
2a519311 13312
505a2e88 13313 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
f9d15d16
JB		 13314 aborted ? NL80211_CMD_SCAN_ABORTED :
13315 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311 13316 nlmsg_free(msg);
f9d15d16 13317 return NULL;
2a519311
JB		 13318 }
13319
f9d15d16 13320 return msg;
2a519311
JB		 13321}
13322
505a2e88
AVS		 13323/* send message created by nl80211_build_scan_msg() */
13324void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
13325 struct sk_buff *msg)
807f8a8c 13326{
807f8a8c
LC		 13327 if (!msg)
13328 return;
13329
68eb5503 13330 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13331 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13332}
13333
96b08fd6 13334void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13335{
13336 struct sk_buff *msg;
13337
58050fce 13338 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
807f8a8c
LC		 13339 if (!msg)
13340 return;
13341
96b08fd6 13342 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
807f8a8c
LC		 13343 nlmsg_free(msg);
13344 return;
13345 }
13346
96b08fd6 13347 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
2a94fe48 13348 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13349}
13350
b0d7aa59
JD		 13351static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
13352 struct regulatory_request *request)
73d54c9e 13353{
73d54c9e 13354 /* Userspace can always count this one always being set */
9360ffd1
DM		 13355 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
13356 goto nla_put_failure;
13357
13358 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
13359 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13360 NL80211_REGDOM_TYPE_WORLD))
13361 goto nla_put_failure;
13362 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
13363 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13364 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
13365 goto nla_put_failure;
13366 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
13367 request->intersect) {
13368 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13369 NL80211_REGDOM_TYPE_INTERSECTION))
13370 goto nla_put_failure;
13371 } else {
13372 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13373 NL80211_REGDOM_TYPE_COUNTRY) ||
13374 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
13375 request->alpha2))
13376 goto nla_put_failure;
13377 }
13378
ad30ca2c
AN		 13379 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
13380 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
13381
13382 if (wiphy &&
13383 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
13384 goto nla_put_failure;
1bdd716c
AN		 13385
13386 if (wiphy &&
13387 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
13388 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
13389 goto nla_put_failure;
ad30ca2c 13390 }
73d54c9e 13391
b0d7aa59
JD		 13392 return true;
13393
13394nla_put_failure:
13395 return false;
13396}
13397
13398/*
13399 * This can happen on global regulatory changes or device specific settings
13400 * based on custom regulatory domains.
13401 */
13402void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
13403 struct regulatory_request *request)
13404{
13405 struct sk_buff *msg;
13406 void *hdr;
13407
13408 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13409 if (!msg)
13410 return;
13411
13412 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
13413 if (!hdr) {
13414 nlmsg_free(msg);
13415 return;
13416 }
13417
13418 if (nl80211_reg_change_event_fill(msg, request) == false)
13419 goto nla_put_failure;
13420
3b7b72ee 13421 genlmsg_end(msg, hdr);
73d54c9e 13422
bc43b28c 13423 rcu_read_lock();
68eb5503 13424 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13425 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
bc43b28c 13426 rcu_read_unlock();
73d54c9e
LR		 13427
13428 return;
13429
13430nla_put_failure:
13431 genlmsg_cancel(msg, hdr);
13432 nlmsg_free(msg);
13433}
13434
6039f6d2
JM		 13435static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
13436 struct net_device *netdev,
13437 const u8 *buf, size_t len,
b0b6aa2c
EP		 13438 enum nl80211_commands cmd, gfp_t gfp,
13439 int uapsd_queues)
6039f6d2
JM		 13440{
13441 struct sk_buff *msg;
13442 void *hdr;
13443
4ef8c1c9 13444 msg = nlmsg_new(100 + len, gfp);
6039f6d2
JM		 13445 if (!msg)
13446 return;
13447
13448 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13449 if (!hdr) {
13450 nlmsg_free(msg);
13451 return;
13452 }
13453
9360ffd1
DM		 13454 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13455 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13456 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
13457 goto nla_put_failure;
6039f6d2 13458
b0b6aa2c
EP		 13459 if (uapsd_queues >= 0) {
13460 struct nlattr *nla_wmm =
13461 nla_nest_start(msg, NL80211_ATTR_STA_WME);
13462 if (!nla_wmm)
13463 goto nla_put_failure;
13464
13465 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
13466 uapsd_queues))
13467 goto nla_put_failure;
13468
13469 nla_nest_end(msg, nla_wmm);
13470 }
13471
3b7b72ee 13472 genlmsg_end(msg, hdr);
6039f6d2 13473
68eb5503 13474 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13475 NL80211_MCGRP_MLME, gfp);
6039f6d2
JM		 13476 return;
13477
13478 nla_put_failure:
13479 genlmsg_cancel(msg, hdr);
13480 nlmsg_free(msg);
13481}
13482
13483void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13484 struct net_device *netdev, const u8 *buf,
13485 size_t len, gfp_t gfp)
6039f6d2
JM		 13486{
13487 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13488 NL80211_CMD_AUTHENTICATE, gfp, -1);
6039f6d2
JM		 13489}
13490
13491void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
13492 struct net_device *netdev, const u8 *buf,
b0b6aa2c 13493 size_t len, gfp_t gfp, int uapsd_queues)
6039f6d2 13494{
e6d6e342 13495 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13496 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
6039f6d2
JM		 13497}
13498
53b46b84 13499void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13500 struct net_device *netdev, const u8 *buf,
13501 size_t len, gfp_t gfp)
6039f6d2
JM		 13502{
13503 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13504 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
6039f6d2
JM		 13505}
13506
53b46b84
JM		 13507void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
13508 struct net_device *netdev, const u8 *buf,
e6d6e342 13509 size_t len, gfp_t gfp)
6039f6d2
JM		 13510{
13511 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13512 NL80211_CMD_DISASSOCIATE, gfp, -1);
6039f6d2
JM		 13513}
13514
6ff57cf8
JB		 13515void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
13516 size_t len)
cf4e594e 13517{
947add36
JB		 13518 struct wireless_dev *wdev = dev->ieee80211_ptr;
13519 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13520 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
6ff57cf8
JB		 13521 const struct ieee80211_mgmt *mgmt = (void *)buf;
13522 u32 cmd;
947add36 13523
6ff57cf8
JB		 13524 if (WARN_ON(len < 2))
13525 return;
cf4e594e 13526
6ff57cf8
JB		 13527 if (ieee80211_is_deauth(mgmt->frame_control))
13528 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
13529 else
13530 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
947add36 13531
6ff57cf8 13532 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
b0b6aa2c 13533 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
cf4e594e 13534}
6ff57cf8 13535EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
cf4e594e 13536
1b06bb40
LR		 13537static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
13538 struct net_device *netdev, int cmd,
e6d6e342 13539 const u8 *addr, gfp_t gfp)
1965c853
JM		 13540{
13541 struct sk_buff *msg;
13542 void *hdr;
13543
e6d6e342 13544 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 13545 if (!msg)
13546 return;
13547
13548 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13549 if (!hdr) {
13550 nlmsg_free(msg);
13551 return;
13552 }
13553
9360ffd1
DM		 13554 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13555 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13556 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
13557 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
13558 goto nla_put_failure;
1965c853 13559
3b7b72ee 13560 genlmsg_end(msg, hdr);
1965c853 13561
68eb5503 13562 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13563 NL80211_MCGRP_MLME, gfp);
1965c853
JM		 13564 return;
13565
13566 nla_put_failure:
13567 genlmsg_cancel(msg, hdr);
13568 nlmsg_free(msg);
13569}
13570
13571void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13572 struct net_device *netdev, const u8 *addr,
13573 gfp_t gfp)
1965c853
JM		 13574{
13575 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 13576 addr, gfp);
1965c853
JM		 13577}
13578
13579void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13580 struct net_device *netdev, const u8 *addr,
13581 gfp_t gfp)
1965c853 13582{
e6d6e342
JB		 13583 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
13584 addr, gfp);
1965c853
JM		 13585}
13586
b23aa676 13587void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
5349a0f7
VK		 13588 struct net_device *netdev,
13589 struct cfg80211_connect_resp_params *cr,
3093ebbe 13590 gfp_t gfp)
b23aa676
SO		 13591{
13592 struct sk_buff *msg;
13593 void *hdr;
13594
a3caf744
VK		 13595 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
13596 cr->fils_kek_len + cr->pmk_len +
13597 (cr->pmkid ? WLAN_PMKID_LEN : 0), gfp);
b23aa676
SO		 13598 if (!msg)
13599 return;
13600
13601 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
13602 if (!hdr) {
13603 nlmsg_free(msg);
13604 return;
13605 }
13606
9360ffd1
DM		 13607 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13608 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
5349a0f7
VK		 13609 (cr->bssid &&
13610 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
bf1ecd21 13611 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
5349a0f7
VK		 13612 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
13613 cr->status) ||
13614 (cr->status < 0 &&
3093ebbe 13615 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
5349a0f7
VK		 13616 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
13617 cr->timeout_reason))) ||
13618 (cr->req_ie &&
13619 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
13620 (cr->resp_ie &&
13621 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
a3caf744
VK		 13622 cr->resp_ie)) ||
13623 (cr->update_erp_next_seq_num &&
13624 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
13625 cr->fils_erp_next_seq_num)) ||
13626 (cr->status == WLAN_STATUS_SUCCESS &&
13627 ((cr->fils_kek &&
13628 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils_kek_len,
13629 cr->fils_kek)) ||
13630 (cr->pmk &&
13631 nla_put(msg, NL80211_ATTR_PMK, cr->pmk_len, cr->pmk)) ||
13632 (cr->pmkid &&
13633 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->pmkid)))))
9360ffd1 13634 goto nla_put_failure;
b23aa676 13635
3b7b72ee 13636 genlmsg_end(msg, hdr);
b23aa676 13637
68eb5503 13638 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13639 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13640 return;
13641
13642 nla_put_failure:
13643 genlmsg_cancel(msg, hdr);
13644 nlmsg_free(msg);
b23aa676
SO		 13645}
13646
13647void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
29ce6ecb
AS		 13648 struct net_device *netdev,
13649 struct cfg80211_roam_info *info, gfp_t gfp)
b23aa676
SO		 13650{
13651 struct sk_buff *msg;
13652 void *hdr;
29ce6ecb 13653 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
b23aa676 13654
29ce6ecb 13655 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len, gfp);
b23aa676
SO		 13656 if (!msg)
13657 return;
13658
13659 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
13660 if (!hdr) {
13661 nlmsg_free(msg);
13662 return;
13663 }
13664
9360ffd1
DM		 13665 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13666 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13667 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
29ce6ecb
AS		 13668 (info->req_ie &&
13669 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
13670 info->req_ie)) ||
13671 (info->resp_ie &&
13672 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
13673 info->resp_ie)))
9360ffd1 13674 goto nla_put_failure;
b23aa676 13675
3b7b72ee 13676 genlmsg_end(msg, hdr);
b23aa676 13677
68eb5503 13678 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13679 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13680 return;
13681
13682 nla_put_failure:
13683 genlmsg_cancel(msg, hdr);
13684 nlmsg_free(msg);
b23aa676
SO		 13685}
13686
13687void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
13688 struct net_device *netdev, u16 reason,
667503dd 13689 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 13690{
13691 struct sk_buff *msg;
13692 void *hdr;
13693
4ef8c1c9 13694 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
b23aa676
SO		 13695 if (!msg)
13696 return;
13697
13698 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
13699 if (!hdr) {
13700 nlmsg_free(msg);
13701 return;
13702 }
13703
9360ffd1
DM		 13704 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13705 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13706 (from_ap && reason &&
13707 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
13708 (from_ap &&
13709 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
13710 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
13711 goto nla_put_failure;
b23aa676 13712
3b7b72ee 13713 genlmsg_end(msg, hdr);
b23aa676 13714
68eb5503 13715 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13716 NL80211_MCGRP_MLME, GFP_KERNEL);
b23aa676
SO		 13717 return;
13718
13719 nla_put_failure:
13720 genlmsg_cancel(msg, hdr);
13721 nlmsg_free(msg);
b23aa676
SO		 13722}
13723
04a773ad
JB		 13724void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
13725 struct net_device *netdev, const u8 *bssid,
13726 gfp_t gfp)
13727{
13728 struct sk_buff *msg;
13729 void *hdr;
13730
fd2120ca 13731 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 13732 if (!msg)
13733 return;
13734
13735 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
13736 if (!hdr) {
13737 nlmsg_free(msg);
13738 return;
13739 }
13740
9360ffd1
DM		 13741 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13742 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13743 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
13744 goto nla_put_failure;
04a773ad 13745
3b7b72ee 13746 genlmsg_end(msg, hdr);
04a773ad 13747
68eb5503 13748 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13749 NL80211_MCGRP_MLME, gfp);
04a773ad
JB		 13750 return;
13751
13752 nla_put_failure:
13753 genlmsg_cancel(msg, hdr);
13754 nlmsg_free(msg);
13755}
13756
947add36
JB		 13757void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
13758 const u8* ie, u8 ie_len, gfp_t gfp)
c93b5e71 13759{
947add36 13760 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 13761 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
c93b5e71
JC		 13762 struct sk_buff *msg;
13763 void *hdr;
13764
947add36
JB		 13765 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
13766 return;
13767
13768 trace_cfg80211_notify_new_peer_candidate(dev, addr);
13769
4ef8c1c9 13770 msg = nlmsg_new(100 + ie_len, gfp);
c93b5e71
JC		 13771 if (!msg)
13772 return;
13773
13774 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
13775 if (!hdr) {
13776 nlmsg_free(msg);
13777 return;
13778 }
13779
9360ffd1 13780 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36
JB		 13781 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
13782 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9360ffd1
DM		 13783 (ie_len && ie &&
13784 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
13785 goto nla_put_failure;
c93b5e71 13786
3b7b72ee 13787 genlmsg_end(msg, hdr);
c93b5e71 13788
68eb5503 13789 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13790 NL80211_MCGRP_MLME, gfp);
c93b5e71
JC		 13791 return;
13792
13793 nla_put_failure:
13794 genlmsg_cancel(msg, hdr);
13795 nlmsg_free(msg);
13796}
947add36 13797EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
c93b5e71 13798
a3b8b056
JM		 13799void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
13800 struct net_device *netdev, const u8 *addr,
13801 enum nl80211_key_type key_type, int key_id,
e6d6e342 13802 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 13803{
13804 struct sk_buff *msg;
13805 void *hdr;
13806
e6d6e342 13807 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 13808 if (!msg)
13809 return;
13810
13811 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
13812 if (!hdr) {
13813 nlmsg_free(msg);
13814 return;
13815 }
13816
9360ffd1
DM		 13817 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13818 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13819 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
13820 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
13821 (key_id != -1 &&
13822 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
13823 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
13824 goto nla_put_failure;
a3b8b056 13825
3b7b72ee 13826 genlmsg_end(msg, hdr);
a3b8b056 13827
68eb5503 13828 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13829 NL80211_MCGRP_MLME, gfp);
a3b8b056
JM		 13830 return;
13831
13832 nla_put_failure:
13833 genlmsg_cancel(msg, hdr);
13834 nlmsg_free(msg);
13835}
13836
6bad8766
LR		 13837void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
13838 struct ieee80211_channel *channel_before,
13839 struct ieee80211_channel *channel_after)
13840{
13841 struct sk_buff *msg;
13842 void *hdr;
13843 struct nlattr *nl_freq;
13844
fd2120ca 13845 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 13846 if (!msg)
13847 return;
13848
13849 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
13850 if (!hdr) {
13851 nlmsg_free(msg);
13852 return;
13853 }
13854
13855 /*
13856 * Since we are applying the beacon hint to a wiphy we know its
13857 * wiphy_idx is valid
13858 */
9360ffd1
DM		 13859 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
13860 goto nla_put_failure;
6bad8766
LR		 13861
13862 /* Before */
13863 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
13864 if (!nl_freq)
13865 goto nla_put_failure;
cdc89b97 13866 if (nl80211_msg_put_channel(msg, channel_before, false))
6bad8766
LR		 13867 goto nla_put_failure;
13868 nla_nest_end(msg, nl_freq);
13869
13870 /* After */
13871 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
13872 if (!nl_freq)
13873 goto nla_put_failure;
cdc89b97 13874 if (nl80211_msg_put_channel(msg, channel_after, false))
6bad8766
LR		 13875 goto nla_put_failure;
13876 nla_nest_end(msg, nl_freq);
13877
3b7b72ee 13878 genlmsg_end(msg, hdr);
6bad8766 13879
463d0183 13880 rcu_read_lock();
68eb5503 13881 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13882 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
463d0183 13883 rcu_read_unlock();
6bad8766
LR		 13884
13885 return;
13886
13887nla_put_failure:
13888 genlmsg_cancel(msg, hdr);
13889 nlmsg_free(msg);
13890}
13891
9588bbd5
JM		 13892static void nl80211_send_remain_on_chan_event(
13893 int cmd, struct cfg80211_registered_device *rdev,
71bbc994 13894 struct wireless_dev *wdev, u64 cookie,
9588bbd5 13895 struct ieee80211_channel *chan,
9588bbd5
JM		 13896 unsigned int duration, gfp_t gfp)
13897{
13898 struct sk_buff *msg;
13899 void *hdr;
13900
13901 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
13902 if (!msg)
13903 return;
13904
13905 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13906 if (!hdr) {
13907 nlmsg_free(msg);
13908 return;
13909 }
13910
9360ffd1 13911 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 13912 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13913 wdev->netdev->ifindex)) ||
2dad624e
ND		 13914 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13915 NL80211_ATTR_PAD) ||
9360ffd1 13916 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
42d97a59
JB		 13917 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
13918 NL80211_CHAN_NO_HT) ||
2dad624e
ND		 13919 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
13920 NL80211_ATTR_PAD))
9360ffd1 13921 goto nla_put_failure;
9588bbd5 13922
9360ffd1
DM		 13923 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
13924 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
13925 goto nla_put_failure;
9588bbd5 13926
3b7b72ee 13927 genlmsg_end(msg, hdr);
9588bbd5 13928
68eb5503 13929 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13930 NL80211_MCGRP_MLME, gfp);
9588bbd5
JM		 13931 return;
13932
13933 nla_put_failure:
13934 genlmsg_cancel(msg, hdr);
13935 nlmsg_free(msg);
13936}
13937
947add36
JB		 13938void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
13939 struct ieee80211_channel *chan,
13940 unsigned int duration, gfp_t gfp)
9588bbd5 13941{
947add36 13942 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13943 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 13944
13945 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9588bbd5 13946 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
71bbc994 13947 rdev, wdev, cookie, chan,
42d97a59 13948 duration, gfp);
9588bbd5 13949}
947add36 13950EXPORT_SYMBOL(cfg80211_ready_on_channel);
9588bbd5 13951
947add36
JB		 13952void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
13953 struct ieee80211_channel *chan,
13954 gfp_t gfp)
9588bbd5 13955{
947add36 13956 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13957 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 13958
13959 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9588bbd5 13960 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
42d97a59 13961 rdev, wdev, cookie, chan, 0, gfp);
9588bbd5 13962}
947add36 13963EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9588bbd5 13964
947add36
JB		 13965void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
13966 struct station_info *sinfo, gfp_t gfp)
98b62183 13967{
947add36 13968 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 13969 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
98b62183
JB		 13970 struct sk_buff *msg;
13971
947add36
JB		 13972 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
13973
58050fce 13974 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
98b62183
JB		 13975 if (!msg)
13976 return;
13977
cf5ead82 13978 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
66266b3a 13979 rdev, dev, mac_addr, sinfo) < 0) {
98b62183
JB		 13980 nlmsg_free(msg);
13981 return;
13982 }
13983
68eb5503 13984 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13985 NL80211_MCGRP_MLME, gfp);
98b62183 13986}
947add36 13987EXPORT_SYMBOL(cfg80211_new_sta);
98b62183 13988
cf5ead82
JB		 13989void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
13990 struct station_info *sinfo, gfp_t gfp)
ec15e68b 13991{
947add36 13992 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 13993 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ec15e68b 13994 struct sk_buff *msg;
cf5ead82
JB		 13995 struct station_info empty_sinfo = {};
13996
13997 if (!sinfo)
13998 sinfo = &empty_sinfo;
ec15e68b 13999
947add36
JB		 14000 trace_cfg80211_del_sta(dev, mac_addr);
14001
58050fce 14002 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
ec15e68b
JM		 14003 if (!msg)
14004 return;
14005
cf5ead82 14006 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
57007121 14007 rdev, dev, mac_addr, sinfo) < 0) {
ec15e68b
JM		 14008 nlmsg_free(msg);
14009 return;
14010 }
14011
68eb5503 14012 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14013 NL80211_MCGRP_MLME, gfp);
ec15e68b 14014}
cf5ead82 14015EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
ec15e68b 14016
947add36
JB		 14017void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
14018 enum nl80211_connect_failed_reason reason,
14019 gfp_t gfp)
ed44a951 14020{
947add36 14021 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14022 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ed44a951
PP		 14023 struct sk_buff *msg;
14024 void *hdr;
14025
14026 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
14027 if (!msg)
14028 return;
14029
14030 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
14031 if (!hdr) {
14032 nlmsg_free(msg);
14033 return;
14034 }
14035
14036 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14037 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
14038 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
14039 goto nla_put_failure;
14040
14041 genlmsg_end(msg, hdr);
14042
68eb5503 14043 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14044 NL80211_MCGRP_MLME, gfp);
ed44a951
PP		 14045 return;
14046
14047 nla_put_failure:
14048 genlmsg_cancel(msg, hdr);
14049 nlmsg_free(msg);
14050}
947add36 14051EXPORT_SYMBOL(cfg80211_conn_failed);
ed44a951 14052
b92ab5d8
JB		 14053static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
14054 const u8 *addr, gfp_t gfp)
28946da7
JB		 14055{
14056 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14057 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
28946da7
JB		 14058 struct sk_buff *msg;
14059 void *hdr;
15e47304 14060 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
28946da7 14061
15e47304 14062 if (!nlportid)
28946da7
JB		 14063 return false;
14064
14065 msg = nlmsg_new(100, gfp);
14066 if (!msg)
14067 return true;
14068
b92ab5d8 14069 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
28946da7
JB		 14070 if (!hdr) {
14071 nlmsg_free(msg);
14072 return true;
14073 }
14074
9360ffd1
DM		 14075 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14076 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14077 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
14078 goto nla_put_failure;
28946da7 14079
9c90a9f6 14080 genlmsg_end(msg, hdr);
15e47304 14081 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
28946da7
JB		 14082 return true;
14083
14084 nla_put_failure:
14085 genlmsg_cancel(msg, hdr);
14086 nlmsg_free(msg);
14087 return true;
14088}
14089
947add36
JB		 14090bool cfg80211_rx_spurious_frame(struct net_device *dev,
14091 const u8 *addr, gfp_t gfp)
b92ab5d8 14092{
947add36
JB		 14093 struct wireless_dev *wdev = dev->ieee80211_ptr;
14094 bool ret;
14095
14096 trace_cfg80211_rx_spurious_frame(dev, addr);
14097
14098 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14099 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
14100 trace_cfg80211_return_bool(false);
14101 return false;
14102 }
14103 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
14104 addr, gfp);
14105 trace_cfg80211_return_bool(ret);
14106 return ret;
b92ab5d8 14107}
947add36 14108EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
b92ab5d8 14109
947add36
JB		 14110bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
14111 const u8 *addr, gfp_t gfp)
b92ab5d8 14112{
947add36
JB		 14113 struct wireless_dev *wdev = dev->ieee80211_ptr;
14114 bool ret;
14115
14116 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
14117
14118 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14119 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
14120 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
14121 trace_cfg80211_return_bool(false);
14122 return false;
14123 }
14124 ret = __nl80211_unexpected_frame(dev,
14125 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
14126 addr, gfp);
14127 trace_cfg80211_return_bool(ret);
14128 return ret;
b92ab5d8 14129}
947add36 14130EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
b92ab5d8 14131
2e161f78 14132int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15e47304 14133 struct wireless_dev *wdev, u32 nlportid,
804483e9 14134 int freq, int sig_dbm,
19504cf5 14135 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
026331c4 14136{
71bbc994 14137 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14138 struct sk_buff *msg;
14139 void *hdr;
026331c4 14140
4ef8c1c9 14141 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14142 if (!msg)
14143 return -ENOMEM;
14144
2e161f78 14145 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
026331c4
JM		 14146 if (!hdr) {
14147 nlmsg_free(msg);
14148 return -ENOMEM;
14149 }
14150
9360ffd1 14151 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14152 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14153 netdev->ifindex)) ||
2dad624e
ND		 14154 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14155 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14156 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
14157 (sig_dbm &&
14158 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19504cf5
VK		 14159 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
14160 (flags &&
14161 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
9360ffd1 14162 goto nla_put_failure;
026331c4 14163
3b7b72ee 14164 genlmsg_end(msg, hdr);
026331c4 14165
15e47304 14166 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
026331c4
JM		 14167
14168 nla_put_failure:
14169 genlmsg_cancel(msg, hdr);
14170 nlmsg_free(msg);
14171 return -ENOBUFS;
14172}
14173
947add36
JB		 14174void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
14175 const u8 *buf, size_t len, bool ack, gfp_t gfp)
026331c4 14176{
947add36 14177 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14178 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
71bbc994 14179 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14180 struct sk_buff *msg;
14181 void *hdr;
14182
947add36
JB		 14183 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
14184
4ef8c1c9 14185 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14186 if (!msg)
14187 return;
14188
2e161f78 14189 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
026331c4
JM		 14190 if (!hdr) {
14191 nlmsg_free(msg);
14192 return;
14193 }
14194
9360ffd1 14195 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14196 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14197 netdev->ifindex)) ||
2dad624e
ND		 14198 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14199 NL80211_ATTR_PAD) ||
9360ffd1 14200 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
2dad624e
ND		 14201 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14202 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14203 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
14204 goto nla_put_failure;
026331c4 14205
3b7b72ee 14206 genlmsg_end(msg, hdr);
026331c4 14207
68eb5503 14208 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14209 NL80211_MCGRP_MLME, gfp);
026331c4
JM		 14210 return;
14211
14212 nla_put_failure:
14213 genlmsg_cancel(msg, hdr);
14214 nlmsg_free(msg);
14215}
947add36 14216EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
026331c4 14217
5b97f49d
JB		 14218static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
14219 const char *mac, gfp_t gfp)
d6dc1a38 14220{
947add36 14221 struct wireless_dev *wdev = dev->ieee80211_ptr;
5b97f49d
JB		 14222 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
14223 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14224 void **cb;
947add36 14225
d6dc1a38 14226 if (!msg)
5b97f49d 14227 return NULL;
d6dc1a38 14228
5b97f49d
JB		 14229 cb = (void **)msg->cb;
14230
14231 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
14232 if (!cb[0]) {
d6dc1a38 14233 nlmsg_free(msg);
5b97f49d 14234 return NULL;
d6dc1a38
JO		 14235 }
14236
9360ffd1 14237 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36 14238 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9360ffd1 14239 goto nla_put_failure;
d6dc1a38 14240
5b97f49d 14241 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
d6dc1a38
JO		 14242 goto nla_put_failure;
14243
5b97f49d
JB		 14244 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
14245 if (!cb[1])
9360ffd1 14246 goto nla_put_failure;
d6dc1a38 14247
5b97f49d 14248 cb[2] = rdev;
d6dc1a38 14249
5b97f49d
JB		 14250 return msg;
14251 nla_put_failure:
14252 nlmsg_free(msg);
14253 return NULL;
14254}
14255
14256static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
14257{
14258 void **cb = (void **)msg->cb;
14259 struct cfg80211_registered_device *rdev = cb[2];
14260
14261 nla_nest_end(msg, cb[1]);
14262 genlmsg_end(msg, cb[0]);
14263
14264 memset(msg->cb, 0, sizeof(msg->cb));
d6dc1a38 14265
68eb5503 14266 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14267 NL80211_MCGRP_MLME, gfp);
5b97f49d
JB		 14268}
14269
14270void cfg80211_cqm_rssi_notify(struct net_device *dev,
14271 enum nl80211_cqm_rssi_threshold_event rssi_event,
bee427b8 14272 s32 rssi_level, gfp_t gfp)
5b97f49d
JB		 14273{
14274 struct sk_buff *msg;
4a4b8169
AZ		 14275 struct wireless_dev *wdev = dev->ieee80211_ptr;
14276 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
5b97f49d 14277
bee427b8 14278 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
5b97f49d 14279
98f03342
JB		 14280 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
14281 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
14282 return;
14283
4a4b8169
AZ		 14284 if (wdev->cqm_config) {
14285 wdev->cqm_config->last_rssi_event_value = rssi_level;
14286
14287 cfg80211_cqm_rssi_update(rdev, dev);
14288
14289 if (rssi_level == 0)
14290 rssi_level = wdev->cqm_config->last_rssi_event_value;
14291 }
14292
5b97f49d
JB		 14293 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14294 if (!msg)
14295 return;
14296
14297 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
14298 rssi_event))
14299 goto nla_put_failure;
14300
bee427b8
AZ		 14301 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
14302 rssi_level))
14303 goto nla_put_failure;
14304
5b97f49d
JB		 14305 cfg80211_send_cqm(msg, gfp);
14306
d6dc1a38
JO		 14307 return;
14308
14309 nla_put_failure:
d6dc1a38
JO		 14310 nlmsg_free(msg);
14311}
947add36 14312EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
d6dc1a38 14313
5b97f49d
JB		 14314void cfg80211_cqm_txe_notify(struct net_device *dev,
14315 const u8 *peer, u32 num_packets,
14316 u32 rate, u32 intvl, gfp_t gfp)
14317{
14318 struct sk_buff *msg;
14319
14320 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14321 if (!msg)
14322 return;
14323
14324 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
14325 goto nla_put_failure;
14326
14327 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
14328 goto nla_put_failure;
14329
14330 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
14331 goto nla_put_failure;
14332
14333 cfg80211_send_cqm(msg, gfp);
14334 return;
14335
14336 nla_put_failure:
14337 nlmsg_free(msg);
14338}
14339EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
14340
14341void cfg80211_cqm_pktloss_notify(struct net_device *dev,
14342 const u8 *peer, u32 num_packets, gfp_t gfp)
14343{
14344 struct sk_buff *msg;
14345
14346 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
14347
14348 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14349 if (!msg)
14350 return;
14351
14352 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
14353 goto nla_put_failure;
14354
14355 cfg80211_send_cqm(msg, gfp);
14356 return;
14357
14358 nla_put_failure:
14359 nlmsg_free(msg);
14360}
14361EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
14362
98f03342
JB		 14363void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
14364{
14365 struct sk_buff *msg;
14366
14367 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14368 if (!msg)
14369 return;
14370
14371 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
14372 goto nla_put_failure;
14373
14374 cfg80211_send_cqm(msg, gfp);
14375 return;
14376
14377 nla_put_failure:
14378 nlmsg_free(msg);
14379}
14380EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
14381
947add36
JB		 14382static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
14383 struct net_device *netdev, const u8 *bssid,
14384 const u8 *replay_ctr, gfp_t gfp)
e5497d76
JB		 14385{
14386 struct sk_buff *msg;
14387 struct nlattr *rekey_attr;
14388 void *hdr;
14389
58050fce 14390 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
e5497d76
JB		 14391 if (!msg)
14392 return;
14393
14394 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
14395 if (!hdr) {
14396 nlmsg_free(msg);
14397 return;
14398 }
14399
9360ffd1
DM		 14400 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14401 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14402 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14403 goto nla_put_failure;
e5497d76
JB		 14404
14405 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
14406 if (!rekey_attr)
14407 goto nla_put_failure;
14408
9360ffd1
DM		 14409 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
14410 NL80211_REPLAY_CTR_LEN, replay_ctr))
14411 goto nla_put_failure;
e5497d76
JB		 14412
14413 nla_nest_end(msg, rekey_attr);
14414
3b7b72ee 14415 genlmsg_end(msg, hdr);
e5497d76 14416
68eb5503 14417 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14418 NL80211_MCGRP_MLME, gfp);
e5497d76
JB		 14419 return;
14420
14421 nla_put_failure:
14422 genlmsg_cancel(msg, hdr);
14423 nlmsg_free(msg);
14424}
14425
947add36
JB		 14426void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
14427 const u8 *replay_ctr, gfp_t gfp)
14428{
14429 struct wireless_dev *wdev = dev->ieee80211_ptr;
14430 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14431 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14432
14433 trace_cfg80211_gtk_rekey_notify(dev, bssid);
14434 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
14435}
14436EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
14437
14438static void
14439nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
14440 struct net_device *netdev, int index,
14441 const u8 *bssid, bool preauth, gfp_t gfp)
c9df56b4
JM		 14442{
14443 struct sk_buff *msg;
14444 struct nlattr *attr;
14445 void *hdr;
14446
58050fce 14447 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
c9df56b4
JM		 14448 if (!msg)
14449 return;
14450
14451 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
14452 if (!hdr) {
14453 nlmsg_free(msg);
14454 return;
14455 }
14456
9360ffd1
DM		 14457 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14458 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14459 goto nla_put_failure;
c9df56b4
JM		 14460
14461 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
14462 if (!attr)
14463 goto nla_put_failure;
14464
9360ffd1
DM		 14465 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
14466 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
14467 (preauth &&
14468 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
14469 goto nla_put_failure;
c9df56b4
JM		 14470
14471 nla_nest_end(msg, attr);
14472
3b7b72ee 14473 genlmsg_end(msg, hdr);
c9df56b4 14474
68eb5503 14475 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14476 NL80211_MCGRP_MLME, gfp);
c9df56b4
JM		 14477 return;
14478
14479 nla_put_failure:
14480 genlmsg_cancel(msg, hdr);
14481 nlmsg_free(msg);
14482}
14483
947add36
JB		 14484void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
14485 const u8 *bssid, bool preauth, gfp_t gfp)
14486{
14487 struct wireless_dev *wdev = dev->ieee80211_ptr;
14488 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14489 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14490
14491 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
14492 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
14493}
14494EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
14495
14496static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
14497 struct net_device *netdev,
14498 struct cfg80211_chan_def *chandef,
f8d7552e
LC		 14499 gfp_t gfp,
14500 enum nl80211_commands notif,
14501 u8 count)
5314526b
TP		 14502{
14503 struct sk_buff *msg;
14504 void *hdr;
14505
58050fce 14506 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5314526b
TP		 14507 if (!msg)
14508 return;
14509
f8d7552e 14510 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
5314526b
TP		 14511 if (!hdr) {
14512 nlmsg_free(msg);
14513 return;
14514 }
14515
683b6d3b
JB		 14516 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14517 goto nla_put_failure;
14518
14519 if (nl80211_send_chandef(msg, chandef))
7eab0f64 14520 goto nla_put_failure;
5314526b 14521
f8d7552e
LC		 14522 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
14523 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
14524 goto nla_put_failure;
14525
5314526b
TP		 14526 genlmsg_end(msg, hdr);
14527
68eb5503 14528 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14529 NL80211_MCGRP_MLME, gfp);
5314526b
TP		 14530 return;
14531
14532 nla_put_failure:
14533 genlmsg_cancel(msg, hdr);
14534 nlmsg_free(msg);
14535}
14536
947add36
JB		 14537void cfg80211_ch_switch_notify(struct net_device *dev,
14538 struct cfg80211_chan_def *chandef)
84f10708 14539{
947add36
JB		 14540 struct wireless_dev *wdev = dev->ieee80211_ptr;
14541 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14542 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36 14543
e487eaeb 14544 ASSERT_WDEV_LOCK(wdev);
947add36 14545
e487eaeb 14546 trace_cfg80211_ch_switch_notify(dev, chandef);
947add36 14547
9e0e2961 14548 wdev->chandef = *chandef;
96f55f12 14549 wdev->preset_chandef = *chandef;
f8d7552e
LC		 14550 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14551 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
947add36
JB		 14552}
14553EXPORT_SYMBOL(cfg80211_ch_switch_notify);
14554
f8d7552e
LC		 14555void cfg80211_ch_switch_started_notify(struct net_device *dev,
14556 struct cfg80211_chan_def *chandef,
14557 u8 count)
14558{
14559 struct wireless_dev *wdev = dev->ieee80211_ptr;
14560 struct wiphy *wiphy = wdev->wiphy;
14561 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14562
14563 trace_cfg80211_ch_switch_started_notify(dev, chandef);
14564
14565 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14566 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
14567}
14568EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
14569
04f39047
SW		 14570void
14571nl80211_radar_notify(struct cfg80211_registered_device *rdev,
d2859df5 14572 const struct cfg80211_chan_def *chandef,
04f39047
SW		 14573 enum nl80211_radar_event event,
14574 struct net_device *netdev, gfp_t gfp)
14575{
14576 struct sk_buff *msg;
14577 void *hdr;
14578
14579 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14580 if (!msg)
14581 return;
14582
14583 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
14584 if (!hdr) {
14585 nlmsg_free(msg);
14586 return;
14587 }
14588
14589 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
14590 goto nla_put_failure;
14591
14592 /* NOP and radar events don't need a netdev parameter */
14593 if (netdev) {
14594 struct wireless_dev *wdev = netdev->ieee80211_ptr;
14595
14596 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
2dad624e
ND		 14597 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14598 NL80211_ATTR_PAD))
04f39047
SW		 14599 goto nla_put_failure;
14600 }
14601
14602 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
14603 goto nla_put_failure;
14604
14605 if (nl80211_send_chandef(msg, chandef))
14606 goto nla_put_failure;
14607
9c90a9f6 14608 genlmsg_end(msg, hdr);
04f39047 14609
68eb5503 14610 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14611 NL80211_MCGRP_MLME, gfp);
04f39047
SW		 14612 return;
14613
14614 nla_put_failure:
14615 genlmsg_cancel(msg, hdr);
14616 nlmsg_free(msg);
14617}
14618
7f6cf311
JB		 14619void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
14620 u64 cookie, bool acked, gfp_t gfp)
14621{
14622 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14623 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
7f6cf311
JB		 14624 struct sk_buff *msg;
14625 void *hdr;
7f6cf311 14626
4ee3e063
BL		 14627 trace_cfg80211_probe_status(dev, addr, cookie, acked);
14628
58050fce 14629 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4ee3e063 14630
7f6cf311
JB		 14631 if (!msg)
14632 return;
14633
14634 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
14635 if (!hdr) {
14636 nlmsg_free(msg);
14637 return;
14638 }
14639
9360ffd1
DM		 14640 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14641 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14642 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
2dad624e
ND		 14643 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14644 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14645 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
14646 goto nla_put_failure;
7f6cf311 14647
9c90a9f6 14648 genlmsg_end(msg, hdr);
7f6cf311 14649
68eb5503 14650 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14651 NL80211_MCGRP_MLME, gfp);
7f6cf311
JB		 14652 return;
14653
14654 nla_put_failure:
14655 genlmsg_cancel(msg, hdr);
14656 nlmsg_free(msg);
14657}
14658EXPORT_SYMBOL(cfg80211_probe_status);
14659
5e760230
JB		 14660void cfg80211_report_obss_beacon(struct wiphy *wiphy,
14661 const u8 *frame, size_t len,
37c73b5f 14662 int freq, int sig_dbm)
5e760230 14663{
f26cbf40 14664 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5e760230
JB		 14665 struct sk_buff *msg;
14666 void *hdr;
37c73b5f 14667 struct cfg80211_beacon_registration *reg;
5e760230 14668
4ee3e063
BL		 14669 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
14670
37c73b5f
BG		 14671 spin_lock_bh(&rdev->beacon_registrations_lock);
14672 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
14673 msg = nlmsg_new(len + 100, GFP_ATOMIC);
14674 if (!msg) {
14675 spin_unlock_bh(&rdev->beacon_registrations_lock);
14676 return;
14677 }
5e760230 14678
37c73b5f
BG		 14679 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
14680 if (!hdr)
14681 goto nla_put_failure;
5e760230 14682
37c73b5f
BG		 14683 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14684 (freq &&
14685 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
14686 (sig_dbm &&
14687 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
14688 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
14689 goto nla_put_failure;
5e760230 14690
37c73b5f 14691 genlmsg_end(msg, hdr);
5e760230 14692
37c73b5f
BG		 14693 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
14694 }
14695 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 14696 return;
14697
14698 nla_put_failure:
37c73b5f
BG		 14699 spin_unlock_bh(&rdev->beacon_registrations_lock);
14700 if (hdr)
14701 genlmsg_cancel(msg, hdr);
5e760230
JB		 14702 nlmsg_free(msg);
14703}
14704EXPORT_SYMBOL(cfg80211_report_obss_beacon);
14705
cd8f7cb4 14706#ifdef CONFIG_PM
8cd4d456
LC		 14707static int cfg80211_net_detect_results(struct sk_buff *msg,
14708 struct cfg80211_wowlan_wakeup *wakeup)
14709{
14710 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
14711 struct nlattr *nl_results, *nl_match, *nl_freqs;
14712 int i, j;
14713
14714 nl_results = nla_nest_start(
14715 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
14716 if (!nl_results)
14717 return -EMSGSIZE;
14718
14719 for (i = 0; i < nd->n_matches; i++) {
14720 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
14721
14722 nl_match = nla_nest_start(msg, i);
14723 if (!nl_match)
14724 break;
14725
14726 /* The SSID attribute is optional in nl80211, but for
14727 * simplicity reasons it's always present in the
14728 * cfg80211 structure. If a driver can't pass the
14729 * SSID, that needs to be changed. A zero length SSID
14730 * is still a valid SSID (wildcard), so it cannot be
14731 * used for this purpose.
14732 */
14733 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
14734 match->ssid.ssid)) {
14735 nla_nest_cancel(msg, nl_match);
14736 goto out;
14737 }
14738
14739 if (match->n_channels) {
14740 nl_freqs = nla_nest_start(
14741 msg, NL80211_ATTR_SCAN_FREQUENCIES);
14742 if (!nl_freqs) {
14743 nla_nest_cancel(msg, nl_match);
14744 goto out;
14745 }
14746
14747 for (j = 0; j < match->n_channels; j++) {
5528fae8 14748 if (nla_put_u32(msg, j, match->channels[j])) {
8cd4d456
LC		 14749 nla_nest_cancel(msg, nl_freqs);
14750 nla_nest_cancel(msg, nl_match);
14751 goto out;
14752 }
14753 }
14754
14755 nla_nest_end(msg, nl_freqs);
14756 }
14757
14758 nla_nest_end(msg, nl_match);
14759 }
14760
14761out:
14762 nla_nest_end(msg, nl_results);
14763 return 0;
14764}
14765
cd8f7cb4
JB		 14766void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
14767 struct cfg80211_wowlan_wakeup *wakeup,
14768 gfp_t gfp)
14769{
f26cbf40 14770 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
cd8f7cb4
JB		 14771 struct sk_buff *msg;
14772 void *hdr;
9c90a9f6 14773 int size = 200;
cd8f7cb4
JB		 14774
14775 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
14776
14777 if (wakeup)
14778 size += wakeup->packet_present_len;
14779
14780 msg = nlmsg_new(size, gfp);
14781 if (!msg)
14782 return;
14783
14784 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
14785 if (!hdr)
14786 goto free_msg;
14787
14788 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 14789 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14790 NL80211_ATTR_PAD))
cd8f7cb4
JB		 14791 goto free_msg;
14792
14793 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14794 wdev->netdev->ifindex))
14795 goto free_msg;
14796
14797 if (wakeup) {
14798 struct nlattr *reasons;
14799
14800 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7fa322c8
JB		 14801 if (!reasons)
14802 goto free_msg;
cd8f7cb4
JB		 14803
14804 if (wakeup->disconnect &&
14805 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
14806 goto free_msg;
14807 if (wakeup->magic_pkt &&
14808 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
14809 goto free_msg;
14810 if (wakeup->gtk_rekey_failure &&
14811 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
14812 goto free_msg;
14813 if (wakeup->eap_identity_req &&
14814 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
14815 goto free_msg;
14816 if (wakeup->four_way_handshake &&
14817 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
14818 goto free_msg;
14819 if (wakeup->rfkill_release &&
14820 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
14821 goto free_msg;
14822
14823 if (wakeup->pattern_idx >= 0 &&
14824 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
14825 wakeup->pattern_idx))
14826 goto free_msg;
14827
ae917c9f
JB		 14828 if (wakeup->tcp_match &&
14829 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
14830 goto free_msg;
2a0e047e 14831
ae917c9f
JB		 14832 if (wakeup->tcp_connlost &&
14833 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
14834 goto free_msg;
2a0e047e 14835
ae917c9f
JB		 14836 if (wakeup->tcp_nomoretokens &&
14837 nla_put_flag(msg,
14838 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
14839 goto free_msg;
2a0e047e 14840
cd8f7cb4
JB		 14841 if (wakeup->packet) {
14842 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
14843 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
14844
14845 if (!wakeup->packet_80211) {
14846 pkt_attr =
14847 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
14848 len_attr =
14849 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
14850 }
14851
14852 if (wakeup->packet_len &&
14853 nla_put_u32(msg, len_attr, wakeup->packet_len))
14854 goto free_msg;
14855
14856 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
14857 wakeup->packet))
14858 goto free_msg;
14859 }
14860
8cd4d456
LC		 14861 if (wakeup->net_detect &&
14862 cfg80211_net_detect_results(msg, wakeup))
14863 goto free_msg;
14864
cd8f7cb4
JB		 14865 nla_nest_end(msg, reasons);
14866 }
14867
9c90a9f6 14868 genlmsg_end(msg, hdr);
cd8f7cb4 14869
68eb5503 14870 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14871 NL80211_MCGRP_MLME, gfp);
cd8f7cb4
JB		 14872 return;
14873
14874 free_msg:
14875 nlmsg_free(msg);
14876}
14877EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
14878#endif
14879
3475b094
JM		 14880void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
14881 enum nl80211_tdls_operation oper,
14882 u16 reason_code, gfp_t gfp)
14883{
14884 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14885 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
3475b094
JM		 14886 struct sk_buff *msg;
14887 void *hdr;
3475b094
JM		 14888
14889 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
14890 reason_code);
14891
14892 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14893 if (!msg)
14894 return;
14895
14896 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
14897 if (!hdr) {
14898 nlmsg_free(msg);
14899 return;
14900 }
14901
14902 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14903 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14904 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
14905 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
14906 (reason_code > 0 &&
14907 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
14908 goto nla_put_failure;
14909
9c90a9f6 14910 genlmsg_end(msg, hdr);
3475b094 14911
68eb5503 14912 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14913 NL80211_MCGRP_MLME, gfp);
3475b094
JM		 14914 return;
14915
14916 nla_put_failure:
14917 genlmsg_cancel(msg, hdr);
14918 nlmsg_free(msg);
14919}
14920EXPORT_SYMBOL(cfg80211_tdls_oper_request);
14921
026331c4
JM		 14922static int nl80211_netlink_notify(struct notifier_block * nb,
14923 unsigned long state,
14924 void *_notify)
14925{
14926 struct netlink_notify *notify = _notify;
14927 struct cfg80211_registered_device *rdev;
14928 struct wireless_dev *wdev;
37c73b5f 14929 struct cfg80211_beacon_registration *reg, *tmp;
026331c4 14930
8f815cdd 14931 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
026331c4
JM		 14932 return NOTIFY_DONE;
14933
14934 rcu_read_lock();
14935
5e760230 14936 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
ca986ad9 14937 struct cfg80211_sched_scan_request *sched_scan_req;
753aacfd 14938
ca986ad9
AVS		 14939 list_for_each_entry_rcu(sched_scan_req,
14940 &rdev->sched_scan_req_list,
14941 list) {
14942 if (sched_scan_req->owner_nlportid == notify->portid) {
14943 sched_scan_req->nl_owner_dead = true;
753aacfd 14944 schedule_work(&rdev->sched_scan_stop_wk);
ca986ad9 14945 }
753aacfd 14946 }
78f22b6a 14947
53873f13 14948 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
15e47304 14949 cfg80211_mlme_unregister_socket(wdev, notify->portid);
37c73b5f 14950
ab81007a
JB		 14951 if (wdev->owner_nlportid == notify->portid) {
14952 wdev->nl_owner_dead = true;
14953 schedule_work(&rdev->destroy_work);
14954 } else if (wdev->conn_owner_nlportid == notify->portid) {
bd2522b1 14955 schedule_work(&wdev->disconnect_wk);
ab81007a 14956 }
78f22b6a
JB		 14957 }
14958
37c73b5f
BG		 14959 spin_lock_bh(&rdev->beacon_registrations_lock);
14960 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
14961 list) {
14962 if (reg->nlportid == notify->portid) {
14963 list_del(&reg->list);
14964 kfree(reg);
14965 break;
14966 }
14967 }
14968 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230 14969 }
026331c4
JM		 14970
14971 rcu_read_unlock();
14972
05050753
I		 14973 /*
14974 * It is possible that the user space process that is controlling the
14975 * indoor setting disappeared, so notify the regulatory core.
14976 */
14977 regulatory_netlink_notify(notify->portid);
6784c7db 14978 return NOTIFY_OK;
026331c4
JM		 14979}
14980
14981static struct notifier_block nl80211_netlink_notifier = {
14982 .notifier_call = nl80211_netlink_notify,
14983};
14984
355199e0
JM		 14985void cfg80211_ft_event(struct net_device *netdev,
14986 struct cfg80211_ft_event_params *ft_event)
14987{
14988 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
f26cbf40 14989 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
355199e0
JM		 14990 struct sk_buff *msg;
14991 void *hdr;
355199e0
JM		 14992
14993 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
14994
14995 if (!ft_event->target_ap)
14996 return;
14997
4ef8c1c9 14998 msg = nlmsg_new(100 + ft_event->ric_ies_len, GFP_KERNEL);
355199e0
JM		 14999 if (!msg)
15000 return;
15001
15002 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
ae917c9f
JB		 15003 if (!hdr)
15004 goto out;
355199e0 15005
ae917c9f
JB		 15006 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15007 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15008 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
15009 goto out;
355199e0 15010
ae917c9f
JB		 15011 if (ft_event->ies &&
15012 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
15013 goto out;
15014 if (ft_event->ric_ies &&
15015 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
15016 ft_event->ric_ies))
15017 goto out;
355199e0 15018
9c90a9f6 15019 genlmsg_end(msg, hdr);
355199e0 15020
68eb5503 15021 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15022 NL80211_MCGRP_MLME, GFP_KERNEL);
ae917c9f
JB		 15023 return;
15024 out:
15025 nlmsg_free(msg);
355199e0
JM		 15026}
15027EXPORT_SYMBOL(cfg80211_ft_event);
15028
5de17984
AS		 15029void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
15030{
15031 struct cfg80211_registered_device *rdev;
15032 struct sk_buff *msg;
15033 void *hdr;
15034 u32 nlportid;
15035
f26cbf40 15036 rdev = wiphy_to_rdev(wdev->wiphy);
5de17984
AS		 15037 if (!rdev->crit_proto_nlportid)
15038 return;
15039
15040 nlportid = rdev->crit_proto_nlportid;
15041 rdev->crit_proto_nlportid = 0;
15042
15043 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15044 if (!msg)
15045 return;
15046
15047 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
15048 if (!hdr)
15049 goto nla_put_failure;
15050
15051 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 15052 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15053 NL80211_ATTR_PAD))
5de17984
AS		 15054 goto nla_put_failure;
15055
15056 genlmsg_end(msg, hdr);
15057
15058 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15059 return;
15060
15061 nla_put_failure:
15062 if (hdr)
15063 genlmsg_cancel(msg, hdr);
15064 nlmsg_free(msg);
5de17984
AS		 15065}
15066EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
15067
348baf0e
JB		 15068void nl80211_send_ap_stopped(struct wireless_dev *wdev)
15069{
15070 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 15071 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
348baf0e
JB		 15072 struct sk_buff *msg;
15073 void *hdr;
15074
15075 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15076 if (!msg)
15077 return;
15078
15079 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
15080 if (!hdr)
15081 goto out;
15082
15083 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15084 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
2dad624e
ND		 15085 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15086 NL80211_ATTR_PAD))
348baf0e
JB		 15087 goto out;
15088
15089 genlmsg_end(msg, hdr);
15090
15091 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
15092 NL80211_MCGRP_MLME, GFP_KERNEL);
15093 return;
15094 out:
15095 nlmsg_free(msg);
15096}
15097
55682965
JB		 15098/* initialisation/exit functions */
15099
56989f6d 15100int __init nl80211_init(void)
55682965 15101{
0d63cbb5 15102 int err;
55682965 15103
489111e5 15104 err = genl_register_family(&nl80211_fam);
55682965
JB		 15105 if (err)
15106 return err;
15107
026331c4
JM		 15108 err = netlink_register_notifier(&nl80211_netlink_notifier);
15109 if (err)
15110 goto err_out;
15111
55682965
JB		 15112 return 0;
15113 err_out:
15114 genl_unregister_family(&nl80211_fam);
15115 return err;
15116}
15117
15118void nl80211_exit(void)
15119{
026331c4 15120 netlink_unregister_notifier(&nl80211_netlink_notifier);
55682965
JB		 15121 genl_unregister_family(&nl80211_fam);
15122}
ubuntu-bionic-kernel mirror