]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - net/wireless/nl80211.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UBUNTU: [Config] CONFIG_SND_SOC_DIO2125=m
[mirror_ubuntu-artful-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 },
8feb69c7 350 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] = {. type = NLA_U32 },
77765eaf
VT		 351 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
352 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
9d62a986
JM		 353 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
354 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
3713b4e3 355 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
ee2aca34
JB		 356 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
357 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
358 .len = NL80211_VHT_CAPABILITY_LEN,
359 },
355199e0
JM		 360 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
361 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
362 .len = IEEE80211_MAX_DATA_LEN },
5e4b6f56 363 [NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
16ef1fe2
SW		 364 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
365 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
366 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
9a774c78
AO		 367 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
368 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
c01fc9ad
SD		 369 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
370 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
5336fa88 371 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
60f4a7b1 372 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
ad7e718c
JB		 373 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
374 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
375 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
fa9ffc74
KP		 376 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
377 .len = IEEE80211_QOS_MAP_LEN_MAX },
1df4a510
JM		 378 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
379 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
df942e7b 380 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
18e5ca65 381 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
34d22ce2 382 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
bab5ab7d 383 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
960d01ac
JB		 384 [NL80211_ATTR_TSID] = { .type = NLA_U8 },
385 [NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
386 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
18998c38 387 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
ad2b26ab 388 [NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
1bdd716c 389 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
4b681c82 390 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
9c748934 391 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
05050753 392 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
34d50519 393 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
38de03d2 394 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
17b94247 395 [NL80211_ATTR_STA_SUPPORT_P2P_PS] = { .type = NLA_U8 },
c6e6a0c8
AE		 396 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
397 .len = VHT_MUMIMO_GROUPS_DATA_LEN
398 },
399 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = { .len = ETH_ALEN },
cb3b7d87 400 [NL80211_ATTR_NAN_MASTER_PREF] = { .type = NLA_U8 },
8585989d 401 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
a442b761 402 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
348bd456
JM		 403 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
404 .len = FILS_MAX_KEK_LEN },
405 [NL80211_ATTR_FILS_NONCES] = { .len = 2 * FILS_NONCE_LEN },
ce0ce13a 406 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
2fa436b3 407 [NL80211_ATTR_BSSID] = { .len = ETH_ALEN },
bf95ecdb 408 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
409 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
410 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
411 },
3093ebbe 412 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
a3caf744
VK		 413 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
414 .len = FILS_ERP_MAX_USERNAME_LEN },
415 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
416 .len = FILS_ERP_MAX_REALM_LEN },
417 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
418 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
419 .len = FILS_ERP_MAX_RRK_LEN },
420 [NL80211_ATTR_FILS_CACHE_ID] = { .len = 2 },
421 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
ca986ad9 422 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
55682965
JB		 423};
424
e31b8213 425/* policy for the key attributes */
b54452b0 426static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
fffd0934 427 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 428 [NL80211_KEY_IDX] = { .type = NLA_U8 },
429 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
81962267 430 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
b9454e83
JB		 431 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
432 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
e31b8213 433 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
dbd2fd65
JB		 434 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
435};
436
437/* policy for the key default flags */
438static const struct nla_policy
439nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
440 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
441 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
b9454e83
JB		 442};
443
f83ace3b 444#ifdef CONFIG_PM
ff1b6e69
JB		 445/* policy for WoWLAN attributes */
446static const struct nla_policy
447nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
448 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
449 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
450 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
451 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
77dbbb13
JB		 452 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
453 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
454 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
455 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
2a0e047e 456 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
8cd4d456 457 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
2a0e047e
JB		 458};
459
460static const struct nla_policy
461nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
462 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
463 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
464 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
465 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
466 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
467 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
468 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
469 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
470 },
471 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
472 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
473 },
474 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
475 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
476 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
ff1b6e69 477};
f83ace3b 478#endif /* CONFIG_PM */
ff1b6e69 479
be29b99a
AK		 480/* policy for coalesce rule attributes */
481static const struct nla_policy
482nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
483 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
484 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
485 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
486};
487
e5497d76
JB		 488/* policy for GTK rekey offload attributes */
489static const struct nla_policy
490nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
491 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
492 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
493 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
494};
495
a1f1c21c
LC		 496static const struct nla_policy
497nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
4a4ab0d7 498 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
a1f1c21c 499 .len = IEEE80211_MAX_SSID_LEN },
3007e352 500 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = { .len = ETH_ALEN },
88e920b4 501 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
a1f1c21c
LC		 502};
503
3b06d277
AS		 504static const struct nla_policy
505nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
506 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
507 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
508};
509
38de03d2
AS		 510static const struct nla_policy
511nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
512 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
513 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
514 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
515 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
516 },
517};
518
a442b761
AB		 519/* policy for NAN function attributes */
520static const struct nla_policy
521nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
522 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
0a27844c 523 [NL80211_NAN_FUNC_SERVICE_ID] = {
a442b761
AB		 524 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
525 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
526 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
527 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
528 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
529 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
530 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { .len = ETH_ALEN },
531 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
532 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
533 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
534 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
535 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
536 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
537 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
538 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
539 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
540};
541
542/* policy for Service Response Filter attributes */
543static const struct nla_policy
544nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
545 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
546 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
547 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
548 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
549 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
550};
551
4279f78b
PX		 552/* policy for packet pattern attributes */
553static const struct nla_policy
554nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
555 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
556 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
557 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
558};
559
97990a06
JB		 560static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
561 struct netlink_callback *cb,
562 struct cfg80211_registered_device **rdev,
563 struct wireless_dev **wdev)
a043897a 564{
97990a06 565 int err;
a043897a 566
97990a06
JB		 567 if (!cb->args[0]) {
568 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da 569 genl_family_attrbuf(&nl80211_fam),
fceb6435 570 nl80211_fam.maxattr, nl80211_policy, NULL);
97990a06 571 if (err)
ea90e0dc 572 return err;
67748893 573
c90c39da
JB		 574 *wdev = __cfg80211_wdev_from_attrs(
575 sock_net(skb->sk),
576 genl_family_attrbuf(&nl80211_fam));
ea90e0dc
JB		 577 if (IS_ERR(*wdev))
578 return PTR_ERR(*wdev);
f26cbf40 579 *rdev = wiphy_to_rdev((*wdev)->wiphy);
c319d50b
JB		 580 /* 0 is the first index - add 1 to parse only once */
581 cb->args[0] = (*rdev)->wiphy_idx + 1;
97990a06
JB		 582 cb->args[1] = (*wdev)->identifier;
583 } else {
c319d50b
JB		 584 /* subtract the 1 again here */
585 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
97990a06 586 struct wireless_dev *tmp;
67748893 587
ea90e0dc
JB		 588 if (!wiphy)
589 return -ENODEV;
f26cbf40 590 *rdev = wiphy_to_rdev(wiphy);
97990a06 591 *wdev = NULL;
67748893 592
53873f13 593 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
97990a06
JB		 594 if (tmp->identifier == cb->args[1]) {
595 *wdev = tmp;
596 break;
597 }
598 }
67748893 599
ea90e0dc
JB		 600 if (!*wdev)
601 return -ENODEV;
67748893
JB		 602 }
603
67748893 604 return 0;
67748893
JB		 605}
606
f4a11bb0
JB		 607/* IE validation */
608static bool is_valid_ie_attr(const struct nlattr *attr)
609{
610 const u8 *pos;
611 int len;
612
613 if (!attr)
614 return true;
615
616 pos = nla_data(attr);
617 len = nla_len(attr);
618
619 while (len) {
620 u8 elemlen;
621
622 if (len < 2)
623 return false;
624 len -= 2;
625
626 elemlen = pos[1];
627 if (elemlen > len)
628 return false;
629
630 len -= elemlen;
631 pos += 2 + elemlen;
632 }
633
634 return true;
635}
636
55682965 637/* message building helper */
15e47304 638static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
55682965
JB		 639 int flags, u8 cmd)
640{
641 /* since there is no private header just add the generic one */
15e47304 642 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
55682965
JB		 643}
644
5dab3b8a 645static int nl80211_msg_put_channel(struct sk_buff *msg,
cdc89b97
JB		 646 struct ieee80211_channel *chan,
647 bool large)
5dab3b8a 648{
ea077c1c
RL		 649 /* Some channels must be completely excluded from the
650 * list to protect old user-space tools from breaking
651 */
652 if (!large && chan->flags &
653 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
654 return 0;
655
9360ffd1
DM		 656 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
657 chan->center_freq))
658 goto nla_put_failure;
5dab3b8a 659
9360ffd1
DM		 660 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
661 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
662 goto nla_put_failure;
8fe02e16
LR		 663 if (chan->flags & IEEE80211_CHAN_NO_IR) {
664 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
665 goto nla_put_failure;
666 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
667 goto nla_put_failure;
668 }
cdc89b97
JB		 669 if (chan->flags & IEEE80211_CHAN_RADAR) {
670 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
671 goto nla_put_failure;
672 if (large) {
673 u32 time;
674
675 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
676
677 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
678 chan->dfs_state))
679 goto nla_put_failure;
680 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
681 time))
682 goto nla_put_failure;
089027e5
JD		 683 if (nla_put_u32(msg,
684 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
685 chan->dfs_cac_ms))
686 goto nla_put_failure;
cdc89b97
JB		 687 }
688 }
5dab3b8a 689
fe1abafd
JB		 690 if (large) {
691 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
692 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
693 goto nla_put_failure;
694 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
695 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
696 goto nla_put_failure;
697 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
698 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
699 goto nla_put_failure;
700 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
701 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
702 goto nla_put_failure;
570dbde1
DS		 703 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
704 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
705 goto nla_put_failure;
06f207fc
AN		 706 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
707 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
570dbde1 708 goto nla_put_failure;
ea077c1c
RL		 709 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
710 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
711 goto nla_put_failure;
712 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
713 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
714 goto nla_put_failure;
fe1abafd
JB		 715 }
716
9360ffd1
DM		 717 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
718 DBM_TO_MBM(chan->max_power)))
719 goto nla_put_failure;
5dab3b8a
LR		 720
721 return 0;
722
723 nla_put_failure:
724 return -ENOBUFS;
725}
726
55682965
JB		 727/* netlink command implementations */
728
b9454e83
JB		 729struct key_parse {
730 struct key_params p;
731 int idx;
e31b8213 732 int type;
b9454e83 733 bool def, defmgmt;
dbd2fd65 734 bool def_uni, def_multi;
b9454e83
JB		 735};
736
737static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
738{
739 struct nlattr *tb[NL80211_KEY_MAX + 1];
740 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
fceb6435 741 nl80211_key_policy, NULL);
b9454e83
JB		 742 if (err)
743 return err;
744
745 k->def = !!tb[NL80211_KEY_DEFAULT];
746 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
747
dbd2fd65
JB		 748 if (k->def) {
749 k->def_uni = true;
750 k->def_multi = true;
751 }
752 if (k->defmgmt)
753 k->def_multi = true;
754
b9454e83
JB		 755 if (tb[NL80211_KEY_IDX])
756 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
757
758 if (tb[NL80211_KEY_DATA]) {
759 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
760 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
761 }
762
763 if (tb[NL80211_KEY_SEQ]) {
764 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
765 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
766 }
767
768 if (tb[NL80211_KEY_CIPHER])
769 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
770
e31b8213
JB		 771 if (tb[NL80211_KEY_TYPE]) {
772 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
773 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
774 return -EINVAL;
775 }
776
dbd2fd65
JB		 777 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
778 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
7a087e74 779
2da8f419
JB		 780 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
781 tb[NL80211_KEY_DEFAULT_TYPES],
fceb6435 782 nl80211_key_default_policy, NULL);
dbd2fd65
JB		 783 if (err)
784 return err;
785
786 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
787 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
788 }
789
b9454e83
JB		 790 return 0;
791}
792
793static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
794{
795 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
796 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
797 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
798 }
799
800 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
801 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
802 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
803 }
804
805 if (info->attrs[NL80211_ATTR_KEY_IDX])
806 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
807
808 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
809 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
810
811 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
812 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
813
dbd2fd65
JB		 814 if (k->def) {
815 k->def_uni = true;
816 k->def_multi = true;
817 }
818 if (k->defmgmt)
819 k->def_multi = true;
820
e31b8213
JB		 821 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
822 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
823 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
824 return -EINVAL;
825 }
826
dbd2fd65
JB		 827 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
828 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
fceb6435
JB		 829 int err = nla_parse_nested(kdt,
830 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
831 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
fe52145f
JB		 832 nl80211_key_default_policy,
833 info->extack);
dbd2fd65
JB		 834 if (err)
835 return err;
836
837 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
838 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
839 }
840
b9454e83
JB		 841 return 0;
842}
843
844static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
845{
846 int err;
847
848 memset(k, 0, sizeof(*k));
849 k->idx = -1;
e31b8213 850 k->type = -1;
b9454e83
JB		 851
852 if (info->attrs[NL80211_ATTR_KEY])
853 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
854 else
855 err = nl80211_parse_key_old(info, k);
856
857 if (err)
858 return err;
859
860 if (k->def && k->defmgmt)
861 return -EINVAL;
862
dbd2fd65
JB		 863 if (k->defmgmt) {
864 if (k->def_uni || !k->def_multi)
865 return -EINVAL;
866 }
867
b9454e83
JB		 868 if (k->idx != -1) {
869 if (k->defmgmt) {
870 if (k->idx < 4 || k->idx > 5)
871 return -EINVAL;
872 } else if (k->def) {
873 if (k->idx < 0 || k->idx > 3)
874 return -EINVAL;
875 } else {
876 if (k->idx < 0 || k->idx > 5)
877 return -EINVAL;
878 }
879 }
880
881 return 0;
882}
883
fffd0934
JB		 884static struct cfg80211_cached_keys *
885nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
de7044ee 886 struct nlattr *keys, bool *no_ht)
fffd0934
JB		 887{
888 struct key_parse parse;
889 struct nlattr *key;
890 struct cfg80211_cached_keys *result;
891 int rem, err, def = 0;
f1c1f17a
JB		 892 bool have_key = false;
893
894 nla_for_each_nested(key, keys, rem) {
895 have_key = true;
896 break;
897 }
898
899 if (!have_key)
900 return NULL;
fffd0934
JB		 901
902 result = kzalloc(sizeof(*result), GFP_KERNEL);
903 if (!result)
904 return ERR_PTR(-ENOMEM);
905
906 result->def = -1;
fffd0934
JB		 907
908 nla_for_each_nested(key, keys, rem) {
909 memset(&parse, 0, sizeof(parse));
910 parse.idx = -1;
911
912 err = nl80211_parse_key_new(key, &parse);
913 if (err)
914 goto error;
915 err = -EINVAL;
916 if (!parse.p.key)
917 goto error;
42ee231c 918 if (parse.idx < 0 || parse.idx > 3)
fffd0934
JB		 919 goto error;
920 if (parse.def) {
921 if (def)
922 goto error;
923 def = 1;
924 result->def = parse.idx;
dbd2fd65
JB		 925 if (!parse.def_uni || !parse.def_multi)
926 goto error;
fffd0934
JB		 927 } else if (parse.defmgmt)
928 goto error;
929 err = cfg80211_validate_key_settings(rdev, &parse.p,
e31b8213 930 parse.idx, false, NULL);
fffd0934
JB		 931 if (err)
932 goto error;
386b1f27
JB		 933 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
934 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
935 err = -EINVAL;
936 goto error;
937 }
fffd0934
JB		 938 result->params[parse.idx].cipher = parse.p.cipher;
939 result->params[parse.idx].key_len = parse.p.key_len;
940 result->params[parse.idx].key = result->data[parse.idx];
941 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
de7044ee 942
386b1f27
JB		 943 /* must be WEP key if we got here */
944 if (no_ht)
945 *no_ht = true;
fffd0934
JB		 946 }
947
f1c1f17a
JB		 948 if (result->def < 0) {
949 err = -EINVAL;
950 goto error;
951 }
952
fffd0934
JB		 953 return result;
954 error:
955 kfree(result);
956 return ERR_PTR(err);
957}
958
959static int nl80211_key_allowed(struct wireless_dev *wdev)
960{
961 ASSERT_WDEV_LOCK(wdev);
962
fffd0934
JB		 963 switch (wdev->iftype) {
964 case NL80211_IFTYPE_AP:
965 case NL80211_IFTYPE_AP_VLAN:
074ac8df 966 case NL80211_IFTYPE_P2P_GO:
ff973af7 967 case NL80211_IFTYPE_MESH_POINT:
fffd0934
JB		 968 break;
969 case NL80211_IFTYPE_ADHOC:
fffd0934 970 case NL80211_IFTYPE_STATION:
074ac8df 971 case NL80211_IFTYPE_P2P_CLIENT:
ceca7b71 972 if (!wdev->current_bss)
fffd0934
JB		 973 return -ENOLINK;
974 break;
de4fcbad 975 case NL80211_IFTYPE_UNSPECIFIED:
6e0bd6c3 976 case NL80211_IFTYPE_OCB:
de4fcbad 977 case NL80211_IFTYPE_MONITOR:
cb3b7d87 978 case NL80211_IFTYPE_NAN:
de4fcbad
JB		 979 case NL80211_IFTYPE_P2P_DEVICE:
980 case NL80211_IFTYPE_WDS:
981 case NUM_NL80211_IFTYPES:
fffd0934
JB		 982 return -EINVAL;
983 }
984
985 return 0;
986}
987
664834de
JM		 988static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
989 struct nlattr *tb)
990{
991 struct ieee80211_channel *chan;
992
993 if (tb == NULL)
994 return NULL;
995 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
996 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
997 return NULL;
998 return chan;
999}
1000
7527a782
JB		 1001static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1002{
1003 struct nlattr *nl_modes = nla_nest_start(msg, attr);
1004 int i;
1005
1006 if (!nl_modes)
1007 goto nla_put_failure;
1008
1009 i = 0;
1010 while (ifmodes) {
9360ffd1
DM		 1011 if ((ifmodes & 1) && nla_put_flag(msg, i))
1012 goto nla_put_failure;
7527a782
JB		 1013 ifmodes >>= 1;
1014 i++;
1015 }
1016
1017 nla_nest_end(msg, nl_modes);
1018 return 0;
1019
1020nla_put_failure:
1021 return -ENOBUFS;
1022}
1023
1024static int nl80211_put_iface_combinations(struct wiphy *wiphy,
cdc89b97
JB		 1025 struct sk_buff *msg,
1026 bool large)
7527a782
JB		 1027{
1028 struct nlattr *nl_combis;
1029 int i, j;
1030
1031 nl_combis = nla_nest_start(msg,
1032 NL80211_ATTR_INTERFACE_COMBINATIONS);
1033 if (!nl_combis)
1034 goto nla_put_failure;
1035
1036 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1037 const struct ieee80211_iface_combination *c;
1038 struct nlattr *nl_combi, *nl_limits;
1039
1040 c = &wiphy->iface_combinations[i];
1041
1042 nl_combi = nla_nest_start(msg, i + 1);
1043 if (!nl_combi)
1044 goto nla_put_failure;
1045
1046 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
1047 if (!nl_limits)
1048 goto nla_put_failure;
1049
1050 for (j = 0; j < c->n_limits; j++) {
1051 struct nlattr *nl_limit;
1052
1053 nl_limit = nla_nest_start(msg, j + 1);
1054 if (!nl_limit)
1055 goto nla_put_failure;
9360ffd1
DM		 1056 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1057 c->limits[j].max))
1058 goto nla_put_failure;
7527a782
JB		 1059 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1060 c->limits[j].types))
1061 goto nla_put_failure;
1062 nla_nest_end(msg, nl_limit);
1063 }
1064
1065 nla_nest_end(msg, nl_limits);
1066
9360ffd1
DM		 1067 if (c->beacon_int_infra_match &&
1068 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1069 goto nla_put_failure;
1070 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1071 c->num_different_channels) ||
1072 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1073 c->max_interfaces))
1074 goto nla_put_failure;
cdc89b97 1075 if (large &&
8c48b50a
FF		 1076 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1077 c->radar_detect_widths) ||
1078 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1079 c->radar_detect_regions)))
cdc89b97 1080 goto nla_put_failure;
0c317a02
PK		 1081 if (c->beacon_int_min_gcd &&
1082 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1083 c->beacon_int_min_gcd))
1084 goto nla_put_failure;
7527a782
JB		 1085
1086 nla_nest_end(msg, nl_combi);
1087 }
1088
1089 nla_nest_end(msg, nl_combis);
1090
1091 return 0;
1092nla_put_failure:
1093 return -ENOBUFS;
1094}
1095
3713b4e3 1096#ifdef CONFIG_PM
b56cf720
JB		 1097static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1098 struct sk_buff *msg)
1099{
964dc9e2 1100 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
b56cf720
JB		 1101 struct nlattr *nl_tcp;
1102
1103 if (!tcp)
1104 return 0;
1105
1106 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1107 if (!nl_tcp)
1108 return -ENOBUFS;
1109
1110 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1111 tcp->data_payload_max))
1112 return -ENOBUFS;
1113
1114 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1115 tcp->data_payload_max))
1116 return -ENOBUFS;
1117
1118 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1119 return -ENOBUFS;
1120
1121 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1122 sizeof(*tcp->tok), tcp->tok))
1123 return -ENOBUFS;
1124
1125 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1126 tcp->data_interval_max))
1127 return -ENOBUFS;
1128
1129 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1130 tcp->wake_payload_max))
1131 return -ENOBUFS;
1132
1133 nla_nest_end(msg, nl_tcp);
1134 return 0;
1135}
1136
3713b4e3 1137static int nl80211_send_wowlan(struct sk_buff *msg,
1b8ec87a 1138 struct cfg80211_registered_device *rdev,
b56cf720 1139 bool large)
55682965 1140{
3713b4e3 1141 struct nlattr *nl_wowlan;
55682965 1142
1b8ec87a 1143 if (!rdev->wiphy.wowlan)
3713b4e3 1144 return 0;
55682965 1145
3713b4e3
JB		 1146 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1147 if (!nl_wowlan)
1148 return -ENOBUFS;
9360ffd1 1149
1b8ec87a 1150 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
3713b4e3 1151 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1b8ec87a 1152 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
3713b4e3 1153 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1b8ec87a 1154 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
3713b4e3 1155 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1b8ec87a 1156 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
3713b4e3 1157 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1b8ec87a 1158 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
3713b4e3 1159 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1b8ec87a 1160 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
3713b4e3 1161 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1b8ec87a 1162 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
3713b4e3 1163 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1b8ec87a 1164 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
3713b4e3
JB		 1165 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1166 return -ENOBUFS;
9360ffd1 1167
1b8ec87a 1168 if (rdev->wiphy.wowlan->n_patterns) {
50ac6607 1169 struct nl80211_pattern_support pat = {
1b8ec87a
ZG		 1170 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1171 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1172 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1173 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
3713b4e3 1174 };
9360ffd1 1175
3713b4e3
JB		 1176 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1177 sizeof(pat), &pat))
1178 return -ENOBUFS;
1179 }
9360ffd1 1180
75453ccb
LC		 1181 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1182 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1183 rdev->wiphy.wowlan->max_nd_match_sets))
1184 return -ENOBUFS;
1185
1b8ec87a 1186 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
b56cf720
JB		 1187 return -ENOBUFS;
1188
3713b4e3 1189 nla_nest_end(msg, nl_wowlan);
9360ffd1 1190
3713b4e3
JB		 1191 return 0;
1192}
1193#endif
9360ffd1 1194
be29b99a 1195static int nl80211_send_coalesce(struct sk_buff *msg,
1b8ec87a 1196 struct cfg80211_registered_device *rdev)
be29b99a
AK		 1197{
1198 struct nl80211_coalesce_rule_support rule;
1199
1b8ec87a 1200 if (!rdev->wiphy.coalesce)
be29b99a
AK		 1201 return 0;
1202
1b8ec87a
ZG		 1203 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1204 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1205 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1206 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1207 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1208 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
be29b99a
AK		 1209
1210 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1211 return -ENOBUFS;
1212
1213 return 0;
1214}
1215
3713b4e3
JB		 1216static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1217 struct ieee80211_supported_band *sband)
1218{
1219 struct nlattr *nl_rates, *nl_rate;
1220 struct ieee80211_rate *rate;
1221 int i;
87bbbe22 1222
3713b4e3
JB		 1223 /* add HT info */
1224 if (sband->ht_cap.ht_supported &&
1225 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1226 sizeof(sband->ht_cap.mcs),
1227 &sband->ht_cap.mcs) ||
1228 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1229 sband->ht_cap.cap) ||
1230 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1231 sband->ht_cap.ampdu_factor) ||
1232 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1233 sband->ht_cap.ampdu_density)))
1234 return -ENOBUFS;
afe0cbf8 1235
3713b4e3
JB		 1236 /* add VHT info */
1237 if (sband->vht_cap.vht_supported &&
1238 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1239 sizeof(sband->vht_cap.vht_mcs),
1240 &sband->vht_cap.vht_mcs) ||
1241 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1242 sband->vht_cap.cap)))
1243 return -ENOBUFS;
f59ac048 1244
3713b4e3
JB		 1245 /* add bitrates */
1246 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1247 if (!nl_rates)
1248 return -ENOBUFS;
ee688b00 1249
3713b4e3
JB		 1250 for (i = 0; i < sband->n_bitrates; i++) {
1251 nl_rate = nla_nest_start(msg, i);
1252 if (!nl_rate)
1253 return -ENOBUFS;
ee688b00 1254
3713b4e3
JB		 1255 rate = &sband->bitrates[i];
1256 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1257 rate->bitrate))
1258 return -ENOBUFS;
1259 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1260 nla_put_flag(msg,
1261 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1262 return -ENOBUFS;
ee688b00 1263
3713b4e3
JB		 1264 nla_nest_end(msg, nl_rate);
1265 }
d51626df 1266
3713b4e3 1267 nla_nest_end(msg, nl_rates);
bf0c111e 1268
3713b4e3
JB		 1269 return 0;
1270}
ee688b00 1271
3713b4e3
JB		 1272static int
1273nl80211_send_mgmt_stypes(struct sk_buff *msg,
1274 const struct ieee80211_txrx_stypes *mgmt_stypes)
1275{
1276 u16 stypes;
1277 struct nlattr *nl_ftypes, *nl_ifs;
1278 enum nl80211_iftype ift;
1279 int i;
ee688b00 1280
3713b4e3
JB		 1281 if (!mgmt_stypes)
1282 return 0;
5dab3b8a 1283
3713b4e3
JB		 1284 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1285 if (!nl_ifs)
1286 return -ENOBUFS;
e2f367f2 1287
3713b4e3
JB		 1288 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1289 nl_ftypes = nla_nest_start(msg, ift);
1290 if (!nl_ftypes)
1291 return -ENOBUFS;
1292 i = 0;
1293 stypes = mgmt_stypes[ift].tx;
1294 while (stypes) {
1295 if ((stypes & 1) &&
1296 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1297 (i << 4) | IEEE80211_FTYPE_MGMT))
1298 return -ENOBUFS;
1299 stypes >>= 1;
1300 i++;
ee688b00 1301 }
3713b4e3
JB		 1302 nla_nest_end(msg, nl_ftypes);
1303 }
ee688b00 1304
3713b4e3 1305 nla_nest_end(msg, nl_ifs);
ee688b00 1306
3713b4e3
JB		 1307 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1308 if (!nl_ifs)
1309 return -ENOBUFS;
ee688b00 1310
3713b4e3
JB		 1311 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1312 nl_ftypes = nla_nest_start(msg, ift);
1313 if (!nl_ftypes)
1314 return -ENOBUFS;
1315 i = 0;
1316 stypes = mgmt_stypes[ift].rx;
1317 while (stypes) {
1318 if ((stypes & 1) &&
1319 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1320 (i << 4) | IEEE80211_FTYPE_MGMT))
1321 return -ENOBUFS;
1322 stypes >>= 1;
1323 i++;
1324 }
1325 nla_nest_end(msg, nl_ftypes);
1326 }
1327 nla_nest_end(msg, nl_ifs);
ee688b00 1328
3713b4e3
JB		 1329 return 0;
1330}
ee688b00 1331
1794899e
JB		 1332#define CMD(op, n) \
1333 do { \
1334 if (rdev->ops->op) { \
1335 i++; \
1336 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1337 goto nla_put_failure; \
1338 } \
1339 } while (0)
1340
1341static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1342 struct sk_buff *msg)
1343{
1344 int i = 0;
1345
1346 /*
1347 * do *NOT* add anything into this function, new things need to be
1348 * advertised only to new versions of userspace that can deal with
1349 * the split (and they can't possibly care about new features...
1350 */
1351 CMD(add_virtual_intf, NEW_INTERFACE);
1352 CMD(change_virtual_intf, SET_INTERFACE);
1353 CMD(add_key, NEW_KEY);
1354 CMD(start_ap, START_AP);
1355 CMD(add_station, NEW_STATION);
1356 CMD(add_mpath, NEW_MPATH);
1357 CMD(update_mesh_config, SET_MESH_CONFIG);
1358 CMD(change_bss, SET_BSS);
1359 CMD(auth, AUTHENTICATE);
1360 CMD(assoc, ASSOCIATE);
1361 CMD(deauth, DEAUTHENTICATE);
1362 CMD(disassoc, DISASSOCIATE);
1363 CMD(join_ibss, JOIN_IBSS);
1364 CMD(join_mesh, JOIN_MESH);
1365 CMD(set_pmksa, SET_PMKSA);
1366 CMD(del_pmksa, DEL_PMKSA);
1367 CMD(flush_pmksa, FLUSH_PMKSA);
1368 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1369 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1370 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1371 CMD(mgmt_tx, FRAME);
1372 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1373 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1374 i++;
1375 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1376 goto nla_put_failure;
1377 }
1378 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1379 rdev->ops->join_mesh) {
1380 i++;
1381 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1382 goto nla_put_failure;
1383 }
1384 CMD(set_wds_peer, SET_WDS_PEER);
1385 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1386 CMD(tdls_mgmt, TDLS_MGMT);
1387 CMD(tdls_oper, TDLS_OPER);
1388 }
ca986ad9 1389 if (rdev->wiphy.max_sched_scan_reqs)
1794899e
JB		 1390 CMD(sched_scan_start, START_SCHED_SCAN);
1391 CMD(probe_client, PROBE_CLIENT);
1392 CMD(set_noack_map, SET_NOACK_MAP);
1393 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1394 i++;
1395 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1396 goto nla_put_failure;
1397 }
1398 CMD(start_p2p_device, START_P2P_DEVICE);
1399 CMD(set_mcast_rate, SET_MCAST_RATE);
1400#ifdef CONFIG_NL80211_TESTMODE
1401 CMD(testmode_cmd, TESTMODE);
1402#endif
1403
1404 if (rdev->ops->connect || rdev->ops->auth) {
1405 i++;
1406 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1407 goto nla_put_failure;
1408 }
1409
1410 if (rdev->ops->disconnect || rdev->ops->deauth) {
1411 i++;
1412 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1413 goto nla_put_failure;
1414 }
1415
1416 return i;
1417 nla_put_failure:
1418 return -ENOBUFS;
1419}
1420
86e8cf98
JB		 1421struct nl80211_dump_wiphy_state {
1422 s64 filter_wiphy;
1423 long start;
019ae3a9 1424 long split_start, band_start, chan_start, capa_start;
86e8cf98
JB		 1425 bool split;
1426};
1427
1b8ec87a 1428static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
3bb20556 1429 enum nl80211_commands cmd,
3713b4e3 1430 struct sk_buff *msg, u32 portid, u32 seq,
86e8cf98 1431 int flags, struct nl80211_dump_wiphy_state *state)
3713b4e3
JB		 1432{
1433 void *hdr;
1434 struct nlattr *nl_bands, *nl_band;
1435 struct nlattr *nl_freqs, *nl_freq;
1436 struct nlattr *nl_cmds;
57fbcce3 1437 enum nl80211_band band;
3713b4e3
JB		 1438 struct ieee80211_channel *chan;
1439 int i;
1440 const struct ieee80211_txrx_stypes *mgmt_stypes =
1b8ec87a 1441 rdev->wiphy.mgmt_stypes;
fe1abafd 1442 u32 features;
ee688b00 1443
3bb20556 1444 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3713b4e3
JB		 1445 if (!hdr)
1446 return -ENOBUFS;
ee688b00 1447
86e8cf98
JB		 1448 if (WARN_ON(!state))
1449 return -EINVAL;
ee688b00 1450
1b8ec87a 1451 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3713b4e3 1452 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1b8ec87a 1453 wiphy_name(&rdev->wiphy)) ||
3713b4e3
JB		 1454 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1455 cfg80211_rdev_list_generation))
8fdc621d
JB		 1456 goto nla_put_failure;
1457
3bb20556
JB		 1458 if (cmd != NL80211_CMD_NEW_WIPHY)
1459 goto finish;
1460
86e8cf98 1461 switch (state->split_start) {
3713b4e3
JB		 1462 case 0:
1463 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1b8ec87a 1464 rdev->wiphy.retry_short) ||
3713b4e3 1465 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1b8ec87a 1466 rdev->wiphy.retry_long) ||
3713b4e3 1467 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1b8ec87a 1468 rdev->wiphy.frag_threshold) ||
3713b4e3 1469 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1b8ec87a 1470 rdev->wiphy.rts_threshold) ||
3713b4e3 1471 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1b8ec87a 1472 rdev->wiphy.coverage_class) ||
3713b4e3 1473 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1b8ec87a 1474 rdev->wiphy.max_scan_ssids) ||
3713b4e3 1475 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1b8ec87a 1476 rdev->wiphy.max_sched_scan_ssids) ||
3713b4e3 1477 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1b8ec87a 1478 rdev->wiphy.max_scan_ie_len) ||
3713b4e3 1479 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1b8ec87a 1480 rdev->wiphy.max_sched_scan_ie_len) ||
3713b4e3 1481 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
3b06d277
AS		 1482 rdev->wiphy.max_match_sets) ||
1483 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1484 rdev->wiphy.max_sched_scan_plans) ||
1485 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1486 rdev->wiphy.max_sched_scan_plan_interval) ||
1487 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1488 rdev->wiphy.max_sched_scan_plan_iterations))
9360ffd1 1489 goto nla_put_failure;
3713b4e3 1490
1b8ec87a 1491 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
3713b4e3 1492 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
aa430da4 1493 goto nla_put_failure;
1b8ec87a 1494 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
3713b4e3
JB		 1495 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1496 goto nla_put_failure;
1b8ec87a 1497 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3713b4e3
JB		 1498 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1499 goto nla_put_failure;
1b8ec87a 1500 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
3713b4e3
JB		 1501 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1502 goto nla_put_failure;
1b8ec87a 1503 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
3713b4e3
JB		 1504 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1505 goto nla_put_failure;
1b8ec87a 1506 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
3713b4e3 1507 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
9360ffd1 1508 goto nla_put_failure;
86e8cf98
JB		 1509 state->split_start++;
1510 if (state->split)
3713b4e3
JB		 1511 break;
1512 case 1:
1513 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1b8ec87a
ZG		 1514 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1515 rdev->wiphy.cipher_suites))
3713b4e3 1516 goto nla_put_failure;
4745fc09 1517
3713b4e3 1518 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1b8ec87a 1519 rdev->wiphy.max_num_pmkids))
3713b4e3 1520 goto nla_put_failure;
b23aa676 1521
1b8ec87a 1522 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
3713b4e3 1523 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
9360ffd1 1524 goto nla_put_failure;
b23aa676 1525
3713b4e3 1526 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1b8ec87a 1527 rdev->wiphy.available_antennas_tx) ||
3713b4e3 1528 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1b8ec87a 1529 rdev->wiphy.available_antennas_rx))
9360ffd1 1530 goto nla_put_failure;
b23aa676 1531
1b8ec87a 1532 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
3713b4e3 1533 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1b8ec87a 1534 rdev->wiphy.probe_resp_offload))
3713b4e3 1535 goto nla_put_failure;
8fdc621d 1536
1b8ec87a
ZG		 1537 if ((rdev->wiphy.available_antennas_tx ||
1538 rdev->wiphy.available_antennas_rx) &&
1539 rdev->ops->get_antenna) {
3713b4e3
JB		 1540 u32 tx_ant = 0, rx_ant = 0;
1541 int res;
7a087e74 1542
1b8ec87a 1543 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
3713b4e3
JB		 1544 if (!res) {
1545 if (nla_put_u32(msg,
1546 NL80211_ATTR_WIPHY_ANTENNA_TX,
1547 tx_ant) ||
1548 nla_put_u32(msg,
1549 NL80211_ATTR_WIPHY_ANTENNA_RX,
1550 rx_ant))
1551 goto nla_put_failure;
1552 }
1553 }
a293911d 1554
86e8cf98
JB		 1555 state->split_start++;
1556 if (state->split)
3713b4e3
JB		 1557 break;
1558 case 2:
1559 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1b8ec87a 1560 rdev->wiphy.interface_modes))
3713b4e3 1561 goto nla_put_failure;
86e8cf98
JB		 1562 state->split_start++;
1563 if (state->split)
3713b4e3
JB		 1564 break;
1565 case 3:
1566 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1567 if (!nl_bands)
1568 goto nla_put_failure;
f7ca38df 1569
86e8cf98 1570 for (band = state->band_start;
57fbcce3 1571 band < NUM_NL80211_BANDS; band++) {
3713b4e3 1572 struct ieee80211_supported_band *sband;
2e161f78 1573
1b8ec87a 1574 sband = rdev->wiphy.bands[band];
2e161f78 1575
3713b4e3
JB		 1576 if (!sband)
1577 continue;
1578
1579 nl_band = nla_nest_start(msg, band);
1580 if (!nl_band)
2e161f78 1581 goto nla_put_failure;
3713b4e3 1582
86e8cf98 1583 switch (state->chan_start) {
3713b4e3
JB		 1584 case 0:
1585 if (nl80211_send_band_rateinfo(msg, sband))
9360ffd1 1586 goto nla_put_failure;
86e8cf98
JB		 1587 state->chan_start++;
1588 if (state->split)
3713b4e3
JB		 1589 break;
1590 default:
1591 /* add frequencies */
1592 nl_freqs = nla_nest_start(
1593 msg, NL80211_BAND_ATTR_FREQS);
1594 if (!nl_freqs)
1595 goto nla_put_failure;
1596
86e8cf98 1597 for (i = state->chan_start - 1;
3713b4e3
JB		 1598 i < sband->n_channels;
1599 i++) {
1600 nl_freq = nla_nest_start(msg, i);
1601 if (!nl_freq)
1602 goto nla_put_failure;
1603
1604 chan = &sband->channels[i];
1605
86e8cf98
JB		 1606 if (nl80211_msg_put_channel(
1607 msg, chan,
1608 state->split))
3713b4e3
JB		 1609 goto nla_put_failure;
1610
1611 nla_nest_end(msg, nl_freq);
86e8cf98 1612 if (state->split)
3713b4e3
JB		 1613 break;
1614 }
1615 if (i < sband->n_channels)
86e8cf98 1616 state->chan_start = i + 2;
3713b4e3 1617 else
86e8cf98 1618 state->chan_start = 0;
3713b4e3
JB		 1619 nla_nest_end(msg, nl_freqs);
1620 }
1621
1622 nla_nest_end(msg, nl_band);
1623
86e8cf98 1624 if (state->split) {
3713b4e3 1625 /* start again here */
86e8cf98 1626 if (state->chan_start)
3713b4e3
JB		 1627 band--;
1628 break;
2e161f78 1629 }
2e161f78 1630 }
3713b4e3 1631 nla_nest_end(msg, nl_bands);
2e161f78 1632
57fbcce3 1633 if (band < NUM_NL80211_BANDS)
86e8cf98 1634 state->band_start = band + 1;
3713b4e3 1635 else
86e8cf98 1636 state->band_start = 0;
74b70a4e 1637
3713b4e3 1638 /* if bands & channels are done, continue outside */
86e8cf98
JB		 1639 if (state->band_start == 0 && state->chan_start == 0)
1640 state->split_start++;
1641 if (state->split)
3713b4e3
JB		 1642 break;
1643 case 4:
1644 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1645 if (!nl_cmds)
2e161f78
JB		 1646 goto nla_put_failure;
1647
1794899e
JB		 1648 i = nl80211_add_commands_unsplit(rdev, msg);
1649 if (i < 0)
1650 goto nla_put_failure;
86e8cf98 1651 if (state->split) {
5de17984
AS		 1652 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1653 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1b8ec87a 1654 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
16ef1fe2 1655 CMD(channel_switch, CHANNEL_SWITCH);
02df00eb 1656 CMD(set_qos_map, SET_QOS_MAP);
723e73ac
JB		 1657 if (rdev->wiphy.features &
1658 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
960d01ac 1659 CMD(add_tx_ts, ADD_TX_TS);
ce0ce13a 1660 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
088e8df8 1661 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
5de17984 1662 }
3713b4e3 1663#undef CMD
ff1b6e69 1664
3713b4e3 1665 nla_nest_end(msg, nl_cmds);
86e8cf98
JB		 1666 state->split_start++;
1667 if (state->split)
3713b4e3
JB		 1668 break;
1669 case 5:
1b8ec87a
ZG		 1670 if (rdev->ops->remain_on_channel &&
1671 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
3713b4e3
JB		 1672 nla_put_u32(msg,
1673 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1b8ec87a 1674 rdev->wiphy.max_remain_on_channel_duration))
3713b4e3
JB		 1675 goto nla_put_failure;
1676
1b8ec87a 1677 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
3713b4e3
JB		 1678 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1679 goto nla_put_failure;
1680
1681 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1682 goto nla_put_failure;
86e8cf98
JB		 1683 state->split_start++;
1684 if (state->split)
3713b4e3
JB		 1685 break;
1686 case 6:
1687#ifdef CONFIG_PM
1b8ec87a 1688 if (nl80211_send_wowlan(msg, rdev, state->split))
3713b4e3 1689 goto nla_put_failure;
86e8cf98
JB		 1690 state->split_start++;
1691 if (state->split)
3713b4e3
JB		 1692 break;
1693#else
86e8cf98 1694 state->split_start++;
dfb89c56 1695#endif
3713b4e3
JB		 1696 case 7:
1697 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1b8ec87a 1698 rdev->wiphy.software_iftypes))
3713b4e3 1699 goto nla_put_failure;
ff1b6e69 1700
1b8ec87a 1701 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
86e8cf98 1702 state->split))
3713b4e3 1703 goto nla_put_failure;
7527a782 1704
86e8cf98
JB		 1705 state->split_start++;
1706 if (state->split)
3713b4e3
JB		 1707 break;
1708 case 8:
1b8ec87a 1709 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
3713b4e3 1710 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1b8ec87a 1711 rdev->wiphy.ap_sme_capa))
3713b4e3 1712 goto nla_put_failure;
7527a782 1713
1b8ec87a 1714 features = rdev->wiphy.features;
fe1abafd
JB		 1715 /*
1716 * We can only add the per-channel limit information if the
1717 * dump is split, otherwise it makes it too big. Therefore
1718 * only advertise it in that case.
1719 */
86e8cf98 1720 if (state->split)
fe1abafd
JB		 1721 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1722 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
3713b4e3 1723 goto nla_put_failure;
562a7480 1724
1b8ec87a 1725 if (rdev->wiphy.ht_capa_mod_mask &&
3713b4e3 1726 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1b8ec87a
ZG		 1727 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1728 rdev->wiphy.ht_capa_mod_mask))
3713b4e3 1729 goto nla_put_failure;
1f074bd8 1730
1b8ec87a
ZG		 1731 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1732 rdev->wiphy.max_acl_mac_addrs &&
3713b4e3 1733 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1b8ec87a 1734 rdev->wiphy.max_acl_mac_addrs))
3713b4e3 1735 goto nla_put_failure;
7e7c8926 1736
3713b4e3
JB		 1737 /*
1738 * Any information below this point is only available to
1739 * applications that can deal with it being split. This
1740 * helps ensure that newly added capabilities don't break
1741 * older tools by overrunning their buffers.
1742 *
1743 * We still increment split_start so that in the split
1744 * case we'll continue with more data in the next round,
1745 * but break unconditionally so unsplit data stops here.
1746 */
86e8cf98 1747 state->split_start++;
3713b4e3
JB		 1748 break;
1749 case 9:
1b8ec87a 1750 if (rdev->wiphy.extended_capabilities &&
fe1abafd 1751 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1b8ec87a
ZG		 1752 rdev->wiphy.extended_capabilities_len,
1753 rdev->wiphy.extended_capabilities) ||
fe1abafd 1754 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1b8ec87a
ZG		 1755 rdev->wiphy.extended_capabilities_len,
1756 rdev->wiphy.extended_capabilities_mask)))
fe1abafd 1757 goto nla_put_failure;
a50df0c4 1758
1b8ec87a 1759 if (rdev->wiphy.vht_capa_mod_mask &&
ee2aca34 1760 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1b8ec87a
ZG		 1761 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1762 rdev->wiphy.vht_capa_mod_mask))
ee2aca34
JB		 1763 goto nla_put_failure;
1764
be29b99a
AK		 1765 state->split_start++;
1766 break;
1767 case 10:
1b8ec87a 1768 if (nl80211_send_coalesce(msg, rdev))
be29b99a
AK		 1769 goto nla_put_failure;
1770
1b8ec87a 1771 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
01e0daa4
FF		 1772 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1773 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1774 goto nla_put_failure;
b43504cf 1775
1b8ec87a 1776 if (rdev->wiphy.max_ap_assoc_sta &&
b43504cf 1777 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1b8ec87a 1778 rdev->wiphy.max_ap_assoc_sta))
b43504cf
JM		 1779 goto nla_put_failure;
1780
ad7e718c
JB		 1781 state->split_start++;
1782 break;
1783 case 11:
1b8ec87a 1784 if (rdev->wiphy.n_vendor_commands) {
567ffc35
JB		 1785 const struct nl80211_vendor_cmd_info *info;
1786 struct nlattr *nested;
1787
1788 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1789 if (!nested)
1790 goto nla_put_failure;
1791
1b8ec87a
ZG		 1792 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1793 info = &rdev->wiphy.vendor_commands[i].info;
567ffc35
JB		 1794 if (nla_put(msg, i + 1, sizeof(*info), info))
1795 goto nla_put_failure;
1796 }
1797 nla_nest_end(msg, nested);
1798 }
1799
1b8ec87a 1800 if (rdev->wiphy.n_vendor_events) {
567ffc35
JB		 1801 const struct nl80211_vendor_cmd_info *info;
1802 struct nlattr *nested;
ad7e718c 1803
567ffc35
JB		 1804 nested = nla_nest_start(msg,
1805 NL80211_ATTR_VENDOR_EVENTS);
1806 if (!nested)
ad7e718c 1807 goto nla_put_failure;
567ffc35 1808
1b8ec87a
ZG		 1809 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1810 info = &rdev->wiphy.vendor_events[i];
567ffc35
JB		 1811 if (nla_put(msg, i + 1, sizeof(*info), info))
1812 goto nla_put_failure;
1813 }
1814 nla_nest_end(msg, nested);
1815 }
9a774c78
AO		 1816 state->split_start++;
1817 break;
1818 case 12:
1819 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1820 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1821 rdev->wiphy.max_num_csa_counters))
1822 goto nla_put_failure;
01e0daa4 1823
1bdd716c
AN		 1824 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
1825 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
1826 goto nla_put_failure;
1827
ca986ad9
AVS		 1828 if (rdev->wiphy.max_sched_scan_reqs &&
1829 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
1830 rdev->wiphy.max_sched_scan_reqs))
1831 goto nla_put_failure;
1832
d75bb06b
GKS		 1833 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
1834 sizeof(rdev->wiphy.ext_features),
1835 rdev->wiphy.ext_features))
1836 goto nla_put_failure;
1837
38de03d2
AS		 1838 if (rdev->wiphy.bss_select_support) {
1839 struct nlattr *nested;
1840 u32 bss_select_support = rdev->wiphy.bss_select_support;
1841
1842 nested = nla_nest_start(msg, NL80211_ATTR_BSS_SELECT);
1843 if (!nested)
1844 goto nla_put_failure;
1845
1846 i = 0;
1847 while (bss_select_support) {
1848 if ((bss_select_support & 1) &&
1849 nla_put_flag(msg, i))
1850 goto nla_put_failure;
1851 i++;
1852 bss_select_support >>= 1;
1853 }
1854 nla_nest_end(msg, nested);
1855 }
1856
019ae3a9
KV		 1857 state->split_start++;
1858 break;
1859 case 13:
1860 if (rdev->wiphy.num_iftype_ext_capab &&
1861 rdev->wiphy.iftype_ext_capab) {
1862 struct nlattr *nested_ext_capab, *nested;
1863
1864 nested = nla_nest_start(msg,
1865 NL80211_ATTR_IFTYPE_EXT_CAPA);
1866 if (!nested)
1867 goto nla_put_failure;
1868
1869 for (i = state->capa_start;
1870 i < rdev->wiphy.num_iftype_ext_capab; i++) {
1871 const struct wiphy_iftype_ext_capab *capab;
1872
1873 capab = &rdev->wiphy.iftype_ext_capab[i];
1874
1875 nested_ext_capab = nla_nest_start(msg, i);
1876 if (!nested_ext_capab ||
1877 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
1878 capab->iftype) ||
1879 nla_put(msg, NL80211_ATTR_EXT_CAPA,
1880 capab->extended_capabilities_len,
1881 capab->extended_capabilities) ||
1882 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1883 capab->extended_capabilities_len,
1884 capab->extended_capabilities_mask))
1885 goto nla_put_failure;
1886
1887 nla_nest_end(msg, nested_ext_capab);
1888 if (state->split)
1889 break;
1890 }
1891 nla_nest_end(msg, nested);
1892 if (i < rdev->wiphy.num_iftype_ext_capab) {
1893 state->capa_start = i + 1;
1894 break;
1895 }
1896 }
1897
8585989d
LC		 1898 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
1899 rdev->wiphy.nan_supported_bands))
1900 goto nla_put_failure;
1901
3713b4e3 1902 /* done */
86e8cf98 1903 state->split_start = 0;
3713b4e3
JB		 1904 break;
1905 }
3bb20556 1906 finish:
053c095a
JB		 1907 genlmsg_end(msg, hdr);
1908 return 0;
55682965
JB		 1909
1910 nla_put_failure:
bc3ed28c
TG		 1911 genlmsg_cancel(msg, hdr);
1912 return -EMSGSIZE;
55682965
JB		 1913}
1914
86e8cf98
JB		 1915static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
1916 struct netlink_callback *cb,
1917 struct nl80211_dump_wiphy_state *state)
1918{
c90c39da 1919 struct nlattr **tb = genl_family_attrbuf(&nl80211_fam);
fceb6435
JB		 1920 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb,
1921 nl80211_fam.maxattr, nl80211_policy, NULL);
86e8cf98
JB		 1922 /* ignore parse errors for backward compatibility */
1923 if (ret)
1924 return 0;
1925
1926 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1927 if (tb[NL80211_ATTR_WIPHY])
1928 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1929 if (tb[NL80211_ATTR_WDEV])
1930 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1931 if (tb[NL80211_ATTR_IFINDEX]) {
1932 struct net_device *netdev;
1933 struct cfg80211_registered_device *rdev;
1934 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1935
7f2b8562 1936 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
86e8cf98
JB		 1937 if (!netdev)
1938 return -ENODEV;
1939 if (netdev->ieee80211_ptr) {
f26cbf40 1940 rdev = wiphy_to_rdev(
86e8cf98
JB		 1941 netdev->ieee80211_ptr->wiphy);
1942 state->filter_wiphy = rdev->wiphy_idx;
1943 }
86e8cf98
JB		 1944 }
1945
1946 return 0;
1947}
1948
55682965
JB		 1949static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1950{
645e77de 1951 int idx = 0, ret;
86e8cf98 1952 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
1b8ec87a 1953 struct cfg80211_registered_device *rdev;
3a5a423b 1954
5fe231e8 1955 rtnl_lock();
86e8cf98
JB		 1956 if (!state) {
1957 state = kzalloc(sizeof(*state), GFP_KERNEL);
57ed5cd6
JL		 1958 if (!state) {
1959 rtnl_unlock();
86e8cf98 1960 return -ENOMEM;
3713b4e3 1961 }
86e8cf98
JB		 1962 state->filter_wiphy = -1;
1963 ret = nl80211_dump_wiphy_parse(skb, cb, state);
1964 if (ret) {
1965 kfree(state);
1966 rtnl_unlock();
1967 return ret;
3713b4e3 1968 }
86e8cf98 1969 cb->args[0] = (long)state;
3713b4e3
JB		 1970 }
1971
1b8ec87a
ZG		 1972 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1973 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 1974 continue;
86e8cf98 1975 if (++idx <= state->start)
55682965 1976 continue;
86e8cf98 1977 if (state->filter_wiphy != -1 &&
1b8ec87a 1978 state->filter_wiphy != rdev->wiphy_idx)
3713b4e3
JB		 1979 continue;
1980 /* attempt to fit multiple wiphy data chunks into the skb */
1981 do {
3bb20556
JB		 1982 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
1983 skb,
3713b4e3
JB		 1984 NETLINK_CB(cb->skb).portid,
1985 cb->nlh->nlmsg_seq,
86e8cf98 1986 NLM_F_MULTI, state);
3713b4e3
JB		 1987 if (ret < 0) {
1988 /*
1989 * If sending the wiphy data didn't fit (ENOBUFS
1990 * or EMSGSIZE returned), this SKB is still
1991 * empty (so it's not too big because another
1992 * wiphy dataset is already in the skb) and
1993 * we've not tried to adjust the dump allocation
1994 * yet ... then adjust the alloc size to be
1995 * bigger, and return 1 but with the empty skb.
1996 * This results in an empty message being RX'ed
1997 * in userspace, but that is ignored.
1998 *
1999 * We can then retry with the larger buffer.
2000 */
2001 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
f12cb289 2002 !skb->len && !state->split &&
3713b4e3
JB		 2003 cb->min_dump_alloc < 4096) {
2004 cb->min_dump_alloc = 4096;
f12cb289 2005 state->split_start = 0;
d98cae64 2006 rtnl_unlock();
3713b4e3
JB		 2007 return 1;
2008 }
2009 idx--;
2010 break;
645e77de 2011 }
86e8cf98 2012 } while (state->split_start > 0);
3713b4e3 2013 break;
55682965 2014 }
5fe231e8 2015 rtnl_unlock();
55682965 2016
86e8cf98 2017 state->start = idx;
55682965
JB		 2018
2019 return skb->len;
2020}
2021
86e8cf98
JB		 2022static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2023{
2024 kfree((void *)cb->args[0]);
2025 return 0;
2026}
2027
55682965
JB		 2028static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2029{
2030 struct sk_buff *msg;
1b8ec87a 2031 struct cfg80211_registered_device *rdev = info->user_ptr[0];
86e8cf98 2032 struct nl80211_dump_wiphy_state state = {};
55682965 2033
645e77de 2034 msg = nlmsg_new(4096, GFP_KERNEL);
55682965 2035 if (!msg)
4c476991 2036 return -ENOMEM;
55682965 2037
3bb20556
JB		 2038 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2039 info->snd_portid, info->snd_seq, 0,
86e8cf98 2040 &state) < 0) {
4c476991
JB		 2041 nlmsg_free(msg);
2042 return -ENOBUFS;
2043 }
55682965 2044
134e6375 2045 return genlmsg_reply(msg, info);
55682965
JB		 2046}
2047
31888487
JM		 2048static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2049 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2050 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2051 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2052 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2053 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2054};
2055
2056static int parse_txq_params(struct nlattr *tb[],
2057 struct ieee80211_txq_params *txq_params)
2058{
a3304b0a 2059 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
31888487
JM		 2060 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2061 !tb[NL80211_TXQ_ATTR_AIFS])
2062 return -EINVAL;
2063
a3304b0a 2064 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
31888487
JM		 2065 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2066 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2067 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2068 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2069
a3304b0a
JB		 2070 if (txq_params->ac >= NL80211_NUM_ACS)
2071 return -EINVAL;
2072
31888487
JM		 2073 return 0;
2074}
2075
f444de05
JB		 2076static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2077{
2078 /*
cc1d2806
JB		 2079 * You can only set the channel explicitly for WDS interfaces,
2080 * all others have their channel managed via their respective
2081 * "establish a connection" command (connect, join, ...)
2082 *
2083 * For AP/GO and mesh mode, the channel can be set with the
2084 * channel userspace API, but is only stored and passed to the
2085 * low-level driver when the AP starts or the mesh is joined.
2086 * This is for backward compatibility, userspace can also give
2087 * the channel in the start-ap or join-mesh commands instead.
f444de05
JB		 2088 *
2089 * Monitors are special as they are normally slaved to
e8c9bd5b
JB		 2090 * whatever else is going on, so they have their own special
2091 * operation to set the monitor channel if possible.
f444de05
JB		 2092 */
2093 return !wdev ||
2094 wdev->iftype == NL80211_IFTYPE_AP ||
f444de05 2095 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
074ac8df
JB		 2096 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2097 wdev->iftype == NL80211_IFTYPE_P2P_GO;
f444de05
JB		 2098}
2099
683b6d3b
JB		 2100static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2101 struct genl_info *info,
2102 struct cfg80211_chan_def *chandef)
2103{
dbeca2ea 2104 u32 control_freq;
683b6d3b
JB		 2105
2106 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
2107 return -EINVAL;
2108
2109 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
2110
2111 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
3d9d1d66
JB		 2112 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2113 chandef->center_freq1 = control_freq;
2114 chandef->center_freq2 = 0;
683b6d3b
JB		 2115
2116 /* Primary channel not allowed */
2117 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
2118 return -EINVAL;
2119
3d9d1d66
JB		 2120 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2121 enum nl80211_channel_type chantype;
2122
2123 chantype = nla_get_u32(
2124 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2125
2126 switch (chantype) {
2127 case NL80211_CHAN_NO_HT:
2128 case NL80211_CHAN_HT20:
2129 case NL80211_CHAN_HT40PLUS:
2130 case NL80211_CHAN_HT40MINUS:
2131 cfg80211_chandef_create(chandef, chandef->chan,
2132 chantype);
2133 break;
2134 default:
2135 return -EINVAL;
2136 }
2137 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2138 chandef->width =
2139 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2140 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
2141 chandef->center_freq1 =
2142 nla_get_u32(
2143 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
2144 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
2145 chandef->center_freq2 =
2146 nla_get_u32(
2147 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
2148 }
2149
9f5e8f6e 2150 if (!cfg80211_chandef_valid(chandef))
3d9d1d66
JB		 2151 return -EINVAL;
2152
9f5e8f6e
JB		 2153 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2154 IEEE80211_CHAN_DISABLED))
3d9d1d66
JB		 2155 return -EINVAL;
2156
2f301ab2
SW		 2157 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2158 chandef->width == NL80211_CHAN_WIDTH_10) &&
2159 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ))
2160 return -EINVAL;
2161
683b6d3b
JB		 2162 return 0;
2163}
2164
f444de05 2165static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
e16821bc 2166 struct net_device *dev,
f444de05
JB		 2167 struct genl_info *info)
2168{
683b6d3b 2169 struct cfg80211_chan_def chandef;
f444de05 2170 int result;
e8c9bd5b 2171 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
e16821bc 2172 struct wireless_dev *wdev = NULL;
e8c9bd5b 2173
e16821bc
JM		 2174 if (dev)
2175 wdev = dev->ieee80211_ptr;
f444de05
JB		 2176 if (!nl80211_can_set_dev_channel(wdev))
2177 return -EOPNOTSUPP;
e16821bc
JM		 2178 if (wdev)
2179 iftype = wdev->iftype;
f444de05 2180
683b6d3b
JB		 2181 result = nl80211_parse_chandef(rdev, info, &chandef);
2182 if (result)
2183 return result;
f444de05 2184
e8c9bd5b 2185 switch (iftype) {
aa430da4
JB		 2186 case NL80211_IFTYPE_AP:
2187 case NL80211_IFTYPE_P2P_GO:
923b352f
AN		 2188 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2189 iftype)) {
aa430da4
JB		 2190 result = -EINVAL;
2191 break;
2192 }
e16821bc
JM		 2193 if (wdev->beacon_interval) {
2194 if (!dev || !rdev->ops->set_ap_chanwidth ||
2195 !(rdev->wiphy.features &
2196 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2197 result = -EBUSY;
2198 break;
2199 }
2200
2201 /* Only allow dynamic channel width changes */
2202 if (chandef.chan != wdev->preset_chandef.chan) {
2203 result = -EBUSY;
2204 break;
2205 }
2206 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2207 if (result)
2208 break;
2209 }
683b6d3b 2210 wdev->preset_chandef = chandef;
aa430da4
JB		 2211 result = 0;
2212 break;
cc1d2806 2213 case NL80211_IFTYPE_MESH_POINT:
683b6d3b 2214 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
cc1d2806 2215 break;
e8c9bd5b 2216 case NL80211_IFTYPE_MONITOR:
683b6d3b 2217 result = cfg80211_set_monitor_channel(rdev, &chandef);
e8c9bd5b 2218 break;
aa430da4 2219 default:
e8c9bd5b 2220 result = -EINVAL;
f444de05 2221 }
f444de05
JB		 2222
2223 return result;
2224}
2225
2226static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2227{
4c476991
JB		 2228 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2229 struct net_device *netdev = info->user_ptr[1];
f444de05 2230
e16821bc 2231 return __nl80211_set_channel(rdev, netdev, info);
f444de05
JB		 2232}
2233
e8347eba
BJ		 2234static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2235{
43b19952
JB		 2236 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2237 struct net_device *dev = info->user_ptr[1];
2238 struct wireless_dev *wdev = dev->ieee80211_ptr;
388ac775 2239 const u8 *bssid;
e8347eba
BJ		 2240
2241 if (!info->attrs[NL80211_ATTR_MAC])
2242 return -EINVAL;
2243
43b19952
JB		 2244 if (netif_running(dev))
2245 return -EBUSY;
e8347eba 2246
43b19952
JB		 2247 if (!rdev->ops->set_wds_peer)
2248 return -EOPNOTSUPP;
e8347eba 2249
43b19952
JB		 2250 if (wdev->iftype != NL80211_IFTYPE_WDS)
2251 return -EOPNOTSUPP;
e8347eba
BJ		 2252
2253 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
e35e4d28 2254 return rdev_set_wds_peer(rdev, dev, bssid);
e8347eba
BJ		 2255}
2256
55682965
JB		 2257static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2258{
2259 struct cfg80211_registered_device *rdev;
f444de05
JB		 2260 struct net_device *netdev = NULL;
2261 struct wireless_dev *wdev;
a1e567c8 2262 int result = 0, rem_txq_params = 0;
31888487 2263 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 2264 u32 changed;
2265 u8 retry_short = 0, retry_long = 0;
2266 u32 frag_threshold = 0, rts_threshold = 0;
81077e82 2267 u8 coverage_class = 0;
55682965 2268
5fe231e8
JB		 2269 ASSERT_RTNL();
2270
f444de05
JB		 2271 /*
2272 * Try to find the wiphy and netdev. Normally this
2273 * function shouldn't need the netdev, but this is
2274 * done for backward compatibility -- previously
2275 * setting the channel was done per wiphy, but now
2276 * it is per netdev. Previous userland like hostapd
2277 * also passed a netdev to set_wiphy, so that it is
2278 * possible to let that go to the right netdev!
2279 */
4bbf4d56 2280
f444de05
JB		 2281 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2282 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2283
7f2b8562 2284 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
5fe231e8 2285 if (netdev && netdev->ieee80211_ptr)
f26cbf40 2286 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
5fe231e8 2287 else
f444de05 2288 netdev = NULL;
4bbf4d56
JB		 2289 }
2290
f444de05 2291 if (!netdev) {
878d9ec7
JB		 2292 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2293 info->attrs);
5fe231e8 2294 if (IS_ERR(rdev))
4c476991 2295 return PTR_ERR(rdev);
f444de05
JB		 2296 wdev = NULL;
2297 netdev = NULL;
2298 result = 0;
71fe96bf 2299 } else
f444de05 2300 wdev = netdev->ieee80211_ptr;
f444de05
JB		 2301
2302 /*
2303 * end workaround code, by now the rdev is available
2304 * and locked, and wdev may or may not be NULL.
2305 */
4bbf4d56
JB		 2306
2307 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 2308 result = cfg80211_dev_rename(
2309 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56 2310
4bbf4d56 2311 if (result)
7f2b8562 2312 return result;
31888487
JM		 2313
2314 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2315 struct ieee80211_txq_params txq_params;
2316 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2317
7f2b8562
YX		 2318 if (!rdev->ops->set_txq_params)
2319 return -EOPNOTSUPP;
31888487 2320
7f2b8562
YX		 2321 if (!netdev)
2322 return -EINVAL;
f70f01c2 2323
133a3ff2 2324 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7f2b8562
YX		 2325 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2326 return -EINVAL;
133a3ff2 2327
7f2b8562
YX		 2328 if (!netif_running(netdev))
2329 return -ENETDOWN;
2b5f8b0b 2330
31888487
JM		 2331 nla_for_each_nested(nl_txq_params,
2332 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2333 rem_txq_params) {
bfe2c7b1
JB		 2334 result = nla_parse_nested(tb, NL80211_TXQ_ATTR_MAX,
2335 nl_txq_params,
fe52145f
JB		 2336 txq_params_policy,
2337 info->extack);
ae811e21
JB		 2338 if (result)
2339 return result;
31888487
JM		 2340 result = parse_txq_params(tb, &txq_params);
2341 if (result)
7f2b8562 2342 return result;
31888487 2343
e35e4d28
HG		 2344 result = rdev_set_txq_params(rdev, netdev,
2345 &txq_params);
31888487 2346 if (result)
7f2b8562 2347 return result;
31888487
JM		 2348 }
2349 }
55682965 2350
72bdcf34 2351 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
e16821bc
JM		 2352 result = __nl80211_set_channel(
2353 rdev,
2354 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2355 info);
72bdcf34 2356 if (result)
7f2b8562 2357 return result;
72bdcf34
JM		 2358 }
2359
98d2ff8b 2360 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
c8442118 2361 struct wireless_dev *txp_wdev = wdev;
98d2ff8b
JO		 2362 enum nl80211_tx_power_setting type;
2363 int idx, mbm = 0;
2364
c8442118
JB		 2365 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2366 txp_wdev = NULL;
2367
7f2b8562
YX		 2368 if (!rdev->ops->set_tx_power)
2369 return -EOPNOTSUPP;
98d2ff8b
JO		 2370
2371 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2372 type = nla_get_u32(info->attrs[idx]);
2373
2374 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
7f2b8562
YX		 2375 (type != NL80211_TX_POWER_AUTOMATIC))
2376 return -EINVAL;
98d2ff8b
JO		 2377
2378 if (type != NL80211_TX_POWER_AUTOMATIC) {
2379 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2380 mbm = nla_get_u32(info->attrs[idx]);
2381 }
2382
c8442118 2383 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
98d2ff8b 2384 if (result)
7f2b8562 2385 return result;
98d2ff8b
JO		 2386 }
2387
afe0cbf8
BR		 2388 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2389 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2390 u32 tx_ant, rx_ant;
7a087e74 2391
7f531e03
BR		 2392 if ((!rdev->wiphy.available_antennas_tx &&
2393 !rdev->wiphy.available_antennas_rx) ||
7f2b8562
YX		 2394 !rdev->ops->set_antenna)
2395 return -EOPNOTSUPP;
afe0cbf8
BR		 2396
2397 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2398 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2399
a7ffac95 2400 /* reject antenna configurations which don't match the
7f531e03
BR		 2401 * available antenna masks, except for the "all" mask */
2402 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
7f2b8562
YX		 2403 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2404 return -EINVAL;
a7ffac95 2405
7f531e03
BR		 2406 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2407 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
a7ffac95 2408
e35e4d28 2409 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
afe0cbf8 2410 if (result)
7f2b8562 2411 return result;
afe0cbf8
BR		 2412 }
2413
b9a5f8ca
JM		 2414 changed = 0;
2415
2416 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2417 retry_short = nla_get_u8(
2418 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
7f2b8562
YX		 2419 if (retry_short == 0)
2420 return -EINVAL;
2421
b9a5f8ca
JM		 2422 changed |= WIPHY_PARAM_RETRY_SHORT;
2423 }
2424
2425 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2426 retry_long = nla_get_u8(
2427 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
7f2b8562
YX		 2428 if (retry_long == 0)
2429 return -EINVAL;
2430
b9a5f8ca
JM		 2431 changed |= WIPHY_PARAM_RETRY_LONG;
2432 }
2433
2434 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2435 frag_threshold = nla_get_u32(
2436 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
7f2b8562
YX		 2437 if (frag_threshold < 256)
2438 return -EINVAL;
2439
b9a5f8ca
JM		 2440 if (frag_threshold != (u32) -1) {
2441 /*
2442 * Fragments (apart from the last one) are required to
2443 * have even length. Make the fragmentation code
2444 * simpler by stripping LSB should someone try to use
2445 * odd threshold value.
2446 */
2447 frag_threshold &= ~0x1;
2448 }
2449 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2450 }
2451
2452 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2453 rts_threshold = nla_get_u32(
2454 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2455 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2456 }
2457
81077e82 2458 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3057dbfd
LB		 2459 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2460 return -EINVAL;
2461
81077e82
LT		 2462 coverage_class = nla_get_u8(
2463 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2464 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2465 }
2466
3057dbfd
LB		 2467 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2468 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2469 return -EOPNOTSUPP;
2470
2471 changed |= WIPHY_PARAM_DYN_ACK;
81077e82
LT		 2472 }
2473
b9a5f8ca
JM		 2474 if (changed) {
2475 u8 old_retry_short, old_retry_long;
2476 u32 old_frag_threshold, old_rts_threshold;
81077e82 2477 u8 old_coverage_class;
b9a5f8ca 2478
7f2b8562
YX		 2479 if (!rdev->ops->set_wiphy_params)
2480 return -EOPNOTSUPP;
b9a5f8ca
JM		 2481
2482 old_retry_short = rdev->wiphy.retry_short;
2483 old_retry_long = rdev->wiphy.retry_long;
2484 old_frag_threshold = rdev->wiphy.frag_threshold;
2485 old_rts_threshold = rdev->wiphy.rts_threshold;
81077e82 2486 old_coverage_class = rdev->wiphy.coverage_class;
b9a5f8ca
JM		 2487
2488 if (changed & WIPHY_PARAM_RETRY_SHORT)
2489 rdev->wiphy.retry_short = retry_short;
2490 if (changed & WIPHY_PARAM_RETRY_LONG)
2491 rdev->wiphy.retry_long = retry_long;
2492 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2493 rdev->wiphy.frag_threshold = frag_threshold;
2494 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2495 rdev->wiphy.rts_threshold = rts_threshold;
81077e82
LT		 2496 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2497 rdev->wiphy.coverage_class = coverage_class;
b9a5f8ca 2498
e35e4d28 2499 result = rdev_set_wiphy_params(rdev, changed);
b9a5f8ca
JM		 2500 if (result) {
2501 rdev->wiphy.retry_short = old_retry_short;
2502 rdev->wiphy.retry_long = old_retry_long;
2503 rdev->wiphy.frag_threshold = old_frag_threshold;
2504 rdev->wiphy.rts_threshold = old_rts_threshold;
81077e82 2505 rdev->wiphy.coverage_class = old_coverage_class;
9189ee31 2506 return result;
b9a5f8ca
JM		 2507 }
2508 }
7f2b8562 2509 return 0;
55682965
JB		 2510}
2511
71bbc994
JB		 2512static inline u64 wdev_id(struct wireless_dev *wdev)
2513{
2514 return (u64)wdev->identifier |
f26cbf40 2515 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
71bbc994 2516}
55682965 2517
683b6d3b 2518static int nl80211_send_chandef(struct sk_buff *msg,
d2859df5 2519 const struct cfg80211_chan_def *chandef)
683b6d3b 2520{
601555cd
JB		 2521 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2522 return -EINVAL;
3d9d1d66 2523
683b6d3b
JB		 2524 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2525 chandef->chan->center_freq))
2526 return -ENOBUFS;
3d9d1d66
JB		 2527 switch (chandef->width) {
2528 case NL80211_CHAN_WIDTH_20_NOHT:
2529 case NL80211_CHAN_WIDTH_20:
2530 case NL80211_CHAN_WIDTH_40:
2531 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2532 cfg80211_get_chandef_type(chandef)))
2533 return -ENOBUFS;
2534 break;
2535 default:
2536 break;
2537 }
2538 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2539 return -ENOBUFS;
2540 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2541 return -ENOBUFS;
2542 if (chandef->center_freq2 &&
2543 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
683b6d3b
JB		 2544 return -ENOBUFS;
2545 return 0;
2546}
2547
15e47304 2548static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
d726405a 2549 struct cfg80211_registered_device *rdev,
8f894be2 2550 struct wireless_dev *wdev, bool removal)
55682965 2551{
72fb2abc 2552 struct net_device *dev = wdev->netdev;
8f894be2 2553 u8 cmd = NL80211_CMD_NEW_INTERFACE;
55682965
JB		 2554 void *hdr;
2555
8f894be2
TB		 2556 if (removal)
2557 cmd = NL80211_CMD_DEL_INTERFACE;
2558
2559 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
55682965
JB		 2560 if (!hdr)
2561 return -1;
2562
72fb2abc
JB		 2563 if (dev &&
2564 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
98104fde 2565 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
72fb2abc
JB		 2566 goto nla_put_failure;
2567
2568 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2569 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2dad624e
ND		 2570 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
2571 NL80211_ATTR_PAD) ||
98104fde 2572 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
9360ffd1
DM		 2573 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2574 rdev->devlist_generation ^
2575 (cfg80211_rdev_list_generation << 2)))
2576 goto nla_put_failure;
f5ea9120 2577
5b7ccaf3 2578 if (rdev->ops->get_channel) {
683b6d3b
JB		 2579 int ret;
2580 struct cfg80211_chan_def chandef;
2581
2582 ret = rdev_get_channel(rdev, wdev, &chandef);
2583 if (ret == 0) {
2584 if (nl80211_send_chandef(msg, &chandef))
2585 goto nla_put_failure;
2586 }
d91df0e3
PF		 2587 }
2588
d55d0d59
RM		 2589 if (rdev->ops->get_tx_power) {
2590 int dbm, ret;
2591
2592 ret = rdev_get_tx_power(rdev, wdev, &dbm);
2593 if (ret == 0 &&
2594 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
2595 DBM_TO_MBM(dbm)))
2596 goto nla_put_failure;
2597 }
2598
b84e7a05
AQ		 2599 if (wdev->ssid_len) {
2600 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2601 goto nla_put_failure;
2602 }
2603
053c095a
JB		 2604 genlmsg_end(msg, hdr);
2605 return 0;
55682965
JB		 2606
2607 nla_put_failure:
bc3ed28c
TG		 2608 genlmsg_cancel(msg, hdr);
2609 return -EMSGSIZE;
55682965
JB		 2610}
2611
2612static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2613{
2614 int wp_idx = 0;
2615 int if_idx = 0;
2616 int wp_start = cb->args[0];
2617 int if_start = cb->args[1];
b7fb44da 2618 int filter_wiphy = -1;
f5ea9120 2619 struct cfg80211_registered_device *rdev;
55682965 2620 struct wireless_dev *wdev;
ea90e0dc 2621 int ret;
55682965 2622
5fe231e8 2623 rtnl_lock();
b7fb44da
DK		 2624 if (!cb->args[2]) {
2625 struct nl80211_dump_wiphy_state state = {
2626 .filter_wiphy = -1,
2627 };
b7fb44da
DK		 2628
2629 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
2630 if (ret)
ea90e0dc 2631 goto out_unlock;
b7fb44da
DK		 2632
2633 filter_wiphy = state.filter_wiphy;
2634
2635 /*
2636 * if filtering, set cb->args[2] to +1 since 0 is the default
2637 * value needed to determine that parsing is necessary.
2638 */
2639 if (filter_wiphy >= 0)
2640 cb->args[2] = filter_wiphy + 1;
2641 else
2642 cb->args[2] = -1;
2643 } else if (cb->args[2] > 0) {
2644 filter_wiphy = cb->args[2] - 1;
2645 }
2646
f5ea9120
JB		 2647 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2648 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2649 continue;
bba95fef
JB		 2650 if (wp_idx < wp_start) {
2651 wp_idx++;
55682965 2652 continue;
bba95fef 2653 }
b7fb44da
DK		 2654
2655 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
2656 continue;
2657
55682965
JB		 2658 if_idx = 0;
2659
53873f13 2660 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
bba95fef
JB		 2661 if (if_idx < if_start) {
2662 if_idx++;
55682965 2663 continue;
bba95fef 2664 }
15e47304 2665 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
55682965 2666 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8f894be2 2667 rdev, wdev, false) < 0) {
bba95fef
JB		 2668 goto out;
2669 }
2670 if_idx++;
55682965 2671 }
bba95fef
JB		 2672
2673 wp_idx++;
55682965 2674 }
bba95fef 2675 out:
55682965
JB		 2676 cb->args[0] = wp_idx;
2677 cb->args[1] = if_idx;
2678
ea90e0dc
JB		 2679 ret = skb->len;
2680 out_unlock:
2681 rtnl_unlock();
2682
2683 return ret;
55682965
JB		 2684}
2685
2686static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2687{
2688 struct sk_buff *msg;
1b8ec87a 2689 struct cfg80211_registered_device *rdev = info->user_ptr[0];
72fb2abc 2690 struct wireless_dev *wdev = info->user_ptr[1];
55682965 2691
fd2120ca 2692 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965 2693 if (!msg)
4c476991 2694 return -ENOMEM;
55682965 2695
15e47304 2696 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2697 rdev, wdev, false) < 0) {
4c476991
JB		 2698 nlmsg_free(msg);
2699 return -ENOBUFS;
2700 }
55682965 2701
134e6375 2702 return genlmsg_reply(msg, info);
55682965
JB		 2703}
2704
66f7ac50
MW		 2705static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2706 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2707 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2708 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2709 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2710 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
e057d3c3 2711 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
66f7ac50
MW		 2712};
2713
2714static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2715{
2716 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2717 int flag;
2718
2719 *mntrflags = 0;
2720
2721 if (!nla)
2722 return -EINVAL;
2723
fceb6435
JB		 2724 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX, nla,
2725 mntr_flags_policy, NULL))
66f7ac50
MW		 2726 return -EINVAL;
2727
2728 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2729 if (flags[flag])
2730 *mntrflags |= (1<<flag);
2731
818a986e
JB		 2732 *mntrflags |= MONITOR_FLAG_CHANGED;
2733
66f7ac50
MW		 2734 return 0;
2735}
2736
1db77596
JB		 2737static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
2738 enum nl80211_iftype type,
2739 struct genl_info *info,
2740 struct vif_params *params)
2741{
2742 bool change = false;
2743 int err;
2744
2745 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2746 if (type != NL80211_IFTYPE_MONITOR)
2747 return -EINVAL;
2748
2749 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2750 &params->flags);
2751 if (err)
2752 return err;
2753
2754 change = true;
2755 }
2756
2757 if (params->flags & MONITOR_FLAG_ACTIVE &&
2758 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2759 return -EOPNOTSUPP;
2760
2761 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
2762 const u8 *mumimo_groups;
2763 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2764
2765 if (type != NL80211_IFTYPE_MONITOR)
2766 return -EINVAL;
2767
2768 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2769 return -EOPNOTSUPP;
2770
2771 mumimo_groups =
2772 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
2773
2774 /* bits 0 and 63 are reserved and must be zero */
4954601f
JB		 2775 if ((mumimo_groups[0] & BIT(0)) ||
2776 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
1db77596
JB		 2777 return -EINVAL;
2778
2779 params->vht_mumimo_groups = mumimo_groups;
2780 change = true;
2781 }
2782
2783 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
2784 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2785
2786 if (type != NL80211_IFTYPE_MONITOR)
2787 return -EINVAL;
2788
2789 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2790 return -EOPNOTSUPP;
2791
2792 params->vht_mumimo_follow_addr =
2793 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
2794 change = true;
2795 }
2796
2797 return change ? 1 : 0;
2798}
2799
9bc383de 2800static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
ad4bb6f8
JB		 2801 struct net_device *netdev, u8 use_4addr,
2802 enum nl80211_iftype iftype)
9bc383de 2803{
ad4bb6f8 2804 if (!use_4addr) {
f350a0a8 2805 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
ad4bb6f8 2806 return -EBUSY;
9bc383de 2807 return 0;
ad4bb6f8 2808 }
9bc383de
JB		 2809
2810 switch (iftype) {
2811 case NL80211_IFTYPE_AP_VLAN:
2812 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2813 return 0;
2814 break;
2815 case NL80211_IFTYPE_STATION:
2816 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2817 return 0;
2818 break;
2819 default:
2820 break;
2821 }
2822
2823 return -EOPNOTSUPP;
2824}
2825
55682965
JB		 2826static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2827{
4c476991 2828 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2829 struct vif_params params;
e36d56b6 2830 int err;
04a773ad 2831 enum nl80211_iftype otype, ntype;
4c476991 2832 struct net_device *dev = info->user_ptr[1];
ac7f9cfa 2833 bool change = false;
55682965 2834
2ec600d6
LCC		 2835 memset(&params, 0, sizeof(params));
2836
04a773ad 2837 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 2838
723b038d 2839 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 2840 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 2841 if (otype != ntype)
ac7f9cfa 2842 change = true;
4c476991
JB		 2843 if (ntype > NL80211_IFTYPE_MAX)
2844 return -EINVAL;
723b038d
JB		 2845 }
2846
92ffe055 2847 if (info->attrs[NL80211_ATTR_MESH_ID]) {
29cbe68c
JB		 2848 struct wireless_dev *wdev = dev->ieee80211_ptr;
2849
4c476991
JB		 2850 if (ntype != NL80211_IFTYPE_MESH_POINT)
2851 return -EINVAL;
29cbe68c
JB		 2852 if (netif_running(dev))
2853 return -EBUSY;
2854
2855 wdev_lock(wdev);
2856 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2857 IEEE80211_MAX_MESH_ID_LEN);
2858 wdev->mesh_id_up_len =
2859 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2860 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2861 wdev->mesh_id_up_len);
2862 wdev_unlock(wdev);
2ec600d6
LCC		 2863 }
2864
8b787643
FF		 2865 if (info->attrs[NL80211_ATTR_4ADDR]) {
2866 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2867 change = true;
ad4bb6f8 2868 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
9bc383de 2869 if (err)
4c476991 2870 return err;
8b787643
FF		 2871 } else {
2872 params.use_4addr = -1;
2873 }
2874
1db77596
JB		 2875 err = nl80211_parse_mon_options(rdev, ntype, info, &params);
2876 if (err < 0)
2877 return err;
2878 if (err > 0)
c6e6a0c8 2879 change = true;
e057d3c3 2880
ac7f9cfa 2881 if (change)
818a986e 2882 err = cfg80211_change_iface(rdev, dev, ntype, &params);
ac7f9cfa
JB		 2883 else
2884 err = 0;
60719ffd 2885
9bc383de
JB		 2886 if (!err && params.use_4addr != -1)
2887 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2888
55682965
JB		 2889 return err;
2890}
2891
2892static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2893{
4c476991 2894 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2895 struct vif_params params;
84efbb84 2896 struct wireless_dev *wdev;
896ff063 2897 struct sk_buff *msg;
55682965
JB		 2898 int err;
2899 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2900
78f22b6a
JB		 2901 /* to avoid failing a new interface creation due to pending removal */
2902 cfg80211_destroy_ifaces(rdev);
2903
2ec600d6
LCC		 2904 memset(&params, 0, sizeof(params));
2905
55682965
JB		 2906 if (!info->attrs[NL80211_ATTR_IFNAME])
2907 return -EINVAL;
2908
2909 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2910 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2911 if (type > NL80211_IFTYPE_MAX)
2912 return -EINVAL;
2913 }
2914
79c97e97 2915 if (!rdev->ops->add_virtual_intf ||
4c476991
JB		 2916 !(rdev->wiphy.interface_modes & (1 << type)))
2917 return -EOPNOTSUPP;
55682965 2918
cb3b7d87 2919 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
e8f479b1
BG		 2920 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2921 info->attrs[NL80211_ATTR_MAC]) {
1c18f145
AS		 2922 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2923 ETH_ALEN);
2924 if (!is_valid_ether_addr(params.macaddr))
2925 return -EADDRNOTAVAIL;
2926 }
2927
9bc383de 2928 if (info->attrs[NL80211_ATTR_4ADDR]) {
8b787643 2929 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
ad4bb6f8 2930 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
9bc383de 2931 if (err)
4c476991 2932 return err;
9bc383de 2933 }
8b787643 2934
1db77596
JB		 2935 err = nl80211_parse_mon_options(rdev, type, info, &params);
2936 if (err < 0)
2937 return err;
e057d3c3 2938
a18c7192
JB		 2939 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2940 if (!msg)
2941 return -ENOMEM;
2942
e35e4d28
HG		 2943 wdev = rdev_add_virtual_intf(rdev,
2944 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
818a986e 2945 NET_NAME_USER, type, &params);
d687cbb7
RM		 2946 if (WARN_ON(!wdev)) {
2947 nlmsg_free(msg);
2948 return -EPROTO;
2949 } else if (IS_ERR(wdev)) {
1c90f9d4 2950 nlmsg_free(msg);
84efbb84 2951 return PTR_ERR(wdev);
1c90f9d4 2952 }
2ec600d6 2953
18e5ca65 2954 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
78f22b6a
JB		 2955 wdev->owner_nlportid = info->snd_portid;
2956
98104fde
JB		 2957 switch (type) {
2958 case NL80211_IFTYPE_MESH_POINT:
2959 if (!info->attrs[NL80211_ATTR_MESH_ID])
2960 break;
29cbe68c
JB		 2961 wdev_lock(wdev);
2962 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2963 IEEE80211_MAX_MESH_ID_LEN);
2964 wdev->mesh_id_up_len =
2965 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2966 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2967 wdev->mesh_id_up_len);
2968 wdev_unlock(wdev);
98104fde 2969 break;
cb3b7d87 2970 case NL80211_IFTYPE_NAN:
98104fde
JB		 2971 case NL80211_IFTYPE_P2P_DEVICE:
2972 /*
cb3b7d87 2973 * P2P Device and NAN do not have a netdev, so don't go
98104fde
JB		 2974 * through the netdev notifier and must be added here
2975 */
2976 mutex_init(&wdev->mtx);
2977 INIT_LIST_HEAD(&wdev->event_list);
2978 spin_lock_init(&wdev->event_lock);
2979 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2980 spin_lock_init(&wdev->mgmt_registrations_lock);
2981
98104fde 2982 wdev->identifier = ++rdev->wdev_id;
53873f13 2983 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
98104fde 2984 rdev->devlist_generation++;
98104fde
JB		 2985 break;
2986 default:
2987 break;
29cbe68c
JB		 2988 }
2989
15e47304 2990 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2991 rdev, wdev, false) < 0) {
1c90f9d4
JB		 2992 nlmsg_free(msg);
2993 return -ENOBUFS;
2994 }
2995
896ff063
DK		 2996 /*
2997 * For wdevs which have no associated netdev object (e.g. of type
2998 * NL80211_IFTYPE_P2P_DEVICE), emit the NEW_INTERFACE event here.
2999 * For all other types, the event will be generated from the
3000 * netdev notifier
3001 */
3002 if (!wdev->netdev)
3003 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
8f894be2 3004
1c90f9d4 3005 return genlmsg_reply(msg, info);
55682965
JB		 3006}
3007
3008static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3009{
4c476991 3010 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84efbb84 3011 struct wireless_dev *wdev = info->user_ptr[1];
55682965 3012
4c476991
JB		 3013 if (!rdev->ops->del_virtual_intf)
3014 return -EOPNOTSUPP;
55682965 3015
84efbb84
JB		 3016 /*
3017 * If we remove a wireless device without a netdev then clear
3018 * user_ptr[1] so that nl80211_post_doit won't dereference it
3019 * to check if it needs to do dev_put(). Otherwise it crashes
3020 * since the wdev has been freed, unlike with a netdev where
3021 * we need the dev_put() for the netdev to really be freed.
3022 */
3023 if (!wdev->netdev)
3024 info->user_ptr[1] = NULL;
3025
7f8ed01e 3026 return rdev_del_virtual_intf(rdev, wdev);
55682965
JB		 3027}
3028
1d9d9213
SW		 3029static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3030{
3031 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3032 struct net_device *dev = info->user_ptr[1];
3033 u16 noack_map;
3034
3035 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3036 return -EINVAL;
3037
3038 if (!rdev->ops->set_noack_map)
3039 return -EOPNOTSUPP;
3040
3041 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3042
e35e4d28 3043 return rdev_set_noack_map(rdev, dev, noack_map);
1d9d9213
SW		 3044}
3045
41ade00f
JB		 3046struct get_key_cookie {
3047 struct sk_buff *msg;
3048 int error;
b9454e83 3049 int idx;
41ade00f
JB		 3050};
3051
3052static void get_key_callback(void *c, struct key_params *params)
3053{
b9454e83 3054 struct nlattr *key;
41ade00f
JB		 3055 struct get_key_cookie *cookie = c;
3056
9360ffd1
DM		 3057 if ((params->key &&
3058 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3059 params->key_len, params->key)) ||
3060 (params->seq &&
3061 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3062 params->seq_len, params->seq)) ||
3063 (params->cipher &&
3064 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3065 params->cipher)))
3066 goto nla_put_failure;
41ade00f 3067
b9454e83
JB		 3068 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
3069 if (!key)
3070 goto nla_put_failure;
3071
9360ffd1
DM		 3072 if ((params->key &&
3073 nla_put(cookie->msg, NL80211_KEY_DATA,
3074 params->key_len, params->key)) ||
3075 (params->seq &&
3076 nla_put(cookie->msg, NL80211_KEY_SEQ,
3077 params->seq_len, params->seq)) ||
3078 (params->cipher &&
3079 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3080 params->cipher)))
3081 goto nla_put_failure;
b9454e83 3082
9360ffd1
DM		 3083 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
3084 goto nla_put_failure;
b9454e83
JB		 3085
3086 nla_nest_end(cookie->msg, key);
3087
41ade00f
JB		 3088 return;
3089 nla_put_failure:
3090 cookie->error = 1;
3091}
3092
3093static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3094{
4c476991 3095 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3096 int err;
4c476991 3097 struct net_device *dev = info->user_ptr[1];
41ade00f 3098 u8 key_idx = 0;
e31b8213
JB		 3099 const u8 *mac_addr = NULL;
3100 bool pairwise;
41ade00f
JB		 3101 struct get_key_cookie cookie = {
3102 .error = 0,
3103 };
3104 void *hdr;
3105 struct sk_buff *msg;
3106
3107 if (info->attrs[NL80211_ATTR_KEY_IDX])
3108 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3109
3cfcf6ac 3110 if (key_idx > 5)
41ade00f
JB		 3111 return -EINVAL;
3112
3113 if (info->attrs[NL80211_ATTR_MAC])
3114 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3115
e31b8213
JB		 3116 pairwise = !!mac_addr;
3117 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3118 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
7a087e74 3119
e31b8213
JB		 3120 if (kt >= NUM_NL80211_KEYTYPES)
3121 return -EINVAL;
3122 if (kt != NL80211_KEYTYPE_GROUP &&
3123 kt != NL80211_KEYTYPE_PAIRWISE)
3124 return -EINVAL;
3125 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3126 }
3127
4c476991
JB		 3128 if (!rdev->ops->get_key)
3129 return -EOPNOTSUPP;
41ade00f 3130
0fa7b391
JB		 3131 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3132 return -ENOENT;
3133
fd2120ca 3134 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 3135 if (!msg)
3136 return -ENOMEM;
41ade00f 3137
15e47304 3138 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
41ade00f 3139 NL80211_CMD_NEW_KEY);
cb35fba3 3140 if (!hdr)
9fe271af 3141 goto nla_put_failure;
41ade00f
JB		 3142
3143 cookie.msg = msg;
b9454e83 3144 cookie.idx = key_idx;
41ade00f 3145
9360ffd1
DM		 3146 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3147 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3148 goto nla_put_failure;
3149 if (mac_addr &&
3150 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3151 goto nla_put_failure;
41ade00f 3152
e35e4d28
HG		 3153 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3154 get_key_callback);
41ade00f
JB		 3155
3156 if (err)
6c95e2a2 3157 goto free_msg;
41ade00f
JB		 3158
3159 if (cookie.error)
3160 goto nla_put_failure;
3161
3162 genlmsg_end(msg, hdr);
4c476991 3163 return genlmsg_reply(msg, info);
41ade00f
JB		 3164
3165 nla_put_failure:
3166 err = -ENOBUFS;
6c95e2a2 3167 free_msg:
41ade00f 3168 nlmsg_free(msg);
41ade00f
JB		 3169 return err;
3170}
3171
3172static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3173{
4c476991 3174 struct cfg80211_registered_device *rdev = info->user_ptr[0];
b9454e83 3175 struct key_parse key;
41ade00f 3176 int err;
4c476991 3177 struct net_device *dev = info->user_ptr[1];
41ade00f 3178
b9454e83
JB		 3179 err = nl80211_parse_key(info, &key);
3180 if (err)
3181 return err;
41ade00f 3182
b9454e83 3183 if (key.idx < 0)
41ade00f
JB		 3184 return -EINVAL;
3185
b9454e83
JB		 3186 /* only support setting default key */
3187 if (!key.def && !key.defmgmt)
41ade00f
JB		 3188 return -EINVAL;
3189
dbd2fd65 3190 wdev_lock(dev->ieee80211_ptr);
3cfcf6ac 3191
dbd2fd65
JB		 3192 if (key.def) {
3193 if (!rdev->ops->set_default_key) {
3194 err = -EOPNOTSUPP;
3195 goto out;
3196 }
41ade00f 3197
dbd2fd65
JB		 3198 err = nl80211_key_allowed(dev->ieee80211_ptr);
3199 if (err)
3200 goto out;
3201
e35e4d28 3202 err = rdev_set_default_key(rdev, dev, key.idx,
dbd2fd65
JB		 3203 key.def_uni, key.def_multi);
3204
3205 if (err)
3206 goto out;
fffd0934 3207
3d23e349 3208#ifdef CONFIG_CFG80211_WEXT
dbd2fd65
JB		 3209 dev->ieee80211_ptr->wext.default_key = key.idx;
3210#endif
3211 } else {
3212 if (key.def_uni || !key.def_multi) {
3213 err = -EINVAL;
3214 goto out;
3215 }
3216
3217 if (!rdev->ops->set_default_mgmt_key) {
3218 err = -EOPNOTSUPP;
3219 goto out;
3220 }
3221
3222 err = nl80211_key_allowed(dev->ieee80211_ptr);
3223 if (err)
3224 goto out;
3225
e35e4d28 3226 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
dbd2fd65
JB		 3227 if (err)
3228 goto out;
3229
3230#ifdef CONFIG_CFG80211_WEXT
3231 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126 3232#endif
dbd2fd65
JB		 3233 }
3234
3235 out:
fffd0934 3236 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3237
41ade00f
JB		 3238 return err;
3239}
3240
3241static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3242{
4c476991 3243 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fffd0934 3244 int err;
4c476991 3245 struct net_device *dev = info->user_ptr[1];
b9454e83 3246 struct key_parse key;
e31b8213 3247 const u8 *mac_addr = NULL;
41ade00f 3248
b9454e83
JB		 3249 err = nl80211_parse_key(info, &key);
3250 if (err)
3251 return err;
41ade00f 3252
b9454e83 3253 if (!key.p.key)
41ade00f
JB		 3254 return -EINVAL;
3255
41ade00f
JB		 3256 if (info->attrs[NL80211_ATTR_MAC])
3257 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3258
e31b8213
JB		 3259 if (key.type == -1) {
3260 if (mac_addr)
3261 key.type = NL80211_KEYTYPE_PAIRWISE;
3262 else
3263 key.type = NL80211_KEYTYPE_GROUP;
3264 }
3265
3266 /* for now */
3267 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3268 key.type != NL80211_KEYTYPE_GROUP)
3269 return -EINVAL;
3270
4c476991
JB		 3271 if (!rdev->ops->add_key)
3272 return -EOPNOTSUPP;
25e47c18 3273
e31b8213
JB		 3274 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3275 key.type == NL80211_KEYTYPE_PAIRWISE,
3276 mac_addr))
4c476991 3277 return -EINVAL;
41ade00f 3278
fffd0934
JB		 3279 wdev_lock(dev->ieee80211_ptr);
3280 err = nl80211_key_allowed(dev->ieee80211_ptr);
3281 if (!err)
e35e4d28
HG		 3282 err = rdev_add_key(rdev, dev, key.idx,
3283 key.type == NL80211_KEYTYPE_PAIRWISE,
3284 mac_addr, &key.p);
fffd0934 3285 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3286
41ade00f
JB		 3287 return err;
3288}
3289
3290static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3291{
4c476991 3292 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3293 int err;
4c476991 3294 struct net_device *dev = info->user_ptr[1];
41ade00f 3295 u8 *mac_addr = NULL;
b9454e83 3296 struct key_parse key;
41ade00f 3297
b9454e83
JB		 3298 err = nl80211_parse_key(info, &key);
3299 if (err)
3300 return err;
41ade00f
JB		 3301
3302 if (info->attrs[NL80211_ATTR_MAC])
3303 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3304
e31b8213
JB		 3305 if (key.type == -1) {
3306 if (mac_addr)
3307 key.type = NL80211_KEYTYPE_PAIRWISE;
3308 else
3309 key.type = NL80211_KEYTYPE_GROUP;
3310 }
3311
3312 /* for now */
3313 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3314 key.type != NL80211_KEYTYPE_GROUP)
3315 return -EINVAL;
3316
4c476991
JB		 3317 if (!rdev->ops->del_key)
3318 return -EOPNOTSUPP;
41ade00f 3319
fffd0934
JB		 3320 wdev_lock(dev->ieee80211_ptr);
3321 err = nl80211_key_allowed(dev->ieee80211_ptr);
e31b8213 3322
0fa7b391 3323 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
e31b8213
JB		 3324 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3325 err = -ENOENT;
3326
fffd0934 3327 if (!err)
e35e4d28
HG		 3328 err = rdev_del_key(rdev, dev, key.idx,
3329 key.type == NL80211_KEYTYPE_PAIRWISE,
3330 mac_addr);
41ade00f 3331
3d23e349 3332#ifdef CONFIG_CFG80211_WEXT
08645126 3333 if (!err) {
b9454e83 3334 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 3335 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 3336 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 3337 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3338 }
3339#endif
fffd0934 3340 wdev_unlock(dev->ieee80211_ptr);
08645126 3341
41ade00f
JB		 3342 return err;
3343}
3344
77765eaf
VT		 3345/* This function returns an error or the number of nested attributes */
3346static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3347{
3348 struct nlattr *attr;
3349 int n_entries = 0, tmp;
3350
3351 nla_for_each_nested(attr, nl_attr, tmp) {
3352 if (nla_len(attr) != ETH_ALEN)
3353 return -EINVAL;
3354
3355 n_entries++;
3356 }
3357
3358 return n_entries;
3359}
3360
3361/*
3362 * This function parses ACL information and allocates memory for ACL data.
3363 * On successful return, the calling function is responsible to free the
3364 * ACL buffer returned by this function.
3365 */
3366static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3367 struct genl_info *info)
3368{
3369 enum nl80211_acl_policy acl_policy;
3370 struct nlattr *attr;
3371 struct cfg80211_acl_data *acl;
3372 int i = 0, n_entries, tmp;
3373
3374 if (!wiphy->max_acl_mac_addrs)
3375 return ERR_PTR(-EOPNOTSUPP);
3376
3377 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3378 return ERR_PTR(-EINVAL);
3379
3380 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3381 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3382 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3383 return ERR_PTR(-EINVAL);
3384
3385 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3386 return ERR_PTR(-EINVAL);
3387
3388 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3389 if (n_entries < 0)
3390 return ERR_PTR(n_entries);
3391
3392 if (n_entries > wiphy->max_acl_mac_addrs)
3393 return ERR_PTR(-ENOTSUPP);
3394
3395 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3396 GFP_KERNEL);
3397 if (!acl)
3398 return ERR_PTR(-ENOMEM);
3399
3400 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3401 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3402 i++;
3403 }
3404
3405 acl->n_acl_entries = n_entries;
3406 acl->acl_policy = acl_policy;
3407
3408 return acl;
3409}
3410
3411static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3412{
3413 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3414 struct net_device *dev = info->user_ptr[1];
3415 struct cfg80211_acl_data *acl;
3416 int err;
3417
3418 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3419 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3420 return -EOPNOTSUPP;
3421
3422 if (!dev->ieee80211_ptr->beacon_interval)
3423 return -EINVAL;
3424
3425 acl = parse_acl_data(&rdev->wiphy, info);
3426 if (IS_ERR(acl))
3427 return PTR_ERR(acl);
3428
3429 err = rdev_set_mac_acl(rdev, dev, acl);
3430
3431 kfree(acl);
3432
3433 return err;
3434}
3435
a7c7fbff
PK		 3436static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
3437 u8 *rates, u8 rates_len)
3438{
3439 u8 i;
3440 u32 mask = 0;
3441
3442 for (i = 0; i < rates_len; i++) {
3443 int rate = (rates[i] & 0x7f) * 5;
3444 int ridx;
3445
3446 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
3447 struct ieee80211_rate *srate =
3448 &sband->bitrates[ridx];
3449 if (rate == srate->bitrate) {
3450 mask |= 1 << ridx;
3451 break;
3452 }
3453 }
3454 if (ridx == sband->n_bitrates)
3455 return 0; /* rate not found */
3456 }
3457
3458 return mask;
3459}
3460
3461static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
3462 u8 *rates, u8 rates_len,
3463 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
3464{
3465 u8 i;
3466
3467 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
3468
3469 for (i = 0; i < rates_len; i++) {
3470 int ridx, rbit;
3471
3472 ridx = rates[i] / 8;
3473 rbit = BIT(rates[i] % 8);
3474
3475 /* check validity */
3476 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
3477 return false;
3478
3479 /* check availability */
3480 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
3481 mcs[ridx] |= rbit;
3482 else
3483 return false;
3484 }
3485
3486 return true;
3487}
3488
3489static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
3490{
3491 u16 mcs_mask = 0;
3492
3493 switch (vht_mcs_map) {
3494 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
3495 break;
3496 case IEEE80211_VHT_MCS_SUPPORT_0_7:
3497 mcs_mask = 0x00FF;
3498 break;
3499 case IEEE80211_VHT_MCS_SUPPORT_0_8:
3500 mcs_mask = 0x01FF;
3501 break;
3502 case IEEE80211_VHT_MCS_SUPPORT_0_9:
3503 mcs_mask = 0x03FF;
3504 break;
3505 default:
3506 break;
3507 }
3508
3509 return mcs_mask;
3510}
3511
3512static void vht_build_mcs_mask(u16 vht_mcs_map,
3513 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
3514{
3515 u8 nss;
3516
3517 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
3518 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
3519 vht_mcs_map >>= 2;
3520 }
3521}
3522
3523static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
3524 struct nl80211_txrate_vht *txrate,
3525 u16 mcs[NL80211_VHT_NSS_MAX])
3526{
3527 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3528 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
3529 u8 i;
3530
3531 if (!sband->vht_cap.vht_supported)
3532 return false;
3533
3534 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
3535
3536 /* Build vht_mcs_mask from VHT capabilities */
3537 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
3538
3539 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3540 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
3541 mcs[i] = txrate->mcs[i];
3542 else
3543 return false;
3544 }
3545
3546 return true;
3547}
3548
3549static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
3550 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
3551 .len = NL80211_MAX_SUPP_RATES },
3552 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
3553 .len = NL80211_MAX_SUPP_HT_RATES },
3554 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
3555 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
3556};
3557
3558static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
3559 struct cfg80211_bitrate_mask *mask)
3560{
3561 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
3562 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3563 int rem, i;
3564 struct nlattr *tx_rates;
3565 struct ieee80211_supported_band *sband;
3566 u16 vht_tx_mcs_map;
3567
3568 memset(mask, 0, sizeof(*mask));
3569 /* Default to all rates enabled */
3570 for (i = 0; i < NUM_NL80211_BANDS; i++) {
3571 sband = rdev->wiphy.bands[i];
3572
3573 if (!sband)
3574 continue;
3575
3576 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
3577 memcpy(mask->control[i].ht_mcs,
3578 sband->ht_cap.mcs.rx_mask,
3579 sizeof(mask->control[i].ht_mcs));
3580
3581 if (!sband->vht_cap.vht_supported)
3582 continue;
3583
3584 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3585 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
3586 }
3587
3588 /* if no rates are given set it back to the defaults */
3589 if (!info->attrs[NL80211_ATTR_TX_RATES])
3590 goto out;
3591
3592 /* The nested attribute uses enum nl80211_band as the index. This maps
3593 * directly to the enum nl80211_band values used in cfg80211.
3594 */
3595 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
3596 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
3597 enum nl80211_band band = nla_type(tx_rates);
3598 int err;
3599
3600 if (band < 0 || band >= NUM_NL80211_BANDS)
3601 return -EINVAL;
3602 sband = rdev->wiphy.bands[band];
3603 if (sband == NULL)
3604 return -EINVAL;
bfe2c7b1 3605 err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
fe52145f 3606 nl80211_txattr_policy, info->extack);
a7c7fbff
PK		 3607 if (err)
3608 return err;
3609 if (tb[NL80211_TXRATE_LEGACY]) {
3610 mask->control[band].legacy = rateset_to_mask(
3611 sband,
3612 nla_data(tb[NL80211_TXRATE_LEGACY]),
3613 nla_len(tb[NL80211_TXRATE_LEGACY]));
3614 if ((mask->control[band].legacy == 0) &&
3615 nla_len(tb[NL80211_TXRATE_LEGACY]))
3616 return -EINVAL;
3617 }
3618 if (tb[NL80211_TXRATE_HT]) {
3619 if (!ht_rateset_to_mask(
3620 sband,
3621 nla_data(tb[NL80211_TXRATE_HT]),
3622 nla_len(tb[NL80211_TXRATE_HT]),
3623 mask->control[band].ht_mcs))
3624 return -EINVAL;
3625 }
3626 if (tb[NL80211_TXRATE_VHT]) {
3627 if (!vht_set_mcs_mask(
3628 sband,
3629 nla_data(tb[NL80211_TXRATE_VHT]),
3630 mask->control[band].vht_mcs))
3631 return -EINVAL;
3632 }
3633 if (tb[NL80211_TXRATE_GI]) {
3634 mask->control[band].gi =
3635 nla_get_u8(tb[NL80211_TXRATE_GI]);
3636 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
3637 return -EINVAL;
3638 }
3639
3640 if (mask->control[band].legacy == 0) {
3641 /* don't allow empty legacy rates if HT or VHT
3642 * are not even supported.
3643 */
3644 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
3645 rdev->wiphy.bands[band]->vht_cap.vht_supported))
3646 return -EINVAL;
3647
3648 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3649 if (mask->control[band].ht_mcs[i])
3650 goto out;
3651
3652 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3653 if (mask->control[band].vht_mcs[i])
3654 goto out;
3655
3656 /* legacy and mcs rates may not be both empty */
3657 return -EINVAL;
3658 }
3659 }
3660
3661out:
3662 return 0;
3663}
3664
8564e382
JB		 3665static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
3666 enum nl80211_band band,
3667 struct cfg80211_bitrate_mask *beacon_rate)
a7c7fbff 3668{
8564e382
JB		 3669 u32 count_ht, count_vht, i;
3670 u32 rate = beacon_rate->control[band].legacy;
a7c7fbff
PK		 3671
3672 /* Allow only one rate */
3673 if (hweight32(rate) > 1)
3674 return -EINVAL;
3675
3676 count_ht = 0;
3677 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
8564e382 3678 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
a7c7fbff 3679 return -EINVAL;
8564e382 3680 } else if (beacon_rate->control[band].ht_mcs[i]) {
a7c7fbff
PK		 3681 count_ht++;
3682 if (count_ht > 1)
3683 return -EINVAL;
3684 }
3685 if (count_ht && rate)
3686 return -EINVAL;
3687 }
3688
3689 count_vht = 0;
3690 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8564e382 3691 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
a7c7fbff 3692 return -EINVAL;
8564e382 3693 } else if (beacon_rate->control[band].vht_mcs[i]) {
a7c7fbff
PK		 3694 count_vht++;
3695 if (count_vht > 1)
3696 return -EINVAL;
3697 }
3698 if (count_vht && rate)
3699 return -EINVAL;
3700 }
3701
3702 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
3703 return -EINVAL;
3704
8564e382
JB		 3705 if (rate &&
3706 !wiphy_ext_feature_isset(&rdev->wiphy,
3707 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
3708 return -EINVAL;
3709 if (count_ht &&
3710 !wiphy_ext_feature_isset(&rdev->wiphy,
3711 NL80211_EXT_FEATURE_BEACON_RATE_HT))
3712 return -EINVAL;
3713 if (count_vht &&
3714 !wiphy_ext_feature_isset(&rdev->wiphy,
3715 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
3716 return -EINVAL;
3717
a7c7fbff
PK		 3718 return 0;
3719}
3720
a1193be8 3721static int nl80211_parse_beacon(struct nlattr *attrs[],
8860020e 3722 struct cfg80211_beacon_data *bcn)
ed1b6cc7 3723{
8860020e 3724 bool haveinfo = false;
ed1b6cc7 3725
a1193be8
SW		 3726 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3727 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3728 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3729 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
f4a11bb0
JB		 3730 return -EINVAL;
3731
8860020e 3732 memset(bcn, 0, sizeof(*bcn));
ed1b6cc7 3733
a1193be8
SW		 3734 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
3735 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3736 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
8860020e
JB		 3737 if (!bcn->head_len)
3738 return -EINVAL;
3739 haveinfo = true;
ed1b6cc7
JB		 3740 }
3741
a1193be8
SW		 3742 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3743 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3744 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
8860020e 3745 haveinfo = true;
ed1b6cc7
JB		 3746 }
3747
4c476991
JB		 3748 if (!haveinfo)
3749 return -EINVAL;
3b85875a 3750
a1193be8
SW		 3751 if (attrs[NL80211_ATTR_IE]) {
3752 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3753 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
9946ecfb
JM		 3754 }
3755
a1193be8 3756 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
8860020e 3757 bcn->proberesp_ies =
a1193be8 3758 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
8860020e 3759 bcn->proberesp_ies_len =
a1193be8 3760 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
9946ecfb
JM		 3761 }
3762
a1193be8 3763 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
8860020e 3764 bcn->assocresp_ies =
a1193be8 3765 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
8860020e 3766 bcn->assocresp_ies_len =
a1193be8 3767 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
9946ecfb
JM		 3768 }
3769
a1193be8
SW		 3770 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3771 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3772 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
00f740e1
AN		 3773 }
3774
8860020e
JB		 3775 return 0;
3776}
3777
66cd794e
JB		 3778static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
3779 const u8 *rates)
3780{
3781 int i;
3782
3783 if (!rates)
3784 return;
3785
3786 for (i = 0; i < rates[1]; i++) {
3787 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
3788 params->ht_required = true;
3789 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
3790 params->vht_required = true;
3791 }
3792}
3793
3794/*
3795 * Since the nl80211 API didn't include, from the beginning, attributes about
3796 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
3797 * benefit of drivers that rebuild IEs in the firmware.
3798 */
3799static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
3800{
3801 const struct cfg80211_beacon_data *bcn = &params->beacon;
3802 size_t ies_len = bcn->beacon_ies_len;
3803 const u8 *ies = bcn->beacon_ies;
3804 const u8 *rates;
3805 const u8 *cap;
3806
3807 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
3808 nl80211_check_ap_rate_selectors(params, rates);
3809
3810 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
3811 nl80211_check_ap_rate_selectors(params, rates);
3812
3813 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
3814 if (cap && cap[1] >= sizeof(*params->ht_cap))
3815 params->ht_cap = (void *)(cap + 2);
3816 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
3817 if (cap && cap[1] >= sizeof(*params->vht_cap))
3818 params->vht_cap = (void *)(cap + 2);
3819}
3820
46c1dd0c
FF		 3821static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3822 struct cfg80211_ap_settings *params)
3823{
3824 struct wireless_dev *wdev;
3825 bool ret = false;
3826
53873f13 3827 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
46c1dd0c
FF		 3828 if (wdev->iftype != NL80211_IFTYPE_AP &&
3829 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3830 continue;
3831
683b6d3b 3832 if (!wdev->preset_chandef.chan)
46c1dd0c
FF		 3833 continue;
3834
683b6d3b 3835 params->chandef = wdev->preset_chandef;
46c1dd0c
FF		 3836 ret = true;
3837 break;
3838 }
3839
46c1dd0c
FF		 3840 return ret;
3841}
3842
e39e5b5e
JM		 3843static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3844 enum nl80211_auth_type auth_type,
3845 enum nl80211_commands cmd)
3846{
3847 if (auth_type > NL80211_AUTHTYPE_MAX)
3848 return false;
3849
3850 switch (cmd) {
3851 case NL80211_CMD_AUTHENTICATE:
3852 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3853 auth_type == NL80211_AUTHTYPE_SAE)
3854 return false;
63181060
JM		 3855 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3856 NL80211_EXT_FEATURE_FILS_STA) &&
3857 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3858 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3859 auth_type == NL80211_AUTHTYPE_FILS_PK))
3860 return false;
e39e5b5e
JM		 3861 return true;
3862 case NL80211_CMD_CONNECT:
a3caf744
VK		 3863 /* SAE not supported yet */
3864 if (auth_type == NL80211_AUTHTYPE_SAE)
3865 return false;
3866 /* FILS with SK PFS or PK not supported yet */
3867 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3868 auth_type == NL80211_AUTHTYPE_FILS_PK)
3869 return false;
3870 if (!wiphy_ext_feature_isset(
3871 &rdev->wiphy,
3872 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
3873 auth_type == NL80211_AUTHTYPE_FILS_SK)
3874 return false;
3875 return true;
e39e5b5e
JM		 3876 case NL80211_CMD_START_AP:
3877 /* SAE not supported yet */
3878 if (auth_type == NL80211_AUTHTYPE_SAE)
3879 return false;
63181060
JM		 3880 /* FILS not supported yet */
3881 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3882 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3883 auth_type == NL80211_AUTHTYPE_FILS_PK)
3884 return false;
e39e5b5e
JM		 3885 return true;
3886 default:
3887 return false;
3888 }
3889}
3890
8860020e
JB		 3891static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3892{
3893 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3894 struct net_device *dev = info->user_ptr[1];
3895 struct wireless_dev *wdev = dev->ieee80211_ptr;
3896 struct cfg80211_ap_settings params;
3897 int err;
3898
3899 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3900 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3901 return -EOPNOTSUPP;
3902
3903 if (!rdev->ops->start_ap)
3904 return -EOPNOTSUPP;
3905
3906 if (wdev->beacon_interval)
3907 return -EALREADY;
3908
3909 memset(&params, 0, sizeof(params));
3910
3911 /* these are required for START_AP */
3912 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3913 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3914 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3915 return -EINVAL;
3916
a1193be8 3917 err = nl80211_parse_beacon(info->attrs, &params.beacon);
8860020e
JB		 3918 if (err)
3919 return err;
3920
3921 params.beacon_interval =
3922 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3923 params.dtim_period =
3924 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3925
0c317a02
PK		 3926 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
3927 params.beacon_interval);
8860020e
JB		 3928 if (err)
3929 return err;
3930
3931 /*
3932 * In theory, some of these attributes should be required here
3933 * but since they were not used when the command was originally
3934 * added, keep them optional for old user space programs to let
3935 * them continue to work with drivers that do not need the
3936 * additional information -- drivers must check!
3937 */
3938 if (info->attrs[NL80211_ATTR_SSID]) {
3939 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3940 params.ssid_len =
3941 nla_len(info->attrs[NL80211_ATTR_SSID]);
3942 if (params.ssid_len == 0 ||
3943 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3944 return -EINVAL;
3945 }
3946
3947 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3948 params.hidden_ssid = nla_get_u32(
3949 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3950 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3951 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3952 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3953 return -EINVAL;
3954 }
3955
3956 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3957
3958 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3959 params.auth_type = nla_get_u32(
3960 info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 3961 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3962 NL80211_CMD_START_AP))
8860020e
JB		 3963 return -EINVAL;
3964 } else
3965 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3966
3967 err = nl80211_crypto_settings(rdev, info, &params.crypto,
3968 NL80211_MAX_NR_CIPHER_SUITES);
3969 if (err)
3970 return err;
3971
1b658f11
VT		 3972 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3973 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3974 return -EOPNOTSUPP;
3975 params.inactivity_timeout = nla_get_u16(
3976 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3977 }
3978
53cabad7
JB		 3979 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3980 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3981 return -EINVAL;
3982 params.p2p_ctwindow =
3983 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3984 if (params.p2p_ctwindow > 127)
3985 return -EINVAL;
3986 if (params.p2p_ctwindow != 0 &&
3987 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3988 return -EINVAL;
3989 }
3990
3991 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3992 u8 tmp;
3993
3994 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3995 return -EINVAL;
3996 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3997 if (tmp > 1)
3998 return -EINVAL;
3999 params.p2p_opp_ps = tmp;
4000 if (params.p2p_opp_ps != 0 &&
4001 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4002 return -EINVAL;
4003 }
4004
aa430da4 4005 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 4006 err = nl80211_parse_chandef(rdev, info, &params.chandef);
4007 if (err)
4008 return err;
4009 } else if (wdev->preset_chandef.chan) {
4010 params.chandef = wdev->preset_chandef;
46c1dd0c 4011 } else if (!nl80211_get_ap_channel(rdev, &params))
aa430da4
JB		 4012 return -EINVAL;
4013
923b352f
AN		 4014 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
4015 wdev->iftype))
aa430da4
JB		 4016 return -EINVAL;
4017
a7c7fbff
PK		 4018 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4019 err = nl80211_parse_tx_bitrate_mask(info, &params.beacon_rate);
4020 if (err)
4021 return err;
4022
8564e382
JB		 4023 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4024 &params.beacon_rate);
a7c7fbff
PK		 4025 if (err)
4026 return err;
4027 }
4028
18998c38
EP		 4029 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4030 params.smps_mode =
4031 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4032 switch (params.smps_mode) {
4033 case NL80211_SMPS_OFF:
4034 break;
4035 case NL80211_SMPS_STATIC:
4036 if (!(rdev->wiphy.features &
4037 NL80211_FEATURE_STATIC_SMPS))
4038 return -EINVAL;
4039 break;
4040 case NL80211_SMPS_DYNAMIC:
4041 if (!(rdev->wiphy.features &
4042 NL80211_FEATURE_DYNAMIC_SMPS))
4043 return -EINVAL;
4044 break;
4045 default:
4046 return -EINVAL;
4047 }
4048 } else {
4049 params.smps_mode = NL80211_SMPS_OFF;
4050 }
4051
6e8ef842
PK		 4052 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4053 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4054 return -EOPNOTSUPP;
4055
4baf6bea
OO		 4056 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4057 params.acl = parse_acl_data(&rdev->wiphy, info);
4058 if (IS_ERR(params.acl))
4059 return PTR_ERR(params.acl);
4060 }
4061
66cd794e
JB		 4062 nl80211_calculate_ap_params(&params);
4063
c56589ed 4064 wdev_lock(wdev);
e35e4d28 4065 err = rdev_start_ap(rdev, dev, &params);
46c1dd0c 4066 if (!err) {
683b6d3b 4067 wdev->preset_chandef = params.chandef;
8860020e 4068 wdev->beacon_interval = params.beacon_interval;
9e0e2961 4069 wdev->chandef = params.chandef;
06e191e2
AQ		 4070 wdev->ssid_len = params.ssid_len;
4071 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
46c1dd0c 4072 }
c56589ed 4073 wdev_unlock(wdev);
77765eaf
VT		 4074
4075 kfree(params.acl);
4076
56d1893d 4077 return err;
ed1b6cc7
JB		 4078}
4079
8860020e
JB		 4080static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4081{
4082 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4083 struct net_device *dev = info->user_ptr[1];
4084 struct wireless_dev *wdev = dev->ieee80211_ptr;
4085 struct cfg80211_beacon_data params;
4086 int err;
4087
4088 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4089 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4090 return -EOPNOTSUPP;
4091
4092 if (!rdev->ops->change_beacon)
4093 return -EOPNOTSUPP;
4094
4095 if (!wdev->beacon_interval)
4096 return -EINVAL;
4097
a1193be8 4098 err = nl80211_parse_beacon(info->attrs, &params);
8860020e
JB		 4099 if (err)
4100 return err;
4101
c56589ed
SW		 4102 wdev_lock(wdev);
4103 err = rdev_change_beacon(rdev, dev, &params);
4104 wdev_unlock(wdev);
4105
4106 return err;
8860020e
JB		 4107}
4108
4109static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
ed1b6cc7 4110{
4c476991
JB		 4111 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4112 struct net_device *dev = info->user_ptr[1];
ed1b6cc7 4113
7c8d5e03 4114 return cfg80211_stop_ap(rdev, dev, false);
ed1b6cc7
JB		 4115}
4116
5727ef1b
JB		 4117static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4118 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4119 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4120 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 4121 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
b39c48fa 4122 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
d83023da 4123 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5727ef1b
JB		 4124};
4125
eccb8e8f 4126static int parse_station_flags(struct genl_info *info,
bdd3ae3d 4127 enum nl80211_iftype iftype,
eccb8e8f 4128 struct station_parameters *params)
5727ef1b
JB		 4129{
4130 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 4131 struct nlattr *nla;
5727ef1b
JB		 4132 int flag;
4133
eccb8e8f
JB		 4134 /*
4135 * Try parsing the new attribute first so userspace
4136 * can specify both for older kernels.
4137 */
4138 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4139 if (nla) {
4140 struct nl80211_sta_flag_update *sta_flags;
4141
4142 sta_flags = nla_data(nla);
4143 params->sta_flags_mask = sta_flags->mask;
4144 params->sta_flags_set = sta_flags->set;
77ee7c89 4145 params->sta_flags_set &= params->sta_flags_mask;
eccb8e8f
JB		 4146 if ((params->sta_flags_mask |
4147 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4148 return -EINVAL;
4149 return 0;
4150 }
4151
4152 /* if present, parse the old attribute */
5727ef1b 4153
eccb8e8f 4154 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 4155 if (!nla)
4156 return 0;
4157
fceb6435 4158 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, nla,
fe52145f 4159 sta_flags_policy, info->extack))
5727ef1b
JB		 4160 return -EINVAL;
4161
bdd3ae3d
JB		 4162 /*
4163 * Only allow certain flags for interface types so that
4164 * other attributes are silently ignored. Remember that
4165 * this is backward compatibility code with old userspace
4166 * and shouldn't be hit in other cases anyway.
4167 */
4168 switch (iftype) {
4169 case NL80211_IFTYPE_AP:
4170 case NL80211_IFTYPE_AP_VLAN:
4171 case NL80211_IFTYPE_P2P_GO:
4172 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4173 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4174 BIT(NL80211_STA_FLAG_WME) |
4175 BIT(NL80211_STA_FLAG_MFP);
4176 break;
4177 case NL80211_IFTYPE_P2P_CLIENT:
4178 case NL80211_IFTYPE_STATION:
4179 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4180 BIT(NL80211_STA_FLAG_TDLS_PEER);
4181 break;
4182 case NL80211_IFTYPE_MESH_POINT:
4183 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4184 BIT(NL80211_STA_FLAG_MFP) |
4185 BIT(NL80211_STA_FLAG_AUTHORIZED);
4186 default:
4187 return -EINVAL;
4188 }
5727ef1b 4189
3383b5a6
JB		 4190 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4191 if (flags[flag]) {
eccb8e8f 4192 params->sta_flags_set |= (1<<flag);
5727ef1b 4193
3383b5a6
JB		 4194 /* no longer support new API additions in old API */
4195 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4196 return -EINVAL;
4197 }
4198 }
4199
5727ef1b
JB		 4200 return 0;
4201}
4202
c8dcfd8a
FF		 4203static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
4204 int attr)
4205{
4206 struct nlattr *rate;
8eb41c8d
VK		 4207 u32 bitrate;
4208 u16 bitrate_compat;
bbf67e45 4209 enum nl80211_rate_info rate_flg;
c8dcfd8a
FF		 4210
4211 rate = nla_nest_start(msg, attr);
4212 if (!rate)
db9c64cf 4213 return false;
c8dcfd8a
FF		 4214
4215 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4216 bitrate = cfg80211_calculate_bitrate(info);
8eb41c8d
VK		 4217 /* report 16-bit bitrate only if we can */
4218 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
db9c64cf
JB		 4219 if (bitrate > 0 &&
4220 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4221 return false;
4222 if (bitrate_compat > 0 &&
4223 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4224 return false;
4225
b51f3bee
JB		 4226 switch (info->bw) {
4227 case RATE_INFO_BW_5:
4228 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4229 break;
4230 case RATE_INFO_BW_10:
4231 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4232 break;
4233 default:
4234 WARN_ON(1);
4235 /* fall through */
4236 case RATE_INFO_BW_20:
4237 rate_flg = 0;
4238 break;
4239 case RATE_INFO_BW_40:
4240 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4241 break;
4242 case RATE_INFO_BW_80:
4243 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4244 break;
4245 case RATE_INFO_BW_160:
4246 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4247 break;
4248 }
4249
4250 if (rate_flg && nla_put_flag(msg, rate_flg))
4251 return false;
4252
db9c64cf
JB		 4253 if (info->flags & RATE_INFO_FLAGS_MCS) {
4254 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4255 return false;
db9c64cf
JB		 4256 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4257 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4258 return false;
4259 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4260 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4261 return false;
4262 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4263 return false;
db9c64cf
JB		 4264 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4265 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4266 return false;
4267 }
c8dcfd8a
FF		 4268
4269 nla_nest_end(msg, rate);
4270 return true;
c8dcfd8a
FF		 4271}
4272
119363c7
FF		 4273static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4274 int id)
4275{
4276 void *attr;
4277 int i = 0;
4278
4279 if (!mask)
4280 return true;
4281
4282 attr = nla_nest_start(msg, id);
4283 if (!attr)
4284 return false;
4285
4286 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4287 if (!(mask & BIT(i)))
4288 continue;
4289
4290 if (nla_put_u8(msg, i, signal[i]))
4291 return false;
4292 }
4293
4294 nla_nest_end(msg, attr);
4295
4296 return true;
4297}
4298
cf5ead82
JB		 4299static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4300 u32 seq, int flags,
66266b3a
JL		 4301 struct cfg80211_registered_device *rdev,
4302 struct net_device *dev,
98b62183 4303 const u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 4304{
4305 void *hdr;
f4263c98 4306 struct nlattr *sinfoattr, *bss_param;
fd5b74dc 4307
cf5ead82 4308 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
fd5b74dc
JB		 4309 if (!hdr)
4310 return -1;
4311
9360ffd1
DM		 4312 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4313 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
4314 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
4315 goto nla_put_failure;
f5ea9120 4316
2ec600d6
LCC		 4317 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
4318 if (!sinfoattr)
fd5b74dc 4319 goto nla_put_failure;
319090bf
JB		 4320
4321#define PUT_SINFO(attr, memb, type) do { \
d686b920 4322 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
739960f1 4323 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
319090bf
JB		 4324 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
4325 sinfo->memb)) \
4326 goto nla_put_failure; \
4327 } while (0)
d686b920
JB		 4328#define PUT_SINFO_U64(attr, memb) do { \
4329 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
4330 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
4331 sinfo->memb, NL80211_STA_INFO_PAD)) \
4332 goto nla_put_failure; \
4333 } while (0)
319090bf
JB		 4334
4335 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
4336 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
4337
4338 if (sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES) |
4339 BIT(NL80211_STA_INFO_RX_BYTES64)) &&
9360ffd1 4340 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
42745e03 4341 (u32)sinfo->rx_bytes))
9360ffd1 4342 goto nla_put_failure;
319090bf
JB		 4343
4344 if (sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES) |
4345 BIT(NL80211_STA_INFO_TX_BYTES64)) &&
9360ffd1 4346 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
42745e03
VK		 4347 (u32)sinfo->tx_bytes))
4348 goto nla_put_failure;
319090bf 4349
d686b920
JB		 4350 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
4351 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
319090bf
JB		 4352 PUT_SINFO(LLID, llid, u16);
4353 PUT_SINFO(PLID, plid, u16);
4354 PUT_SINFO(PLINK_STATE, plink_state, u8);
d686b920 4355 PUT_SINFO_U64(RX_DURATION, rx_duration);
319090bf 4356
66266b3a
JL		 4357 switch (rdev->wiphy.signal_type) {
4358 case CFG80211_SIGNAL_TYPE_MBM:
319090bf
JB		 4359 PUT_SINFO(SIGNAL, signal, u8);
4360 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
66266b3a
JL		 4361 break;
4362 default:
4363 break;
4364 }
319090bf 4365 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL)) {
119363c7
FF		 4366 if (!nl80211_put_signal(msg, sinfo->chains,
4367 sinfo->chain_signal,
4368 NL80211_STA_INFO_CHAIN_SIGNAL))
4369 goto nla_put_failure;
4370 }
319090bf 4371 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
119363c7
FF		 4372 if (!nl80211_put_signal(msg, sinfo->chains,
4373 sinfo->chain_signal_avg,
4374 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
4375 goto nla_put_failure;
4376 }
319090bf 4377 if (sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {
c8dcfd8a
FF		 4378 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
4379 NL80211_STA_INFO_TX_BITRATE))
4380 goto nla_put_failure;
4381 }
319090bf 4382 if (sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE)) {
c8dcfd8a
FF		 4383 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
4384 NL80211_STA_INFO_RX_BITRATE))
420e7fab 4385 goto nla_put_failure;
420e7fab 4386 }
319090bf
JB		 4387
4388 PUT_SINFO(RX_PACKETS, rx_packets, u32);
4389 PUT_SINFO(TX_PACKETS, tx_packets, u32);
4390 PUT_SINFO(TX_RETRIES, tx_retries, u32);
4391 PUT_SINFO(TX_FAILED, tx_failed, u32);
4392 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
4393 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
4394 PUT_SINFO(LOCAL_PM, local_pm, u32);
4395 PUT_SINFO(PEER_PM, peer_pm, u32);
4396 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
4397
4398 if (sinfo->filled & BIT(NL80211_STA_INFO_BSS_PARAM)) {
f4263c98
PS		 4399 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
4400 if (!bss_param)
4401 goto nla_put_failure;
4402
9360ffd1
DM		 4403 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
4404 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
4405 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
4406 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
4407 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
4408 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
4409 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
4410 sinfo->bss_param.dtim_period) ||
4411 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
4412 sinfo->bss_param.beacon_interval))
4413 goto nla_put_failure;
f4263c98
PS		 4414
4415 nla_nest_end(msg, bss_param);
4416 }
319090bf 4417 if ((sinfo->filled & BIT(NL80211_STA_INFO_STA_FLAGS)) &&
9360ffd1
DM		 4418 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
4419 sizeof(struct nl80211_sta_flag_update),
4420 &sinfo->sta_flags))
4421 goto nla_put_failure;
319090bf 4422
d686b920
JB		 4423 PUT_SINFO_U64(T_OFFSET, t_offset);
4424 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
4425 PUT_SINFO_U64(BEACON_RX, rx_beacon);
a76b1942 4426 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
319090bf
JB		 4427
4428#undef PUT_SINFO
d686b920 4429#undef PUT_SINFO_U64
6de39808
JB		 4430
4431 if (sinfo->filled & BIT(NL80211_STA_INFO_TID_STATS)) {
4432 struct nlattr *tidsattr;
4433 int tid;
4434
4435 tidsattr = nla_nest_start(msg, NL80211_STA_INFO_TID_STATS);
4436 if (!tidsattr)
4437 goto nla_put_failure;
4438
4439 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
4440 struct cfg80211_tid_stats *tidstats;
4441 struct nlattr *tidattr;
4442
4443 tidstats = &sinfo->pertid[tid];
4444
4445 if (!tidstats->filled)
4446 continue;
4447
4448 tidattr = nla_nest_start(msg, tid + 1);
4449 if (!tidattr)
4450 goto nla_put_failure;
4451
d686b920 4452#define PUT_TIDVAL_U64(attr, memb) do { \
6de39808 4453 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
d686b920
JB		 4454 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
4455 tidstats->memb, NL80211_TID_STATS_PAD)) \
6de39808
JB		 4456 goto nla_put_failure; \
4457 } while (0)
4458
d686b920
JB		 4459 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
4460 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
4461 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
4462 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
6de39808 4463
d686b920 4464#undef PUT_TIDVAL_U64
6de39808
JB		 4465 nla_nest_end(msg, tidattr);
4466 }
4467
4468 nla_nest_end(msg, tidsattr);
4469 }
4470
2ec600d6 4471 nla_nest_end(msg, sinfoattr);
fd5b74dc 4472
319090bf 4473 if (sinfo->assoc_req_ies_len &&
9360ffd1
DM		 4474 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
4475 sinfo->assoc_req_ies))
4476 goto nla_put_failure;
50d3dfb7 4477
053c095a
JB		 4478 genlmsg_end(msg, hdr);
4479 return 0;
fd5b74dc
JB		 4480
4481 nla_put_failure:
bc3ed28c
TG		 4482 genlmsg_cancel(msg, hdr);
4483 return -EMSGSIZE;
fd5b74dc
JB		 4484}
4485
2ec600d6 4486static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 4487 struct netlink_callback *cb)
2ec600d6 4488{
2ec600d6 4489 struct station_info sinfo;
1b8ec87a 4490 struct cfg80211_registered_device *rdev;
97990a06 4491 struct wireless_dev *wdev;
2ec600d6 4492 u8 mac_addr[ETH_ALEN];
97990a06 4493 int sta_idx = cb->args[2];
2ec600d6 4494 int err;
2ec600d6 4495
ea90e0dc 4496 rtnl_lock();
1b8ec87a 4497 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 4498 if (err)
ea90e0dc 4499 goto out_err;
bba95fef 4500
97990a06
JB		 4501 if (!wdev->netdev) {
4502 err = -EINVAL;
4503 goto out_err;
4504 }
4505
1b8ec87a 4506 if (!rdev->ops->dump_station) {
eec60b03 4507 err = -EOPNOTSUPP;
bba95fef
JB		 4508 goto out_err;
4509 }
4510
bba95fef 4511 while (1) {
f612cedf 4512 memset(&sinfo, 0, sizeof(sinfo));
1b8ec87a 4513 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
e35e4d28 4514 mac_addr, &sinfo);
bba95fef
JB		 4515 if (err == -ENOENT)
4516 break;
4517 if (err)
3b85875a 4518 goto out_err;
bba95fef 4519
cf5ead82 4520 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
15e47304 4521 NETLINK_CB(cb->skb).portid,
bba95fef 4522 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1b8ec87a 4523 rdev, wdev->netdev, mac_addr,
bba95fef
JB		 4524 &sinfo) < 0)
4525 goto out;
4526
4527 sta_idx++;
4528 }
4529
bba95fef 4530 out:
97990a06 4531 cb->args[2] = sta_idx;
bba95fef 4532 err = skb->len;
bba95fef 4533 out_err:
ea90e0dc 4534 rtnl_unlock();
bba95fef
JB		 4535
4536 return err;
2ec600d6 4537}
fd5b74dc 4538
5727ef1b
JB		 4539static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
4540{
4c476991
JB		 4541 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4542 struct net_device *dev = info->user_ptr[1];
2ec600d6 4543 struct station_info sinfo;
fd5b74dc
JB		 4544 struct sk_buff *msg;
4545 u8 *mac_addr = NULL;
4c476991 4546 int err;
fd5b74dc 4547
2ec600d6 4548 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 4549
4550 if (!info->attrs[NL80211_ATTR_MAC])
4551 return -EINVAL;
4552
4553 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4554
4c476991
JB		 4555 if (!rdev->ops->get_station)
4556 return -EOPNOTSUPP;
3b85875a 4557
e35e4d28 4558 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
fd5b74dc 4559 if (err)
4c476991 4560 return err;
2ec600d6 4561
fd2120ca 4562 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc 4563 if (!msg)
4c476991 4564 return -ENOMEM;
fd5b74dc 4565
cf5ead82
JB		 4566 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
4567 info->snd_portid, info->snd_seq, 0,
66266b3a 4568 rdev, dev, mac_addr, &sinfo) < 0) {
4c476991
JB		 4569 nlmsg_free(msg);
4570 return -ENOBUFS;
4571 }
3b85875a 4572
4c476991 4573 return genlmsg_reply(msg, info);
5727ef1b
JB		 4574}
4575
77ee7c89
JB		 4576int cfg80211_check_station_change(struct wiphy *wiphy,
4577 struct station_parameters *params,
4578 enum cfg80211_station_type statype)
4579{
e4208427
AB		 4580 if (params->listen_interval != -1 &&
4581 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89 4582 return -EINVAL;
e4208427 4583
17b94247
AB		 4584 if (params->support_p2p_ps != -1 &&
4585 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
4586 return -EINVAL;
4587
c72e1140 4588 if (params->aid &&
e4208427
AB		 4589 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
4590 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89
JB		 4591 return -EINVAL;
4592
4593 /* When you run into this, adjust the code below for the new flag */
4594 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4595
4596 switch (statype) {
eef941e6
TP		 4597 case CFG80211_STA_MESH_PEER_KERNEL:
4598 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 4599 /*
4600 * No ignoring the TDLS flag here -- the userspace mesh
4601 * code doesn't have the bug of including TDLS in the
4602 * mask everywhere.
4603 */
4604 if (params->sta_flags_mask &
4605 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4606 BIT(NL80211_STA_FLAG_MFP) |
4607 BIT(NL80211_STA_FLAG_AUTHORIZED)))
4608 return -EINVAL;
4609 break;
4610 case CFG80211_STA_TDLS_PEER_SETUP:
4611 case CFG80211_STA_TDLS_PEER_ACTIVE:
4612 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4613 return -EINVAL;
4614 /* ignore since it can't change */
4615 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4616 break;
4617 default:
4618 /* disallow mesh-specific things */
4619 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
4620 return -EINVAL;
4621 if (params->local_pm)
4622 return -EINVAL;
4623 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4624 return -EINVAL;
4625 }
4626
4627 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4628 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
4629 /* TDLS can't be set, ... */
4630 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4631 return -EINVAL;
4632 /*
4633 * ... but don't bother the driver with it. This works around
4634 * a hostapd/wpa_supplicant issue -- it always includes the
4635 * TLDS_PEER flag in the mask even for AP mode.
4636 */
4637 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4638 }
4639
47edb11b
AB		 4640 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4641 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4642 /* reject other things that can't change */
4643 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
4644 return -EINVAL;
4645 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
4646 return -EINVAL;
4647 if (params->supported_rates)
4648 return -EINVAL;
4649 if (params->ext_capab || params->ht_capa || params->vht_capa)
4650 return -EINVAL;
4651 }
4652
47edb11b
AB		 4653 if (statype != CFG80211_STA_AP_CLIENT &&
4654 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4655 if (params->vlan)
4656 return -EINVAL;
4657 }
4658
4659 switch (statype) {
4660 case CFG80211_STA_AP_MLME_CLIENT:
4661 /* Use this only for authorizing/unauthorizing a station */
4662 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4663 return -EOPNOTSUPP;
4664 break;
4665 case CFG80211_STA_AP_CLIENT:
47edb11b 4666 case CFG80211_STA_AP_CLIENT_UNASSOC:
77ee7c89
JB		 4667 /* accept only the listed bits */
4668 if (params->sta_flags_mask &
4669 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4670 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4671 BIT(NL80211_STA_FLAG_ASSOCIATED) |
4672 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4673 BIT(NL80211_STA_FLAG_WME) |
4674 BIT(NL80211_STA_FLAG_MFP)))
4675 return -EINVAL;
4676
4677 /* but authenticated/associated only if driver handles it */
4678 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4679 params->sta_flags_mask &
4680 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4681 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4682 return -EINVAL;
4683 break;
4684 case CFG80211_STA_IBSS:
4685 case CFG80211_STA_AP_STA:
4686 /* reject any changes other than AUTHORIZED */
4687 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
4688 return -EINVAL;
4689 break;
4690 case CFG80211_STA_TDLS_PEER_SETUP:
4691 /* reject any changes other than AUTHORIZED or WME */
4692 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4693 BIT(NL80211_STA_FLAG_WME)))
4694 return -EINVAL;
4695 /* force (at least) rates when authorizing */
4696 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
4697 !params->supported_rates)
4698 return -EINVAL;
4699 break;
4700 case CFG80211_STA_TDLS_PEER_ACTIVE:
4701 /* reject any changes */
4702 return -EINVAL;
eef941e6 4703 case CFG80211_STA_MESH_PEER_KERNEL:
77ee7c89
JB		 4704 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4705 return -EINVAL;
4706 break;
eef941e6 4707 case CFG80211_STA_MESH_PEER_USER:
42925040
CYY		 4708 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
4709 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
77ee7c89
JB		 4710 return -EINVAL;
4711 break;
4712 }
4713
06f7c88c
BL		 4714 /*
4715 * Older kernel versions ignored this attribute entirely, so don't
4716 * reject attempts to update it but mark it as unused instead so the
4717 * driver won't look at the data.
4718 */
4719 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
4720 statype != CFG80211_STA_TDLS_PEER_SETUP)
4721 params->opmode_notif_used = false;
4722
77ee7c89
JB		 4723 return 0;
4724}
4725EXPORT_SYMBOL(cfg80211_check_station_change);
4726
5727ef1b 4727/*
c258d2de 4728 * Get vlan interface making sure it is running and on the right wiphy.
5727ef1b 4729 */
80b99899
JB		 4730static struct net_device *get_vlan(struct genl_info *info,
4731 struct cfg80211_registered_device *rdev)
5727ef1b 4732{
463d0183 4733 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
80b99899
JB		 4734 struct net_device *v;
4735 int ret;
4736
4737 if (!vlanattr)
4738 return NULL;
4739
4740 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4741 if (!v)
4742 return ERR_PTR(-ENODEV);
4743
4744 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4745 ret = -EINVAL;
4746 goto error;
5727ef1b 4747 }
80b99899 4748
77ee7c89
JB		 4749 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4750 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4751 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4752 ret = -EINVAL;
4753 goto error;
4754 }
4755
80b99899
JB		 4756 if (!netif_running(v)) {
4757 ret = -ENETDOWN;
4758 goto error;
4759 }
4760
4761 return v;
4762 error:
4763 dev_put(v);
4764 return ERR_PTR(ret);
5727ef1b
JB		 4765}
4766
94e860f1
JB		 4767static const struct nla_policy
4768nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
df881293
JM		 4769 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4770 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4771};
4772
ff276691
JB		 4773static int nl80211_parse_sta_wme(struct genl_info *info,
4774 struct station_parameters *params)
df881293 4775{
df881293
JM		 4776 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4777 struct nlattr *nla;
4778 int err;
4779
df881293
JM		 4780 /* parse WME attributes if present */
4781 if (!info->attrs[NL80211_ATTR_STA_WME])
4782 return 0;
4783
4784 nla = info->attrs[NL80211_ATTR_STA_WME];
4785 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
fe52145f 4786 nl80211_sta_wme_policy, info->extack);
df881293
JM		 4787 if (err)
4788 return err;
4789
4790 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4791 params->uapsd_queues = nla_get_u8(
4792 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4793 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4794 return -EINVAL;
4795
4796 if (tb[NL80211_STA_WME_MAX_SP])
4797 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4798
4799 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4800 return -EINVAL;
4801
4802 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4803
4804 return 0;
4805}
4806
c01fc9ad
SD		 4807static int nl80211_parse_sta_channel_info(struct genl_info *info,
4808 struct station_parameters *params)
4809{
4810 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4811 params->supported_channels =
4812 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4813 params->supported_channels_len =
4814 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4815 /*
4816 * Need to include at least one (first channel, number of
4817 * channels) tuple for each subband, and must have proper
4818 * tuples for the rest of the data as well.
4819 */
4820 if (params->supported_channels_len < 2)
4821 return -EINVAL;
4822 if (params->supported_channels_len % 2)
4823 return -EINVAL;
4824 }
4825
4826 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4827 params->supported_oper_classes =
4828 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4829 params->supported_oper_classes_len =
4830 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4831 /*
4832 * The value of the Length field of the Supported Operating
4833 * Classes element is between 2 and 253.
4834 */
4835 if (params->supported_oper_classes_len < 2 ||
4836 params->supported_oper_classes_len > 253)
4837 return -EINVAL;
4838 }
4839 return 0;
4840}
4841
ff276691
JB		 4842static int nl80211_set_station_tdls(struct genl_info *info,
4843 struct station_parameters *params)
4844{
c01fc9ad 4845 int err;
ff276691 4846 /* Dummy STA entry gets updated once the peer capabilities are known */
5e4b6f56
JM		 4847 if (info->attrs[NL80211_ATTR_PEER_AID])
4848 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
ff276691
JB		 4849 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4850 params->ht_capa =
4851 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4852 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4853 params->vht_capa =
4854 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4855
c01fc9ad
SD		 4856 err = nl80211_parse_sta_channel_info(info, params);
4857 if (err)
4858 return err;
4859
ff276691
JB		 4860 return nl80211_parse_sta_wme(info, params);
4861}
4862
5727ef1b
JB		 4863static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4864{
4c476991 4865 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4866 struct net_device *dev = info->user_ptr[1];
5727ef1b 4867 struct station_parameters params;
77ee7c89
JB		 4868 u8 *mac_addr;
4869 int err;
5727ef1b
JB		 4870
4871 memset(&params, 0, sizeof(params));
4872
77ee7c89
JB		 4873 if (!rdev->ops->change_station)
4874 return -EOPNOTSUPP;
4875
e4208427
AB		 4876 /*
4877 * AID and listen_interval properties can be set only for unassociated
4878 * station. Include these parameters here and will check them in
4879 * cfg80211_check_station_change().
4880 */
a9bc31e4
AB		 4881 if (info->attrs[NL80211_ATTR_STA_AID])
4882 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
e4208427
AB		 4883
4884 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4885 params.listen_interval =
4886 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
4887 else
4888 params.listen_interval = -1;
5727ef1b 4889
17b94247
AB		 4890 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
4891 u8 tmp;
4892
4893 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
4894 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
4895 return -EINVAL;
4896
4897 params.support_p2p_ps = tmp;
4898 } else {
4899 params.support_p2p_ps = -1;
4900 }
4901
5727ef1b
JB		 4902 if (!info->attrs[NL80211_ATTR_MAC])
4903 return -EINVAL;
4904
4905 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4906
4907 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4908 params.supported_rates =
4909 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4910 params.supported_rates_len =
4911 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4912 }
4913
9d62a986
JM		 4914 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4915 params.capability =
4916 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4917 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4918 }
4919
4920 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4921 params.ext_capab =
4922 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4923 params.ext_capab_len =
4924 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4925 }
4926
bdd3ae3d 4927 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 4928 return -EINVAL;
4929
f8bacc21 4930 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
2ec600d6 4931 params.plink_action =
f8bacc21
JB		 4932 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4933 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4934 return -EINVAL;
4935 }
2ec600d6 4936
f8bacc21 4937 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
9c3990aa 4938 params.plink_state =
f8bacc21
JB		 4939 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
4940 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
4941 return -EINVAL;
7d27a0ba
MH		 4942 if (info->attrs[NL80211_ATTR_MESH_PEER_AID]) {
4943 params.peer_aid = nla_get_u16(
4944 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
4945 if (params.peer_aid > IEEE80211_MAX_AID)
4946 return -EINVAL;
4947 }
f8bacc21
JB		 4948 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
4949 }
9c3990aa 4950
3b1c5a53
MP		 4951 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
4952 enum nl80211_mesh_power_mode pm = nla_get_u32(
4953 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
4954
4955 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
4956 pm > NL80211_MESH_POWER_MAX)
4957 return -EINVAL;
4958
4959 params.local_pm = pm;
4960 }
4961
06f7c88c
BL		 4962 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
4963 params.opmode_notif_used = true;
4964 params.opmode_notif =
4965 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
4966 }
4967
77ee7c89
JB		 4968 /* Include parameters for TDLS peer (will check later) */
4969 err = nl80211_set_station_tdls(info, &params);
4970 if (err)
4971 return err;
4972
4973 params.vlan = get_vlan(info, rdev);
4974 if (IS_ERR(params.vlan))
4975 return PTR_ERR(params.vlan);
4976
a97f4424
JB		 4977 switch (dev->ieee80211_ptr->iftype) {
4978 case NL80211_IFTYPE_AP:
4979 case NL80211_IFTYPE_AP_VLAN:
074ac8df 4980 case NL80211_IFTYPE_P2P_GO:
074ac8df 4981 case NL80211_IFTYPE_P2P_CLIENT:
a97f4424 4982 case NL80211_IFTYPE_STATION:
267335d6 4983 case NL80211_IFTYPE_ADHOC:
a97f4424 4984 case NL80211_IFTYPE_MESH_POINT:
a97f4424
JB		 4985 break;
4986 default:
77ee7c89
JB		 4987 err = -EOPNOTSUPP;
4988 goto out_put_vlan;
034d655e
JB		 4989 }
4990
77ee7c89 4991 /* driver will call cfg80211_check_station_change() */
e35e4d28 4992 err = rdev_change_station(rdev, dev, mac_addr, &params);
5727ef1b 4993
77ee7c89 4994 out_put_vlan:
5727ef1b
JB		 4995 if (params.vlan)
4996 dev_put(params.vlan);
3b85875a 4997
5727ef1b
JB		 4998 return err;
4999}
5000
5001static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
5002{
4c476991 5003 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5727ef1b 5004 int err;
4c476991 5005 struct net_device *dev = info->user_ptr[1];
5727ef1b
JB		 5006 struct station_parameters params;
5007 u8 *mac_addr = NULL;
bda95eb1
JB		 5008 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5009 BIT(NL80211_STA_FLAG_ASSOCIATED);
5727ef1b
JB		 5010
5011 memset(&params, 0, sizeof(params));
5012
984c311b
JB		 5013 if (!rdev->ops->add_station)
5014 return -EOPNOTSUPP;
5015
5727ef1b
JB		 5016 if (!info->attrs[NL80211_ATTR_MAC])
5017 return -EINVAL;
5018
5727ef1b
JB		 5019 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5020 return -EINVAL;
5021
5022 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5023 return -EINVAL;
5024
5e4b6f56
JM		 5025 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5026 !info->attrs[NL80211_ATTR_PEER_AID])
0e956c13
TLSC		 5027 return -EINVAL;
5028
5727ef1b
JB		 5029 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5030 params.supported_rates =
5031 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5032 params.supported_rates_len =
5033 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5034 params.listen_interval =
5035 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 5036
17b94247
AB		 5037 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5038 u8 tmp;
5039
5040 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5041 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
5042 return -EINVAL;
5043
5044 params.support_p2p_ps = tmp;
5045 } else {
5046 /*
5047 * if not specified, assume it's supported for P2P GO interface,
5048 * and is NOT supported for AP interface
5049 */
5050 params.support_p2p_ps =
5051 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5052 }
5053
3d124ea2 5054 if (info->attrs[NL80211_ATTR_PEER_AID])
5e4b6f56 5055 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
3d124ea2
JM		 5056 else
5057 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
0e956c13
TLSC		 5058 if (!params.aid || params.aid > IEEE80211_MAX_AID)
5059 return -EINVAL;
51b50fbe 5060
9d62a986
JM		 5061 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5062 params.capability =
5063 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5064 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5065 }
5066
5067 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5068 params.ext_capab =
5069 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5070 params.ext_capab_len =
5071 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5072 }
5073
36aedc90
JM		 5074 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5075 params.ht_capa =
5076 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 5077
f461be3e
MP		 5078 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5079 params.vht_capa =
5080 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5081
60f4a7b1
MK		 5082 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5083 params.opmode_notif_used = true;
5084 params.opmode_notif =
5085 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5086 }
5087
f8bacc21 5088 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
96b78dff 5089 params.plink_action =
f8bacc21
JB		 5090 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5091 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
5092 return -EINVAL;
5093 }
96b78dff 5094
c01fc9ad
SD		 5095 err = nl80211_parse_sta_channel_info(info, &params);
5096 if (err)
5097 return err;
5098
ff276691
JB		 5099 err = nl80211_parse_sta_wme(info, &params);
5100 if (err)
5101 return err;
bdd90d5e 5102
bdd3ae3d 5103 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 5104 return -EINVAL;
5105
496fcc29
JB		 5106 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5107 * as userspace might just pass through the capabilities from the IEs
5108 * directly, rather than enforcing this restriction and returning an
5109 * error in this case.
5110 */
5111 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5112 params.ht_capa = NULL;
5113 params.vht_capa = NULL;
5114 }
5115
77ee7c89
JB		 5116 /* When you run into this, adjust the code below for the new flag */
5117 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5118
bdd90d5e
JB		 5119 switch (dev->ieee80211_ptr->iftype) {
5120 case NL80211_IFTYPE_AP:
5121 case NL80211_IFTYPE_AP_VLAN:
5122 case NL80211_IFTYPE_P2P_GO:
984c311b
JB		 5123 /* ignore WME attributes if iface/sta is not capable */
5124 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5125 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5126 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
c75786c9 5127
bdd90d5e 5128 /* TDLS peers cannot be added */
3d124ea2
JM		 5129 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5130 info->attrs[NL80211_ATTR_PEER_AID])
4319e193 5131 return -EINVAL;
bdd90d5e
JB		 5132 /* but don't bother the driver with it */
5133 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3b9ce80c 5134
d582cffb
JB		 5135 /* allow authenticated/associated only if driver handles it */
5136 if (!(rdev->wiphy.features &
5137 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
bda95eb1 5138 params.sta_flags_mask & auth_assoc)
d582cffb
JB		 5139 return -EINVAL;
5140
bda95eb1
JB		 5141 /* Older userspace, or userspace wanting to be compatible with
5142 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5143 * and assoc flags in the mask, but assumes the station will be
5144 * added as associated anyway since this was the required driver
5145 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5146 * introduced.
5147 * In order to not bother drivers with this quirk in the API
5148 * set the flags in both the mask and set for new stations in
5149 * this case.
5150 */
5151 if (!(params.sta_flags_mask & auth_assoc)) {
5152 params.sta_flags_mask |= auth_assoc;
5153 params.sta_flags_set |= auth_assoc;
5154 }
5155
bdd90d5e
JB		 5156 /* must be last in here for error handling */
5157 params.vlan = get_vlan(info, rdev);
5158 if (IS_ERR(params.vlan))
5159 return PTR_ERR(params.vlan);
5160 break;
5161 case NL80211_IFTYPE_MESH_POINT:
984c311b
JB		 5162 /* ignore uAPSD data */
5163 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5164
d582cffb
JB		 5165 /* associated is disallowed */
5166 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5167 return -EINVAL;
bdd90d5e 5168 /* TDLS peers cannot be added */
3d124ea2
JM		 5169 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5170 info->attrs[NL80211_ATTR_PEER_AID])
bdd90d5e
JB		 5171 return -EINVAL;
5172 break;
5173 case NL80211_IFTYPE_STATION:
93d08f0b 5174 case NL80211_IFTYPE_P2P_CLIENT:
984c311b
JB		 5175 /* ignore uAPSD data */
5176 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5177
77ee7c89
JB		 5178 /* these are disallowed */
5179 if (params.sta_flags_mask &
5180 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5181 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
d582cffb 5182 return -EINVAL;
bdd90d5e
JB		 5183 /* Only TDLS peers can be added */
5184 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5185 return -EINVAL;
5186 /* Can only add if TDLS ... */
5187 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5188 return -EOPNOTSUPP;
5189 /* ... with external setup is supported */
5190 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5191 return -EOPNOTSUPP;
77ee7c89
JB		 5192 /*
5193 * Older wpa_supplicant versions always mark the TDLS peer
5194 * as authorized, but it shouldn't yet be.
5195 */
5196 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
bdd90d5e
JB		 5197 break;
5198 default:
5199 return -EOPNOTSUPP;
c75786c9
EP		 5200 }
5201
bdd90d5e 5202 /* be aware of params.vlan when changing code here */
5727ef1b 5203
e35e4d28 5204 err = rdev_add_station(rdev, dev, mac_addr, &params);
5727ef1b 5205
5727ef1b
JB		 5206 if (params.vlan)
5207 dev_put(params.vlan);
5727ef1b
JB		 5208 return err;
5209}
5210
5211static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5212{
4c476991
JB		 5213 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5214 struct net_device *dev = info->user_ptr[1];
89c771e5
JM		 5215 struct station_del_parameters params;
5216
5217 memset(&params, 0, sizeof(params));
5727ef1b
JB		 5218
5219 if (info->attrs[NL80211_ATTR_MAC])
89c771e5 5220 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5727ef1b 5221
e80cf853 5222 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
d5d9de02 5223 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
074ac8df 5224 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4c476991
JB		 5225 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5226 return -EINVAL;
5727ef1b 5227
4c476991
JB		 5228 if (!rdev->ops->del_station)
5229 return -EOPNOTSUPP;
3b85875a 5230
98856866
JM		 5231 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
5232 params.subtype =
5233 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
5234 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
5235 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
5236 return -EINVAL;
5237 } else {
5238 /* Default to Deauthentication frame */
5239 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
5240 }
5241
5242 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
5243 params.reason_code =
5244 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5245 if (params.reason_code == 0)
5246 return -EINVAL; /* 0 is reserved */
5247 } else {
5248 /* Default to reason code 2 */
5249 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
5250 }
5251
89c771e5 5252 return rdev_del_station(rdev, dev, &params);
5727ef1b
JB		 5253}
5254
15e47304 5255static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
2ec600d6
LCC		 5256 int flags, struct net_device *dev,
5257 u8 *dst, u8 *next_hop,
5258 struct mpath_info *pinfo)
5259{
5260 void *hdr;
5261 struct nlattr *pinfoattr;
5262
1ef4c850 5263 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
2ec600d6
LCC		 5264 if (!hdr)
5265 return -1;
5266
9360ffd1
DM		 5267 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5268 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
5269 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
5270 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
5271 goto nla_put_failure;
f5ea9120 5272
2ec600d6
LCC		 5273 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
5274 if (!pinfoattr)
5275 goto nla_put_failure;
9360ffd1
DM		 5276 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
5277 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
5278 pinfo->frame_qlen))
5279 goto nla_put_failure;
5280 if (((pinfo->filled & MPATH_INFO_SN) &&
5281 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
5282 ((pinfo->filled & MPATH_INFO_METRIC) &&
5283 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
5284 pinfo->metric)) ||
5285 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
5286 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
5287 pinfo->exptime)) ||
5288 ((pinfo->filled & MPATH_INFO_FLAGS) &&
5289 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
5290 pinfo->flags)) ||
5291 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
5292 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
5293 pinfo->discovery_timeout)) ||
5294 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
5295 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
5296 pinfo->discovery_retries)))
5297 goto nla_put_failure;
2ec600d6
LCC		 5298
5299 nla_nest_end(msg, pinfoattr);
5300
053c095a
JB		 5301 genlmsg_end(msg, hdr);
5302 return 0;
2ec600d6
LCC		 5303
5304 nla_put_failure:
bc3ed28c
TG		 5305 genlmsg_cancel(msg, hdr);
5306 return -EMSGSIZE;
2ec600d6
LCC		 5307}
5308
5309static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 5310 struct netlink_callback *cb)
2ec600d6 5311{
2ec600d6 5312 struct mpath_info pinfo;
1b8ec87a 5313 struct cfg80211_registered_device *rdev;
97990a06 5314 struct wireless_dev *wdev;
2ec600d6
LCC		 5315 u8 dst[ETH_ALEN];
5316 u8 next_hop[ETH_ALEN];
97990a06 5317 int path_idx = cb->args[2];
2ec600d6 5318 int err;
2ec600d6 5319
ea90e0dc 5320 rtnl_lock();
1b8ec87a 5321 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 5322 if (err)
ea90e0dc 5323 goto out_err;
bba95fef 5324
1b8ec87a 5325 if (!rdev->ops->dump_mpath) {
eec60b03 5326 err = -EOPNOTSUPP;
bba95fef
JB		 5327 goto out_err;
5328 }
5329
97990a06 5330 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
eec60b03 5331 err = -EOPNOTSUPP;
0448b5fc 5332 goto out_err;
eec60b03
JM		 5333 }
5334
bba95fef 5335 while (1) {
1b8ec87a 5336 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
97990a06 5337 next_hop, &pinfo);
bba95fef 5338 if (err == -ENOENT)
2ec600d6 5339 break;
bba95fef 5340 if (err)
3b85875a 5341 goto out_err;
2ec600d6 5342
15e47304 5343 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
bba95fef 5344 cb->nlh->nlmsg_seq, NLM_F_MULTI,
97990a06 5345 wdev->netdev, dst, next_hop,
bba95fef
JB		 5346 &pinfo) < 0)
5347 goto out;
2ec600d6 5348
bba95fef 5349 path_idx++;
2ec600d6 5350 }
2ec600d6 5351
bba95fef 5352 out:
97990a06 5353 cb->args[2] = path_idx;
bba95fef 5354 err = skb->len;
bba95fef 5355 out_err:
ea90e0dc 5356 rtnl_unlock();
bba95fef 5357 return err;
2ec600d6
LCC		 5358}
5359
5360static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
5361{
4c476991 5362 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 5363 int err;
4c476991 5364 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5365 struct mpath_info pinfo;
5366 struct sk_buff *msg;
5367 u8 *dst = NULL;
5368 u8 next_hop[ETH_ALEN];
5369
5370 memset(&pinfo, 0, sizeof(pinfo));
5371
5372 if (!info->attrs[NL80211_ATTR_MAC])
5373 return -EINVAL;
5374
5375 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5376
4c476991
JB		 5377 if (!rdev->ops->get_mpath)
5378 return -EOPNOTSUPP;
2ec600d6 5379
4c476991
JB		 5380 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5381 return -EOPNOTSUPP;
eec60b03 5382
e35e4d28 5383 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
2ec600d6 5384 if (err)
4c476991 5385 return err;
2ec600d6 5386
fd2120ca 5387 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6 5388 if (!msg)
4c476991 5389 return -ENOMEM;
2ec600d6 5390
15e47304 5391 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4c476991
JB		 5392 dev, dst, next_hop, &pinfo) < 0) {
5393 nlmsg_free(msg);
5394 return -ENOBUFS;
5395 }
3b85875a 5396
4c476991 5397 return genlmsg_reply(msg, info);
2ec600d6
LCC		 5398}
5399
5400static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
5401{
4c476991
JB		 5402 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5403 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5404 u8 *dst = NULL;
5405 u8 *next_hop = NULL;
5406
5407 if (!info->attrs[NL80211_ATTR_MAC])
5408 return -EINVAL;
5409
5410 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5411 return -EINVAL;
5412
5413 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5414 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5415
4c476991
JB		 5416 if (!rdev->ops->change_mpath)
5417 return -EOPNOTSUPP;
35a8efe1 5418
4c476991
JB		 5419 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5420 return -EOPNOTSUPP;
2ec600d6 5421
e35e4d28 5422 return rdev_change_mpath(rdev, dev, dst, next_hop);
2ec600d6 5423}
4c476991 5424
2ec600d6
LCC		 5425static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
5426{
4c476991
JB		 5427 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5428 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5429 u8 *dst = NULL;
5430 u8 *next_hop = NULL;
5431
5432 if (!info->attrs[NL80211_ATTR_MAC])
5433 return -EINVAL;
5434
5435 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5436 return -EINVAL;
5437
5438 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5439 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5440
4c476991
JB		 5441 if (!rdev->ops->add_mpath)
5442 return -EOPNOTSUPP;
35a8efe1 5443
4c476991
JB		 5444 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5445 return -EOPNOTSUPP;
2ec600d6 5446
e35e4d28 5447 return rdev_add_mpath(rdev, dev, dst, next_hop);
2ec600d6
LCC		 5448}
5449
5450static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
5451{
4c476991
JB		 5452 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5453 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5454 u8 *dst = NULL;
5455
5456 if (info->attrs[NL80211_ATTR_MAC])
5457 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5458
4c476991
JB		 5459 if (!rdev->ops->del_mpath)
5460 return -EOPNOTSUPP;
3b85875a 5461
e35e4d28 5462 return rdev_del_mpath(rdev, dev, dst);
2ec600d6
LCC		 5463}
5464
66be7d2b
HR		 5465static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
5466{
5467 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5468 int err;
5469 struct net_device *dev = info->user_ptr[1];
5470 struct mpath_info pinfo;
5471 struct sk_buff *msg;
5472 u8 *dst = NULL;
5473 u8 mpp[ETH_ALEN];
5474
5475 memset(&pinfo, 0, sizeof(pinfo));
5476
5477 if (!info->attrs[NL80211_ATTR_MAC])
5478 return -EINVAL;
5479
5480 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5481
5482 if (!rdev->ops->get_mpp)
5483 return -EOPNOTSUPP;
5484
5485 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5486 return -EOPNOTSUPP;
5487
5488 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
5489 if (err)
5490 return err;
5491
5492 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5493 if (!msg)
5494 return -ENOMEM;
5495
5496 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
5497 dev, dst, mpp, &pinfo) < 0) {
5498 nlmsg_free(msg);
5499 return -ENOBUFS;
5500 }
5501
5502 return genlmsg_reply(msg, info);
5503}
5504
5505static int nl80211_dump_mpp(struct sk_buff *skb,
5506 struct netlink_callback *cb)
5507{
5508 struct mpath_info pinfo;
5509 struct cfg80211_registered_device *rdev;
5510 struct wireless_dev *wdev;
5511 u8 dst[ETH_ALEN];
5512 u8 mpp[ETH_ALEN];
5513 int path_idx = cb->args[2];
5514 int err;
5515
ea90e0dc 5516 rtnl_lock();
66be7d2b
HR		 5517 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5518 if (err)
ea90e0dc 5519 goto out_err;
66be7d2b
HR		 5520
5521 if (!rdev->ops->dump_mpp) {
5522 err = -EOPNOTSUPP;
5523 goto out_err;
5524 }
5525
5526 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
5527 err = -EOPNOTSUPP;
5528 goto out_err;
5529 }
5530
5531 while (1) {
5532 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
5533 mpp, &pinfo);
5534 if (err == -ENOENT)
5535 break;
5536 if (err)
5537 goto out_err;
5538
5539 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
5540 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5541 wdev->netdev, dst, mpp,
5542 &pinfo) < 0)
5543 goto out;
5544
5545 path_idx++;
5546 }
5547
5548 out:
5549 cb->args[2] = path_idx;
5550 err = skb->len;
5551 out_err:
ea90e0dc 5552 rtnl_unlock();
66be7d2b
HR		 5553 return err;
5554}
5555
9f1ba906
JM		 5556static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
5557{
4c476991
JB		 5558 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5559 struct net_device *dev = info->user_ptr[1];
c56589ed 5560 struct wireless_dev *wdev = dev->ieee80211_ptr;
9f1ba906 5561 struct bss_parameters params;
c56589ed 5562 int err;
9f1ba906
JM		 5563
5564 memset(&params, 0, sizeof(params));
5565 /* default to not changing parameters */
5566 params.use_cts_prot = -1;
5567 params.use_short_preamble = -1;
5568 params.use_short_slot_time = -1;
fd8aaaf3 5569 params.ap_isolate = -1;
50b12f59 5570 params.ht_opmode = -1;
53cabad7
JB		 5571 params.p2p_ctwindow = -1;
5572 params.p2p_opp_ps = -1;
9f1ba906
JM		 5573
5574 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
5575 params.use_cts_prot =
5576 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
5577 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
5578 params.use_short_preamble =
5579 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
5580 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
5581 params.use_short_slot_time =
5582 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 5583 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5584 params.basic_rates =
5585 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5586 params.basic_rates_len =
5587 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5588 }
fd8aaaf3
FF		 5589 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
5590 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
50b12f59
HS		 5591 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
5592 params.ht_opmode =
5593 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9f1ba906 5594
53cabad7
JB		 5595 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
5596 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5597 return -EINVAL;
5598 params.p2p_ctwindow =
5599 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
5600 if (params.p2p_ctwindow < 0)
5601 return -EINVAL;
5602 if (params.p2p_ctwindow != 0 &&
5603 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
5604 return -EINVAL;
5605 }
5606
5607 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
5608 u8 tmp;
5609
5610 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5611 return -EINVAL;
5612 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
5613 if (tmp > 1)
5614 return -EINVAL;
5615 params.p2p_opp_ps = tmp;
5616 if (params.p2p_opp_ps &&
5617 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
5618 return -EINVAL;
5619 }
5620
4c476991
JB		 5621 if (!rdev->ops->change_bss)
5622 return -EOPNOTSUPP;
9f1ba906 5623
074ac8df 5624 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4c476991
JB		 5625 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5626 return -EOPNOTSUPP;
3b85875a 5627
c56589ed
SW		 5628 wdev_lock(wdev);
5629 err = rdev_change_bss(rdev, dev, &params);
5630 wdev_unlock(wdev);
5631
5632 return err;
9f1ba906
JM		 5633}
5634
b2e1b302
LR		 5635static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
5636{
b2e1b302 5637 char *data = NULL;
05050753 5638 bool is_indoor;
57b5ce07 5639 enum nl80211_user_reg_hint_type user_reg_hint_type;
05050753
I		 5640 u32 owner_nlportid;
5641
80778f18
LR		 5642 /*
5643 * You should only get this when cfg80211 hasn't yet initialized
5644 * completely when built-in to the kernel right between the time
5645 * window between nl80211_init() and regulatory_init(), if that is
5646 * even possible.
5647 */
458f4f9e 5648 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
fe33eb39 5649 return -EINPROGRESS;
80778f18 5650
57b5ce07
LR		 5651 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
5652 user_reg_hint_type =
5653 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
5654 else
5655 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
5656
5657 switch (user_reg_hint_type) {
5658 case NL80211_USER_REG_HINT_USER:
5659 case NL80211_USER_REG_HINT_CELL_BASE:
52616f2b
IP		 5660 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5661 return -EINVAL;
5662
5663 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5664 return regulatory_hint_user(data, user_reg_hint_type);
5665 case NL80211_USER_REG_HINT_INDOOR:
05050753
I		 5666 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
5667 owner_nlportid = info->snd_portid;
5668 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
5669 } else {
5670 owner_nlportid = 0;
5671 is_indoor = true;
5672 }
5673
5674 return regulatory_hint_indoor(is_indoor, owner_nlportid);
57b5ce07
LR		 5675 default:
5676 return -EINVAL;
5677 }
b2e1b302
LR		 5678}
5679
24bdd9f4 5680static int nl80211_get_mesh_config(struct sk_buff *skb,
29cbe68c 5681 struct genl_info *info)
93da9cc1 5682{
4c476991 5683 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 5684 struct net_device *dev = info->user_ptr[1];
29cbe68c
JB		 5685 struct wireless_dev *wdev = dev->ieee80211_ptr;
5686 struct mesh_config cur_params;
5687 int err = 0;
93da9cc1 5688 void *hdr;
5689 struct nlattr *pinfoattr;
5690 struct sk_buff *msg;
5691
29cbe68c
JB		 5692 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5693 return -EOPNOTSUPP;
5694
24bdd9f4 5695 if (!rdev->ops->get_mesh_config)
4c476991 5696 return -EOPNOTSUPP;
f3f92586 5697
29cbe68c
JB		 5698 wdev_lock(wdev);
5699 /* If not connected, get default parameters */
5700 if (!wdev->mesh_id_len)
5701 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
5702 else
e35e4d28 5703 err = rdev_get_mesh_config(rdev, dev, &cur_params);
29cbe68c
JB		 5704 wdev_unlock(wdev);
5705
93da9cc1 5706 if (err)
4c476991 5707 return err;
93da9cc1 5708
5709 /* Draw up a netlink message to send back */
fd2120ca 5710 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 5711 if (!msg)
5712 return -ENOMEM;
15e47304 5713 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
24bdd9f4 5714 NL80211_CMD_GET_MESH_CONFIG);
93da9cc1 5715 if (!hdr)
efe1cf0c 5716 goto out;
24bdd9f4 5717 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
93da9cc1 5718 if (!pinfoattr)
5719 goto nla_put_failure;
9360ffd1
DM		 5720 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5721 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
5722 cur_params.dot11MeshRetryTimeout) ||
5723 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5724 cur_params.dot11MeshConfirmTimeout) ||
5725 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
5726 cur_params.dot11MeshHoldingTimeout) ||
5727 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
5728 cur_params.dot11MeshMaxPeerLinks) ||
5729 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
5730 cur_params.dot11MeshMaxRetries) ||
5731 nla_put_u8(msg, NL80211_MESHCONF_TTL,
5732 cur_params.dot11MeshTTL) ||
5733 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
5734 cur_params.element_ttl) ||
5735 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5736 cur_params.auto_open_plinks) ||
7eab0f64
JL		 5737 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5738 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
9360ffd1
DM		 5739 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5740 cur_params.dot11MeshHWMPmaxPREQretries) ||
5741 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
5742 cur_params.path_refresh_time) ||
5743 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5744 cur_params.min_discovery_timeout) ||
5745 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5746 cur_params.dot11MeshHWMPactivePathTimeout) ||
5747 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
5748 cur_params.dot11MeshHWMPpreqMinInterval) ||
5749 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
5750 cur_params.dot11MeshHWMPperrMinInterval) ||
5751 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5752 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
5753 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
5754 cur_params.dot11MeshHWMPRootMode) ||
5755 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5756 cur_params.dot11MeshHWMPRannInterval) ||
5757 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5758 cur_params.dot11MeshGateAnnouncementProtocol) ||
5759 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
5760 cur_params.dot11MeshForwarding) ||
335d5349 5761 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
70c33eaa
AN		 5762 cur_params.rssi_threshold) ||
5763 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5764 cur_params.ht_opmode) ||
5765 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5766 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
5767 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5768 cur_params.dot11MeshHWMProotInterval) ||
5769 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3b1c5a53
MP		 5770 cur_params.dot11MeshHWMPconfirmationInterval) ||
5771 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5772 cur_params.power_mode) ||
5773 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8e7c0538
CT		 5774 cur_params.dot11MeshAwakeWindowDuration) ||
5775 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5776 cur_params.plink_timeout))
9360ffd1 5777 goto nla_put_failure;
93da9cc1 5778 nla_nest_end(msg, pinfoattr);
5779 genlmsg_end(msg, hdr);
4c476991 5780 return genlmsg_reply(msg, info);
93da9cc1 5781
3b85875a 5782 nla_put_failure:
93da9cc1 5783 genlmsg_cancel(msg, hdr);
efe1cf0c 5784 out:
d080e275 5785 nlmsg_free(msg);
4c476991 5786 return -ENOBUFS;
93da9cc1 5787}
5788
b54452b0 5789static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
93da9cc1 5790 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5791 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5792 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5793 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5794 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5795 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
45904f21 5796 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
93da9cc1 5797 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
d299a1f2 5798 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
93da9cc1 5799 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5800 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5801 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5802 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5803 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
dca7e943 5804 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
93da9cc1 5805 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
699403db 5806 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
0507e159 5807 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
16dd7267 5808 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
94f90656 5809 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
a4f606ea
CYY		 5810 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5811 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
ac1073a6
CYY		 5812 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5813 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
728b19e5 5814 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3b1c5a53
MP		 5815 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5816 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8e7c0538 5817 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
93da9cc1 5818};
5819
c80d545d
JC		 5820static const struct nla_policy
5821 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
d299a1f2 5822 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
c80d545d
JC		 5823 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5824 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
15d5dda6 5825 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6e16d90b 5826 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
bb2798d4 5827 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
581a8b0f 5828 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
a4f606ea 5829 .len = IEEE80211_MAX_DATA_LEN },
b130e5ce 5830 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
c80d545d
JC		 5831};
5832
f151d9db
AB		 5833static int nl80211_check_bool(const struct nlattr *nla, u8 min, u8 max, bool *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_u8(const struct nlattr *nla, u8 min, u8 max, u8 *out)
5843{
5844 u8 val = nla_get_u8(nla);
5845 if (val < min || val > max)
5846 return -EINVAL;
5847 *out = val;
5848 return 0;
5849}
5850
5851static int nl80211_check_u16(const struct nlattr *nla, u16 min, u16 max, u16 *out)
5852{
5853 u16 val = nla_get_u16(nla);
5854 if (val < min || val > max)
5855 return -EINVAL;
5856 *out = val;
5857 return 0;
5858}
5859
5860static int nl80211_check_u32(const struct nlattr *nla, u32 min, u32 max, u32 *out)
5861{
5862 u32 val = nla_get_u32(nla);
5863 if (val < min || val > max)
5864 return -EINVAL;
5865 *out = val;
5866 return 0;
5867}
5868
5869static int nl80211_check_s32(const struct nlattr *nla, s32 min, s32 max, s32 *out)
5870{
5871 s32 val = nla_get_s32(nla);
5872 if (val < min || val > max)
5873 return -EINVAL;
5874 *out = val;
5875 return 0;
5876}
5877
ff9a71af
JB		 5878static int nl80211_check_power_mode(const struct nlattr *nla,
5879 enum nl80211_mesh_power_mode min,
5880 enum nl80211_mesh_power_mode max,
5881 enum nl80211_mesh_power_mode *out)
5882{
5883 u32 val = nla_get_u32(nla);
5884 if (val < min || val > max)
5885 return -EINVAL;
5886 *out = val;
5887 return 0;
5888}
5889
24bdd9f4 5890static int nl80211_parse_mesh_config(struct genl_info *info,
bd90fdcc
JB		 5891 struct mesh_config *cfg,
5892 u32 *mask_out)
93da9cc1 5893{
93da9cc1 5894 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
bd90fdcc 5895 u32 mask = 0;
9757235f 5896 u16 ht_opmode;
93da9cc1 5897
ea54fba2
MP		 5898#define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5899do { \
5900 if (tb[attr]) { \
f151d9db 5901 if (fn(tb[attr], min, max, &cfg->param)) \
ea54fba2 5902 return -EINVAL; \
ea54fba2
MP		 5903 mask |= (1 << (attr - 1)); \
5904 } \
5905} while (0)
bd90fdcc 5906
24bdd9f4 5907 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
93da9cc1 5908 return -EINVAL;
5909 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
24bdd9f4 5910 info->attrs[NL80211_ATTR_MESH_CONFIG],
fe52145f 5911 nl80211_meshconf_params_policy, info->extack))
93da9cc1 5912 return -EINVAL;
5913
93da9cc1 5914 /* This makes sure that there aren't more than 32 mesh config
5915 * parameters (otherwise our bitfield scheme would not work.) */
5916 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
5917
5918 /* Fill in the params struct */
ea54fba2 5919 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
a4f606ea 5920 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
f151d9db 5921 nl80211_check_u16);
ea54fba2 5922 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
a4f606ea 5923 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
f151d9db 5924 nl80211_check_u16);
ea54fba2 5925 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
a4f606ea 5926 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
f151d9db 5927 nl80211_check_u16);
ea54fba2 5928 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
a4f606ea 5929 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
f151d9db 5930 nl80211_check_u16);
ea54fba2 5931 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
a4f606ea 5932 mask, NL80211_MESHCONF_MAX_RETRIES,
f151d9db 5933 nl80211_check_u8);
ea54fba2 5934 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
f151d9db 5935 mask, NL80211_MESHCONF_TTL, nl80211_check_u8);
ea54fba2 5936 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
a4f606ea 5937 mask, NL80211_MESHCONF_ELEMENT_TTL,
f151d9db 5938 nl80211_check_u8);
ea54fba2 5939 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
a4f606ea 5940 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
f151d9db 5941 nl80211_check_bool);
ea54fba2
MP		 5942 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
5943 1, 255, mask,
a4f606ea 5944 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
f151d9db 5945 nl80211_check_u32);
ea54fba2 5946 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
a4f606ea 5947 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
f151d9db 5948 nl80211_check_u8);
ea54fba2 5949 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
a4f606ea 5950 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
f151d9db 5951 nl80211_check_u32);
ea54fba2 5952 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
a4f606ea 5953 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
f151d9db 5954 nl80211_check_u16);
ea54fba2
MP		 5955 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
5956 1, 65535, mask,
a4f606ea 5957 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
f151d9db 5958 nl80211_check_u32);
93da9cc1 5959 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
ea54fba2
MP		 5960 1, 65535, mask,
5961 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
f151d9db 5962 nl80211_check_u16);
dca7e943 5963 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
ea54fba2
MP		 5964 1, 65535, mask,
5965 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
f151d9db 5966 nl80211_check_u16);
93da9cc1 5967 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5968 dot11MeshHWMPnetDiameterTraversalTime,
5969 1, 65535, mask,
a4f606ea 5970 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
f151d9db 5971 nl80211_check_u16);
ea54fba2
MP		 5972 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
5973 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
f151d9db 5974 nl80211_check_u8);
ea54fba2
MP		 5975 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
5976 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
f151d9db 5977 nl80211_check_u16);
63c5723b 5978 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5979 dot11MeshGateAnnouncementProtocol, 0, 1,
5980 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
f151d9db 5981 nl80211_check_bool);
ea54fba2 5982 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
a4f606ea 5983 mask, NL80211_MESHCONF_FORWARDING,
f151d9db 5984 nl80211_check_bool);
83374fe9 5985 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
a4f606ea 5986 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
f151d9db 5987 nl80211_check_s32);
9757235f
MH		 5988 /*
5989 * Check HT operation mode based on
5990 * IEEE 802.11 2012 8.4.2.59 HT Operation element.
5991 */
5992 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
5993 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
5994
5995 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
5996 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
5997 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
5998 return -EINVAL;
5999
6000 if ((ht_opmode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
6001 (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6002 return -EINVAL;
6003
6004 switch (ht_opmode & IEEE80211_HT_OP_MODE_PROTECTION) {
6005 case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
6006 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
6007 if (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT)
6008 return -EINVAL;
6009 break;
6010 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
6011 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
6012 if (!(ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6013 return -EINVAL;
6014 break;
6015 }
6016 cfg->ht_opmode = ht_opmode;
fd551bac 6017 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
9757235f 6018 }
ac1073a6 6019 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
ea54fba2 6020 1, 65535, mask,
ac1073a6 6021 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
f151d9db 6022 nl80211_check_u32);
ea54fba2 6023 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
ac1073a6 6024 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
f151d9db 6025 nl80211_check_u16);
728b19e5 6026 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6027 dot11MeshHWMPconfirmationInterval,
6028 1, 65535, mask,
728b19e5 6029 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
f151d9db 6030 nl80211_check_u16);
3b1c5a53
MP		 6031 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
6032 NL80211_MESH_POWER_ACTIVE,
6033 NL80211_MESH_POWER_MAX,
6034 mask, NL80211_MESHCONF_POWER_MODE,
ff9a71af 6035 nl80211_check_power_mode);
3b1c5a53
MP		 6036 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
6037 0, 65535, mask,
f151d9db 6038 NL80211_MESHCONF_AWAKE_WINDOW, nl80211_check_u16);
31f909a2 6039 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 0, 0xffffffff,
8e7c0538 6040 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
f151d9db 6041 nl80211_check_u32);
bd90fdcc
JB		 6042 if (mask_out)
6043 *mask_out = mask;
c80d545d 6044
bd90fdcc
JB		 6045 return 0;
6046
6047#undef FILL_IN_MESH_PARAM_IF_SET
6048}
6049
c80d545d
JC		 6050static int nl80211_parse_mesh_setup(struct genl_info *info,
6051 struct mesh_setup *setup)
6052{
bb2798d4 6053 struct cfg80211_registered_device *rdev = info->user_ptr[0];
c80d545d
JC		 6054 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6055
6056 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6057 return -EINVAL;
6058 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
6059 info->attrs[NL80211_ATTR_MESH_SETUP],
fe52145f 6060 nl80211_mesh_setup_params_policy, info->extack))
c80d545d
JC		 6061 return -EINVAL;
6062
d299a1f2
JC		 6063 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6064 setup->sync_method =
6065 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6066 IEEE80211_SYNC_METHOD_VENDOR :
6067 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6068
c80d545d
JC		 6069 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6070 setup->path_sel_proto =
6071 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6072 IEEE80211_PATH_PROTOCOL_VENDOR :
6073 IEEE80211_PATH_PROTOCOL_HWMP;
6074
6075 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6076 setup->path_metric =
6077 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6078 IEEE80211_PATH_METRIC_VENDOR :
6079 IEEE80211_PATH_METRIC_AIRTIME;
6080
581a8b0f 6081 if (tb[NL80211_MESH_SETUP_IE]) {
c80d545d 6082 struct nlattr *ieattr =
581a8b0f 6083 tb[NL80211_MESH_SETUP_IE];
c80d545d
JC		 6084 if (!is_valid_ie_attr(ieattr))
6085 return -EINVAL;
581a8b0f
JC		 6086 setup->ie = nla_data(ieattr);
6087 setup->ie_len = nla_len(ieattr);
c80d545d 6088 }
bb2798d4
TP		 6089 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6090 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6091 return -EINVAL;
6092 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
b130e5ce
JC		 6093 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6094 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
bb2798d4
TP		 6095 if (setup->is_secure)
6096 setup->user_mpm = true;
c80d545d 6097
6e16d90b
CT		 6098 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6099 if (!setup->user_mpm)
6100 return -EINVAL;
6101 setup->auth_id =
6102 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6103 }
6104
c80d545d
JC		 6105 return 0;
6106}
6107
24bdd9f4 6108static int nl80211_update_mesh_config(struct sk_buff *skb,
29cbe68c 6109 struct genl_info *info)
bd90fdcc
JB		 6110{
6111 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6112 struct net_device *dev = info->user_ptr[1];
29cbe68c 6113 struct wireless_dev *wdev = dev->ieee80211_ptr;
bd90fdcc
JB		 6114 struct mesh_config cfg;
6115 u32 mask;
6116 int err;
6117
29cbe68c
JB		 6118 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6119 return -EOPNOTSUPP;
6120
24bdd9f4 6121 if (!rdev->ops->update_mesh_config)
bd90fdcc
JB		 6122 return -EOPNOTSUPP;
6123
24bdd9f4 6124 err = nl80211_parse_mesh_config(info, &cfg, &mask);
bd90fdcc
JB		 6125 if (err)
6126 return err;
6127
29cbe68c
JB		 6128 wdev_lock(wdev);
6129 if (!wdev->mesh_id_len)
6130 err = -ENOLINK;
6131
6132 if (!err)
e35e4d28 6133 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
29cbe68c
JB		 6134
6135 wdev_unlock(wdev);
6136
6137 return err;
93da9cc1 6138}
6139
ad30ca2c
AN		 6140static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6141 struct sk_buff *msg)
f130347c 6142{
f130347c
LR		 6143 struct nlattr *nl_reg_rules;
6144 unsigned int i;
f130347c 6145
458f4f9e
JB		 6146 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6147 (regdom->dfs_region &&
6148 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
ad30ca2c 6149 goto nla_put_failure;
458f4f9e 6150
f130347c
LR		 6151 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
6152 if (!nl_reg_rules)
ad30ca2c 6153 goto nla_put_failure;
f130347c 6154
458f4f9e 6155 for (i = 0; i < regdom->n_reg_rules; i++) {
f130347c
LR		 6156 struct nlattr *nl_reg_rule;
6157 const struct ieee80211_reg_rule *reg_rule;
6158 const struct ieee80211_freq_range *freq_range;
6159 const struct ieee80211_power_rule *power_rule;
97524820 6160 unsigned int max_bandwidth_khz;
f130347c 6161
458f4f9e 6162 reg_rule = &regdom->reg_rules[i];
f130347c
LR		 6163 freq_range = &reg_rule->freq_range;
6164 power_rule = &reg_rule->power_rule;
6165
6166 nl_reg_rule = nla_nest_start(msg, i);
6167 if (!nl_reg_rule)
ad30ca2c 6168 goto nla_put_failure;
f130347c 6169
97524820
JD		 6170 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6171 if (!max_bandwidth_khz)
6172 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6173 reg_rule);
6174
9360ffd1
DM		 6175 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6176 reg_rule->flags) ||
6177 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6178 freq_range->start_freq_khz) ||
6179 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6180 freq_range->end_freq_khz) ||
6181 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
97524820 6182 max_bandwidth_khz) ||
9360ffd1
DM		 6183 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6184 power_rule->max_antenna_gain) ||
6185 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
089027e5
JD		 6186 power_rule->max_eirp) ||
6187 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6188 reg_rule->dfs_cac_ms))
ad30ca2c 6189 goto nla_put_failure;
f130347c
LR		 6190
6191 nla_nest_end(msg, nl_reg_rule);
6192 }
6193
6194 nla_nest_end(msg, nl_reg_rules);
ad30ca2c
AN		 6195 return 0;
6196
6197nla_put_failure:
6198 return -EMSGSIZE;
6199}
6200
6201static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6202{
6203 const struct ieee80211_regdomain *regdom = NULL;
6204 struct cfg80211_registered_device *rdev;
6205 struct wiphy *wiphy = NULL;
6206 struct sk_buff *msg;
6207 void *hdr;
6208
6209 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6210 if (!msg)
6211 return -ENOBUFS;
6212
6213 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6214 NL80211_CMD_GET_REG);
6215 if (!hdr)
6216 goto put_failure;
6217
6218 if (info->attrs[NL80211_ATTR_WIPHY]) {
1bdd716c
AN		 6219 bool self_managed;
6220
ad30ca2c
AN		 6221 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6222 if (IS_ERR(rdev)) {
6223 nlmsg_free(msg);
6224 return PTR_ERR(rdev);
6225 }
6226
6227 wiphy = &rdev->wiphy;
1bdd716c
AN		 6228 self_managed = wiphy->regulatory_flags &
6229 REGULATORY_WIPHY_SELF_MANAGED;
ad30ca2c
AN		 6230 regdom = get_wiphy_regdom(wiphy);
6231
1bdd716c
AN		 6232 /* a self-managed-reg device must have a private regdom */
6233 if (WARN_ON(!regdom && self_managed)) {
6234 nlmsg_free(msg);
6235 return -EINVAL;
6236 }
6237
ad30ca2c
AN		 6238 if (regdom &&
6239 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6240 goto nla_put_failure;
6241 }
6242
6243 if (!wiphy && reg_last_request_cell_base() &&
6244 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6245 NL80211_USER_REG_HINT_CELL_BASE))
6246 goto nla_put_failure;
6247
6248 rcu_read_lock();
6249
6250 if (!regdom)
6251 regdom = rcu_dereference(cfg80211_regdomain);
6252
6253 if (nl80211_put_regdom(regdom, msg))
6254 goto nla_put_failure_rcu;
6255
6256 rcu_read_unlock();
f130347c
LR		 6257
6258 genlmsg_end(msg, hdr);
5fe231e8 6259 return genlmsg_reply(msg, info);
f130347c 6260
458f4f9e
JB		 6261nla_put_failure_rcu:
6262 rcu_read_unlock();
f130347c
LR		 6263nla_put_failure:
6264 genlmsg_cancel(msg, hdr);
efe1cf0c 6265put_failure:
d080e275 6266 nlmsg_free(msg);
5fe231e8 6267 return -EMSGSIZE;
f130347c
LR		 6268}
6269
ad30ca2c
AN		 6270static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6271 u32 seq, int flags, struct wiphy *wiphy,
6272 const struct ieee80211_regdomain *regdom)
6273{
6274 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6275 NL80211_CMD_GET_REG);
6276
6277 if (!hdr)
6278 return -1;
6279
6280 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
6281
6282 if (nl80211_put_regdom(regdom, msg))
6283 goto nla_put_failure;
6284
6285 if (!wiphy && reg_last_request_cell_base() &&
6286 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6287 NL80211_USER_REG_HINT_CELL_BASE))
6288 goto nla_put_failure;
6289
6290 if (wiphy &&
6291 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6292 goto nla_put_failure;
6293
1bdd716c
AN		 6294 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
6295 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
6296 goto nla_put_failure;
6297
053c095a
JB		 6298 genlmsg_end(msg, hdr);
6299 return 0;
ad30ca2c
AN		 6300
6301nla_put_failure:
6302 genlmsg_cancel(msg, hdr);
6303 return -EMSGSIZE;
6304}
6305
6306static int nl80211_get_reg_dump(struct sk_buff *skb,
6307 struct netlink_callback *cb)
6308{
6309 const struct ieee80211_regdomain *regdom = NULL;
6310 struct cfg80211_registered_device *rdev;
6311 int err, reg_idx, start = cb->args[2];
6312
6313 rtnl_lock();
6314
6315 if (cfg80211_regdomain && start == 0) {
6316 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6317 NLM_F_MULTI, NULL,
6318 rtnl_dereference(cfg80211_regdomain));
6319 if (err < 0)
6320 goto out_err;
6321 }
6322
6323 /* the global regdom is idx 0 */
6324 reg_idx = 1;
6325 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
6326 regdom = get_wiphy_regdom(&rdev->wiphy);
6327 if (!regdom)
6328 continue;
6329
6330 if (++reg_idx <= start)
6331 continue;
6332
6333 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6334 NLM_F_MULTI, &rdev->wiphy, regdom);
6335 if (err < 0) {
6336 reg_idx--;
6337 break;
6338 }
6339 }
6340
6341 cb->args[2] = reg_idx;
6342 err = skb->len;
6343out_err:
6344 rtnl_unlock();
6345 return err;
6346}
6347
b6863036
JB		 6348#ifdef CONFIG_CFG80211_CRDA_SUPPORT
6349static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
6350 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6351 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6352 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6353 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6354 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6355 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6356 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
6357};
6358
6359static int parse_reg_rule(struct nlattr *tb[],
6360 struct ieee80211_reg_rule *reg_rule)
6361{
6362 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
6363 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
6364
6365 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
6366 return -EINVAL;
6367 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
6368 return -EINVAL;
6369 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
6370 return -EINVAL;
6371 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
6372 return -EINVAL;
6373 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
6374 return -EINVAL;
6375
6376 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
6377
6378 freq_range->start_freq_khz =
6379 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
6380 freq_range->end_freq_khz =
6381 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
6382 freq_range->max_bandwidth_khz =
6383 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
6384
6385 power_rule->max_eirp =
6386 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
6387
6388 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
6389 power_rule->max_antenna_gain =
6390 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
6391
6392 if (tb[NL80211_ATTR_DFS_CAC_TIME])
6393 reg_rule->dfs_cac_ms =
6394 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
6395
6396 return 0;
6397}
6398
b2e1b302
LR		 6399static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
6400{
6401 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
6402 struct nlattr *nl_reg_rule;
ea372c54
JB		 6403 char *alpha2;
6404 int rem_reg_rules, r;
b2e1b302 6405 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4c7d3982 6406 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
ea372c54 6407 struct ieee80211_regdomain *rd;
b2e1b302
LR		 6408
6409 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6410 return -EINVAL;
6411
6412 if (!info->attrs[NL80211_ATTR_REG_RULES])
6413 return -EINVAL;
6414
6415 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6416
8b60b078
LR		 6417 if (info->attrs[NL80211_ATTR_DFS_REGION])
6418 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
6419
b2e1b302 6420 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6421 rem_reg_rules) {
b2e1b302
LR		 6422 num_rules++;
6423 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 6424 return -EINVAL;
b2e1b302
LR		 6425 }
6426
e438768f
LR		 6427 if (!reg_is_valid_request(alpha2))
6428 return -EINVAL;
6429
b2e1b302 6430 size_of_regd = sizeof(struct ieee80211_regdomain) +
1a919318 6431 num_rules * sizeof(struct ieee80211_reg_rule);
b2e1b302
LR		 6432
6433 rd = kzalloc(size_of_regd, GFP_KERNEL);
6913b49a
JB		 6434 if (!rd)
6435 return -ENOMEM;
b2e1b302
LR		 6436
6437 rd->n_reg_rules = num_rules;
6438 rd->alpha2[0] = alpha2[0];
6439 rd->alpha2[1] = alpha2[1];
6440
8b60b078
LR		 6441 /*
6442 * Disable DFS master mode if the DFS region was
6443 * not supported or known on this kernel.
6444 */
6445 if (reg_supported_dfs_region(dfs_region))
6446 rd->dfs_region = dfs_region;
6447
b2e1b302 6448 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6449 rem_reg_rules) {
bfe2c7b1 6450 r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
fe52145f
JB		 6451 nl_reg_rule, reg_rule_policy,
6452 info->extack);
ae811e21
JB		 6453 if (r)
6454 goto bad_reg;
b2e1b302
LR		 6455 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
6456 if (r)
6457 goto bad_reg;
6458
6459 rule_idx++;
6460
d0e18f83
LR		 6461 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
6462 r = -EINVAL;
b2e1b302 6463 goto bad_reg;
d0e18f83 6464 }
b2e1b302
LR		 6465 }
6466
06627990
JB		 6467 /* set_regdom takes ownership of rd */
6468 return set_regdom(rd, REGD_SOURCE_CRDA);
d2372b31 6469 bad_reg:
b2e1b302 6470 kfree(rd);
d0e18f83 6471 return r;
b2e1b302 6472}
b6863036 6473#endif /* CONFIG_CFG80211_CRDA_SUPPORT */
b2e1b302 6474
83f5e2cf
JB		 6475static int validate_scan_freqs(struct nlattr *freqs)
6476{
6477 struct nlattr *attr1, *attr2;
6478 int n_channels = 0, tmp1, tmp2;
6479
d7f13f74
SD		 6480 nla_for_each_nested(attr1, freqs, tmp1)
6481 if (nla_len(attr1) != sizeof(u32))
6482 return 0;
6483
83f5e2cf
JB		 6484 nla_for_each_nested(attr1, freqs, tmp1) {
6485 n_channels++;
6486 /*
6487 * Some hardware has a limited channel list for
6488 * scanning, and it is pretty much nonsensical
6489 * to scan for a channel twice, so disallow that
6490 * and don't require drivers to check that the
6491 * channel list they get isn't longer than what
6492 * they can scan, as long as they can scan all
6493 * the channels they registered at once.
6494 */
6495 nla_for_each_nested(attr2, freqs, tmp2)
6496 if (attr1 != attr2 &&
6497 nla_get_u32(attr1) == nla_get_u32(attr2))
6498 return 0;
6499 }
6500
6501 return n_channels;
6502}
6503
57fbcce3 6504static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
38de03d2 6505{
57fbcce3 6506 return b < NUM_NL80211_BANDS && wiphy->bands[b];
38de03d2
AS		 6507}
6508
6509static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
6510 struct cfg80211_bss_selection *bss_select)
6511{
6512 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
6513 struct nlattr *nest;
6514 int err;
6515 bool found = false;
6516 int i;
6517
6518 /* only process one nested attribute */
6519 nest = nla_data(nla);
6520 if (!nla_ok(nest, nla_len(nest)))
6521 return -EINVAL;
6522
bfe2c7b1 6523 err = nla_parse_nested(attr, NL80211_BSS_SELECT_ATTR_MAX, nest,
fceb6435 6524 nl80211_bss_select_policy, NULL);
38de03d2
AS		 6525 if (err)
6526 return err;
6527
6528 /* only one attribute may be given */
6529 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
6530 if (attr[i]) {
6531 if (found)
6532 return -EINVAL;
6533 found = true;
6534 }
6535 }
6536
6537 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
6538
6539 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
6540 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
6541
6542 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
6543 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
6544 bss_select->param.band_pref =
6545 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
6546 if (!is_band_valid(wiphy, bss_select->param.band_pref))
6547 return -EINVAL;
6548 }
6549
6550 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
6551 struct nl80211_bss_select_rssi_adjust *adj_param;
6552
6553 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
6554 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
6555 bss_select->param.adjust.band = adj_param->band;
6556 bss_select->param.adjust.delta = adj_param->delta;
6557 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
6558 return -EINVAL;
6559 }
6560
6561 /* user-space did not provide behaviour attribute */
6562 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
6563 return -EINVAL;
6564
6565 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
6566 return -EINVAL;
6567
6568 return 0;
6569}
6570
ad2b26ab
JB		 6571static int nl80211_parse_random_mac(struct nlattr **attrs,
6572 u8 *mac_addr, u8 *mac_addr_mask)
6573{
6574 int i;
6575
6576 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
d2beae10
JP		 6577 eth_zero_addr(mac_addr);
6578 eth_zero_addr(mac_addr_mask);
ad2b26ab
JB		 6579 mac_addr[0] = 0x2;
6580 mac_addr_mask[0] = 0x3;
6581
6582 return 0;
6583 }
6584
6585 /* need both or none */
6586 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
6587 return -EINVAL;
6588
6589 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
6590 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
6591
6592 /* don't allow or configure an mcast address */
6593 if (!is_multicast_ether_addr(mac_addr_mask) ||
6594 is_multicast_ether_addr(mac_addr))
6595 return -EINVAL;
6596
6597 /*
6598 * allow users to pass a MAC address that has bits set outside
6599 * of the mask, but don't bother drivers with having to deal
6600 * with such bits
6601 */
6602 for (i = 0; i < ETH_ALEN; i++)
6603 mac_addr[i] &= mac_addr_mask[i];
6604
6605 return 0;
6606}
6607
34373d12
VT		 6608static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
6609{
6610 ASSERT_WDEV_LOCK(wdev);
6611
6612 if (!cfg80211_beaconing_iface_active(wdev))
6613 return true;
6614
6615 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
6616 return true;
6617
6618 return regulatory_pre_cac_allowed(wdev->wiphy);
6619}
6620
2a519311
JB		 6621static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
6622{
4c476991 6623 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd014284 6624 struct wireless_dev *wdev = info->user_ptr[1];
2a519311 6625 struct cfg80211_scan_request *request;
2a519311
JB		 6626 struct nlattr *attr;
6627 struct wiphy *wiphy;
83f5e2cf 6628 int err, tmp, n_ssids = 0, n_channels, i;
70692ad2 6629 size_t ie_len;
2a519311 6630
f4a11bb0
JB		 6631 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6632 return -EINVAL;
6633
79c97e97 6634 wiphy = &rdev->wiphy;
2a519311 6635
cb3b7d87
AB		 6636 if (wdev->iftype == NL80211_IFTYPE_NAN)
6637 return -EOPNOTSUPP;
6638
4c476991
JB		 6639 if (!rdev->ops->scan)
6640 return -EOPNOTSUPP;
2a519311 6641
f9d15d16 6642 if (rdev->scan_req || rdev->scan_msg) {
f9f47529
JB		 6643 err = -EBUSY;
6644 goto unlock;
6645 }
2a519311
JB		 6646
6647 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 6648 n_channels = validate_scan_freqs(
6649 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
f9f47529
JB		 6650 if (!n_channels) {
6651 err = -EINVAL;
6652 goto unlock;
6653 }
2a519311 6654 } else {
bdfbec2d 6655 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311
JB		 6656 }
6657
6658 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
6659 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
6660 n_ssids++;
6661
f9f47529
JB		 6662 if (n_ssids > wiphy->max_scan_ssids) {
6663 err = -EINVAL;
6664 goto unlock;
6665 }
2a519311 6666
70692ad2
JM		 6667 if (info->attrs[NL80211_ATTR_IE])
6668 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6669 else
6670 ie_len = 0;
6671
f9f47529
JB		 6672 if (ie_len > wiphy->max_scan_ie_len) {
6673 err = -EINVAL;
6674 goto unlock;
6675 }
18a83659 6676
2a519311 6677 request = kzalloc(sizeof(*request)
a2cd43c5
LC		 6678 + sizeof(*request->ssids) * n_ssids
6679 + sizeof(*request->channels) * n_channels
70692ad2 6680 + ie_len, GFP_KERNEL);
f9f47529
JB		 6681 if (!request) {
6682 err = -ENOMEM;
6683 goto unlock;
6684 }
2a519311 6685
2a519311 6686 if (n_ssids)
5ba63533 6687 request->ssids = (void *)&request->channels[n_channels];
2a519311 6688 request->n_ssids = n_ssids;
70692ad2 6689 if (ie_len) {
13874e4b 6690 if (n_ssids)
70692ad2
JM		 6691 request->ie = (void *)(request->ssids + n_ssids);
6692 else
6693 request->ie = (void *)(request->channels + n_channels);
6694 }
2a519311 6695
584991dc 6696 i = 0;
2a519311
JB		 6697 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
6698 /* user specified, bail out if channel not found */
2a519311 6699 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
584991dc
JB		 6700 struct ieee80211_channel *chan;
6701
6702 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
6703
6704 if (!chan) {
2a519311
JB		 6705 err = -EINVAL;
6706 goto out_free;
6707 }
584991dc
JB		 6708
6709 /* ignore disabled channels */
6710 if (chan->flags & IEEE80211_CHAN_DISABLED)
6711 continue;
6712
6713 request->channels[i] = chan;
2a519311
JB		 6714 i++;
6715 }
6716 } else {
57fbcce3 6717 enum nl80211_band band;
34850ab2 6718
2a519311 6719 /* all channels */
57fbcce3 6720 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2a519311 6721 int j;
7a087e74 6722
2a519311
JB		 6723 if (!wiphy->bands[band])
6724 continue;
6725 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dc
JB		 6726 struct ieee80211_channel *chan;
6727
6728 chan = &wiphy->bands[band]->channels[j];
6729
6730 if (chan->flags & IEEE80211_CHAN_DISABLED)
6731 continue;
6732
6733 request->channels[i] = chan;
2a519311
JB		 6734 i++;
6735 }
6736 }
6737 }
6738
584991dc
JB		 6739 if (!i) {
6740 err = -EINVAL;
6741 goto out_free;
6742 }
6743
6744 request->n_channels = i;
6745
34373d12
VT		 6746 wdev_lock(wdev);
6747 if (!cfg80211_off_channel_oper_allowed(wdev)) {
6748 struct ieee80211_channel *chan;
6749
6750 if (request->n_channels != 1) {
6751 wdev_unlock(wdev);
6752 err = -EBUSY;
6753 goto out_free;
6754 }
6755
6756 chan = request->channels[0];
6757 if (chan->center_freq != wdev->chandef.chan->center_freq) {
6758 wdev_unlock(wdev);
6759 err = -EBUSY;
6760 goto out_free;
6761 }
6762 }
6763 wdev_unlock(wdev);
6764
2a519311 6765 i = 0;
13874e4b 6766 if (n_ssids) {
2a519311 6767 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d 6768 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311
JB		 6769 err = -EINVAL;
6770 goto out_free;
6771 }
57a27e1d 6772 request->ssids[i].ssid_len = nla_len(attr);
2a519311 6773 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2a519311
JB		 6774 i++;
6775 }
6776 }
6777
70692ad2
JM		 6778 if (info->attrs[NL80211_ATTR_IE]) {
6779 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 6780 memcpy((void *)request->ie,
6781 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 6782 request->ie_len);
6783 }
6784
57fbcce3 6785 for (i = 0; i < NUM_NL80211_BANDS; i++)
a401d2bb
JB		 6786 if (wiphy->bands[i])
6787 request->rates[i] =
6788 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab2
JB		 6789
6790 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
6791 nla_for_each_nested(attr,
6792 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
6793 tmp) {
57fbcce3 6794 enum nl80211_band band = nla_type(attr);
34850ab2 6795
57fbcce3 6796 if (band < 0 || band >= NUM_NL80211_BANDS) {
34850ab2
JB		 6797 err = -EINVAL;
6798 goto out_free;
6799 }
1b09cd82
FF		 6800
6801 if (!wiphy->bands[band])
6802 continue;
6803
34850ab2
JB		 6804 err = ieee80211_get_ratemask(wiphy->bands[band],
6805 nla_data(attr),
6806 nla_len(attr),
6807 &request->rates[band]);
6808 if (err)
6809 goto out_free;
6810 }
6811 }
6812
1d76250b
AS		 6813 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
6814 if (!wiphy_ext_feature_isset(wiphy,
6815 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
6816 err = -EOPNOTSUPP;
6817 goto out_free;
6818 }
6819
6820 request->duration =
6821 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
6822 request->duration_mandatory =
6823 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
6824 }
6825
46856bbf 6826 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771
SL		 6827 request->flags = nla_get_u32(
6828 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 6829 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
6830 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 6831 err = -EOPNOTSUPP;
6832 goto out_free;
6833 }
ad2b26ab
JB		 6834
6835 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6836 if (!(wiphy->features &
6837 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)) {
6838 err = -EOPNOTSUPP;
6839 goto out_free;
6840 }
6841
6842 if (wdev->current_bss) {
6843 err = -EOPNOTSUPP;
6844 goto out_free;
6845 }
6846
6847 err = nl80211_parse_random_mac(info->attrs,
6848 request->mac_addr,
6849 request->mac_addr_mask);
6850 if (err)
6851 goto out_free;
6852 }
46856bbf 6853 }
ed473771 6854
e9f935e3
RM		 6855 request->no_cck =
6856 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
6857
2fa436b3
VK		 6858 /* Initial implementation used NL80211_ATTR_MAC to set the specific
6859 * BSSID to scan for. This was problematic because that same attribute
6860 * was already used for another purpose (local random MAC address). The
6861 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
6862 * compatibility with older userspace components, also use the
6863 * NL80211_ATTR_MAC value here if it can be determined to be used for
6864 * the specific BSSID use case instead of the random MAC address
6865 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
6866 */
6867 if (info->attrs[NL80211_ATTR_BSSID])
6868 memcpy(request->bssid,
6869 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
6870 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
6871 info->attrs[NL80211_ATTR_MAC])
818965d3
JM		 6872 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
6873 ETH_ALEN);
6874 else
6875 eth_broadcast_addr(request->bssid);
6876
fd014284 6877 request->wdev = wdev;
79c97e97 6878 request->wiphy = &rdev->wiphy;
15d6030b 6879 request->scan_start = jiffies;
2a519311 6880
79c97e97 6881 rdev->scan_req = request;
e35e4d28 6882 err = rdev_scan(rdev, request);
2a519311 6883
463d0183 6884 if (!err) {
fd014284
JB		 6885 nl80211_send_scan_start(rdev, wdev);
6886 if (wdev->netdev)
6887 dev_hold(wdev->netdev);
4c476991 6888 } else {
2a519311 6889 out_free:
79c97e97 6890 rdev->scan_req = NULL;
2a519311
JB		 6891 kfree(request);
6892 }
3b85875a 6893
f9f47529 6894 unlock:
2a519311
JB		 6895 return err;
6896}
6897
91d3ab46
VK		 6898static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
6899{
6900 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6901 struct wireless_dev *wdev = info->user_ptr[1];
6902
6903 if (!rdev->ops->abort_scan)
6904 return -EOPNOTSUPP;
6905
6906 if (rdev->scan_msg)
6907 return 0;
6908
6909 if (!rdev->scan_req)
6910 return -ENOENT;
6911
6912 rdev_abort_scan(rdev, wdev);
6913 return 0;
6914}
6915
3b06d277
AS		 6916static int
6917nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
6918 struct cfg80211_sched_scan_request *request,
6919 struct nlattr **attrs)
6920{
6921 int tmp, err, i = 0;
6922 struct nlattr *attr;
6923
6924 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
6925 u32 interval;
6926
6927 /*
6928 * If scan plans are not specified,
5a88de53 6929 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
3b06d277
AS		 6930 * case one scan plan will be set with the specified scan
6931 * interval and infinite number of iterations.
6932 */
3b06d277
AS		 6933 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
6934 if (!interval)
6935 return -EINVAL;
6936
6937 request->scan_plans[0].interval =
6938 DIV_ROUND_UP(interval, MSEC_PER_SEC);
6939 if (!request->scan_plans[0].interval)
6940 return -EINVAL;
6941
6942 if (request->scan_plans[0].interval >
6943 wiphy->max_sched_scan_plan_interval)
6944 request->scan_plans[0].interval =
6945 wiphy->max_sched_scan_plan_interval;
6946
6947 return 0;
6948 }
6949
6950 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
6951 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
6952
6953 if (WARN_ON(i >= n_plans))
6954 return -EINVAL;
6955
bfe2c7b1 6956 err = nla_parse_nested(plan, NL80211_SCHED_SCAN_PLAN_MAX,
fceb6435 6957 attr, nl80211_plan_policy, NULL);
3b06d277
AS		 6958 if (err)
6959 return err;
6960
6961 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
6962 return -EINVAL;
6963
6964 request->scan_plans[i].interval =
6965 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
6966 if (!request->scan_plans[i].interval ||
6967 request->scan_plans[i].interval >
6968 wiphy->max_sched_scan_plan_interval)
6969 return -EINVAL;
6970
6971 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
6972 request->scan_plans[i].iterations =
6973 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
6974 if (!request->scan_plans[i].iterations ||
6975 (request->scan_plans[i].iterations >
6976 wiphy->max_sched_scan_plan_iterations))
6977 return -EINVAL;
6978 } else if (i < n_plans - 1) {
6979 /*
6980 * All scan plans but the last one must specify
6981 * a finite number of iterations
6982 */
6983 return -EINVAL;
6984 }
6985
6986 i++;
6987 }
6988
6989 /*
6990 * The last scan plan must not specify the number of
6991 * iterations, it is supposed to run infinitely
6992 */
6993 if (request->scan_plans[n_plans - 1].iterations)
6994 return -EINVAL;
6995
6996 return 0;
6997}
6998
256da02d 6999static struct cfg80211_sched_scan_request *
ad2b26ab 7000nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
aad1e812 7001 struct nlattr **attrs, int max_match_sets)
807f8a8c
LC		 7002{
7003 struct cfg80211_sched_scan_request *request;
807f8a8c 7004 struct nlattr *attr;
3b06d277 7005 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
57fbcce3 7006 enum nl80211_band band;
807f8a8c 7007 size_t ie_len;
a1f1c21c 7008 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
ea73cbce 7009 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
807f8a8c 7010
256da02d
LC		 7011 if (!is_valid_ie_attr(attrs[NL80211_ATTR_IE]))
7012 return ERR_PTR(-EINVAL);
807f8a8c 7013
256da02d 7014 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c 7015 n_channels = validate_scan_freqs(
256da02d 7016 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
807f8a8c 7017 if (!n_channels)
256da02d 7018 return ERR_PTR(-EINVAL);
807f8a8c 7019 } else {
bdfbec2d 7020 n_channels = ieee80211_get_num_supported_channels(wiphy);
807f8a8c
LC		 7021 }
7022
256da02d
LC		 7023 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7024 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c
LC		 7025 tmp)
7026 n_ssids++;
7027
93b6aa69 7028 if (n_ssids > wiphy->max_sched_scan_ssids)
256da02d 7029 return ERR_PTR(-EINVAL);
807f8a8c 7030
ea73cbce
JB		 7031 /*
7032 * First, count the number of 'real' matchsets. Due to an issue with
7033 * the old implementation, matchsets containing only the RSSI attribute
7034 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7035 * RSSI for all matchsets, rather than their own matchset for reporting
7036 * all APs with a strong RSSI. This is needed to be compatible with
7037 * older userspace that treated a matchset with only the RSSI as the
7038 * global RSSI for all other matchsets - if there are other matchsets.
7039 */
256da02d 7040 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7041 nla_for_each_nested(attr,
256da02d 7042 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
ea73cbce
JB		 7043 tmp) {
7044 struct nlattr *rssi;
7045
bfe2c7b1
JB		 7046 err = nla_parse_nested(tb,
7047 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7048 attr, nl80211_match_policy,
7049 NULL);
ea73cbce 7050 if (err)
256da02d 7051 return ERR_PTR(err);
3007e352
AVS		 7052
7053 /* SSID and BSSID are mutually exclusive */
7054 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
7055 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
7056 return ERR_PTR(-EINVAL);
7057
ea73cbce 7058 /* add other standalone attributes here */
3007e352
AVS		 7059 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
7060 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
ea73cbce
JB		 7061 n_match_sets++;
7062 continue;
7063 }
7064 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7065 if (rssi)
7066 default_match_rssi = nla_get_s32(rssi);
7067 }
7068 }
7069
7070 /* However, if there's no other matchset, add the RSSI one */
7071 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7072 n_match_sets = 1;
a1f1c21c 7073
aad1e812 7074 if (n_match_sets > max_match_sets)
256da02d 7075 return ERR_PTR(-EINVAL);
a1f1c21c 7076
256da02d
LC		 7077 if (attrs[NL80211_ATTR_IE])
7078 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
807f8a8c
LC		 7079 else
7080 ie_len = 0;
7081
5a865bad 7082 if (ie_len > wiphy->max_sched_scan_ie_len)
256da02d 7083 return ERR_PTR(-EINVAL);
c10841ca 7084
3b06d277
AS		 7085 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7086 /*
7087 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7088 * each scan plan already specifies its own interval
7089 */
7090 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7091 return ERR_PTR(-EINVAL);
7092
7093 nla_for_each_nested(attr,
7094 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7095 n_plans++;
7096 } else {
7097 /*
7098 * The scan interval attribute is kept for backward
7099 * compatibility. If no scan plans are specified and sched scan
7100 * interval is specified, one scan plan will be set with this
7101 * scan interval and infinite number of iterations.
7102 */
7103 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7104 return ERR_PTR(-EINVAL);
7105
7106 n_plans = 1;
7107 }
7108
7109 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7110 return ERR_PTR(-EINVAL);
7111
bf95ecdb 7112 if (!wiphy_ext_feature_isset(
7113 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7114 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7115 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7116 return ERR_PTR(-EINVAL);
7117
807f8a8c 7118 request = kzalloc(sizeof(*request)
a2cd43c5 7119 + sizeof(*request->ssids) * n_ssids
a1f1c21c 7120 + sizeof(*request->match_sets) * n_match_sets
3b06d277 7121 + sizeof(*request->scan_plans) * n_plans
a2cd43c5 7122 + sizeof(*request->channels) * n_channels
807f8a8c 7123 + ie_len, GFP_KERNEL);
256da02d
LC		 7124 if (!request)
7125 return ERR_PTR(-ENOMEM);
807f8a8c
LC		 7126
7127 if (n_ssids)
7128 request->ssids = (void *)&request->channels[n_channels];
7129 request->n_ssids = n_ssids;
7130 if (ie_len) {
13874e4b 7131 if (n_ssids)
807f8a8c
LC		 7132 request->ie = (void *)(request->ssids + n_ssids);
7133 else
7134 request->ie = (void *)(request->channels + n_channels);
7135 }
7136
a1f1c21c
LC		 7137 if (n_match_sets) {
7138 if (request->ie)
7139 request->match_sets = (void *)(request->ie + ie_len);
13874e4b 7140 else if (n_ssids)
a1f1c21c
LC		 7141 request->match_sets =
7142 (void *)(request->ssids + n_ssids);
7143 else
7144 request->match_sets =
7145 (void *)(request->channels + n_channels);
7146 }
7147 request->n_match_sets = n_match_sets;
7148
3b06d277
AS		 7149 if (n_match_sets)
7150 request->scan_plans = (void *)(request->match_sets +
7151 n_match_sets);
7152 else if (request->ie)
7153 request->scan_plans = (void *)(request->ie + ie_len);
7154 else if (n_ssids)
7155 request->scan_plans = (void *)(request->ssids + n_ssids);
7156 else
7157 request->scan_plans = (void *)(request->channels + n_channels);
7158
7159 request->n_scan_plans = n_plans;
7160
807f8a8c 7161 i = 0;
256da02d 7162 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c
LC		 7163 /* user specified, bail out if channel not found */
7164 nla_for_each_nested(attr,
256da02d 7165 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
807f8a8c
LC		 7166 tmp) {
7167 struct ieee80211_channel *chan;
7168
7169 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7170
7171 if (!chan) {
7172 err = -EINVAL;
7173 goto out_free;
7174 }
7175
7176 /* ignore disabled channels */
7177 if (chan->flags & IEEE80211_CHAN_DISABLED)
7178 continue;
7179
7180 request->channels[i] = chan;
7181 i++;
7182 }
7183 } else {
7184 /* all channels */
57fbcce3 7185 for (band = 0; band < NUM_NL80211_BANDS; band++) {
807f8a8c 7186 int j;
7a087e74 7187
807f8a8c
LC		 7188 if (!wiphy->bands[band])
7189 continue;
7190 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7191 struct ieee80211_channel *chan;
7192
7193 chan = &wiphy->bands[band]->channels[j];
7194
7195 if (chan->flags & IEEE80211_CHAN_DISABLED)
7196 continue;
7197
7198 request->channels[i] = chan;
7199 i++;
7200 }
7201 }
7202 }
7203
7204 if (!i) {
7205 err = -EINVAL;
7206 goto out_free;
7207 }
7208
7209 request->n_channels = i;
7210
7211 i = 0;
13874e4b 7212 if (n_ssids) {
256da02d 7213 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c 7214 tmp) {
57a27e1d 7215 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
807f8a8c
LC		 7216 err = -EINVAL;
7217 goto out_free;
7218 }
57a27e1d 7219 request->ssids[i].ssid_len = nla_len(attr);
807f8a8c
LC		 7220 memcpy(request->ssids[i].ssid, nla_data(attr),
7221 nla_len(attr));
807f8a8c
LC		 7222 i++;
7223 }
7224 }
7225
a1f1c21c 7226 i = 0;
256da02d 7227 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7228 nla_for_each_nested(attr,
256da02d 7229 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
a1f1c21c 7230 tmp) {
3007e352 7231 struct nlattr *ssid, *bssid, *rssi;
a1f1c21c 7232
bfe2c7b1
JB		 7233 err = nla_parse_nested(tb,
7234 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
fceb6435
JB		 7235 attr, nl80211_match_policy,
7236 NULL);
ae811e21
JB		 7237 if (err)
7238 goto out_free;
4a4ab0d7 7239 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
3007e352
AVS		 7240 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
7241 if (ssid || bssid) {
ea73cbce
JB		 7242 if (WARN_ON(i >= n_match_sets)) {
7243 /* this indicates a programming error,
7244 * the loop above should have verified
7245 * things properly
7246 */
7247 err = -EINVAL;
7248 goto out_free;
7249 }
7250
3007e352
AVS		 7251 if (ssid) {
7252 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
7253 err = -EINVAL;
7254 goto out_free;
7255 }
7256 memcpy(request->match_sets[i].ssid.ssid,
7257 nla_data(ssid), nla_len(ssid));
7258 request->match_sets[i].ssid.ssid_len =
7259 nla_len(ssid);
7260 }
7261 if (bssid) {
7262 if (nla_len(bssid) != ETH_ALEN) {
7263 err = -EINVAL;
7264 goto out_free;
7265 }
7266 memcpy(request->match_sets[i].bssid,
7267 nla_data(bssid), ETH_ALEN);
a1f1c21c 7268 }
3007e352 7269
56ab364f 7270 /* special attribute - old implementation w/a */
ea73cbce
JB		 7271 request->match_sets[i].rssi_thold =
7272 default_match_rssi;
7273 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7274 if (rssi)
7275 request->match_sets[i].rssi_thold =
7276 nla_get_s32(rssi);
a1f1c21c
LC		 7277 }
7278 i++;
7279 }
ea73cbce
JB		 7280
7281 /* there was no other matchset, so the RSSI one is alone */
f89f46cf 7282 if (i == 0 && n_match_sets)
ea73cbce
JB		 7283 request->match_sets[0].rssi_thold = default_match_rssi;
7284
7285 request->min_rssi_thold = INT_MAX;
7286 for (i = 0; i < n_match_sets; i++)
7287 request->min_rssi_thold =
7288 min(request->match_sets[i].rssi_thold,
7289 request->min_rssi_thold);
7290 } else {
7291 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
a1f1c21c
LC		 7292 }
7293
9900e484
JB		 7294 if (ie_len) {
7295 request->ie_len = ie_len;
807f8a8c 7296 memcpy((void *)request->ie,
256da02d 7297 nla_data(attrs[NL80211_ATTR_IE]),
807f8a8c
LC		 7298 request->ie_len);
7299 }
7300
256da02d 7301 if (attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771 7302 request->flags = nla_get_u32(
256da02d 7303 attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 7304 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7305 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 7306 err = -EOPNOTSUPP;
7307 goto out_free;
7308 }
ad2b26ab
JB		 7309
7310 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7311 u32 flg = NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
7312
7313 if (!wdev) /* must be net-detect */
7314 flg = NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7315
7316 if (!(wiphy->features & flg)) {
7317 err = -EOPNOTSUPP;
7318 goto out_free;
7319 }
7320
7321 if (wdev && wdev->current_bss) {
7322 err = -EOPNOTSUPP;
7323 goto out_free;
7324 }
7325
7326 err = nl80211_parse_random_mac(attrs, request->mac_addr,
7327 request->mac_addr_mask);
7328 if (err)
7329 goto out_free;
7330 }
46856bbf 7331 }
ed473771 7332
9c748934
LC		 7333 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
7334 request->delay =
7335 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
7336
bf95ecdb 7337 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
7338 request->relative_rssi = nla_get_s8(
7339 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
7340 request->relative_rssi_set = true;
7341 }
7342
7343 if (request->relative_rssi_set &&
7344 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
7345 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
7346
7347 rssi_adjust = nla_data(
7348 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
7349 request->rssi_adjust.band = rssi_adjust->band;
7350 request->rssi_adjust.delta = rssi_adjust->delta;
7351 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
7352 err = -EINVAL;
7353 goto out_free;
7354 }
7355 }
7356
3b06d277
AS		 7357 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
7358 if (err)
7359 goto out_free;
7360
15d6030b 7361 request->scan_start = jiffies;
807f8a8c 7362
256da02d 7363 return request;
807f8a8c
LC		 7364
7365out_free:
7366 kfree(request);
256da02d
LC		 7367 return ERR_PTR(err);
7368}
7369
7370static int nl80211_start_sched_scan(struct sk_buff *skb,
7371 struct genl_info *info)
7372{
7373 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7374 struct net_device *dev = info->user_ptr[1];
ad2b26ab 7375 struct wireless_dev *wdev = dev->ieee80211_ptr;
31a60ed1 7376 struct cfg80211_sched_scan_request *sched_scan_req;
ca986ad9 7377 bool want_multi;
256da02d
LC		 7378 int err;
7379
ca986ad9 7380 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
256da02d
LC		 7381 return -EOPNOTSUPP;
7382
ca986ad9
AVS		 7383 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
7384 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
7385 if (err)
7386 return err;
256da02d 7387
31a60ed1 7388 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
aad1e812
AVS		 7389 info->attrs,
7390 rdev->wiphy.max_match_sets);
31a60ed1
JR		 7391
7392 err = PTR_ERR_OR_ZERO(sched_scan_req);
256da02d
LC		 7393 if (err)
7394 goto out_err;
7395
ca986ad9
AVS		 7396 /* leave request id zero for legacy request
7397 * or if driver does not support multi-scheduled scan
7398 */
7399 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) {
7400 while (!sched_scan_req->reqid)
7401 sched_scan_req->reqid = rdev->wiphy.cookie_counter++;
7402 }
7403
31a60ed1 7404 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
256da02d
LC		 7405 if (err)
7406 goto out_free;
7407
31a60ed1
JR		 7408 sched_scan_req->dev = dev;
7409 sched_scan_req->wiphy = &rdev->wiphy;
7410
93a1e86c
JR		 7411 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
7412 sched_scan_req->owner_nlportid = info->snd_portid;
7413
ca986ad9 7414 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
256da02d 7415
96b08fd6 7416 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
256da02d
LC		 7417 return 0;
7418
7419out_free:
31a60ed1 7420 kfree(sched_scan_req);
256da02d 7421out_err:
807f8a8c
LC		 7422 return err;
7423}
7424
7425static int nl80211_stop_sched_scan(struct sk_buff *skb,
7426 struct genl_info *info)
7427{
ca986ad9 7428 struct cfg80211_sched_scan_request *req;
807f8a8c 7429 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ca986ad9 7430 u64 cookie;
807f8a8c 7431
ca986ad9 7432 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
807f8a8c
LC		 7433 return -EOPNOTSUPP;
7434
ca986ad9
AVS		 7435 if (info->attrs[NL80211_ATTR_COOKIE]) {
7436 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7437 return __cfg80211_stop_sched_scan(rdev, cookie, false);
7438 }
7439
7440 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
7441 struct cfg80211_sched_scan_request,
7442 list);
7443 if (!req || req->reqid ||
7444 (req->owner_nlportid &&
7445 req->owner_nlportid != info->snd_portid))
7446 return -ENOENT;
7447
7448 return cfg80211_stop_sched_scan_req(rdev, req, false);
807f8a8c
LC		 7449}
7450
04f39047
SW		 7451static int nl80211_start_radar_detection(struct sk_buff *skb,
7452 struct genl_info *info)
7453{
7454 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7455 struct net_device *dev = info->user_ptr[1];
7456 struct wireless_dev *wdev = dev->ieee80211_ptr;
7457 struct cfg80211_chan_def chandef;
55f7435c 7458 enum nl80211_dfs_regions dfs_region;
31559f35 7459 unsigned int cac_time_ms;
04f39047
SW		 7460 int err;
7461
55f7435c
LR		 7462 dfs_region = reg_get_dfs_region(wdev->wiphy);
7463 if (dfs_region == NL80211_DFS_UNSET)
7464 return -EINVAL;
7465
04f39047
SW		 7466 err = nl80211_parse_chandef(rdev, info, &chandef);
7467 if (err)
7468 return err;
7469
ff311bc1
SW		 7470 if (netif_carrier_ok(dev))
7471 return -EBUSY;
7472
04f39047
SW		 7473 if (wdev->cac_started)
7474 return -EBUSY;
7475
2beb6dab 7476 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
00ec75fc 7477 wdev->iftype);
04f39047
SW		 7478 if (err < 0)
7479 return err;
7480
7481 if (err == 0)
7482 return -EINVAL;
7483
fe7c3a1f 7484 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
04f39047
SW		 7485 return -EINVAL;
7486
7487 if (!rdev->ops->start_radar_detection)
7488 return -EOPNOTSUPP;
7489
31559f35
JD		 7490 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
7491 if (WARN_ON(!cac_time_ms))
7492 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
7493
a1056b1b 7494 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
04f39047 7495 if (!err) {
9e0e2961 7496 wdev->chandef = chandef;
04f39047
SW		 7497 wdev->cac_started = true;
7498 wdev->cac_start_time = jiffies;
31559f35 7499 wdev->cac_time_ms = cac_time_ms;
04f39047 7500 }
04f39047
SW		 7501 return err;
7502}
7503
16ef1fe2
SW		 7504static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
7505{
7506 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7507 struct net_device *dev = info->user_ptr[1];
7508 struct wireless_dev *wdev = dev->ieee80211_ptr;
7509 struct cfg80211_csa_settings params;
7510 /* csa_attrs is defined static to avoid waste of stack size - this
7511 * function is called under RTNL lock, so this should not be a problem.
7512 */
7513 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
16ef1fe2 7514 int err;
ee4bc9e7 7515 bool need_new_beacon = false;
8d9de16f 7516 bool need_handle_dfs_flag = true;
9a774c78 7517 int len, i;
252e07ca 7518 u32 cs_count;
16ef1fe2
SW		 7519
7520 if (!rdev->ops->channel_switch ||
7521 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
7522 return -EOPNOTSUPP;
7523
ee4bc9e7
SW		 7524 switch (dev->ieee80211_ptr->iftype) {
7525 case NL80211_IFTYPE_AP:
7526 case NL80211_IFTYPE_P2P_GO:
7527 need_new_beacon = true;
8d9de16f
BB		 7528 /* For all modes except AP the handle_dfs flag needs to be
7529 * supplied to tell the kernel that userspace will handle radar
7530 * events when they happen. Otherwise a switch to a channel
7531 * requiring DFS will be rejected.
7532 */
7533 need_handle_dfs_flag = false;
ee4bc9e7
SW		 7534
7535 /* useless if AP is not running */
7536 if (!wdev->beacon_interval)
1ff79dfa 7537 return -ENOTCONN;
ee4bc9e7
SW		 7538 break;
7539 case NL80211_IFTYPE_ADHOC:
1ff79dfa
JB		 7540 if (!wdev->ssid_len)
7541 return -ENOTCONN;
7542 break;
c6da674a 7543 case NL80211_IFTYPE_MESH_POINT:
1ff79dfa
JB		 7544 if (!wdev->mesh_id_len)
7545 return -ENOTCONN;
ee4bc9e7
SW		 7546 break;
7547 default:
16ef1fe2 7548 return -EOPNOTSUPP;
ee4bc9e7 7549 }
16ef1fe2
SW		 7550
7551 memset(&params, 0, sizeof(params));
7552
7553 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7554 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
7555 return -EINVAL;
7556
7557 /* only important for AP, IBSS and mesh create IEs internally */
d0a361a5 7558 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
16ef1fe2
SW		 7559 return -EINVAL;
7560
252e07ca
LC		 7561 /* Even though the attribute is u32, the specification says
7562 * u8, so let's make sure we don't overflow.
7563 */
7564 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
7565 if (cs_count > 255)
7566 return -EINVAL;
7567
7568 params.count = cs_count;
16ef1fe2 7569
ee4bc9e7
SW		 7570 if (!need_new_beacon)
7571 goto skip_beacons;
7572
16ef1fe2
SW		 7573 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
7574 if (err)
7575 return err;
7576
7577 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
7578 info->attrs[NL80211_ATTR_CSA_IES],
fe52145f 7579 nl80211_policy, info->extack);
16ef1fe2
SW		 7580 if (err)
7581 return err;
7582
7583 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
7584 if (err)
7585 return err;
7586
7587 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
7588 return -EINVAL;
7589
9a774c78
AO		 7590 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7591 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7592 return -EINVAL;
7593
9a774c78
AO		 7594 params.n_counter_offsets_beacon = len / sizeof(u16);
7595 if (rdev->wiphy.max_num_csa_counters &&
7596 (params.n_counter_offsets_beacon >
7597 rdev->wiphy.max_num_csa_counters))
16ef1fe2
SW		 7598 return -EINVAL;
7599
9a774c78
AO		 7600 params.counter_offsets_beacon =
7601 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7602
7603 /* sanity checks - counters should fit and be the same */
7604 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
7605 u16 offset = params.counter_offsets_beacon[i];
7606
7607 if (offset >= params.beacon_csa.tail_len)
7608 return -EINVAL;
7609
7610 if (params.beacon_csa.tail[offset] != params.count)
7611 return -EINVAL;
7612 }
7613
16ef1fe2 7614 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
9a774c78
AO		 7615 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7616 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7617 return -EINVAL;
7618
9a774c78
AO		 7619 params.n_counter_offsets_presp = len / sizeof(u16);
7620 if (rdev->wiphy.max_num_csa_counters &&
ad5987b4 7621 (params.n_counter_offsets_presp >
9a774c78 7622 rdev->wiphy.max_num_csa_counters))
16ef1fe2 7623 return -EINVAL;
9a774c78
AO		 7624
7625 params.counter_offsets_presp =
7626 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7627
7628 /* sanity checks - counters should fit and be the same */
7629 for (i = 0; i < params.n_counter_offsets_presp; i++) {
7630 u16 offset = params.counter_offsets_presp[i];
7631
7632 if (offset >= params.beacon_csa.probe_resp_len)
7633 return -EINVAL;
7634
7635 if (params.beacon_csa.probe_resp[offset] !=
7636 params.count)
7637 return -EINVAL;
7638 }
16ef1fe2
SW		 7639 }
7640
ee4bc9e7 7641skip_beacons:
16ef1fe2
SW		 7642 err = nl80211_parse_chandef(rdev, info, &params.chandef);
7643 if (err)
7644 return err;
7645
923b352f
AN		 7646 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
7647 wdev->iftype))
16ef1fe2
SW		 7648 return -EINVAL;
7649
2beb6dab
LC		 7650 err = cfg80211_chandef_dfs_required(wdev->wiphy,
7651 &params.chandef,
7652 wdev->iftype);
7653 if (err < 0)
7654 return err;
7655
8d9de16f 7656 if (err > 0) {
2beb6dab 7657 params.radar_required = true;
8d9de16f
BB		 7658 if (need_handle_dfs_flag &&
7659 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
7660 return -EINVAL;
7661 }
7662 }
16ef1fe2 7663
16ef1fe2
SW		 7664 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
7665 params.block_tx = true;
7666
c56589ed
SW		 7667 wdev_lock(wdev);
7668 err = rdev_channel_switch(rdev, dev, &params);
7669 wdev_unlock(wdev);
7670
7671 return err;
16ef1fe2
SW		 7672}
7673
9720bb3a
JB		 7674static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
7675 u32 seq, int flags,
2a519311 7676 struct cfg80211_registered_device *rdev,
48ab905d
JB		 7677 struct wireless_dev *wdev,
7678 struct cfg80211_internal_bss *intbss)
2a519311 7679{
48ab905d 7680 struct cfg80211_bss *res = &intbss->pub;
9caf0364 7681 const struct cfg80211_bss_ies *ies;
2a519311
JB		 7682 void *hdr;
7683 struct nlattr *bss;
48ab905d
JB		 7684
7685 ASSERT_WDEV_LOCK(wdev);
2a519311 7686
15e47304 7687 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
2a519311
JB		 7688 NL80211_CMD_NEW_SCAN_RESULTS);
7689 if (!hdr)
7690 return -1;
7691
9720bb3a
JB		 7692 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
7693
97990a06
JB		 7694 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
7695 goto nla_put_failure;
7696 if (wdev->netdev &&
9360ffd1
DM		 7697 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
7698 goto nla_put_failure;
2dad624e
ND		 7699 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
7700 NL80211_ATTR_PAD))
97990a06 7701 goto nla_put_failure;
2a519311
JB		 7702
7703 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
7704 if (!bss)
7705 goto nla_put_failure;
9360ffd1 7706 if ((!is_zero_ether_addr(res->bssid) &&
9caf0364 7707 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9360ffd1 7708 goto nla_put_failure;
9caf0364
JB		 7709
7710 rcu_read_lock();
0e227084
JB		 7711 /* indicate whether we have probe response data or not */
7712 if (rcu_access_pointer(res->proberesp_ies) &&
7713 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
7714 goto fail_unlock_rcu;
7715
7716 /* this pointer prefers to be pointed to probe response data
7717 * but is always valid
7718 */
9caf0364 7719 ies = rcu_dereference(res->ies);
8cef2c9d 7720 if (ies) {
2dad624e
ND		 7721 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
7722 NL80211_BSS_PAD))
8cef2c9d 7723 goto fail_unlock_rcu;
8cef2c9d
JB		 7724 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
7725 ies->len, ies->data))
7726 goto fail_unlock_rcu;
9caf0364 7727 }
0e227084
JB		 7728
7729 /* and this pointer is always (unless driver didn't know) beacon data */
9caf0364 7730 ies = rcu_dereference(res->beacon_ies);
0e227084 7731 if (ies && ies->from_beacon) {
2dad624e
ND		 7732 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
7733 NL80211_BSS_PAD))
8cef2c9d
JB		 7734 goto fail_unlock_rcu;
7735 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
7736 ies->len, ies->data))
7737 goto fail_unlock_rcu;
9caf0364
JB		 7738 }
7739 rcu_read_unlock();
7740
9360ffd1
DM		 7741 if (res->beacon_interval &&
7742 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
7743 goto nla_put_failure;
7744 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
7745 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
dcd6eac1 7746 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9360ffd1
DM		 7747 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
7748 jiffies_to_msecs(jiffies - intbss->ts)))
7749 goto nla_put_failure;
2a519311 7750
1d76250b
AS		 7751 if (intbss->parent_tsf &&
7752 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
7753 intbss->parent_tsf, NL80211_BSS_PAD) ||
7754 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
7755 intbss->parent_bssid)))
7756 goto nla_put_failure;
7757
6e19bc4b 7758 if (intbss->ts_boottime &&
2dad624e
ND		 7759 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
7760 intbss->ts_boottime, NL80211_BSS_PAD))
6e19bc4b
DS		 7761 goto nla_put_failure;
7762
77965c97 7763 switch (rdev->wiphy.signal_type) {
2a519311 7764 case CFG80211_SIGNAL_TYPE_MBM:
9360ffd1
DM		 7765 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
7766 goto nla_put_failure;
2a519311
JB		 7767 break;
7768 case CFG80211_SIGNAL_TYPE_UNSPEC:
9360ffd1
DM		 7769 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
7770 goto nla_put_failure;
2a519311
JB		 7771 break;
7772 default:
7773 break;
7774 }
7775
48ab905d 7776 switch (wdev->iftype) {
074ac8df 7777 case NL80211_IFTYPE_P2P_CLIENT:
48ab905d 7778 case NL80211_IFTYPE_STATION:
9360ffd1
DM		 7779 if (intbss == wdev->current_bss &&
7780 nla_put_u32(msg, NL80211_BSS_STATUS,
7781 NL80211_BSS_STATUS_ASSOCIATED))
7782 goto nla_put_failure;
48ab905d
JB		 7783 break;
7784 case NL80211_IFTYPE_ADHOC:
9360ffd1
DM		 7785 if (intbss == wdev->current_bss &&
7786 nla_put_u32(msg, NL80211_BSS_STATUS,
7787 NL80211_BSS_STATUS_IBSS_JOINED))
7788 goto nla_put_failure;
48ab905d
JB		 7789 break;
7790 default:
7791 break;
7792 }
7793
2a519311
JB		 7794 nla_nest_end(msg, bss);
7795
053c095a
JB		 7796 genlmsg_end(msg, hdr);
7797 return 0;
2a519311 7798
8cef2c9d
JB		 7799 fail_unlock_rcu:
7800 rcu_read_unlock();
2a519311
JB		 7801 nla_put_failure:
7802 genlmsg_cancel(msg, hdr);
7803 return -EMSGSIZE;
7804}
7805
97990a06 7806static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
2a519311 7807{
48ab905d 7808 struct cfg80211_registered_device *rdev;
2a519311 7809 struct cfg80211_internal_bss *scan;
48ab905d 7810 struct wireless_dev *wdev;
97990a06 7811 int start = cb->args[2], idx = 0;
2a519311
JB		 7812 int err;
7813
ea90e0dc 7814 rtnl_lock();
97990a06 7815 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
ea90e0dc
JB		 7816 if (err) {
7817 rtnl_unlock();
67748893 7818 return err;
ea90e0dc 7819 }
2a519311 7820
48ab905d
JB		 7821 wdev_lock(wdev);
7822 spin_lock_bh(&rdev->bss_lock);
7823 cfg80211_bss_expire(rdev);
7824
9720bb3a
JB		 7825 cb->seq = rdev->bss_generation;
7826
48ab905d 7827 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 7828 if (++idx <= start)
7829 continue;
9720bb3a 7830 if (nl80211_send_bss(skb, cb,
2a519311 7831 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 7832 rdev, wdev, scan) < 0) {
2a519311 7833 idx--;
67748893 7834 break;
2a519311
JB		 7835 }
7836 }
7837
48ab905d
JB		 7838 spin_unlock_bh(&rdev->bss_lock);
7839 wdev_unlock(wdev);
2a519311 7840
97990a06 7841 cb->args[2] = idx;
ea90e0dc 7842 rtnl_unlock();
2a519311 7843
67748893 7844 return skb->len;
2a519311
JB		 7845}
7846
15e47304 7847static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
11f78ac3
JB		 7848 int flags, struct net_device *dev,
7849 bool allow_radio_stats,
7850 struct survey_info *survey)
61fa713c
HS		 7851{
7852 void *hdr;
7853 struct nlattr *infoattr;
7854
11f78ac3
JB		 7855 /* skip radio stats if userspace didn't request them */
7856 if (!survey->channel && !allow_radio_stats)
7857 return 0;
7858
15e47304 7859 hdr = nl80211hdr_put(msg, portid, seq, flags,
61fa713c
HS		 7860 NL80211_CMD_NEW_SURVEY_RESULTS);
7861 if (!hdr)
7862 return -ENOMEM;
7863
9360ffd1
DM		 7864 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
7865 goto nla_put_failure;
61fa713c
HS		 7866
7867 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
7868 if (!infoattr)
7869 goto nla_put_failure;
7870
11f78ac3
JB		 7871 if (survey->channel &&
7872 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9360ffd1
DM		 7873 survey->channel->center_freq))
7874 goto nla_put_failure;
7875
7876 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
7877 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
7878 goto nla_put_failure;
7879 if ((survey->filled & SURVEY_INFO_IN_USE) &&
7880 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
7881 goto nla_put_failure;
4ed20beb 7882 if ((survey->filled & SURVEY_INFO_TIME) &&
2dad624e
ND		 7883 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
7884 survey->time, NL80211_SURVEY_INFO_PAD))
9360ffd1 7885 goto nla_put_failure;
4ed20beb 7886 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
2dad624e
ND		 7887 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
7888 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7889 goto nla_put_failure;
4ed20beb 7890 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
2dad624e
ND		 7891 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
7892 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7893 goto nla_put_failure;
4ed20beb 7894 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
2dad624e
ND		 7895 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
7896 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7897 goto nla_put_failure;
4ed20beb 7898 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
2dad624e
ND		 7899 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
7900 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7901 goto nla_put_failure;
052536ab 7902 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
2dad624e
ND		 7903 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
7904 survey->time_scan, NL80211_SURVEY_INFO_PAD))
052536ab 7905 goto nla_put_failure;
61fa713c
HS		 7906
7907 nla_nest_end(msg, infoattr);
7908
053c095a
JB		 7909 genlmsg_end(msg, hdr);
7910 return 0;
61fa713c
HS		 7911
7912 nla_put_failure:
7913 genlmsg_cancel(msg, hdr);
7914 return -EMSGSIZE;
7915}
7916
11f78ac3 7917static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
61fa713c 7918{
c90c39da 7919 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
61fa713c 7920 struct survey_info survey;
1b8ec87a 7921 struct cfg80211_registered_device *rdev;
97990a06
JB		 7922 struct wireless_dev *wdev;
7923 int survey_idx = cb->args[2];
61fa713c 7924 int res;
11f78ac3 7925 bool radio_stats;
61fa713c 7926
ea90e0dc 7927 rtnl_lock();
1b8ec87a 7928 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893 7929 if (res)
ea90e0dc 7930 goto out_err;
61fa713c 7931
11f78ac3 7932 /* prepare_wdev_dump parsed the attributes */
c90c39da 7933 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
11f78ac3 7934
97990a06
JB		 7935 if (!wdev->netdev) {
7936 res = -EINVAL;
7937 goto out_err;
7938 }
7939
1b8ec87a 7940 if (!rdev->ops->dump_survey) {
61fa713c
HS		 7941 res = -EOPNOTSUPP;
7942 goto out_err;
7943 }
7944
7945 while (1) {
1b8ec87a 7946 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
61fa713c
HS		 7947 if (res == -ENOENT)
7948 break;
7949 if (res)
7950 goto out_err;
7951
11f78ac3
JB		 7952 /* don't send disabled channels, but do send non-channel data */
7953 if (survey.channel &&
7954 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
180cdc79
LR		 7955 survey_idx++;
7956 continue;
7957 }
7958
61fa713c 7959 if (nl80211_send_survey(skb,
15e47304 7960 NETLINK_CB(cb->skb).portid,
61fa713c 7961 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11f78ac3 7962 wdev->netdev, radio_stats, &survey) < 0)
61fa713c
HS		 7963 goto out;
7964 survey_idx++;
7965 }
7966
7967 out:
97990a06 7968 cb->args[2] = survey_idx;
61fa713c
HS		 7969 res = skb->len;
7970 out_err:
ea90e0dc 7971 rtnl_unlock();
61fa713c
HS		 7972 return res;
7973}
7974
b23aa676
SO		 7975static bool nl80211_valid_wpa_versions(u32 wpa_versions)
7976{
7977 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
7978 NL80211_WPA_VERSION_2));
7979}
7980
636a5d36
JM		 7981static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
7982{
4c476991
JB		 7983 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7984 struct net_device *dev = info->user_ptr[1];
19957bb3 7985 struct ieee80211_channel *chan;
11b6b5a4
JM		 7986 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
7987 int err, ssid_len, ie_len = 0, auth_data_len = 0;
19957bb3 7988 enum nl80211_auth_type auth_type;
fffd0934 7989 struct key_parse key;
d5cdfacb 7990 bool local_state_change;
636a5d36 7991
f4a11bb0
JB		 7992 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7993 return -EINVAL;
7994
7995 if (!info->attrs[NL80211_ATTR_MAC])
7996 return -EINVAL;
7997
1778092e
JM		 7998 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
7999 return -EINVAL;
8000
19957bb3
JB		 8001 if (!info->attrs[NL80211_ATTR_SSID])
8002 return -EINVAL;
8003
8004 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
8005 return -EINVAL;
8006
fffd0934
JB		 8007 err = nl80211_parse_key(info, &key);
8008 if (err)
8009 return err;
8010
8011 if (key.idx >= 0) {
e31b8213
JB		 8012 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
8013 return -EINVAL;
fffd0934
JB		 8014 if (!key.p.key || !key.p.key_len)
8015 return -EINVAL;
8016 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
8017 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
8018 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
8019 key.p.key_len != WLAN_KEY_LEN_WEP104))
8020 return -EINVAL;
b6b5555b 8021 if (key.idx > 3)
fffd0934
JB		 8022 return -EINVAL;
8023 } else {
8024 key.p.key_len = 0;
8025 key.p.key = NULL;
8026 }
8027
afea0b7a
JB		 8028 if (key.idx >= 0) {
8029 int i;
8030 bool ok = false;
7a087e74 8031
afea0b7a
JB		 8032 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
8033 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
8034 ok = true;
8035 break;
8036 }
8037 }
4c476991
JB		 8038 if (!ok)
8039 return -EINVAL;
afea0b7a
JB		 8040 }
8041
4c476991
JB		 8042 if (!rdev->ops->auth)
8043 return -EOPNOTSUPP;
636a5d36 8044
074ac8df 8045 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8046 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8047 return -EOPNOTSUPP;
eec60b03 8048
19957bb3 8049 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
664834de
JM		 8050 chan = nl80211_get_valid_chan(&rdev->wiphy,
8051 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8052 if (!chan)
4c476991 8053 return -EINVAL;
636a5d36 8054
19957bb3
JB		 8055 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8056 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8057
8058 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8059 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8060 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8061 }
8062
19957bb3 8063 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e 8064 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
4c476991 8065 return -EINVAL;
636a5d36 8066
63181060
JM		 8067 if ((auth_type == NL80211_AUTHTYPE_SAE ||
8068 auth_type == NL80211_AUTHTYPE_FILS_SK ||
8069 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
8070 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
11b6b5a4 8071 !info->attrs[NL80211_ATTR_AUTH_DATA])
e39e5b5e
JM		 8072 return -EINVAL;
8073
11b6b5a4 8074 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
63181060
JM		 8075 if (auth_type != NL80211_AUTHTYPE_SAE &&
8076 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8077 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8078 auth_type != NL80211_AUTHTYPE_FILS_PK)
e39e5b5e 8079 return -EINVAL;
11b6b5a4
JM		 8080 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8081 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
e39e5b5e 8082 /* need to include at least Auth Transaction and Status Code */
11b6b5a4 8083 if (auth_data_len < 4)
e39e5b5e
JM		 8084 return -EINVAL;
8085 }
8086
d5cdfacb
JM		 8087 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8088
95de817b
JB		 8089 /*
8090 * Since we no longer track auth state, ignore
8091 * requests to only change local state.
8092 */
8093 if (local_state_change)
8094 return 0;
8095
91bf9b26
JB		 8096 wdev_lock(dev->ieee80211_ptr);
8097 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8098 ssid, ssid_len, ie, ie_len,
8099 key.p.key, key.p.key_len, key.idx,
11b6b5a4 8100 auth_data, auth_data_len);
91bf9b26
JB		 8101 wdev_unlock(dev->ieee80211_ptr);
8102 return err;
636a5d36
JM		 8103}
8104
c0692b8f
JB		 8105static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8106 struct genl_info *info,
3dc27d25
JB		 8107 struct cfg80211_crypto_settings *settings,
8108 int cipher_limit)
b23aa676 8109{
c0b2bbd8
JB		 8110 memset(settings, 0, sizeof(*settings));
8111
b23aa676
SO		 8112 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
8113
c0692b8f
JB		 8114 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
8115 u16 proto;
7a087e74 8116
c0692b8f
JB		 8117 proto = nla_get_u16(
8118 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
8119 settings->control_port_ethertype = cpu_to_be16(proto);
8120 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
8121 proto != ETH_P_PAE)
8122 return -EINVAL;
8123 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
8124 settings->control_port_no_encrypt = true;
8125 } else
8126 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
8127
b23aa676
SO		 8128 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
8129 void *data;
8130 int len, i;
8131
8132 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8133 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8134 settings->n_ciphers_pairwise = len / sizeof(u32);
8135
8136 if (len % sizeof(u32))
8137 return -EINVAL;
8138
3dc27d25 8139 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 8140 return -EINVAL;
8141
8142 memcpy(settings->ciphers_pairwise, data, len);
8143
8144 for (i = 0; i < settings->n_ciphers_pairwise; i++)
38ba3c57
JM		 8145 if (!cfg80211_supported_cipher_suite(
8146 &rdev->wiphy,
b23aa676
SO		 8147 settings->ciphers_pairwise[i]))
8148 return -EINVAL;
8149 }
8150
8151 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
8152 settings->cipher_group =
8153 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
38ba3c57
JM		 8154 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
8155 settings->cipher_group))
b23aa676
SO		 8156 return -EINVAL;
8157 }
8158
8159 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
8160 settings->wpa_versions =
8161 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
8162 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
8163 return -EINVAL;
8164 }
8165
8166 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
8167 void *data;
6d30240e 8168 int len;
b23aa676
SO		 8169
8170 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
8171 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
8172 settings->n_akm_suites = len / sizeof(u32);
8173
8174 if (len % sizeof(u32))
8175 return -EINVAL;
8176
1b9ca027
JM		 8177 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
8178 return -EINVAL;
8179
b23aa676 8180 memcpy(settings->akm_suites, data, len);
b23aa676
SO		 8181 }
8182
91b5ab62
EP		 8183 if (info->attrs[NL80211_ATTR_PMK]) {
8184 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
8185 return -EINVAL;
8186 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8187 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
8188 return -EINVAL;
8189 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
8190 }
8191
b23aa676
SO		 8192 return 0;
8193}
8194
636a5d36
JM		 8195static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
8196{
4c476991
JB		 8197 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8198 struct net_device *dev = info->user_ptr[1];
f444de05 8199 struct ieee80211_channel *chan;
f62fab73
JB		 8200 struct cfg80211_assoc_request req = {};
8201 const u8 *bssid, *ssid;
8202 int err, ssid_len = 0;
636a5d36 8203
f4a11bb0
JB		 8204 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8205 return -EINVAL;
8206
8207 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 8208 !info->attrs[NL80211_ATTR_SSID] ||
8209 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 8210 return -EINVAL;
8211
4c476991
JB		 8212 if (!rdev->ops->assoc)
8213 return -EOPNOTSUPP;
636a5d36 8214
074ac8df 8215 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8216 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8217 return -EOPNOTSUPP;
eec60b03 8218
19957bb3 8219 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8220
664834de
JM		 8221 chan = nl80211_get_valid_chan(&rdev->wiphy,
8222 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8223 if (!chan)
4c476991 8224 return -EINVAL;
636a5d36 8225
19957bb3
JB		 8226 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8227 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8228
8229 if (info->attrs[NL80211_ATTR_IE]) {
f62fab73
JB		 8230 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8231 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8232 }
8233
dc6382ce 8234 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 8235 enum nl80211_mfp mfp =
dc6382ce 8236 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 8237 if (mfp == NL80211_MFP_REQUIRED)
f62fab73 8238 req.use_mfp = true;
4c476991
JB		 8239 else if (mfp != NL80211_MFP_NO)
8240 return -EINVAL;
dc6382ce
JM		 8241 }
8242
3e5d7649 8243 if (info->attrs[NL80211_ATTR_PREV_BSSID])
f62fab73 8244 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3e5d7649 8245
7e7c8926 8246 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
f62fab73 8247 req.flags |= ASSOC_REQ_DISABLE_HT;
7e7c8926
BG		 8248
8249 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
f62fab73
JB		 8250 memcpy(&req.ht_capa_mask,
8251 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8252 sizeof(req.ht_capa_mask));
7e7c8926
BG		 8253
8254 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
f62fab73 8255 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7e7c8926 8256 return -EINVAL;
f62fab73
JB		 8257 memcpy(&req.ht_capa,
8258 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8259 sizeof(req.ht_capa));
7e7c8926
BG		 8260 }
8261
ee2aca34 8262 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
f62fab73 8263 req.flags |= ASSOC_REQ_DISABLE_VHT;
ee2aca34
JB		 8264
8265 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
f62fab73
JB		 8266 memcpy(&req.vht_capa_mask,
8267 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8268 sizeof(req.vht_capa_mask));
ee2aca34
JB		 8269
8270 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
f62fab73 8271 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
ee2aca34 8272 return -EINVAL;
f62fab73
JB		 8273 memcpy(&req.vht_capa,
8274 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8275 sizeof(req.vht_capa));
ee2aca34
JB		 8276 }
8277
bab5ab7d 8278 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8279 if (!((rdev->wiphy.features &
8280 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8281 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8282 !wiphy_ext_feature_isset(&rdev->wiphy,
8283 NL80211_EXT_FEATURE_RRM))
bab5ab7d
AK		 8284 return -EINVAL;
8285 req.flags |= ASSOC_REQ_USE_RRM;
8286 }
8287
348bd456
JM		 8288 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
8289 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
8290 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
8291 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
8292 return -EINVAL;
8293 req.fils_nonces =
8294 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
8295 }
8296
f62fab73 8297 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
91bf9b26
JB		 8298 if (!err) {
8299 wdev_lock(dev->ieee80211_ptr);
bd2522b1 8300
f62fab73
JB		 8301 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
8302 ssid, ssid_len, &req);
bd2522b1
AZ		 8303
8304 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8305 dev->ieee80211_ptr->conn_owner_nlportid =
8306 info->snd_portid;
8307 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8308 bssid, ETH_ALEN);
8309 }
8310
91bf9b26
JB		 8311 wdev_unlock(dev->ieee80211_ptr);
8312 }
636a5d36 8313
636a5d36
JM		 8314 return err;
8315}
8316
8317static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
8318{
4c476991
JB		 8319 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8320 struct net_device *dev = info->user_ptr[1];
19957bb3 8321 const u8 *ie = NULL, *bssid;
91bf9b26 8322 int ie_len = 0, err;
19957bb3 8323 u16 reason_code;
d5cdfacb 8324 bool local_state_change;
636a5d36 8325
f4a11bb0
JB		 8326 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8327 return -EINVAL;
8328
8329 if (!info->attrs[NL80211_ATTR_MAC])
8330 return -EINVAL;
8331
8332 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8333 return -EINVAL;
8334
4c476991
JB		 8335 if (!rdev->ops->deauth)
8336 return -EOPNOTSUPP;
636a5d36 8337
074ac8df 8338 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8339 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8340 return -EOPNOTSUPP;
eec60b03 8341
19957bb3 8342 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8343
19957bb3
JB		 8344 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8345 if (reason_code == 0) {
f4a11bb0 8346 /* Reason Code 0 is reserved */
4c476991 8347 return -EINVAL;
255e737e 8348 }
636a5d36
JM		 8349
8350 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8351 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8352 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8353 }
8354
d5cdfacb
JM		 8355 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8356
91bf9b26
JB		 8357 wdev_lock(dev->ieee80211_ptr);
8358 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
8359 local_state_change);
8360 wdev_unlock(dev->ieee80211_ptr);
8361 return err;
636a5d36
JM		 8362}
8363
8364static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
8365{
4c476991
JB		 8366 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8367 struct net_device *dev = info->user_ptr[1];
19957bb3 8368 const u8 *ie = NULL, *bssid;
91bf9b26 8369 int ie_len = 0, err;
19957bb3 8370 u16 reason_code;
d5cdfacb 8371 bool local_state_change;
636a5d36 8372
f4a11bb0
JB		 8373 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8374 return -EINVAL;
8375
8376 if (!info->attrs[NL80211_ATTR_MAC])
8377 return -EINVAL;
8378
8379 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8380 return -EINVAL;
8381
4c476991
JB		 8382 if (!rdev->ops->disassoc)
8383 return -EOPNOTSUPP;
636a5d36 8384
074ac8df 8385 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8386 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8387 return -EOPNOTSUPP;
eec60b03 8388
19957bb3 8389 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8390
19957bb3
JB		 8391 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8392 if (reason_code == 0) {
f4a11bb0 8393 /* Reason Code 0 is reserved */
4c476991 8394 return -EINVAL;
255e737e 8395 }
636a5d36
JM		 8396
8397 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8398 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8399 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8400 }
8401
d5cdfacb
JM		 8402 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8403
91bf9b26
JB		 8404 wdev_lock(dev->ieee80211_ptr);
8405 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
8406 local_state_change);
8407 wdev_unlock(dev->ieee80211_ptr);
8408 return err;
636a5d36
JM		 8409}
8410
dd5b4cc7
FF		 8411static bool
8412nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
57fbcce3 8413 int mcast_rate[NUM_NL80211_BANDS],
dd5b4cc7
FF		 8414 int rateval)
8415{
8416 struct wiphy *wiphy = &rdev->wiphy;
8417 bool found = false;
8418 int band, i;
8419
57fbcce3 8420 for (band = 0; band < NUM_NL80211_BANDS; band++) {
dd5b4cc7
FF		 8421 struct ieee80211_supported_band *sband;
8422
8423 sband = wiphy->bands[band];
8424 if (!sband)
8425 continue;
8426
8427 for (i = 0; i < sband->n_bitrates; i++) {
8428 if (sband->bitrates[i].bitrate == rateval) {
8429 mcast_rate[band] = i + 1;
8430 found = true;
8431 break;
8432 }
8433 }
8434 }
8435
8436 return found;
8437}
8438
04a773ad
JB		 8439static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
8440{
4c476991
JB		 8441 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8442 struct net_device *dev = info->user_ptr[1];
04a773ad
JB		 8443 struct cfg80211_ibss_params ibss;
8444 struct wiphy *wiphy;
fffd0934 8445 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 8446 int err;
8447
8e30bc55
JB		 8448 memset(&ibss, 0, sizeof(ibss));
8449
04a773ad
JB		 8450 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8451 return -EINVAL;
8452
683b6d3b 8453 if (!info->attrs[NL80211_ATTR_SSID] ||
04a773ad
JB		 8454 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8455 return -EINVAL;
8456
8e30bc55
JB		 8457 ibss.beacon_interval = 100;
8458
12d20fc9 8459 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
8e30bc55
JB		 8460 ibss.beacon_interval =
8461 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 8462
0c317a02
PK		 8463 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
8464 ibss.beacon_interval);
12d20fc9
PK		 8465 if (err)
8466 return err;
8e30bc55 8467
4c476991
JB		 8468 if (!rdev->ops->join_ibss)
8469 return -EOPNOTSUPP;
04a773ad 8470
4c476991
JB		 8471 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8472 return -EOPNOTSUPP;
04a773ad 8473
79c97e97 8474 wiphy = &rdev->wiphy;
04a773ad 8475
39193498 8476 if (info->attrs[NL80211_ATTR_MAC]) {
04a773ad 8477 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
39193498
JB		 8478
8479 if (!is_valid_ether_addr(ibss.bssid))
8480 return -EINVAL;
8481 }
04a773ad
JB		 8482 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8483 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8484
8485 if (info->attrs[NL80211_ATTR_IE]) {
8486 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8487 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8488 }
8489
683b6d3b
JB		 8490 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
8491 if (err)
8492 return err;
04a773ad 8493
174e0cd2
IP		 8494 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
8495 NL80211_IFTYPE_ADHOC))
54858ee5
AS		 8496 return -EINVAL;
8497
2f301ab2 8498 switch (ibss.chandef.width) {
bf372645
SW		 8499 case NL80211_CHAN_WIDTH_5:
8500 case NL80211_CHAN_WIDTH_10:
2f301ab2
SW		 8501 case NL80211_CHAN_WIDTH_20_NOHT:
8502 break;
8503 case NL80211_CHAN_WIDTH_20:
8504 case NL80211_CHAN_WIDTH_40:
ffc11991
JD		 8505 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8506 return -EINVAL;
8507 break;
8508 case NL80211_CHAN_WIDTH_80:
8509 case NL80211_CHAN_WIDTH_80P80:
8510 case NL80211_CHAN_WIDTH_160:
8511 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8512 return -EINVAL;
8513 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8514 NL80211_EXT_FEATURE_VHT_IBSS))
8515 return -EINVAL;
8516 break;
2f301ab2 8517 default:
c04d6150 8518 return -EINVAL;
2f301ab2 8519 }
db9c64cf 8520
04a773ad 8521 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 8522 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
8523
fbd2c8dc
TP		 8524 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8525 u8 *rates =
8526 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8527 int n_rates =
8528 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8529 struct ieee80211_supported_band *sband =
683b6d3b 8530 wiphy->bands[ibss.chandef.chan->band];
fbd2c8dc 8531
34850ab2
JB		 8532 err = ieee80211_get_ratemask(sband, rates, n_rates,
8533 &ibss.basic_rates);
8534 if (err)
8535 return err;
fbd2c8dc 8536 }
dd5b4cc7 8537
803768f5
SW		 8538 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8539 memcpy(&ibss.ht_capa_mask,
8540 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8541 sizeof(ibss.ht_capa_mask));
8542
8543 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
8544 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8545 return -EINVAL;
8546 memcpy(&ibss.ht_capa,
8547 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8548 sizeof(ibss.ht_capa));
8549 }
8550
dd5b4cc7
FF		 8551 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8552 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
8553 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8554 return -EINVAL;
fbd2c8dc 8555
4c476991 8556 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
de7044ee
SM		 8557 bool no_ht = false;
8558
4c476991 8559 connkeys = nl80211_parse_connkeys(rdev,
de7044ee
SM		 8560 info->attrs[NL80211_ATTR_KEYS],
8561 &no_ht);
4c476991
JB		 8562 if (IS_ERR(connkeys))
8563 return PTR_ERR(connkeys);
de7044ee 8564
3d9d1d66
JB		 8565 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
8566 no_ht) {
5e950a78 8567 kzfree(connkeys);
de7044ee
SM		 8568 return -EINVAL;
8569 }
4c476991 8570 }
04a773ad 8571
267335d6
AQ		 8572 ibss.control_port =
8573 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
8574
5336fa88
SW		 8575 ibss.userspace_handles_dfs =
8576 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
8577
4c476991 8578 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
fffd0934 8579 if (err)
b47f610b 8580 kzfree(connkeys);
04a773ad
JB		 8581 return err;
8582}
8583
8584static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
8585{
4c476991
JB		 8586 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8587 struct net_device *dev = info->user_ptr[1];
04a773ad 8588
4c476991
JB		 8589 if (!rdev->ops->leave_ibss)
8590 return -EOPNOTSUPP;
04a773ad 8591
4c476991
JB		 8592 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8593 return -EOPNOTSUPP;
04a773ad 8594
4c476991 8595 return cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 8596}
8597
f4e583c8
AQ		 8598static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
8599{
8600 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8601 struct net_device *dev = info->user_ptr[1];
57fbcce3 8602 int mcast_rate[NUM_NL80211_BANDS];
f4e583c8
AQ		 8603 u32 nla_rate;
8604 int err;
8605
8606 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
876dc930
BVB		 8607 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
8608 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
f4e583c8
AQ		 8609 return -EOPNOTSUPP;
8610
8611 if (!rdev->ops->set_mcast_rate)
8612 return -EOPNOTSUPP;
8613
8614 memset(mcast_rate, 0, sizeof(mcast_rate));
8615
8616 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
8617 return -EINVAL;
8618
8619 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
8620 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
8621 return -EINVAL;
8622
a1056b1b 8623 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
f4e583c8
AQ		 8624
8625 return err;
8626}
8627
ad7e718c
JB		 8628static struct sk_buff *
8629__cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
6c09e791
AK		 8630 struct wireless_dev *wdev, int approxlen,
8631 u32 portid, u32 seq, enum nl80211_commands cmd,
567ffc35
JB		 8632 enum nl80211_attrs attr,
8633 const struct nl80211_vendor_cmd_info *info,
8634 gfp_t gfp)
ad7e718c
JB		 8635{
8636 struct sk_buff *skb;
8637 void *hdr;
8638 struct nlattr *data;
8639
8640 skb = nlmsg_new(approxlen + 100, gfp);
8641 if (!skb)
8642 return NULL;
8643
8644 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
8645 if (!hdr) {
8646 kfree_skb(skb);
8647 return NULL;
8648 }
8649
8650 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
8651 goto nla_put_failure;
567ffc35
JB		 8652
8653 if (info) {
8654 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
8655 info->vendor_id))
8656 goto nla_put_failure;
8657 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
8658 info->subcmd))
8659 goto nla_put_failure;
8660 }
8661
6c09e791 8662 if (wdev) {
2dad624e
ND		 8663 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
8664 wdev_id(wdev), NL80211_ATTR_PAD))
6c09e791
AK		 8665 goto nla_put_failure;
8666 if (wdev->netdev &&
8667 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
8668 wdev->netdev->ifindex))
8669 goto nla_put_failure;
8670 }
8671
ad7e718c 8672 data = nla_nest_start(skb, attr);
76e1fb4b
JB		 8673 if (!data)
8674 goto nla_put_failure;
ad7e718c
JB		 8675
8676 ((void **)skb->cb)[0] = rdev;
8677 ((void **)skb->cb)[1] = hdr;
8678 ((void **)skb->cb)[2] = data;
8679
8680 return skb;
8681
8682 nla_put_failure:
8683 kfree_skb(skb);
8684 return NULL;
8685}
f4e583c8 8686
e03ad6ea 8687struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
6c09e791 8688 struct wireless_dev *wdev,
e03ad6ea
JB		 8689 enum nl80211_commands cmd,
8690 enum nl80211_attrs attr,
8691 int vendor_event_idx,
8692 int approxlen, gfp_t gfp)
8693{
f26cbf40 8694 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
e03ad6ea
JB		 8695 const struct nl80211_vendor_cmd_info *info;
8696
8697 switch (cmd) {
8698 case NL80211_CMD_TESTMODE:
8699 if (WARN_ON(vendor_event_idx != -1))
8700 return NULL;
8701 info = NULL;
8702 break;
8703 case NL80211_CMD_VENDOR:
8704 if (WARN_ON(vendor_event_idx < 0 ||
8705 vendor_event_idx >= wiphy->n_vendor_events))
8706 return NULL;
8707 info = &wiphy->vendor_events[vendor_event_idx];
8708 break;
8709 default:
8710 WARN_ON(1);
8711 return NULL;
8712 }
8713
6c09e791 8714 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, 0, 0,
e03ad6ea
JB		 8715 cmd, attr, info, gfp);
8716}
8717EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
8718
8719void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
8720{
8721 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
8722 void *hdr = ((void **)skb->cb)[1];
8723 struct nlattr *data = ((void **)skb->cb)[2];
8724 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
8725
bd8c78e7
JB		 8726 /* clear CB data for netlink core to own from now on */
8727 memset(skb->cb, 0, sizeof(skb->cb));
8728
e03ad6ea
JB		 8729 nla_nest_end(skb, data);
8730 genlmsg_end(skb, hdr);
8731
8732 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
8733 mcgrp = NL80211_MCGRP_VENDOR;
8734
8735 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
8736 mcgrp, gfp);
8737}
8738EXPORT_SYMBOL(__cfg80211_send_event_skb);
8739
aff89a9b 8740#ifdef CONFIG_NL80211_TESTMODE
aff89a9b
JB		 8741static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
8742{
4c476991 8743 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fc73f11f
DS		 8744 struct wireless_dev *wdev =
8745 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
aff89a9b
JB		 8746 int err;
8747
fc73f11f
DS		 8748 if (!rdev->ops->testmode_cmd)
8749 return -EOPNOTSUPP;
8750
8751 if (IS_ERR(wdev)) {
8752 err = PTR_ERR(wdev);
8753 if (err != -EINVAL)
8754 return err;
8755 wdev = NULL;
8756 } else if (wdev->wiphy != &rdev->wiphy) {
8757 return -EINVAL;
8758 }
8759
aff89a9b
JB		 8760 if (!info->attrs[NL80211_ATTR_TESTDATA])
8761 return -EINVAL;
8762
ad7e718c 8763 rdev->cur_cmd_info = info;
fc73f11f 8764 err = rdev_testmode_cmd(rdev, wdev,
aff89a9b
JB		 8765 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
8766 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
ad7e718c 8767 rdev->cur_cmd_info = NULL;
aff89a9b 8768
aff89a9b
JB		 8769 return err;
8770}
8771
71063f0e
WYG		 8772static int nl80211_testmode_dump(struct sk_buff *skb,
8773 struct netlink_callback *cb)
8774{
00918d33 8775 struct cfg80211_registered_device *rdev;
71063f0e
WYG		 8776 int err;
8777 long phy_idx;
8778 void *data = NULL;
8779 int data_len = 0;
8780
5fe231e8
JB		 8781 rtnl_lock();
8782
71063f0e
WYG		 8783 if (cb->args[0]) {
8784 /*
8785 * 0 is a valid index, but not valid for args[0],
8786 * so we need to offset by 1.
8787 */
8788 phy_idx = cb->args[0] - 1;
a4956dca
LC		 8789
8790 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
8791 if (!rdev) {
8792 err = -ENOENT;
8793 goto out_err;
8794 }
71063f0e 8795 } else {
c90c39da
JB		 8796 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
8797
71063f0e 8798 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
fceb6435
JB		 8799 attrbuf, nl80211_fam.maxattr,
8800 nl80211_policy, NULL);
71063f0e 8801 if (err)
5fe231e8 8802 goto out_err;
00918d33 8803
c90c39da 8804 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
2bd7e35d 8805 if (IS_ERR(rdev)) {
5fe231e8
JB		 8806 err = PTR_ERR(rdev);
8807 goto out_err;
00918d33 8808 }
2bd7e35d 8809 phy_idx = rdev->wiphy_idx;
2bd7e35d 8810
c90c39da
JB		 8811 if (attrbuf[NL80211_ATTR_TESTDATA])
8812 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
71063f0e
WYG		 8813 }
8814
8815 if (cb->args[1]) {
8816 data = nla_data((void *)cb->args[1]);
8817 data_len = nla_len((void *)cb->args[1]);
8818 }
8819
00918d33 8820 if (!rdev->ops->testmode_dump) {
71063f0e
WYG		 8821 err = -EOPNOTSUPP;
8822 goto out_err;
8823 }
8824
8825 while (1) {
15e47304 8826 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
71063f0e
WYG		 8827 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8828 NL80211_CMD_TESTMODE);
8829 struct nlattr *tmdata;
8830
cb35fba3
DC		 8831 if (!hdr)
8832 break;
8833
9360ffd1 8834 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
71063f0e
WYG		 8835 genlmsg_cancel(skb, hdr);
8836 break;
8837 }
8838
8839 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
8840 if (!tmdata) {
8841 genlmsg_cancel(skb, hdr);
8842 break;
8843 }
e35e4d28 8844 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
71063f0e
WYG		 8845 nla_nest_end(skb, tmdata);
8846
8847 if (err == -ENOBUFS || err == -ENOENT) {
8848 genlmsg_cancel(skb, hdr);
8849 break;
8850 } else if (err) {
8851 genlmsg_cancel(skb, hdr);
8852 goto out_err;
8853 }
8854
8855 genlmsg_end(skb, hdr);
8856 }
8857
8858 err = skb->len;
8859 /* see above */
8860 cb->args[0] = phy_idx + 1;
8861 out_err:
5fe231e8 8862 rtnl_unlock();
71063f0e
WYG		 8863 return err;
8864}
aff89a9b
JB		 8865#endif
8866
b23aa676
SO		 8867static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
8868{
4c476991
JB		 8869 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8870 struct net_device *dev = info->user_ptr[1];
b23aa676
SO		 8871 struct cfg80211_connect_params connect;
8872 struct wiphy *wiphy;
fffd0934 8873 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 8874 int err;
8875
8876 memset(&connect, 0, sizeof(connect));
8877
8878 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8879 return -EINVAL;
8880
8881 if (!info->attrs[NL80211_ATTR_SSID] ||
8882 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8883 return -EINVAL;
8884
8885 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
8886 connect.auth_type =
8887 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 8888 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
8889 NL80211_CMD_CONNECT))
b23aa676
SO		 8890 return -EINVAL;
8891 } else
8892 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
8893
8894 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
8895
3a00df57
AS		 8896 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
8897 !wiphy_ext_feature_isset(&rdev->wiphy,
8898 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
8899 return -EINVAL;
8900 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
8901
c0692b8f 8902 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
3dc27d25 8903 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 8904 if (err)
8905 return err;
b23aa676 8906
074ac8df 8907 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8908 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8909 return -EOPNOTSUPP;
b23aa676 8910
79c97e97 8911 wiphy = &rdev->wiphy;
b23aa676 8912
4486ea98
BS		 8913 connect.bg_scan_period = -1;
8914 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
8915 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
8916 connect.bg_scan_period =
8917 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
8918 }
8919
b23aa676
SO		 8920 if (info->attrs[NL80211_ATTR_MAC])
8921 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1df4a510
JM		 8922 else if (info->attrs[NL80211_ATTR_MAC_HINT])
8923 connect.bssid_hint =
8924 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
b23aa676
SO		 8925 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8926 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8927
8928 if (info->attrs[NL80211_ATTR_IE]) {
8929 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8930 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8931 }
8932
cee00a95
JM		 8933 if (info->attrs[NL80211_ATTR_USE_MFP]) {
8934 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
8935 if (connect.mfp != NL80211_MFP_REQUIRED &&
8936 connect.mfp != NL80211_MFP_NO)
8937 return -EINVAL;
8938 } else {
8939 connect.mfp = NL80211_MFP_NO;
8940 }
8941
ba6fbacf
JM		 8942 if (info->attrs[NL80211_ATTR_PREV_BSSID])
8943 connect.prev_bssid =
8944 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
8945
b23aa676 8946 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
664834de
JM		 8947 connect.channel = nl80211_get_valid_chan(
8948 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8949 if (!connect.channel)
1df4a510
JM		 8950 return -EINVAL;
8951 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
664834de
JM		 8952 connect.channel_hint = nl80211_get_valid_chan(
8953 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
8954 if (!connect.channel_hint)
4c476991 8955 return -EINVAL;
b23aa676
SO		 8956 }
8957
fffd0934
JB		 8958 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
8959 connkeys = nl80211_parse_connkeys(rdev,
de7044ee 8960 info->attrs[NL80211_ATTR_KEYS], NULL);
4c476991
JB		 8961 if (IS_ERR(connkeys))
8962 return PTR_ERR(connkeys);
fffd0934
JB		 8963 }
8964
7e7c8926
BG		 8965 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
8966 connect.flags |= ASSOC_REQ_DISABLE_HT;
8967
8968 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8969 memcpy(&connect.ht_capa_mask,
8970 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8971 sizeof(connect.ht_capa_mask));
8972
8973 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
b4e4f47e 8974 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
b47f610b 8975 kzfree(connkeys);
7e7c8926 8976 return -EINVAL;
b4e4f47e 8977 }
7e7c8926
BG		 8978 memcpy(&connect.ht_capa,
8979 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8980 sizeof(connect.ht_capa));
8981 }
8982
ee2aca34
JB		 8983 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
8984 connect.flags |= ASSOC_REQ_DISABLE_VHT;
8985
8986 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
8987 memcpy(&connect.vht_capa_mask,
8988 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8989 sizeof(connect.vht_capa_mask));
8990
8991 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
8992 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
b47f610b 8993 kzfree(connkeys);
ee2aca34
JB		 8994 return -EINVAL;
8995 }
8996 memcpy(&connect.vht_capa,
8997 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8998 sizeof(connect.vht_capa));
8999 }
9000
bab5ab7d 9001 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 9002 if (!((rdev->wiphy.features &
9003 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9004 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9005 !wiphy_ext_feature_isset(&rdev->wiphy,
9006 NL80211_EXT_FEATURE_RRM)) {
707554b4 9007 kzfree(connkeys);
bab5ab7d 9008 return -EINVAL;
707554b4 9009 }
bab5ab7d
AK		 9010 connect.flags |= ASSOC_REQ_USE_RRM;
9011 }
9012
34d50519 9013 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
57fbcce3 9014 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
34d50519
LD		 9015 kzfree(connkeys);
9016 return -EOPNOTSUPP;
9017 }
9018
38de03d2
AS		 9019 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
9020 /* bss selection makes no sense if bssid is set */
9021 if (connect.bssid) {
9022 kzfree(connkeys);
9023 return -EINVAL;
9024 }
9025
9026 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
9027 wiphy, &connect.bss_select);
9028 if (err) {
9029 kzfree(connkeys);
9030 return err;
9031 }
9032 }
9033
a3caf744
VK		 9034 if (wiphy_ext_feature_isset(&rdev->wiphy,
9035 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
9036 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
9037 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
9038 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
9039 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9040 connect.fils_erp_username =
9041 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9042 connect.fils_erp_username_len =
9043 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9044 connect.fils_erp_realm =
9045 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9046 connect.fils_erp_realm_len =
9047 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9048 connect.fils_erp_next_seq_num =
9049 nla_get_u16(
9050 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9051 connect.fils_erp_rrk =
9052 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9053 connect.fils_erp_rrk_len =
9054 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9055 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9056 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9057 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9058 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9059 kzfree(connkeys);
9060 return -EINVAL;
9061 }
9062
83739b03 9063 wdev_lock(dev->ieee80211_ptr);
bd2522b1 9064
4ce2bd9c
JM		 9065 err = cfg80211_connect(rdev, dev, &connect, connkeys,
9066 connect.prev_bssid);
fffd0934 9067 if (err)
b47f610b 9068 kzfree(connkeys);
bd2522b1
AZ		 9069
9070 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9071 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9072 if (connect.bssid)
9073 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9074 connect.bssid, ETH_ALEN);
9075 else
9076 memset(dev->ieee80211_ptr->disconnect_bssid,
9077 0, ETH_ALEN);
9078 }
9079
9080 wdev_unlock(dev->ieee80211_ptr);
9081
b23aa676
SO		 9082 return err;
9083}
9084
088e8df8 9085static int nl80211_update_connect_params(struct sk_buff *skb,
9086 struct genl_info *info)
9087{
9088 struct cfg80211_connect_params connect = {};
9089 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9090 struct net_device *dev = info->user_ptr[1];
9091 struct wireless_dev *wdev = dev->ieee80211_ptr;
9092 u32 changed = 0;
9093 int ret;
9094
9095 if (!rdev->ops->update_connect_params)
9096 return -EOPNOTSUPP;
9097
9098 if (info->attrs[NL80211_ATTR_IE]) {
9099 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9100 return -EINVAL;
9101 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9102 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9103 changed |= UPDATE_ASSOC_IES;
9104 }
9105
9106 wdev_lock(dev->ieee80211_ptr);
9107 if (!wdev->current_bss)
9108 ret = -ENOLINK;
9109 else
9110 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
9111 wdev_unlock(dev->ieee80211_ptr);
9112
9113 return ret;
9114}
9115
b23aa676
SO		 9116static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
9117{
4c476991
JB		 9118 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9119 struct net_device *dev = info->user_ptr[1];
b23aa676 9120 u16 reason;
83739b03 9121 int ret;
b23aa676
SO		 9122
9123 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9124 reason = WLAN_REASON_DEAUTH_LEAVING;
9125 else
9126 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9127
9128 if (reason == 0)
9129 return -EINVAL;
9130
074ac8df 9131 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9132 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9133 return -EOPNOTSUPP;
b23aa676 9134
83739b03
JB		 9135 wdev_lock(dev->ieee80211_ptr);
9136 ret = cfg80211_disconnect(rdev, dev, reason, true);
9137 wdev_unlock(dev->ieee80211_ptr);
9138 return ret;
b23aa676
SO		 9139}
9140
463d0183
JB		 9141static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
9142{
4c476991 9143 struct cfg80211_registered_device *rdev = info->user_ptr[0];
463d0183
JB		 9144 struct net *net;
9145 int err;
463d0183 9146
4b681c82
VK		 9147 if (info->attrs[NL80211_ATTR_PID]) {
9148 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
9149
9150 net = get_net_ns_by_pid(pid);
9151 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
9152 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
463d0183 9153
4b681c82
VK		 9154 net = get_net_ns_by_fd(fd);
9155 } else {
9156 return -EINVAL;
9157 }
463d0183 9158
4c476991
JB		 9159 if (IS_ERR(net))
9160 return PTR_ERR(net);
463d0183
JB		 9161
9162 err = 0;
9163
9164 /* check if anything to do */
4c476991
JB		 9165 if (!net_eq(wiphy_net(&rdev->wiphy), net))
9166 err = cfg80211_switch_netns(rdev, net);
463d0183 9167
463d0183 9168 put_net(net);
463d0183
JB		 9169 return err;
9170}
9171
67fbb16b
SO		 9172static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
9173{
4c476991 9174 struct cfg80211_registered_device *rdev = info->user_ptr[0];
67fbb16b
SO		 9175 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
9176 struct cfg80211_pmksa *pmksa) = NULL;
4c476991 9177 struct net_device *dev = info->user_ptr[1];
67fbb16b
SO		 9178 struct cfg80211_pmksa pmksa;
9179
9180 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
9181
67fbb16b
SO		 9182 if (!info->attrs[NL80211_ATTR_PMKID])
9183 return -EINVAL;
9184
67fbb16b 9185 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
a3caf744
VK		 9186
9187 if (info->attrs[NL80211_ATTR_MAC]) {
9188 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9189 } else if (info->attrs[NL80211_ATTR_SSID] &&
9190 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
9191 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
9192 info->attrs[NL80211_ATTR_PMK])) {
9193 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9194 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9195 pmksa.cache_id =
9196 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
9197 } else {
9198 return -EINVAL;
9199 }
9200 if (info->attrs[NL80211_ATTR_PMK]) {
9201 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9202 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
9203 }
67fbb16b 9204
074ac8df 9205 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9206 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9207 return -EOPNOTSUPP;
67fbb16b
SO		 9208
9209 switch (info->genlhdr->cmd) {
9210 case NL80211_CMD_SET_PMKSA:
9211 rdev_ops = rdev->ops->set_pmksa;
9212 break;
9213 case NL80211_CMD_DEL_PMKSA:
9214 rdev_ops = rdev->ops->del_pmksa;
9215 break;
9216 default:
9217 WARN_ON(1);
9218 break;
9219 }
9220
4c476991
JB		 9221 if (!rdev_ops)
9222 return -EOPNOTSUPP;
67fbb16b 9223
4c476991 9224 return rdev_ops(&rdev->wiphy, dev, &pmksa);
67fbb16b
SO		 9225}
9226
9227static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
9228{
4c476991
JB		 9229 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9230 struct net_device *dev = info->user_ptr[1];
67fbb16b 9231
074ac8df 9232 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9233 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9234 return -EOPNOTSUPP;
67fbb16b 9235
4c476991
JB		 9236 if (!rdev->ops->flush_pmksa)
9237 return -EOPNOTSUPP;
67fbb16b 9238
e35e4d28 9239 return rdev_flush_pmksa(rdev, dev);
67fbb16b
SO		 9240}
9241
109086ce
AN		 9242static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
9243{
9244 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9245 struct net_device *dev = info->user_ptr[1];
9246 u8 action_code, dialog_token;
df942e7b 9247 u32 peer_capability = 0;
109086ce
AN		 9248 u16 status_code;
9249 u8 *peer;
31fa97c5 9250 bool initiator;
109086ce
AN		 9251
9252 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9253 !rdev->ops->tdls_mgmt)
9254 return -EOPNOTSUPP;
9255
9256 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
9257 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
9258 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
9259 !info->attrs[NL80211_ATTR_IE] ||
9260 !info->attrs[NL80211_ATTR_MAC])
9261 return -EINVAL;
9262
9263 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9264 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
9265 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
9266 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
31fa97c5 9267 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
df942e7b
SDU		 9268 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
9269 peer_capability =
9270 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
109086ce 9271
e35e4d28 9272 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
df942e7b 9273 dialog_token, status_code, peer_capability,
31fa97c5 9274 initiator,
e35e4d28
HG		 9275 nla_data(info->attrs[NL80211_ATTR_IE]),
9276 nla_len(info->attrs[NL80211_ATTR_IE]));
109086ce
AN		 9277}
9278
9279static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
9280{
9281 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9282 struct net_device *dev = info->user_ptr[1];
9283 enum nl80211_tdls_operation operation;
9284 u8 *peer;
9285
9286 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9287 !rdev->ops->tdls_oper)
9288 return -EOPNOTSUPP;
9289
9290 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
9291 !info->attrs[NL80211_ATTR_MAC])
9292 return -EINVAL;
9293
9294 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
9295 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9296
e35e4d28 9297 return rdev_tdls_oper(rdev, dev, peer, operation);
109086ce
AN		 9298}
9299
9588bbd5
JM		 9300static int nl80211_remain_on_channel(struct sk_buff *skb,
9301 struct genl_info *info)
9302{
4c476991 9303 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9304 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9305 struct cfg80211_chan_def chandef;
34373d12 9306 const struct cfg80211_chan_def *compat_chandef;
9588bbd5
JM		 9307 struct sk_buff *msg;
9308 void *hdr;
9309 u64 cookie;
683b6d3b 9310 u32 duration;
9588bbd5
JM		 9311 int err;
9312
9313 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9314 !info->attrs[NL80211_ATTR_DURATION])
9315 return -EINVAL;
9316
9317 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
9318
ebf348fc
JB		 9319 if (!rdev->ops->remain_on_channel ||
9320 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
9321 return -EOPNOTSUPP;
9322
9588bbd5 9323 /*
ebf348fc
JB		 9324 * We should be on that channel for at least a minimum amount of
9325 * time (10ms) but no longer than the driver supports.
9588bbd5 9326 */
ebf348fc 9327 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
a293911d 9328 duration > rdev->wiphy.max_remain_on_channel_duration)
9588bbd5
JM		 9329 return -EINVAL;
9330
683b6d3b
JB		 9331 err = nl80211_parse_chandef(rdev, info, &chandef);
9332 if (err)
9333 return err;
9588bbd5 9334
34373d12
VT		 9335 wdev_lock(wdev);
9336 if (!cfg80211_off_channel_oper_allowed(wdev) &&
9337 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
9338 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
9339 &chandef);
9340 if (compat_chandef != &chandef) {
9341 wdev_unlock(wdev);
9342 return -EBUSY;
9343 }
9344 }
9345 wdev_unlock(wdev);
9346
9588bbd5 9347 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9348 if (!msg)
9349 return -ENOMEM;
9588bbd5 9350
15e47304 9351 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9588bbd5 9352 NL80211_CMD_REMAIN_ON_CHANNEL);
cb35fba3
DC		 9353 if (!hdr) {
9354 err = -ENOBUFS;
9588bbd5
JM		 9355 goto free_msg;
9356 }
9357
683b6d3b
JB		 9358 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
9359 duration, &cookie);
9588bbd5
JM		 9360
9361 if (err)
9362 goto free_msg;
9363
2dad624e
ND		 9364 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9365 NL80211_ATTR_PAD))
9360ffd1 9366 goto nla_put_failure;
9588bbd5
JM		 9367
9368 genlmsg_end(msg, hdr);
4c476991
JB		 9369
9370 return genlmsg_reply(msg, info);
9588bbd5
JM		 9371
9372 nla_put_failure:
9373 err = -ENOBUFS;
9374 free_msg:
9375 nlmsg_free(msg);
9588bbd5
JM		 9376 return err;
9377}
9378
9379static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
9380 struct genl_info *info)
9381{
4c476991 9382 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9383 struct wireless_dev *wdev = info->user_ptr[1];
9588bbd5 9384 u64 cookie;
9588bbd5
JM		 9385
9386 if (!info->attrs[NL80211_ATTR_COOKIE])
9387 return -EINVAL;
9388
4c476991
JB		 9389 if (!rdev->ops->cancel_remain_on_channel)
9390 return -EOPNOTSUPP;
9588bbd5 9391
9588bbd5
JM		 9392 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9393
e35e4d28 9394 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
9588bbd5
JM		 9395}
9396
13ae75b1
JM		 9397static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
9398 struct genl_info *info)
9399{
13ae75b1 9400 struct cfg80211_bitrate_mask mask;
a7c7fbff 9401 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9402 struct net_device *dev = info->user_ptr[1];
a7c7fbff 9403 int err;
13ae75b1 9404
4c476991
JB		 9405 if (!rdev->ops->set_bitrate_mask)
9406 return -EOPNOTSUPP;
13ae75b1 9407
a7c7fbff
PK		 9408 err = nl80211_parse_tx_bitrate_mask(info, &mask);
9409 if (err)
9410 return err;
13ae75b1 9411
e35e4d28 9412 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
13ae75b1
JM		 9413}
9414
2e161f78 9415static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9416{
4c476991 9417 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9418 struct wireless_dev *wdev = info->user_ptr[1];
2e161f78 9419 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
026331c4
JM		 9420
9421 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
9422 return -EINVAL;
9423
2e161f78
JB		 9424 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
9425 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
026331c4 9426
71bbc994
JB		 9427 switch (wdev->iftype) {
9428 case NL80211_IFTYPE_STATION:
9429 case NL80211_IFTYPE_ADHOC:
9430 case NL80211_IFTYPE_P2P_CLIENT:
9431 case NL80211_IFTYPE_AP:
9432 case NL80211_IFTYPE_AP_VLAN:
9433 case NL80211_IFTYPE_MESH_POINT:
9434 case NL80211_IFTYPE_P2P_GO:
98104fde 9435 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9436 break;
cb3b7d87 9437 case NL80211_IFTYPE_NAN:
71bbc994 9438 default:
4c476991 9439 return -EOPNOTSUPP;
71bbc994 9440 }
026331c4
JM		 9441
9442 /* not much point in registering if we can't reply */
4c476991
JB		 9443 if (!rdev->ops->mgmt_tx)
9444 return -EOPNOTSUPP;
026331c4 9445
15e47304 9446 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
026331c4
JM		 9447 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
9448 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
026331c4
JM		 9449}
9450
2e161f78 9451static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9452{
4c476991 9453 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9454 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9455 struct cfg80211_chan_def chandef;
026331c4 9456 int err;
d64d373f 9457 void *hdr = NULL;
026331c4 9458 u64 cookie;
e247bd90 9459 struct sk_buff *msg = NULL;
b176e629
AO		 9460 struct cfg80211_mgmt_tx_params params = {
9461 .dont_wait_for_ack =
9462 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
9463 };
026331c4 9464
683b6d3b 9465 if (!info->attrs[NL80211_ATTR_FRAME])
026331c4
JM		 9466 return -EINVAL;
9467
4c476991
JB		 9468 if (!rdev->ops->mgmt_tx)
9469 return -EOPNOTSUPP;
026331c4 9470
71bbc994 9471 switch (wdev->iftype) {
ea141b75
AQ		 9472 case NL80211_IFTYPE_P2P_DEVICE:
9473 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9474 return -EINVAL;
71bbc994
JB		 9475 case NL80211_IFTYPE_STATION:
9476 case NL80211_IFTYPE_ADHOC:
9477 case NL80211_IFTYPE_P2P_CLIENT:
9478 case NL80211_IFTYPE_AP:
9479 case NL80211_IFTYPE_AP_VLAN:
9480 case NL80211_IFTYPE_MESH_POINT:
9481 case NL80211_IFTYPE_P2P_GO:
9482 break;
cb3b7d87 9483 case NL80211_IFTYPE_NAN:
71bbc994 9484 default:
4c476991 9485 return -EOPNOTSUPP;
71bbc994 9486 }
026331c4 9487
f7ca38df 9488 if (info->attrs[NL80211_ATTR_DURATION]) {
7c4ef712 9489 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
f7ca38df 9490 return -EINVAL;
b176e629 9491 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
ebf348fc
JB		 9492
9493 /*
9494 * We should wait on the channel for at least a minimum amount
9495 * of time (10ms) but no longer than the driver supports.
9496 */
b176e629
AO		 9497 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
9498 params.wait > rdev->wiphy.max_remain_on_channel_duration)
ebf348fc 9499 return -EINVAL;
f7ca38df
JB		 9500 }
9501
b176e629 9502 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
f7ca38df 9503
b176e629 9504 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7c4ef712
JB		 9505 return -EINVAL;
9506
b176e629 9507 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3 9508
ea141b75
AQ		 9509 /* get the channel if any has been specified, otherwise pass NULL to
9510 * the driver. The latter will use the current one
9511 */
9512 chandef.chan = NULL;
9513 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9514 err = nl80211_parse_chandef(rdev, info, &chandef);
9515 if (err)
9516 return err;
9517 }
9518
b176e629 9519 if (!chandef.chan && params.offchan)
ea141b75 9520 return -EINVAL;
026331c4 9521
34373d12
VT		 9522 wdev_lock(wdev);
9523 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
9524 wdev_unlock(wdev);
9525 return -EBUSY;
9526 }
9527 wdev_unlock(wdev);
9528
34d22ce2
AO		 9529 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
9530 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
9531
9532 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
9533 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9534 int i;
9535
9536 if (len % sizeof(u16))
9537 return -EINVAL;
9538
9539 params.n_csa_offsets = len / sizeof(u16);
9540 params.csa_offsets =
9541 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9542
9543 /* check that all the offsets fit the frame */
9544 for (i = 0; i < params.n_csa_offsets; i++) {
9545 if (params.csa_offsets[i] >= params.len)
9546 return -EINVAL;
9547 }
9548 }
9549
b176e629 9550 if (!params.dont_wait_for_ack) {
e247bd90
JB		 9551 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9552 if (!msg)
9553 return -ENOMEM;
026331c4 9554
15e47304 9555 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
e247bd90 9556 NL80211_CMD_FRAME);
cb35fba3
DC		 9557 if (!hdr) {
9558 err = -ENOBUFS;
e247bd90
JB		 9559 goto free_msg;
9560 }
026331c4 9561 }
e247bd90 9562
b176e629
AO		 9563 params.chan = chandef.chan;
9564 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
026331c4
JM		 9565 if (err)
9566 goto free_msg;
9567
e247bd90 9568 if (msg) {
2dad624e
ND		 9569 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9570 NL80211_ATTR_PAD))
9360ffd1 9571 goto nla_put_failure;
026331c4 9572
e247bd90
JB		 9573 genlmsg_end(msg, hdr);
9574 return genlmsg_reply(msg, info);
9575 }
9576
9577 return 0;
026331c4
JM		 9578
9579 nla_put_failure:
9580 err = -ENOBUFS;
9581 free_msg:
9582 nlmsg_free(msg);
026331c4
JM		 9583 return err;
9584}
9585
f7ca38df
JB		 9586static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
9587{
9588 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9589 struct wireless_dev *wdev = info->user_ptr[1];
f7ca38df
JB		 9590 u64 cookie;
9591
9592 if (!info->attrs[NL80211_ATTR_COOKIE])
9593 return -EINVAL;
9594
9595 if (!rdev->ops->mgmt_tx_cancel_wait)
9596 return -EOPNOTSUPP;
9597
71bbc994
JB		 9598 switch (wdev->iftype) {
9599 case NL80211_IFTYPE_STATION:
9600 case NL80211_IFTYPE_ADHOC:
9601 case NL80211_IFTYPE_P2P_CLIENT:
9602 case NL80211_IFTYPE_AP:
9603 case NL80211_IFTYPE_AP_VLAN:
9604 case NL80211_IFTYPE_P2P_GO:
98104fde 9605 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9606 break;
cb3b7d87 9607 case NL80211_IFTYPE_NAN:
71bbc994 9608 default:
f7ca38df 9609 return -EOPNOTSUPP;
71bbc994 9610 }
f7ca38df
JB		 9611
9612 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9613
e35e4d28 9614 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
f7ca38df
JB		 9615}
9616
ffb9eb3d
KV		 9617static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
9618{
4c476991 9619 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d 9620 struct wireless_dev *wdev;
4c476991 9621 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9622 u8 ps_state;
9623 bool state;
9624 int err;
9625
4c476991
JB		 9626 if (!info->attrs[NL80211_ATTR_PS_STATE])
9627 return -EINVAL;
ffb9eb3d
KV		 9628
9629 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
9630
4c476991
JB		 9631 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
9632 return -EINVAL;
ffb9eb3d
KV		 9633
9634 wdev = dev->ieee80211_ptr;
9635
4c476991
JB		 9636 if (!rdev->ops->set_power_mgmt)
9637 return -EOPNOTSUPP;
ffb9eb3d
KV		 9638
9639 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
9640
9641 if (state == wdev->ps)
4c476991 9642 return 0;
ffb9eb3d 9643
e35e4d28 9644 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
4c476991
JB		 9645 if (!err)
9646 wdev->ps = state;
ffb9eb3d
KV		 9647 return err;
9648}
9649
9650static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
9651{
4c476991 9652 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d
KV		 9653 enum nl80211_ps_state ps_state;
9654 struct wireless_dev *wdev;
4c476991 9655 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9656 struct sk_buff *msg;
9657 void *hdr;
9658 int err;
9659
ffb9eb3d
KV		 9660 wdev = dev->ieee80211_ptr;
9661
4c476991
JB		 9662 if (!rdev->ops->set_power_mgmt)
9663 return -EOPNOTSUPP;
ffb9eb3d
KV		 9664
9665 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9666 if (!msg)
9667 return -ENOMEM;
ffb9eb3d 9668
15e47304 9669 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ffb9eb3d
KV		 9670 NL80211_CMD_GET_POWER_SAVE);
9671 if (!hdr) {
4c476991 9672 err = -ENOBUFS;
ffb9eb3d
KV		 9673 goto free_msg;
9674 }
9675
9676 if (wdev->ps)
9677 ps_state = NL80211_PS_ENABLED;
9678 else
9679 ps_state = NL80211_PS_DISABLED;
9680
9360ffd1
DM		 9681 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
9682 goto nla_put_failure;
ffb9eb3d
KV		 9683
9684 genlmsg_end(msg, hdr);
4c476991 9685 return genlmsg_reply(msg, info);
ffb9eb3d 9686
4c476991 9687 nla_put_failure:
ffb9eb3d 9688 err = -ENOBUFS;
4c476991 9689 free_msg:
ffb9eb3d 9690 nlmsg_free(msg);
ffb9eb3d
KV		 9691 return err;
9692}
9693
94e860f1
JB		 9694static const struct nla_policy
9695nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
4a4b8169 9696 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
d6dc1a38
JO		 9697 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
9698 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
84f10708
TP		 9699 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
9700 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
9701 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
bee427b8 9702 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
d6dc1a38
JO		 9703};
9704
84f10708 9705static int nl80211_set_cqm_txe(struct genl_info *info,
d9d8b019 9706 u32 rate, u32 pkts, u32 intvl)
84f10708
TP		 9707{
9708 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84f10708 9709 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9710 struct wireless_dev *wdev = dev->ieee80211_ptr;
84f10708 9711
d9d8b019 9712 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
84f10708
TP		 9713 return -EINVAL;
9714
84f10708
TP		 9715 if (!rdev->ops->set_cqm_txe_config)
9716 return -EOPNOTSUPP;
9717
9718 if (wdev->iftype != NL80211_IFTYPE_STATION &&
9719 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9720 return -EOPNOTSUPP;
9721
e35e4d28 9722 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
84f10708
TP		 9723}
9724
4a4b8169
AZ		 9725static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
9726 struct net_device *dev)
9727{
9728 struct wireless_dev *wdev = dev->ieee80211_ptr;
9729 s32 last, low, high;
9730 u32 hyst;
9731 int i, n;
9732 int err;
9733
9734 /* RSSI reporting disabled? */
9735 if (!wdev->cqm_config)
9736 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
9737
9738 /*
9739 * Obtain current RSSI value if possible, if not and no RSSI threshold
9740 * event has been received yet, we should receive an event after a
9741 * connection is established and enough beacons received to calculate
9742 * the average.
9743 */
9744 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
9745 rdev->ops->get_station) {
9746 struct station_info sinfo;
9747 u8 *mac_addr;
9748
9749 mac_addr = wdev->current_bss->pub.bssid;
9750
9751 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
9752 if (err)
9753 return err;
9754
9755 if (sinfo.filled & BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
9756 wdev->cqm_config->last_rssi_event_value =
9757 (s8) sinfo.rx_beacon_signal_avg;
9758 }
9759
9760 last = wdev->cqm_config->last_rssi_event_value;
9761 hyst = wdev->cqm_config->rssi_hyst;
9762 n = wdev->cqm_config->n_rssi_thresholds;
9763
9764 for (i = 0; i < n; i++)
9765 if (last < wdev->cqm_config->rssi_thresholds[i])
9766 break;
9767
9768 low = i > 0 ?
9769 (wdev->cqm_config->rssi_thresholds[i - 1] - hyst) : S32_MIN;
9770 high = i < n ?
9771 (wdev->cqm_config->rssi_thresholds[i] + hyst - 1) : S32_MAX;
9772
9773 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
9774}
9775
d6dc1a38 9776static int nl80211_set_cqm_rssi(struct genl_info *info,
4a4b8169
AZ		 9777 const s32 *thresholds, int n_thresholds,
9778 u32 hysteresis)
d6dc1a38 9779{
4c476991 9780 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9781 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9782 struct wireless_dev *wdev = dev->ieee80211_ptr;
4a4b8169
AZ		 9783 int i, err;
9784 s32 prev = S32_MIN;
d6dc1a38 9785
4a4b8169
AZ		 9786 /* Check all values negative and sorted */
9787 for (i = 0; i < n_thresholds; i++) {
9788 if (thresholds[i] > 0 || thresholds[i] <= prev)
9789 return -EINVAL;
d6dc1a38 9790
4a4b8169
AZ		 9791 prev = thresholds[i];
9792 }
d6dc1a38 9793
074ac8df 9794 if (wdev->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9795 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9796 return -EOPNOTSUPP;
d6dc1a38 9797
4a4b8169
AZ		 9798 wdev_lock(wdev);
9799 cfg80211_cqm_config_free(wdev);
9800 wdev_unlock(wdev);
9801
9802 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
9803 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
9804 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
9805
9806 return rdev_set_cqm_rssi_config(rdev, dev,
9807 thresholds[0], hysteresis);
9808 }
9809
9810 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9811 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
9812 return -EOPNOTSUPP;
9813
9814 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
9815 n_thresholds = 0;
9816
9817 wdev_lock(wdev);
9818 if (n_thresholds) {
9819 struct cfg80211_cqm_config *cqm_config;
9820
9821 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
9822 n_thresholds * sizeof(s32), GFP_KERNEL);
9823 if (!cqm_config) {
9824 err = -ENOMEM;
9825 goto unlock;
9826 }
9827
9828 cqm_config->rssi_hyst = hysteresis;
9829 cqm_config->n_rssi_thresholds = n_thresholds;
9830 memcpy(cqm_config->rssi_thresholds, thresholds,
9831 n_thresholds * sizeof(s32));
9832
9833 wdev->cqm_config = cqm_config;
9834 }
9835
9836 err = cfg80211_cqm_rssi_update(rdev, dev);
9837
9838unlock:
9839 wdev_unlock(wdev);
9840
9841 return err;
d6dc1a38
JO		 9842}
9843
9844static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
9845{
9846 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
9847 struct nlattr *cqm;
9848 int err;
9849
9850 cqm = info->attrs[NL80211_ATTR_CQM];
1da5fcc8
JB		 9851 if (!cqm)
9852 return -EINVAL;
d6dc1a38
JO		 9853
9854 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
fe52145f 9855 nl80211_attr_cqm_policy, info->extack);
d6dc1a38 9856 if (err)
1da5fcc8 9857 return err;
d6dc1a38
JO		 9858
9859 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
9860 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
4a4b8169
AZ		 9861 const s32 *thresholds =
9862 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
9863 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
1da5fcc8 9864 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
d6dc1a38 9865
4a4b8169
AZ		 9866 if (len % 4)
9867 return -EINVAL;
9868
9869 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
9870 hysteresis);
1da5fcc8
JB		 9871 }
9872
9873 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
9874 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
9875 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
9876 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
9877 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
9878 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
9879
9880 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
9881 }
9882
9883 return -EINVAL;
d6dc1a38
JO		 9884}
9885
6e0bd6c3
RL		 9886static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
9887{
9888 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9889 struct net_device *dev = info->user_ptr[1];
9890 struct ocb_setup setup = {};
9891 int err;
9892
9893 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9894 if (err)
9895 return err;
9896
9897 return cfg80211_join_ocb(rdev, dev, &setup);
9898}
9899
9900static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
9901{
9902 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9903 struct net_device *dev = info->user_ptr[1];
9904
9905 return cfg80211_leave_ocb(rdev, dev);
9906}
9907
29cbe68c
JB		 9908static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
9909{
9910 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9911 struct net_device *dev = info->user_ptr[1];
9912 struct mesh_config cfg;
c80d545d 9913 struct mesh_setup setup;
29cbe68c
JB		 9914 int err;
9915
9916 /* start with default */
9917 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
c80d545d 9918 memcpy(&setup, &default_mesh_setup, sizeof(setup));
29cbe68c 9919
24bdd9f4 9920 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
29cbe68c 9921 /* and parse parameters if given */
24bdd9f4 9922 err = nl80211_parse_mesh_config(info, &cfg, NULL);
29cbe68c
JB		 9923 if (err)
9924 return err;
9925 }
9926
9927 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
9928 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
9929 return -EINVAL;
9930
c80d545d
JC		 9931 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
9932 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
9933
4bb62344
CYY		 9934 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9935 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
9936 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9937 return -EINVAL;
9938
9bdbf04d
MP		 9939 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
9940 setup.beacon_interval =
9941 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 9942
0c317a02
PK		 9943 err = cfg80211_validate_beacon_int(rdev,
9944 NL80211_IFTYPE_MESH_POINT,
9945 setup.beacon_interval);
12d20fc9
PK		 9946 if (err)
9947 return err;
9bdbf04d
MP		 9948 }
9949
9950 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
9951 setup.dtim_period =
9952 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
9953 if (setup.dtim_period < 1 || setup.dtim_period > 100)
9954 return -EINVAL;
9955 }
9956
c80d545d
JC		 9957 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
9958 /* parse additional setup parameters if given */
9959 err = nl80211_parse_mesh_setup(info, &setup);
9960 if (err)
9961 return err;
9962 }
9963
d37bb18a
TP		 9964 if (setup.user_mpm)
9965 cfg.auto_open_plinks = false;
9966
cc1d2806 9967 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 9968 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9969 if (err)
9970 return err;
cc1d2806
JB		 9971 } else {
9972 /* cfg80211_join_mesh() will sort it out */
683b6d3b 9973 setup.chandef.chan = NULL;
cc1d2806
JB		 9974 }
9975
ffb3cf30
AN		 9976 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9977 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9978 int n_rates =
9979 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9980 struct ieee80211_supported_band *sband;
9981
9982 if (!setup.chandef.chan)
9983 return -EINVAL;
9984
9985 sband = rdev->wiphy.bands[setup.chandef.chan->band];
9986
9987 err = ieee80211_get_ratemask(sband, rates, n_rates,
9988 &setup.basic_rates);
9989 if (err)
9990 return err;
9991 }
9992
8564e382
JB		 9993 if (info->attrs[NL80211_ATTR_TX_RATES]) {
9994 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
9995 if (err)
9996 return err;
9997
9998 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
9999 &setup.beacon_rate);
10000 if (err)
10001 return err;
10002 }
10003
d37d49c2
BB		 10004 setup.userspace_handles_dfs =
10005 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
10006
c80d545d 10007 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
29cbe68c
JB		 10008}
10009
10010static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
10011{
10012 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10013 struct net_device *dev = info->user_ptr[1];
10014
10015 return cfg80211_leave_mesh(rdev, dev);
10016}
10017
dfb89c56 10018#ifdef CONFIG_PM
bb92d199
AK		 10019static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
10020 struct cfg80211_registered_device *rdev)
10021{
6abb9cb9 10022 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
bb92d199
AK		 10023 struct nlattr *nl_pats, *nl_pat;
10024 int i, pat_len;
10025
6abb9cb9 10026 if (!wowlan->n_patterns)
bb92d199
AK		 10027 return 0;
10028
10029 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
10030 if (!nl_pats)
10031 return -ENOBUFS;
10032
6abb9cb9 10033 for (i = 0; i < wowlan->n_patterns; i++) {
bb92d199
AK		 10034 nl_pat = nla_nest_start(msg, i + 1);
10035 if (!nl_pat)
10036 return -ENOBUFS;
6abb9cb9 10037 pat_len = wowlan->patterns[i].pattern_len;
50ac6607 10038 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
6abb9cb9 10039 wowlan->patterns[i].mask) ||
50ac6607
AK		 10040 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10041 wowlan->patterns[i].pattern) ||
10042 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
6abb9cb9 10043 wowlan->patterns[i].pkt_offset))
bb92d199
AK		 10044 return -ENOBUFS;
10045 nla_nest_end(msg, nl_pat);
10046 }
10047 nla_nest_end(msg, nl_pats);
10048
10049 return 0;
10050}
10051
2a0e047e
JB		 10052static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
10053 struct cfg80211_wowlan_tcp *tcp)
10054{
10055 struct nlattr *nl_tcp;
10056
10057 if (!tcp)
10058 return 0;
10059
10060 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
10061 if (!nl_tcp)
10062 return -ENOBUFS;
10063
930345ea
JB		 10064 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
10065 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
2a0e047e
JB		 10066 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
10067 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
10068 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
10069 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
10070 tcp->payload_len, tcp->payload) ||
10071 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
10072 tcp->data_interval) ||
10073 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
10074 tcp->wake_len, tcp->wake_data) ||
10075 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
10076 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
10077 return -ENOBUFS;
10078
10079 if (tcp->payload_seq.len &&
10080 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
10081 sizeof(tcp->payload_seq), &tcp->payload_seq))
10082 return -ENOBUFS;
10083
10084 if (tcp->payload_tok.len &&
10085 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
10086 sizeof(tcp->payload_tok) + tcp->tokens_size,
10087 &tcp->payload_tok))
10088 return -ENOBUFS;
10089
e248ad30
JB		 10090 nla_nest_end(msg, nl_tcp);
10091
2a0e047e
JB		 10092 return 0;
10093}
10094
75453ccb
LC		 10095static int nl80211_send_wowlan_nd(struct sk_buff *msg,
10096 struct cfg80211_sched_scan_request *req)
10097{
3b06d277 10098 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
75453ccb
LC		 10099 int i;
10100
10101 if (!req)
10102 return 0;
10103
10104 nd = nla_nest_start(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
10105 if (!nd)
10106 return -ENOBUFS;
10107
3b06d277
AS		 10108 if (req->n_scan_plans == 1 &&
10109 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
10110 req->scan_plans[0].interval * 1000))
75453ccb
LC		 10111 return -ENOBUFS;
10112
21fea567
LC		 10113 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
10114 return -ENOBUFS;
10115
bf95ecdb 10116 if (req->relative_rssi_set) {
10117 struct nl80211_bss_select_rssi_adjust rssi_adjust;
10118
10119 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
10120 req->relative_rssi))
10121 return -ENOBUFS;
10122
10123 rssi_adjust.band = req->rssi_adjust.band;
10124 rssi_adjust.delta = req->rssi_adjust.delta;
10125 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
10126 sizeof(rssi_adjust), &rssi_adjust))
10127 return -ENOBUFS;
10128 }
10129
75453ccb
LC		 10130 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10131 if (!freqs)
10132 return -ENOBUFS;
10133
53b18980
JB		 10134 for (i = 0; i < req->n_channels; i++) {
10135 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10136 return -ENOBUFS;
10137 }
75453ccb
LC		 10138
10139 nla_nest_end(msg, freqs);
10140
10141 if (req->n_match_sets) {
10142 matches = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
76e1fb4b
JB		 10143 if (!matches)
10144 return -ENOBUFS;
10145
75453ccb
LC		 10146 for (i = 0; i < req->n_match_sets; i++) {
10147 match = nla_nest_start(msg, i);
76e1fb4b
JB		 10148 if (!match)
10149 return -ENOBUFS;
10150
53b18980
JB		 10151 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
10152 req->match_sets[i].ssid.ssid_len,
10153 req->match_sets[i].ssid.ssid))
10154 return -ENOBUFS;
75453ccb
LC		 10155 nla_nest_end(msg, match);
10156 }
10157 nla_nest_end(msg, matches);
10158 }
10159
3b06d277
AS		 10160 scan_plans = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
10161 if (!scan_plans)
10162 return -ENOBUFS;
10163
10164 for (i = 0; i < req->n_scan_plans; i++) {
10165 scan_plan = nla_nest_start(msg, i + 1);
76e1fb4b
JB		 10166 if (!scan_plan)
10167 return -ENOBUFS;
10168
3b06d277
AS		 10169 if (!scan_plan ||
10170 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
10171 req->scan_plans[i].interval) ||
10172 (req->scan_plans[i].iterations &&
10173 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
10174 req->scan_plans[i].iterations)))
10175 return -ENOBUFS;
10176 nla_nest_end(msg, scan_plan);
10177 }
10178 nla_nest_end(msg, scan_plans);
10179
75453ccb
LC		 10180 nla_nest_end(msg, nd);
10181
10182 return 0;
10183}
10184
ff1b6e69
JB		 10185static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
10186{
10187 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10188 struct sk_buff *msg;
10189 void *hdr;
2a0e047e 10190 u32 size = NLMSG_DEFAULT_SIZE;
ff1b6e69 10191
964dc9e2 10192 if (!rdev->wiphy.wowlan)
ff1b6e69
JB		 10193 return -EOPNOTSUPP;
10194
6abb9cb9 10195 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
2a0e047e 10196 /* adjust size to have room for all the data */
6abb9cb9
JB		 10197 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
10198 rdev->wiphy.wowlan_config->tcp->payload_len +
10199 rdev->wiphy.wowlan_config->tcp->wake_len +
10200 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
2a0e047e
JB		 10201 }
10202
10203 msg = nlmsg_new(size, GFP_KERNEL);
ff1b6e69
JB		 10204 if (!msg)
10205 return -ENOMEM;
10206
15e47304 10207 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ff1b6e69
JB		 10208 NL80211_CMD_GET_WOWLAN);
10209 if (!hdr)
10210 goto nla_put_failure;
10211
6abb9cb9 10212 if (rdev->wiphy.wowlan_config) {
ff1b6e69
JB		 10213 struct nlattr *nl_wowlan;
10214
10215 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10216 if (!nl_wowlan)
10217 goto nla_put_failure;
10218
6abb9cb9 10219 if ((rdev->wiphy.wowlan_config->any &&
9360ffd1 10220 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6abb9cb9 10221 (rdev->wiphy.wowlan_config->disconnect &&
9360ffd1 10222 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6abb9cb9 10223 (rdev->wiphy.wowlan_config->magic_pkt &&
9360ffd1 10224 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6abb9cb9 10225 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
9360ffd1 10226 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6abb9cb9 10227 (rdev->wiphy.wowlan_config->eap_identity_req &&
9360ffd1 10228 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6abb9cb9 10229 (rdev->wiphy.wowlan_config->four_way_handshake &&
9360ffd1 10230 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6abb9cb9 10231 (rdev->wiphy.wowlan_config->rfkill_release &&
9360ffd1
DM		 10232 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
10233 goto nla_put_failure;
2a0e047e 10234
bb92d199
AK		 10235 if (nl80211_send_wowlan_patterns(msg, rdev))
10236 goto nla_put_failure;
2a0e047e 10237
6abb9cb9
JB		 10238 if (nl80211_send_wowlan_tcp(msg,
10239 rdev->wiphy.wowlan_config->tcp))
2a0e047e 10240 goto nla_put_failure;
75453ccb
LC		 10241
10242 if (nl80211_send_wowlan_nd(
10243 msg,
10244 rdev->wiphy.wowlan_config->nd_config))
10245 goto nla_put_failure;
2a0e047e 10246
ff1b6e69
JB		 10247 nla_nest_end(msg, nl_wowlan);
10248 }
10249
10250 genlmsg_end(msg, hdr);
10251 return genlmsg_reply(msg, info);
10252
10253nla_put_failure:
10254 nlmsg_free(msg);
10255 return -ENOBUFS;
10256}
10257
2a0e047e
JB		 10258static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
10259 struct nlattr *attr,
10260 struct cfg80211_wowlan *trig)
10261{
10262 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
10263 struct cfg80211_wowlan_tcp *cfg;
10264 struct nl80211_wowlan_tcp_data_token *tok = NULL;
10265 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
10266 u32 size;
10267 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
10268 int err, port;
10269
964dc9e2 10270 if (!rdev->wiphy.wowlan->tcp)
2a0e047e
JB		 10271 return -EINVAL;
10272
bfe2c7b1 10273 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TCP, attr,
fceb6435 10274 nl80211_wowlan_tcp_policy, NULL);
2a0e047e
JB		 10275 if (err)
10276 return err;
10277
10278 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
10279 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
10280 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
10281 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
10282 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
10283 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
10284 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
10285 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
10286 return -EINVAL;
10287
10288 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
964dc9e2 10289 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
2a0e047e
JB		 10290 return -EINVAL;
10291
10292 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
964dc9e2 10293 rdev->wiphy.wowlan->tcp->data_interval_max ||
723d568a 10294 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
2a0e047e
JB		 10295 return -EINVAL;
10296
10297 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
964dc9e2 10298 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
2a0e047e
JB		 10299 return -EINVAL;
10300
10301 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
10302 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
10303 return -EINVAL;
10304
10305 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
10306 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10307
10308 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10309 tokens_size = tokln - sizeof(*tok);
10310
10311 if (!tok->len || tokens_size % tok->len)
10312 return -EINVAL;
964dc9e2 10313 if (!rdev->wiphy.wowlan->tcp->tok)
2a0e047e 10314 return -EINVAL;
964dc9e2 10315 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
2a0e047e 10316 return -EINVAL;
964dc9e2 10317 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
2a0e047e 10318 return -EINVAL;
964dc9e2 10319 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
2a0e047e
JB		 10320 return -EINVAL;
10321 if (tok->offset + tok->len > data_size)
10322 return -EINVAL;
10323 }
10324
10325 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
10326 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
964dc9e2 10327 if (!rdev->wiphy.wowlan->tcp->seq)
2a0e047e
JB		 10328 return -EINVAL;
10329 if (seq->len == 0 || seq->len > 4)
10330 return -EINVAL;
10331 if (seq->len + seq->offset > data_size)
10332 return -EINVAL;
10333 }
10334
10335 size = sizeof(*cfg);
10336 size += data_size;
10337 size += wake_size + wake_mask_size;
10338 size += tokens_size;
10339
10340 cfg = kzalloc(size, GFP_KERNEL);
10341 if (!cfg)
10342 return -ENOMEM;
67b61f6c
JB		 10343 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
10344 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
2a0e047e
JB		 10345 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
10346 ETH_ALEN);
10347 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
10348 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
10349 else
10350 port = 0;
10351#ifdef CONFIG_INET
10352 /* allocate a socket and port for it and use it */
10353 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
10354 IPPROTO_TCP, &cfg->sock, 1);
10355 if (err) {
10356 kfree(cfg);
10357 return err;
10358 }
10359 if (inet_csk_get_port(cfg->sock->sk, port)) {
10360 sock_release(cfg->sock);
10361 kfree(cfg);
10362 return -EADDRINUSE;
10363 }
10364 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
10365#else
10366 if (!port) {
10367 kfree(cfg);
10368 return -EINVAL;
10369 }
10370 cfg->src_port = port;
10371#endif
10372
10373 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
10374 cfg->payload_len = data_size;
10375 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
10376 memcpy((void *)cfg->payload,
10377 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
10378 data_size);
10379 if (seq)
10380 cfg->payload_seq = *seq;
10381 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
10382 cfg->wake_len = wake_size;
10383 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
10384 memcpy((void *)cfg->wake_data,
10385 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
10386 wake_size);
10387 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
10388 data_size + wake_size;
10389 memcpy((void *)cfg->wake_mask,
10390 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
10391 wake_mask_size);
10392 if (tok) {
10393 cfg->tokens_size = tokens_size;
10394 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
10395 }
10396
10397 trig->tcp = cfg;
10398
10399 return 0;
10400}
10401
8cd4d456
LC		 10402static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
10403 const struct wiphy_wowlan_support *wowlan,
10404 struct nlattr *attr,
10405 struct cfg80211_wowlan *trig)
10406{
10407 struct nlattr **tb;
10408 int err;
10409
10410 tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL);
10411 if (!tb)
10412 return -ENOMEM;
10413
10414 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
10415 err = -EOPNOTSUPP;
10416 goto out;
10417 }
10418
fceb6435
JB		 10419 err = nla_parse_nested(tb, NL80211_ATTR_MAX, attr, nl80211_policy,
10420 NULL);
8cd4d456
LC		 10421 if (err)
10422 goto out;
10423
aad1e812
AVS		 10424 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
10425 wowlan->max_nd_match_sets);
8cd4d456
LC		 10426 err = PTR_ERR_OR_ZERO(trig->nd_config);
10427 if (err)
10428 trig->nd_config = NULL;
10429
10430out:
10431 kfree(tb);
10432 return err;
10433}
10434
ff1b6e69
JB		 10435static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
10436{
10437 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10438 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
ff1b6e69 10439 struct cfg80211_wowlan new_triggers = {};
ae33bd81 10440 struct cfg80211_wowlan *ntrig;
964dc9e2 10441 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
ff1b6e69 10442 int err, i;
6abb9cb9 10443 bool prev_enabled = rdev->wiphy.wowlan_config;
98fc4386 10444 bool regular = false;
ff1b6e69 10445
964dc9e2 10446 if (!wowlan)
ff1b6e69
JB		 10447 return -EOPNOTSUPP;
10448
ae33bd81
JB		 10449 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
10450 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10451 rdev->wiphy.wowlan_config = NULL;
ae33bd81
JB		 10452 goto set_wakeup;
10453 }
ff1b6e69 10454
bfe2c7b1
JB		 10455 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
10456 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
fe52145f 10457 nl80211_wowlan_policy, info->extack);
ff1b6e69
JB		 10458 if (err)
10459 return err;
10460
10461 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
10462 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
10463 return -EINVAL;
10464 new_triggers.any = true;
10465 }
10466
10467 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
10468 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
10469 return -EINVAL;
10470 new_triggers.disconnect = true;
98fc4386 10471 regular = true;
ff1b6e69
JB		 10472 }
10473
10474 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
10475 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
10476 return -EINVAL;
10477 new_triggers.magic_pkt = true;
98fc4386 10478 regular = true;
ff1b6e69
JB		 10479 }
10480
77dbbb13
JB		 10481 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
10482 return -EINVAL;
10483
10484 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
10485 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
10486 return -EINVAL;
10487 new_triggers.gtk_rekey_failure = true;
98fc4386 10488 regular = true;
77dbbb13
JB		 10489 }
10490
10491 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
10492 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
10493 return -EINVAL;
10494 new_triggers.eap_identity_req = true;
98fc4386 10495 regular = true;
77dbbb13
JB		 10496 }
10497
10498 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
10499 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
10500 return -EINVAL;
10501 new_triggers.four_way_handshake = true;
98fc4386 10502 regular = true;
77dbbb13
JB		 10503 }
10504
10505 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
10506 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
10507 return -EINVAL;
10508 new_triggers.rfkill_release = true;
98fc4386 10509 regular = true;
77dbbb13
JB		 10510 }
10511
ff1b6e69
JB		 10512 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
10513 struct nlattr *pat;
10514 int n_patterns = 0;
bb92d199 10515 int rem, pat_len, mask_len, pkt_offset;
50ac6607 10516 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
ff1b6e69 10517
98fc4386
JB		 10518 regular = true;
10519
ff1b6e69
JB		 10520 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10521 rem)
10522 n_patterns++;
10523 if (n_patterns > wowlan->n_patterns)
10524 return -EINVAL;
10525
10526 new_triggers.patterns = kcalloc(n_patterns,
10527 sizeof(new_triggers.patterns[0]),
10528 GFP_KERNEL);
10529 if (!new_triggers.patterns)
10530 return -ENOMEM;
10531
10532 new_triggers.n_patterns = n_patterns;
10533 i = 0;
10534
10535 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10536 rem) {
922bd80f
JB		 10537 u8 *mask_pat;
10538
bfe2c7b1 10539 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
4279f78b
PX		 10540 nl80211_packet_pattern_policy,
10541 info->extack);
ff1b6e69 10542 err = -EINVAL;
50ac6607
AK		 10543 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10544 !pat_tb[NL80211_PKTPAT_PATTERN])
ff1b6e69 10545 goto error;
50ac6607 10546 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
ff1b6e69 10547 mask_len = DIV_ROUND_UP(pat_len, 8);
50ac6607 10548 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
ff1b6e69
JB		 10549 goto error;
10550 if (pat_len > wowlan->pattern_max_len ||
10551 pat_len < wowlan->pattern_min_len)
10552 goto error;
10553
50ac6607 10554 if (!pat_tb[NL80211_PKTPAT_OFFSET])
bb92d199
AK		 10555 pkt_offset = 0;
10556 else
10557 pkt_offset = nla_get_u32(
50ac6607 10558 pat_tb[NL80211_PKTPAT_OFFSET]);
bb92d199
AK		 10559 if (pkt_offset > wowlan->max_pkt_offset)
10560 goto error;
10561 new_triggers.patterns[i].pkt_offset = pkt_offset;
10562
922bd80f
JB		 10563 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10564 if (!mask_pat) {
ff1b6e69
JB		 10565 err = -ENOMEM;
10566 goto error;
10567 }
922bd80f
JB		 10568 new_triggers.patterns[i].mask = mask_pat;
10569 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
ff1b6e69 10570 mask_len);
922bd80f
JB		 10571 mask_pat += mask_len;
10572 new_triggers.patterns[i].pattern = mask_pat;
ff1b6e69 10573 new_triggers.patterns[i].pattern_len = pat_len;
922bd80f 10574 memcpy(mask_pat,
50ac6607 10575 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
ff1b6e69
JB		 10576 pat_len);
10577 i++;
10578 }
10579 }
10580
2a0e047e 10581 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
98fc4386 10582 regular = true;
2a0e047e
JB		 10583 err = nl80211_parse_wowlan_tcp(
10584 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
10585 &new_triggers);
10586 if (err)
10587 goto error;
10588 }
10589
8cd4d456 10590 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
98fc4386 10591 regular = true;
8cd4d456
LC		 10592 err = nl80211_parse_wowlan_nd(
10593 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
10594 &new_triggers);
10595 if (err)
10596 goto error;
10597 }
10598
98fc4386
JB		 10599 /* The 'any' trigger means the device continues operating more or less
10600 * as in its normal operation mode and wakes up the host on most of the
10601 * normal interrupts (like packet RX, ...)
10602 * It therefore makes little sense to combine with the more constrained
10603 * wakeup trigger modes.
10604 */
10605 if (new_triggers.any && regular) {
10606 err = -EINVAL;
10607 goto error;
10608 }
10609
ae33bd81
JB		 10610 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
10611 if (!ntrig) {
10612 err = -ENOMEM;
10613 goto error;
ff1b6e69 10614 }
ae33bd81 10615 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10616 rdev->wiphy.wowlan_config = ntrig;
ff1b6e69 10617
ae33bd81 10618 set_wakeup:
6abb9cb9
JB		 10619 if (rdev->ops->set_wakeup &&
10620 prev_enabled != !!rdev->wiphy.wowlan_config)
10621 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
6d52563f 10622
ff1b6e69
JB		 10623 return 0;
10624 error:
10625 for (i = 0; i < new_triggers.n_patterns; i++)
10626 kfree(new_triggers.patterns[i].mask);
10627 kfree(new_triggers.patterns);
2a0e047e
JB		 10628 if (new_triggers.tcp && new_triggers.tcp->sock)
10629 sock_release(new_triggers.tcp->sock);
10630 kfree(new_triggers.tcp);
e5dbe070 10631 kfree(new_triggers.nd_config);
ff1b6e69
JB		 10632 return err;
10633}
dfb89c56 10634#endif
ff1b6e69 10635
be29b99a
AK		 10636static int nl80211_send_coalesce_rules(struct sk_buff *msg,
10637 struct cfg80211_registered_device *rdev)
10638{
10639 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
10640 int i, j, pat_len;
10641 struct cfg80211_coalesce_rules *rule;
10642
10643 if (!rdev->coalesce->n_rules)
10644 return 0;
10645
10646 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
10647 if (!nl_rules)
10648 return -ENOBUFS;
10649
10650 for (i = 0; i < rdev->coalesce->n_rules; i++) {
10651 nl_rule = nla_nest_start(msg, i + 1);
10652 if (!nl_rule)
10653 return -ENOBUFS;
10654
10655 rule = &rdev->coalesce->rules[i];
10656 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
10657 rule->delay))
10658 return -ENOBUFS;
10659
10660 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
10661 rule->condition))
10662 return -ENOBUFS;
10663
10664 nl_pats = nla_nest_start(msg,
10665 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
10666 if (!nl_pats)
10667 return -ENOBUFS;
10668
10669 for (j = 0; j < rule->n_patterns; j++) {
10670 nl_pat = nla_nest_start(msg, j + 1);
10671 if (!nl_pat)
10672 return -ENOBUFS;
10673 pat_len = rule->patterns[j].pattern_len;
10674 if (nla_put(msg, NL80211_PKTPAT_MASK,
10675 DIV_ROUND_UP(pat_len, 8),
10676 rule->patterns[j].mask) ||
10677 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10678 rule->patterns[j].pattern) ||
10679 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
10680 rule->patterns[j].pkt_offset))
10681 return -ENOBUFS;
10682 nla_nest_end(msg, nl_pat);
10683 }
10684 nla_nest_end(msg, nl_pats);
10685 nla_nest_end(msg, nl_rule);
10686 }
10687 nla_nest_end(msg, nl_rules);
10688
10689 return 0;
10690}
10691
10692static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
10693{
10694 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10695 struct sk_buff *msg;
10696 void *hdr;
10697
10698 if (!rdev->wiphy.coalesce)
10699 return -EOPNOTSUPP;
10700
10701 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10702 if (!msg)
10703 return -ENOMEM;
10704
10705 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10706 NL80211_CMD_GET_COALESCE);
10707 if (!hdr)
10708 goto nla_put_failure;
10709
10710 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
10711 goto nla_put_failure;
10712
10713 genlmsg_end(msg, hdr);
10714 return genlmsg_reply(msg, info);
10715
10716nla_put_failure:
10717 nlmsg_free(msg);
10718 return -ENOBUFS;
10719}
10720
10721void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
10722{
10723 struct cfg80211_coalesce *coalesce = rdev->coalesce;
10724 int i, j;
10725 struct cfg80211_coalesce_rules *rule;
10726
10727 if (!coalesce)
10728 return;
10729
10730 for (i = 0; i < coalesce->n_rules; i++) {
10731 rule = &coalesce->rules[i];
10732 for (j = 0; j < rule->n_patterns; j++)
10733 kfree(rule->patterns[j].mask);
10734 kfree(rule->patterns);
10735 }
10736 kfree(coalesce->rules);
10737 kfree(coalesce);
10738 rdev->coalesce = NULL;
10739}
10740
10741static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
10742 struct nlattr *rule,
10743 struct cfg80211_coalesce_rules *new_rule)
10744{
10745 int err, i;
10746 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10747 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
10748 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
10749 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
10750
bfe2c7b1 10751 err = nla_parse_nested(tb, NL80211_ATTR_COALESCE_RULE_MAX, rule,
fceb6435 10752 nl80211_coalesce_policy, NULL);
be29b99a
AK		 10753 if (err)
10754 return err;
10755
10756 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
10757 new_rule->delay =
10758 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
10759 if (new_rule->delay > coalesce->max_delay)
10760 return -EINVAL;
10761
10762 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
10763 new_rule->condition =
10764 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
10765 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
10766 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
10767 return -EINVAL;
10768
10769 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
10770 return -EINVAL;
10771
10772 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10773 rem)
10774 n_patterns++;
10775 if (n_patterns > coalesce->n_patterns)
10776 return -EINVAL;
10777
10778 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
10779 GFP_KERNEL);
10780 if (!new_rule->patterns)
10781 return -ENOMEM;
10782
10783 new_rule->n_patterns = n_patterns;
10784 i = 0;
10785
10786 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10787 rem) {
922bd80f
JB		 10788 u8 *mask_pat;
10789
4279f78b
PX		 10790 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
10791 nl80211_packet_pattern_policy, NULL);
be29b99a
AK		 10792 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10793 !pat_tb[NL80211_PKTPAT_PATTERN])
10794 return -EINVAL;
10795 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
10796 mask_len = DIV_ROUND_UP(pat_len, 8);
10797 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
10798 return -EINVAL;
10799 if (pat_len > coalesce->pattern_max_len ||
10800 pat_len < coalesce->pattern_min_len)
10801 return -EINVAL;
10802
10803 if (!pat_tb[NL80211_PKTPAT_OFFSET])
10804 pkt_offset = 0;
10805 else
10806 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
10807 if (pkt_offset > coalesce->max_pkt_offset)
10808 return -EINVAL;
10809 new_rule->patterns[i].pkt_offset = pkt_offset;
10810
922bd80f
JB		 10811 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10812 if (!mask_pat)
be29b99a 10813 return -ENOMEM;
922bd80f
JB		 10814
10815 new_rule->patterns[i].mask = mask_pat;
10816 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
10817 mask_len);
10818
10819 mask_pat += mask_len;
10820 new_rule->patterns[i].pattern = mask_pat;
be29b99a 10821 new_rule->patterns[i].pattern_len = pat_len;
922bd80f
JB		 10822 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
10823 pat_len);
be29b99a
AK		 10824 i++;
10825 }
10826
10827 return 0;
10828}
10829
10830static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
10831{
10832 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10833 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10834 struct cfg80211_coalesce new_coalesce = {};
10835 struct cfg80211_coalesce *n_coalesce;
10836 int err, rem_rule, n_rules = 0, i, j;
10837 struct nlattr *rule;
10838 struct cfg80211_coalesce_rules *tmp_rule;
10839
10840 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
10841 return -EOPNOTSUPP;
10842
10843 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
10844 cfg80211_rdev_free_coalesce(rdev);
a1056b1b 10845 rdev_set_coalesce(rdev, NULL);
be29b99a
AK		 10846 return 0;
10847 }
10848
10849 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10850 rem_rule)
10851 n_rules++;
10852 if (n_rules > coalesce->n_rules)
10853 return -EINVAL;
10854
10855 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
10856 GFP_KERNEL);
10857 if (!new_coalesce.rules)
10858 return -ENOMEM;
10859
10860 new_coalesce.n_rules = n_rules;
10861 i = 0;
10862
10863 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10864 rem_rule) {
10865 err = nl80211_parse_coalesce_rule(rdev, rule,
10866 &new_coalesce.rules[i]);
10867 if (err)
10868 goto error;
10869
10870 i++;
10871 }
10872
a1056b1b 10873 err = rdev_set_coalesce(rdev, &new_coalesce);
be29b99a
AK		 10874 if (err)
10875 goto error;
10876
10877 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
10878 if (!n_coalesce) {
10879 err = -ENOMEM;
10880 goto error;
10881 }
10882 cfg80211_rdev_free_coalesce(rdev);
10883 rdev->coalesce = n_coalesce;
10884
10885 return 0;
10886error:
10887 for (i = 0; i < new_coalesce.n_rules; i++) {
10888 tmp_rule = &new_coalesce.rules[i];
10889 for (j = 0; j < tmp_rule->n_patterns; j++)
10890 kfree(tmp_rule->patterns[j].mask);
10891 kfree(tmp_rule->patterns);
10892 }
10893 kfree(new_coalesce.rules);
10894
10895 return err;
10896}
10897
e5497d76
JB		 10898static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
10899{
10900 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10901 struct net_device *dev = info->user_ptr[1];
10902 struct wireless_dev *wdev = dev->ieee80211_ptr;
10903 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
10904 struct cfg80211_gtk_rekey_data rekey_data;
10905 int err;
10906
10907 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
10908 return -EINVAL;
10909
bfe2c7b1
JB		 10910 err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
10911 info->attrs[NL80211_ATTR_REKEY_DATA],
fe52145f 10912 nl80211_rekey_policy, info->extack);
e5497d76
JB		 10913 if (err)
10914 return err;
10915
0aa5a1c8
VD		 10916 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
10917 !tb[NL80211_REKEY_DATA_KCK])
10918 return -EINVAL;
e5497d76
JB		 10919 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
10920 return -ERANGE;
10921 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
10922 return -ERANGE;
10923 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
10924 return -ERANGE;
10925
78f686ca
JB		 10926 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
10927 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
10928 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
e5497d76
JB		 10929
10930 wdev_lock(wdev);
10931 if (!wdev->current_bss) {
10932 err = -ENOTCONN;
10933 goto out;
10934 }
10935
10936 if (!rdev->ops->set_rekey_data) {
10937 err = -EOPNOTSUPP;
10938 goto out;
10939 }
10940
e35e4d28 10941 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
e5497d76
JB		 10942 out:
10943 wdev_unlock(wdev);
10944 return err;
10945}
10946
28946da7
JB		 10947static int nl80211_register_unexpected_frame(struct sk_buff *skb,
10948 struct genl_info *info)
10949{
10950 struct net_device *dev = info->user_ptr[1];
10951 struct wireless_dev *wdev = dev->ieee80211_ptr;
10952
10953 if (wdev->iftype != NL80211_IFTYPE_AP &&
10954 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10955 return -EINVAL;
10956
15e47304 10957 if (wdev->ap_unexpected_nlportid)
28946da7
JB		 10958 return -EBUSY;
10959
15e47304 10960 wdev->ap_unexpected_nlportid = info->snd_portid;
28946da7
JB		 10961 return 0;
10962}
10963
7f6cf311
JB		 10964static int nl80211_probe_client(struct sk_buff *skb,
10965 struct genl_info *info)
10966{
10967 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10968 struct net_device *dev = info->user_ptr[1];
10969 struct wireless_dev *wdev = dev->ieee80211_ptr;
10970 struct sk_buff *msg;
10971 void *hdr;
10972 const u8 *addr;
10973 u64 cookie;
10974 int err;
10975
10976 if (wdev->iftype != NL80211_IFTYPE_AP &&
10977 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10978 return -EOPNOTSUPP;
10979
10980 if (!info->attrs[NL80211_ATTR_MAC])
10981 return -EINVAL;
10982
10983 if (!rdev->ops->probe_client)
10984 return -EOPNOTSUPP;
10985
10986 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10987 if (!msg)
10988 return -ENOMEM;
10989
15e47304 10990 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7f6cf311 10991 NL80211_CMD_PROBE_CLIENT);
cb35fba3
DC		 10992 if (!hdr) {
10993 err = -ENOBUFS;
7f6cf311
JB		 10994 goto free_msg;
10995 }
10996
10997 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
10998
e35e4d28 10999 err = rdev_probe_client(rdev, dev, addr, &cookie);
7f6cf311
JB		 11000 if (err)
11001 goto free_msg;
11002
2dad624e
ND		 11003 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11004 NL80211_ATTR_PAD))
9360ffd1 11005 goto nla_put_failure;
7f6cf311
JB		 11006
11007 genlmsg_end(msg, hdr);
11008
11009 return genlmsg_reply(msg, info);
11010
11011 nla_put_failure:
11012 err = -ENOBUFS;
11013 free_msg:
11014 nlmsg_free(msg);
11015 return err;
11016}
11017
5e760230
JB		 11018static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
11019{
11020 struct cfg80211_registered_device *rdev = info->user_ptr[0];
37c73b5f
BG		 11021 struct cfg80211_beacon_registration *reg, *nreg;
11022 int rv;
5e760230
JB		 11023
11024 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
11025 return -EOPNOTSUPP;
11026
37c73b5f
BG		 11027 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
11028 if (!nreg)
11029 return -ENOMEM;
11030
11031 /* First, check if already registered. */
11032 spin_lock_bh(&rdev->beacon_registrations_lock);
11033 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
11034 if (reg->nlportid == info->snd_portid) {
11035 rv = -EALREADY;
11036 goto out_err;
11037 }
11038 }
11039 /* Add it to the list */
11040 nreg->nlportid = info->snd_portid;
11041 list_add(&nreg->list, &rdev->beacon_registrations);
5e760230 11042
37c73b5f 11043 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 11044
11045 return 0;
37c73b5f
BG		 11046out_err:
11047 spin_unlock_bh(&rdev->beacon_registrations_lock);
11048 kfree(nreg);
11049 return rv;
5e760230
JB		 11050}
11051
98104fde
JB		 11052static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
11053{
11054 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11055 struct wireless_dev *wdev = info->user_ptr[1];
11056 int err;
11057
11058 if (!rdev->ops->start_p2p_device)
11059 return -EOPNOTSUPP;
11060
11061 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11062 return -EOPNOTSUPP;
11063
73c7da3d 11064 if (wdev_running(wdev))
98104fde
JB		 11065 return 0;
11066
b6a55015
LC		 11067 if (rfkill_blocked(rdev->rfkill))
11068 return -ERFKILL;
98104fde 11069
eeb126e9 11070 err = rdev_start_p2p_device(rdev, wdev);
98104fde
JB		 11071 if (err)
11072 return err;
11073
73c7da3d 11074 wdev->is_running = true;
98104fde 11075 rdev->opencount++;
98104fde
JB		 11076
11077 return 0;
11078}
11079
11080static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
11081{
11082 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11083 struct wireless_dev *wdev = info->user_ptr[1];
11084
11085 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11086 return -EOPNOTSUPP;
11087
11088 if (!rdev->ops->stop_p2p_device)
11089 return -EOPNOTSUPP;
11090
f9f47529 11091 cfg80211_stop_p2p_device(rdev, wdev);
98104fde
JB		 11092
11093 return 0;
11094}
11095
cb3b7d87
AB		 11096static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
11097{
11098 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11099 struct wireless_dev *wdev = info->user_ptr[1];
11100 struct cfg80211_nan_conf conf = {};
11101 int err;
11102
11103 if (wdev->iftype != NL80211_IFTYPE_NAN)
11104 return -EOPNOTSUPP;
11105
eeb04a96 11106 if (wdev_running(wdev))
cb3b7d87
AB		 11107 return -EEXIST;
11108
11109 if (rfkill_blocked(rdev->rfkill))
11110 return -ERFKILL;
11111
11112 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
11113 return -EINVAL;
11114
cb3b7d87
AB		 11115 conf.master_pref =
11116 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11117 if (!conf.master_pref)
11118 return -EINVAL;
11119
8585989d
LC		 11120 if (info->attrs[NL80211_ATTR_BANDS]) {
11121 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11122
11123 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11124 return -EOPNOTSUPP;
11125
11126 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11127 return -EINVAL;
11128
11129 conf.bands = bands;
11130 }
cb3b7d87
AB		 11131
11132 err = rdev_start_nan(rdev, wdev, &conf);
11133 if (err)
11134 return err;
11135
73c7da3d 11136 wdev->is_running = true;
cb3b7d87
AB		 11137 rdev->opencount++;
11138
11139 return 0;
11140}
11141
11142static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
11143{
11144 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11145 struct wireless_dev *wdev = info->user_ptr[1];
11146
11147 if (wdev->iftype != NL80211_IFTYPE_NAN)
11148 return -EOPNOTSUPP;
11149
11150 cfg80211_stop_nan(rdev, wdev);
11151
11152 return 0;
11153}
11154
a442b761
AB		 11155static int validate_nan_filter(struct nlattr *filter_attr)
11156{
11157 struct nlattr *attr;
11158 int len = 0, n_entries = 0, rem;
11159
11160 nla_for_each_nested(attr, filter_attr, rem) {
11161 len += nla_len(attr);
11162 n_entries++;
11163 }
11164
11165 if (len >= U8_MAX)
11166 return -EINVAL;
11167
11168 return n_entries;
11169}
11170
11171static int handle_nan_filter(struct nlattr *attr_filter,
11172 struct cfg80211_nan_func *func,
11173 bool tx)
11174{
11175 struct nlattr *attr;
11176 int n_entries, rem, i;
11177 struct cfg80211_nan_func_filter *filter;
11178
11179 n_entries = validate_nan_filter(attr_filter);
11180 if (n_entries < 0)
11181 return n_entries;
11182
11183 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
11184
11185 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
11186 if (!filter)
11187 return -ENOMEM;
11188
11189 i = 0;
11190 nla_for_each_nested(attr, attr_filter, rem) {
b15ca182 11191 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
a442b761
AB		 11192 filter[i].len = nla_len(attr);
11193 i++;
11194 }
11195 if (tx) {
11196 func->num_tx_filters = n_entries;
11197 func->tx_filters = filter;
11198 } else {
11199 func->num_rx_filters = n_entries;
11200 func->rx_filters = filter;
11201 }
11202
11203 return 0;
11204}
11205
11206static int nl80211_nan_add_func(struct sk_buff *skb,
11207 struct genl_info *info)
11208{
11209 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11210 struct wireless_dev *wdev = info->user_ptr[1];
11211 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
11212 struct cfg80211_nan_func *func;
11213 struct sk_buff *msg = NULL;
11214 void *hdr = NULL;
11215 int err = 0;
11216
11217 if (wdev->iftype != NL80211_IFTYPE_NAN)
11218 return -EOPNOTSUPP;
11219
73c7da3d 11220 if (!wdev_running(wdev))
a442b761
AB		 11221 return -ENOTCONN;
11222
11223 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
11224 return -EINVAL;
11225
bfe2c7b1
JB		 11226 err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
11227 info->attrs[NL80211_ATTR_NAN_FUNC],
fe52145f 11228 nl80211_nan_func_policy, info->extack);
a442b761
AB		 11229 if (err)
11230 return err;
11231
11232 func = kzalloc(sizeof(*func), GFP_KERNEL);
11233 if (!func)
11234 return -ENOMEM;
11235
11236 func->cookie = wdev->wiphy->cookie_counter++;
11237
11238 if (!tb[NL80211_NAN_FUNC_TYPE] ||
11239 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
11240 err = -EINVAL;
11241 goto out;
11242 }
11243
11244
11245 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
11246
11247 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
11248 err = -EINVAL;
11249 goto out;
11250 }
11251
11252 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
11253 sizeof(func->service_id));
11254
11255 func->close_range =
11256 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
11257
11258 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
11259 func->serv_spec_info_len =
11260 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
11261 func->serv_spec_info =
11262 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
11263 func->serv_spec_info_len,
11264 GFP_KERNEL);
11265 if (!func->serv_spec_info) {
11266 err = -ENOMEM;
11267 goto out;
11268 }
11269 }
11270
11271 if (tb[NL80211_NAN_FUNC_TTL])
11272 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
11273
11274 switch (func->type) {
11275 case NL80211_NAN_FUNC_PUBLISH:
11276 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
11277 err = -EINVAL;
11278 goto out;
11279 }
11280
11281 func->publish_type =
11282 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
11283 func->publish_bcast =
11284 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
11285
11286 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
11287 func->publish_bcast) {
11288 err = -EINVAL;
11289 goto out;
11290 }
11291 break;
11292 case NL80211_NAN_FUNC_SUBSCRIBE:
11293 func->subscribe_active =
11294 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
11295 break;
11296 case NL80211_NAN_FUNC_FOLLOW_UP:
11297 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
11298 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]) {
11299 err = -EINVAL;
11300 goto out;
11301 }
11302
11303 func->followup_id =
11304 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
11305 func->followup_reqid =
11306 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
11307 memcpy(func->followup_dest.addr,
11308 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
11309 sizeof(func->followup_dest.addr));
11310 if (func->ttl) {
11311 err = -EINVAL;
11312 goto out;
11313 }
11314 break;
11315 default:
11316 err = -EINVAL;
11317 goto out;
11318 }
11319
11320 if (tb[NL80211_NAN_FUNC_SRF]) {
11321 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
11322
bfe2c7b1
JB		 11323 err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
11324 tb[NL80211_NAN_FUNC_SRF],
fe52145f 11325 nl80211_nan_srf_policy, info->extack);
a442b761
AB		 11326 if (err)
11327 goto out;
11328
11329 func->srf_include =
11330 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
11331
11332 if (srf_tb[NL80211_NAN_SRF_BF]) {
11333 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
11334 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
11335 err = -EINVAL;
11336 goto out;
11337 }
11338
11339 func->srf_bf_len =
11340 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
11341 func->srf_bf =
11342 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
11343 func->srf_bf_len, GFP_KERNEL);
11344 if (!func->srf_bf) {
11345 err = -ENOMEM;
11346 goto out;
11347 }
11348
11349 func->srf_bf_idx =
11350 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
11351 } else {
11352 struct nlattr *attr, *mac_attr =
11353 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
11354 int n_entries, rem, i = 0;
11355
11356 if (!mac_attr) {
11357 err = -EINVAL;
11358 goto out;
11359 }
11360
11361 n_entries = validate_acl_mac_addrs(mac_attr);
11362 if (n_entries <= 0) {
11363 err = -EINVAL;
11364 goto out;
11365 }
11366
11367 func->srf_num_macs = n_entries;
11368 func->srf_macs =
11369 kzalloc(sizeof(*func->srf_macs) * n_entries,
11370 GFP_KERNEL);
11371 if (!func->srf_macs) {
11372 err = -ENOMEM;
11373 goto out;
11374 }
11375
11376 nla_for_each_nested(attr, mac_attr, rem)
11377 memcpy(func->srf_macs[i++].addr, nla_data(attr),
11378 sizeof(*func->srf_macs));
11379 }
11380 }
11381
11382 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
11383 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
11384 func, true);
11385 if (err)
11386 goto out;
11387 }
11388
11389 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
11390 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
11391 func, false);
11392 if (err)
11393 goto out;
11394 }
11395
11396 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11397 if (!msg) {
11398 err = -ENOMEM;
11399 goto out;
11400 }
11401
11402 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11403 NL80211_CMD_ADD_NAN_FUNCTION);
11404 /* This can't really happen - we just allocated 4KB */
11405 if (WARN_ON(!hdr)) {
11406 err = -ENOMEM;
11407 goto out;
11408 }
11409
11410 err = rdev_add_nan_func(rdev, wdev, func);
11411out:
11412 if (err < 0) {
11413 cfg80211_free_nan_func(func);
11414 nlmsg_free(msg);
11415 return err;
11416 }
11417
11418 /* propagate the instance id and cookie to userspace */
11419 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
11420 NL80211_ATTR_PAD))
11421 goto nla_put_failure;
11422
11423 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11424 if (!func_attr)
11425 goto nla_put_failure;
11426
11427 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
11428 func->instance_id))
11429 goto nla_put_failure;
11430
11431 nla_nest_end(msg, func_attr);
11432
11433 genlmsg_end(msg, hdr);
11434 return genlmsg_reply(msg, info);
11435
11436nla_put_failure:
11437 nlmsg_free(msg);
11438 return -ENOBUFS;
11439}
11440
11441static int nl80211_nan_del_func(struct sk_buff *skb,
11442 struct genl_info *info)
11443{
11444 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11445 struct wireless_dev *wdev = info->user_ptr[1];
11446 u64 cookie;
11447
11448 if (wdev->iftype != NL80211_IFTYPE_NAN)
11449 return -EOPNOTSUPP;
11450
73c7da3d 11451 if (!wdev_running(wdev))
a442b761
AB		 11452 return -ENOTCONN;
11453
11454 if (!info->attrs[NL80211_ATTR_COOKIE])
11455 return -EINVAL;
11456
a442b761
AB		 11457 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11458
11459 rdev_del_nan_func(rdev, wdev, cookie);
11460
11461 return 0;
11462}
11463
a5a9dcf2
AB		 11464static int nl80211_nan_change_config(struct sk_buff *skb,
11465 struct genl_info *info)
11466{
11467 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11468 struct wireless_dev *wdev = info->user_ptr[1];
11469 struct cfg80211_nan_conf conf = {};
11470 u32 changed = 0;
11471
11472 if (wdev->iftype != NL80211_IFTYPE_NAN)
11473 return -EOPNOTSUPP;
11474
73c7da3d 11475 if (!wdev_running(wdev))
a5a9dcf2
AB		 11476 return -ENOTCONN;
11477
11478 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
11479 conf.master_pref =
11480 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11481 if (conf.master_pref <= 1 || conf.master_pref == 255)
11482 return -EINVAL;
11483
11484 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
11485 }
11486
8585989d
LC		 11487 if (info->attrs[NL80211_ATTR_BANDS]) {
11488 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11489
11490 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11491 return -EOPNOTSUPP;
11492
11493 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11494 return -EINVAL;
11495
11496 conf.bands = bands;
11497 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
a5a9dcf2
AB		 11498 }
11499
11500 if (!changed)
11501 return -EINVAL;
11502
11503 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
11504}
11505
50bcd31d
AB		 11506void cfg80211_nan_match(struct wireless_dev *wdev,
11507 struct cfg80211_nan_match_params *match, gfp_t gfp)
11508{
11509 struct wiphy *wiphy = wdev->wiphy;
11510 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11511 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
11512 struct sk_buff *msg;
11513 void *hdr;
11514
11515 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
11516 return;
11517
11518 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11519 if (!msg)
11520 return;
11521
11522 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
11523 if (!hdr) {
11524 nlmsg_free(msg);
11525 return;
11526 }
11527
11528 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11529 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11530 wdev->netdev->ifindex)) ||
11531 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11532 NL80211_ATTR_PAD))
11533 goto nla_put_failure;
11534
11535 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
11536 NL80211_ATTR_PAD) ||
11537 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
11538 goto nla_put_failure;
11539
11540 match_attr = nla_nest_start(msg, NL80211_ATTR_NAN_MATCH);
11541 if (!match_attr)
11542 goto nla_put_failure;
11543
11544 local_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_LOCAL);
11545 if (!local_func_attr)
11546 goto nla_put_failure;
11547
11548 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
11549 goto nla_put_failure;
11550
11551 nla_nest_end(msg, local_func_attr);
11552
11553 peer_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_PEER);
11554 if (!peer_func_attr)
11555 goto nla_put_failure;
11556
11557 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
11558 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
11559 goto nla_put_failure;
11560
11561 if (match->info && match->info_len &&
11562 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
11563 match->info))
11564 goto nla_put_failure;
11565
11566 nla_nest_end(msg, peer_func_attr);
11567 nla_nest_end(msg, match_attr);
11568 genlmsg_end(msg, hdr);
11569
11570 if (!wdev->owner_nlportid)
11571 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11572 msg, 0, NL80211_MCGRP_NAN, gfp);
11573 else
11574 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11575 wdev->owner_nlportid);
11576
11577 return;
11578
11579nla_put_failure:
11580 nlmsg_free(msg);
11581}
11582EXPORT_SYMBOL(cfg80211_nan_match);
11583
368e5a7b
AB		 11584void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
11585 u8 inst_id,
11586 enum nl80211_nan_func_term_reason reason,
11587 u64 cookie, gfp_t gfp)
11588{
11589 struct wiphy *wiphy = wdev->wiphy;
11590 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11591 struct sk_buff *msg;
11592 struct nlattr *func_attr;
11593 void *hdr;
11594
11595 if (WARN_ON(!inst_id))
11596 return;
11597
11598 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11599 if (!msg)
11600 return;
11601
11602 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
11603 if (!hdr) {
11604 nlmsg_free(msg);
11605 return;
11606 }
11607
11608 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11609 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11610 wdev->netdev->ifindex)) ||
11611 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11612 NL80211_ATTR_PAD))
11613 goto nla_put_failure;
11614
11615 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11616 NL80211_ATTR_PAD))
11617 goto nla_put_failure;
11618
11619 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11620 if (!func_attr)
11621 goto nla_put_failure;
11622
11623 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
11624 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
11625 goto nla_put_failure;
11626
11627 nla_nest_end(msg, func_attr);
11628 genlmsg_end(msg, hdr);
11629
11630 if (!wdev->owner_nlportid)
11631 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11632 msg, 0, NL80211_MCGRP_NAN, gfp);
11633 else
11634 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11635 wdev->owner_nlportid);
11636
11637 return;
11638
11639nla_put_failure:
11640 nlmsg_free(msg);
11641}
11642EXPORT_SYMBOL(cfg80211_nan_func_terminated);
11643
3713b4e3
JB		 11644static int nl80211_get_protocol_features(struct sk_buff *skb,
11645 struct genl_info *info)
11646{
11647 void *hdr;
11648 struct sk_buff *msg;
11649
11650 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11651 if (!msg)
11652 return -ENOMEM;
11653
11654 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11655 NL80211_CMD_GET_PROTOCOL_FEATURES);
11656 if (!hdr)
11657 goto nla_put_failure;
11658
11659 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
11660 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
11661 goto nla_put_failure;
11662
11663 genlmsg_end(msg, hdr);
11664 return genlmsg_reply(msg, info);
11665
11666 nla_put_failure:
11667 kfree_skb(msg);
11668 return -ENOBUFS;
11669}
11670
355199e0
JM		 11671static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
11672{
11673 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11674 struct cfg80211_update_ft_ies_params ft_params;
11675 struct net_device *dev = info->user_ptr[1];
11676
11677 if (!rdev->ops->update_ft_ies)
11678 return -EOPNOTSUPP;
11679
11680 if (!info->attrs[NL80211_ATTR_MDID] ||
11681 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
11682 return -EINVAL;
11683
11684 memset(&ft_params, 0, sizeof(ft_params));
11685 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
11686 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11687 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11688
11689 return rdev_update_ft_ies(rdev, dev, &ft_params);
11690}
11691
5de17984
AS		 11692static int nl80211_crit_protocol_start(struct sk_buff *skb,
11693 struct genl_info *info)
11694{
11695 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11696 struct wireless_dev *wdev = info->user_ptr[1];
11697 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
11698 u16 duration;
11699 int ret;
11700
11701 if (!rdev->ops->crit_proto_start)
11702 return -EOPNOTSUPP;
11703
11704 if (WARN_ON(!rdev->ops->crit_proto_stop))
11705 return -EINVAL;
11706
11707 if (rdev->crit_proto_nlportid)
11708 return -EBUSY;
11709
11710 /* determine protocol if provided */
11711 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
11712 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
11713
11714 if (proto >= NUM_NL80211_CRIT_PROTO)
11715 return -EINVAL;
11716
11717 /* timeout must be provided */
11718 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
11719 return -EINVAL;
11720
11721 duration =
11722 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
11723
11724 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
11725 return -ERANGE;
11726
11727 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
11728 if (!ret)
11729 rdev->crit_proto_nlportid = info->snd_portid;
11730
11731 return ret;
11732}
11733
11734static int nl80211_crit_protocol_stop(struct sk_buff *skb,
11735 struct genl_info *info)
11736{
11737 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11738 struct wireless_dev *wdev = info->user_ptr[1];
11739
11740 if (!rdev->ops->crit_proto_stop)
11741 return -EOPNOTSUPP;
11742
11743 if (rdev->crit_proto_nlportid) {
11744 rdev->crit_proto_nlportid = 0;
11745 rdev_crit_proto_stop(rdev, wdev);
11746 }
11747 return 0;
11748}
11749
ad7e718c
JB		 11750static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
11751{
11752 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11753 struct wireless_dev *wdev =
11754 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
11755 int i, err;
11756 u32 vid, subcmd;
11757
11758 if (!rdev->wiphy.vendor_commands)
11759 return -EOPNOTSUPP;
11760
11761 if (IS_ERR(wdev)) {
11762 err = PTR_ERR(wdev);
11763 if (err != -EINVAL)
11764 return err;
11765 wdev = NULL;
11766 } else if (wdev->wiphy != &rdev->wiphy) {
11767 return -EINVAL;
11768 }
11769
11770 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
11771 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
11772 return -EINVAL;
11773
11774 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
11775 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
11776 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
11777 const struct wiphy_vendor_command *vcmd;
11778 void *data = NULL;
11779 int len = 0;
11780
11781 vcmd = &rdev->wiphy.vendor_commands[i];
11782
11783 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11784 continue;
11785
11786 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11787 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
11788 if (!wdev)
11789 return -EINVAL;
11790 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
11791 !wdev->netdev)
11792 return -EINVAL;
11793
11794 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
73c7da3d 11795 if (!wdev_running(wdev))
ad7e718c
JB		 11796 return -ENETDOWN;
11797 }
7bdbe400
JB		 11798
11799 if (!vcmd->doit)
11800 return -EOPNOTSUPP;
ad7e718c
JB		 11801 } else {
11802 wdev = NULL;
11803 }
11804
11805 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
11806 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11807 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11808 }
11809
11810 rdev->cur_cmd_info = info;
11811 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
11812 data, len);
11813 rdev->cur_cmd_info = NULL;
11814 return err;
11815 }
11816
11817 return -EOPNOTSUPP;
11818}
11819
7bdbe400
JB		 11820static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
11821 struct netlink_callback *cb,
11822 struct cfg80211_registered_device **rdev,
11823 struct wireless_dev **wdev)
11824{
c90c39da 11825 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
7bdbe400
JB		 11826 u32 vid, subcmd;
11827 unsigned int i;
11828 int vcmd_idx = -1;
11829 int err;
11830 void *data = NULL;
11831 unsigned int data_len = 0;
11832
7bdbe400
JB		 11833 if (cb->args[0]) {
11834 /* subtract the 1 again here */
11835 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
11836 struct wireless_dev *tmp;
11837
ea90e0dc
JB		 11838 if (!wiphy)
11839 return -ENODEV;
7bdbe400
JB		 11840 *rdev = wiphy_to_rdev(wiphy);
11841 *wdev = NULL;
11842
11843 if (cb->args[1]) {
53873f13 11844 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
7bdbe400
JB		 11845 if (tmp->identifier == cb->args[1] - 1) {
11846 *wdev = tmp;
11847 break;
11848 }
11849 }
11850 }
11851
11852 /* keep rtnl locked in successful case */
11853 return 0;
11854 }
11855
fceb6435
JB		 11856 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, attrbuf,
11857 nl80211_fam.maxattr, nl80211_policy, NULL);
7bdbe400 11858 if (err)
ea90e0dc 11859 return err;
7bdbe400 11860
c90c39da 11861 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
ea90e0dc
JB		 11862 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD])
11863 return -EINVAL;
7bdbe400 11864
c90c39da 11865 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
7bdbe400
JB		 11866 if (IS_ERR(*wdev))
11867 *wdev = NULL;
11868
c90c39da 11869 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
ea90e0dc
JB		 11870 if (IS_ERR(*rdev))
11871 return PTR_ERR(*rdev);
7bdbe400 11872
c90c39da
JB		 11873 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
11874 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
7bdbe400
JB		 11875
11876 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
11877 const struct wiphy_vendor_command *vcmd;
11878
11879 vcmd = &(*rdev)->wiphy.vendor_commands[i];
11880
11881 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11882 continue;
11883
ea90e0dc
JB		 11884 if (!vcmd->dumpit)
11885 return -EOPNOTSUPP;
7bdbe400
JB		 11886
11887 vcmd_idx = i;
11888 break;
11889 }
11890
ea90e0dc
JB		 11891 if (vcmd_idx < 0)
11892 return -EOPNOTSUPP;
7bdbe400 11893
c90c39da
JB		 11894 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
11895 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
11896 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
7bdbe400
JB		 11897 }
11898
11899 /* 0 is the first index - add 1 to parse only once */
11900 cb->args[0] = (*rdev)->wiphy_idx + 1;
11901 /* add 1 to know if it was NULL */
11902 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
11903 cb->args[2] = vcmd_idx;
11904 cb->args[3] = (unsigned long)data;
11905 cb->args[4] = data_len;
11906
11907 /* keep rtnl locked in successful case */
11908 return 0;
7bdbe400
JB		 11909}
11910
11911static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
11912 struct netlink_callback *cb)
11913{
11914 struct cfg80211_registered_device *rdev;
11915 struct wireless_dev *wdev;
11916 unsigned int vcmd_idx;
11917 const struct wiphy_vendor_command *vcmd;
11918 void *data;
11919 int data_len;
11920 int err;
11921 struct nlattr *vendor_data;
11922
ea90e0dc 11923 rtnl_lock();
7bdbe400
JB		 11924 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
11925 if (err)
ea90e0dc 11926 goto out;
7bdbe400
JB		 11927
11928 vcmd_idx = cb->args[2];
11929 data = (void *)cb->args[3];
11930 data_len = cb->args[4];
11931 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
11932
11933 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11934 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
ea90e0dc
JB		 11935 if (!wdev) {
11936 err = -EINVAL;
11937 goto out;
11938 }
7bdbe400 11939 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
ea90e0dc
JB		 11940 !wdev->netdev) {
11941 err = -EINVAL;
11942 goto out;
11943 }
7bdbe400
JB		 11944
11945 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
ea90e0dc
JB		 11946 if (!wdev_running(wdev)) {
11947 err = -ENETDOWN;
11948 goto out;
11949 }
7bdbe400
JB		 11950 }
11951 }
11952
11953 while (1) {
11954 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
11955 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11956 NL80211_CMD_VENDOR);
11957 if (!hdr)
11958 break;
11959
11960 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 11961 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
11962 wdev_id(wdev),
11963 NL80211_ATTR_PAD))) {
7bdbe400
JB		 11964 genlmsg_cancel(skb, hdr);
11965 break;
11966 }
11967
11968 vendor_data = nla_nest_start(skb, NL80211_ATTR_VENDOR_DATA);
11969 if (!vendor_data) {
11970 genlmsg_cancel(skb, hdr);
11971 break;
11972 }
11973
11974 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
11975 (unsigned long *)&cb->args[5]);
11976 nla_nest_end(skb, vendor_data);
11977
11978 if (err == -ENOBUFS || err == -ENOENT) {
11979 genlmsg_cancel(skb, hdr);
11980 break;
11981 } else if (err) {
11982 genlmsg_cancel(skb, hdr);
11983 goto out;
11984 }
11985
11986 genlmsg_end(skb, hdr);
11987 }
11988
11989 err = skb->len;
11990 out:
11991 rtnl_unlock();
11992 return err;
11993}
11994
ad7e718c
JB		 11995struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
11996 enum nl80211_commands cmd,
11997 enum nl80211_attrs attr,
11998 int approxlen)
11999{
f26cbf40 12000 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ad7e718c
JB		 12001
12002 if (WARN_ON(!rdev->cur_cmd_info))
12003 return NULL;
12004
6c09e791 12005 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
ad7e718c
JB		 12006 rdev->cur_cmd_info->snd_portid,
12007 rdev->cur_cmd_info->snd_seq,
567ffc35 12008 cmd, attr, NULL, GFP_KERNEL);
ad7e718c
JB		 12009}
12010EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
12011
12012int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
12013{
12014 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
12015 void *hdr = ((void **)skb->cb)[1];
12016 struct nlattr *data = ((void **)skb->cb)[2];
12017
bd8c78e7
JB		 12018 /* clear CB data for netlink core to own from now on */
12019 memset(skb->cb, 0, sizeof(skb->cb));
12020
ad7e718c
JB		 12021 if (WARN_ON(!rdev->cur_cmd_info)) {
12022 kfree_skb(skb);
12023 return -EINVAL;
12024 }
12025
12026 nla_nest_end(skb, data);
12027 genlmsg_end(skb, hdr);
12028 return genlmsg_reply(skb, rdev->cur_cmd_info);
12029}
12030EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
12031
fa9ffc74
KP		 12032static int nl80211_set_qos_map(struct sk_buff *skb,
12033 struct genl_info *info)
12034{
12035 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12036 struct cfg80211_qos_map *qos_map = NULL;
12037 struct net_device *dev = info->user_ptr[1];
12038 u8 *pos, len, num_des, des_len, des;
12039 int ret;
12040
12041 if (!rdev->ops->set_qos_map)
12042 return -EOPNOTSUPP;
12043
12044 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
12045 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
12046 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
12047
12048 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
12049 len > IEEE80211_QOS_MAP_LEN_MAX)
12050 return -EINVAL;
12051
12052 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
12053 if (!qos_map)
12054 return -ENOMEM;
12055
12056 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
12057 if (num_des) {
12058 des_len = num_des *
12059 sizeof(struct cfg80211_dscp_exception);
12060 memcpy(qos_map->dscp_exception, pos, des_len);
12061 qos_map->num_des = num_des;
12062 for (des = 0; des < num_des; des++) {
12063 if (qos_map->dscp_exception[des].up > 7) {
12064 kfree(qos_map);
12065 return -EINVAL;
12066 }
12067 }
12068 pos += des_len;
12069 }
12070 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
12071 }
12072
12073 wdev_lock(dev->ieee80211_ptr);
12074 ret = nl80211_key_allowed(dev->ieee80211_ptr);
12075 if (!ret)
12076 ret = rdev_set_qos_map(rdev, dev, qos_map);
12077 wdev_unlock(dev->ieee80211_ptr);
12078
12079 kfree(qos_map);
12080 return ret;
12081}
12082
960d01ac
JB		 12083static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
12084{
12085 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12086 struct net_device *dev = info->user_ptr[1];
12087 struct wireless_dev *wdev = dev->ieee80211_ptr;
12088 const u8 *peer;
12089 u8 tsid, up;
12090 u16 admitted_time = 0;
12091 int err;
12092
723e73ac 12093 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
960d01ac
JB		 12094 return -EOPNOTSUPP;
12095
12096 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
12097 !info->attrs[NL80211_ATTR_USER_PRIO])
12098 return -EINVAL;
12099
12100 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12101 if (tsid >= IEEE80211_NUM_TIDS)
12102 return -EINVAL;
12103
12104 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
12105 if (up >= IEEE80211_NUM_UPS)
12106 return -EINVAL;
12107
12108 /* WMM uses TIDs 0-7 even for TSPEC */
723e73ac 12109 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
960d01ac 12110 /* TODO: handle 802.11 TSPEC/admission control
723e73ac
JB		 12111 * need more attributes for that (e.g. BA session requirement);
12112 * change the WMM adminssion test above to allow both then
960d01ac
JB		 12113 */
12114 return -EINVAL;
12115 }
12116
12117 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12118
12119 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
12120 admitted_time =
12121 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
12122 if (!admitted_time)
12123 return -EINVAL;
12124 }
12125
12126 wdev_lock(wdev);
12127 switch (wdev->iftype) {
12128 case NL80211_IFTYPE_STATION:
12129 case NL80211_IFTYPE_P2P_CLIENT:
12130 if (wdev->current_bss)
12131 break;
12132 err = -ENOTCONN;
12133 goto out;
12134 default:
12135 err = -EOPNOTSUPP;
12136 goto out;
12137 }
12138
12139 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
12140
12141 out:
12142 wdev_unlock(wdev);
12143 return err;
12144}
12145
12146static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
12147{
12148 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12149 struct net_device *dev = info->user_ptr[1];
12150 struct wireless_dev *wdev = dev->ieee80211_ptr;
12151 const u8 *peer;
12152 u8 tsid;
12153 int err;
12154
12155 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
12156 return -EINVAL;
12157
12158 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12159 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12160
12161 wdev_lock(wdev);
12162 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
12163 wdev_unlock(wdev);
12164
12165 return err;
12166}
12167
1057d35e
AN		 12168static int nl80211_tdls_channel_switch(struct sk_buff *skb,
12169 struct genl_info *info)
12170{
12171 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12172 struct net_device *dev = info->user_ptr[1];
12173 struct wireless_dev *wdev = dev->ieee80211_ptr;
12174 struct cfg80211_chan_def chandef = {};
12175 const u8 *addr;
12176 u8 oper_class;
12177 int err;
12178
12179 if (!rdev->ops->tdls_channel_switch ||
12180 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12181 return -EOPNOTSUPP;
12182
12183 switch (dev->ieee80211_ptr->iftype) {
12184 case NL80211_IFTYPE_STATION:
12185 case NL80211_IFTYPE_P2P_CLIENT:
12186 break;
12187 default:
12188 return -EOPNOTSUPP;
12189 }
12190
12191 if (!info->attrs[NL80211_ATTR_MAC] ||
12192 !info->attrs[NL80211_ATTR_OPER_CLASS])
12193 return -EINVAL;
12194
12195 err = nl80211_parse_chandef(rdev, info, &chandef);
12196 if (err)
12197 return err;
12198
12199 /*
12200 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
12201 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
12202 * specification is not defined for them.
12203 */
57fbcce3 12204 if (chandef.chan->band == NL80211_BAND_2GHZ &&
1057d35e
AN		 12205 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
12206 chandef.width != NL80211_CHAN_WIDTH_20)
12207 return -EINVAL;
12208
12209 /* we will be active on the TDLS link */
923b352f
AN		 12210 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
12211 wdev->iftype))
1057d35e
AN		 12212 return -EINVAL;
12213
12214 /* don't allow switching to DFS channels */
12215 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
12216 return -EINVAL;
12217
12218 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12219 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
12220
12221 wdev_lock(wdev);
12222 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
12223 wdev_unlock(wdev);
12224
12225 return err;
12226}
12227
12228static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
12229 struct genl_info *info)
12230{
12231 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12232 struct net_device *dev = info->user_ptr[1];
12233 struct wireless_dev *wdev = dev->ieee80211_ptr;
12234 const u8 *addr;
12235
12236 if (!rdev->ops->tdls_channel_switch ||
12237 !rdev->ops->tdls_cancel_channel_switch ||
12238 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12239 return -EOPNOTSUPP;
12240
12241 switch (dev->ieee80211_ptr->iftype) {
12242 case NL80211_IFTYPE_STATION:
12243 case NL80211_IFTYPE_P2P_CLIENT:
12244 break;
12245 default:
12246 return -EOPNOTSUPP;
12247 }
12248
12249 if (!info->attrs[NL80211_ATTR_MAC])
12250 return -EINVAL;
12251
12252 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12253
12254 wdev_lock(wdev);
12255 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
12256 wdev_unlock(wdev);
12257
12258 return 0;
12259}
12260
ce0ce13a
MB		 12261static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
12262 struct genl_info *info)
12263{
12264 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12265 struct net_device *dev = info->user_ptr[1];
12266 struct wireless_dev *wdev = dev->ieee80211_ptr;
12267 const struct nlattr *nla;
12268 bool enabled;
12269
ce0ce13a
MB		 12270 if (!rdev->ops->set_multicast_to_unicast)
12271 return -EOPNOTSUPP;
12272
12273 if (wdev->iftype != NL80211_IFTYPE_AP &&
12274 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12275 return -EOPNOTSUPP;
12276
12277 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
12278 enabled = nla_get_flag(nla);
12279
12280 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
12281}
12282
3a00df57
AS		 12283static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
12284{
12285 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12286 struct net_device *dev = info->user_ptr[1];
12287 struct wireless_dev *wdev = dev->ieee80211_ptr;
12288 struct cfg80211_pmk_conf pmk_conf = {};
12289 int ret;
12290
12291 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12292 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12293 return -EOPNOTSUPP;
12294
12295 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12296 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
12297 return -EOPNOTSUPP;
12298
12299 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
12300 return -EINVAL;
12301
12302 wdev_lock(wdev);
12303 if (!wdev->current_bss) {
12304 ret = -ENOTCONN;
12305 goto out;
12306 }
12307
12308 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
12309 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
12310 ret = -EINVAL;
12311 goto out;
12312 }
12313
12314 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
12315 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
12316 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
12317 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
12318 ret = -EINVAL;
12319 goto out;
12320 }
12321
12322 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) {
12323 int r0_name_len = nla_len(info->attrs[NL80211_ATTR_PMKR0_NAME]);
12324
12325 if (r0_name_len != WLAN_PMK_NAME_LEN) {
12326 ret = -EINVAL;
12327 goto out;
12328 }
12329
12330 pmk_conf.pmk_r0_name =
12331 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
12332 }
12333
12334 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
12335out:
12336 wdev_unlock(wdev);
12337 return ret;
12338}
12339
12340static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
12341{
12342 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12343 struct net_device *dev = info->user_ptr[1];
12344 struct wireless_dev *wdev = dev->ieee80211_ptr;
12345 const u8 *aa;
12346 int ret;
12347
12348 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12349 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12350 return -EOPNOTSUPP;
12351
12352 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12353 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
12354 return -EOPNOTSUPP;
12355
12356 if (!info->attrs[NL80211_ATTR_MAC])
12357 return -EINVAL;
12358
12359 wdev_lock(wdev);
12360 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
12361 ret = rdev_del_pmk(rdev, dev, aa);
12362 wdev_unlock(wdev);
12363
12364 return ret;
12365}
12366
4c476991
JB		 12367#define NL80211_FLAG_NEED_WIPHY 0x01
12368#define NL80211_FLAG_NEED_NETDEV 0x02
12369#define NL80211_FLAG_NEED_RTNL 0x04
41265714
JB		 12370#define NL80211_FLAG_CHECK_NETDEV_UP 0x08
12371#define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
12372 NL80211_FLAG_CHECK_NETDEV_UP)
1bf614ef 12373#define NL80211_FLAG_NEED_WDEV 0x10
98104fde 12374/* If a netdev is associated, it must be UP, P2P must be started */
1bf614ef
JB		 12375#define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
12376 NL80211_FLAG_CHECK_NETDEV_UP)
5393b917 12377#define NL80211_FLAG_CLEAR_SKB 0x20
4c476991 12378
f84f771d 12379static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12380 struct genl_info *info)
12381{
12382 struct cfg80211_registered_device *rdev;
89a54e48 12383 struct wireless_dev *wdev;
4c476991 12384 struct net_device *dev;
4c476991
JB		 12385 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
12386
12387 if (rtnl)
12388 rtnl_lock();
12389
12390 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
4f7eff10 12391 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
4c476991
JB		 12392 if (IS_ERR(rdev)) {
12393 if (rtnl)
12394 rtnl_unlock();
12395 return PTR_ERR(rdev);
12396 }
12397 info->user_ptr[0] = rdev;
1bf614ef
JB		 12398 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
12399 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
5fe231e8
JB		 12400 ASSERT_RTNL();
12401
89a54e48
JB		 12402 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
12403 info->attrs);
12404 if (IS_ERR(wdev)) {
4c476991
JB		 12405 if (rtnl)
12406 rtnl_unlock();
89a54e48 12407 return PTR_ERR(wdev);
4c476991 12408 }
89a54e48 12409
89a54e48 12410 dev = wdev->netdev;
f26cbf40 12411 rdev = wiphy_to_rdev(wdev->wiphy);
89a54e48 12412
1bf614ef
JB		 12413 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
12414 if (!dev) {
1bf614ef
JB		 12415 if (rtnl)
12416 rtnl_unlock();
12417 return -EINVAL;
12418 }
12419
12420 info->user_ptr[1] = dev;
12421 } else {
12422 info->user_ptr[1] = wdev;
41265714 12423 }
1bf614ef 12424
73c7da3d
AVS		 12425 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
12426 !wdev_running(wdev)) {
12427 if (rtnl)
12428 rtnl_unlock();
12429 return -ENETDOWN;
12430 }
1bf614ef 12431
73c7da3d 12432 if (dev)
1bf614ef 12433 dev_hold(dev);
89a54e48 12434
4c476991 12435 info->user_ptr[0] = rdev;
4c476991
JB		 12436 }
12437
12438 return 0;
12439}
12440
f84f771d 12441static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12442 struct genl_info *info)
12443{
1bf614ef
JB		 12444 if (info->user_ptr[1]) {
12445 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
12446 struct wireless_dev *wdev = info->user_ptr[1];
12447
12448 if (wdev->netdev)
12449 dev_put(wdev->netdev);
12450 } else {
12451 dev_put(info->user_ptr[1]);
12452 }
12453 }
5393b917 12454
4c476991
JB		 12455 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
12456 rtnl_unlock();
5393b917
JB		 12457
12458 /* If needed, clear the netlink message payload from the SKB
12459 * as it might contain key data that shouldn't stick around on
12460 * the heap after the SKB is freed. The netlink message header
12461 * is still needed for further processing, so leave it intact.
12462 */
12463 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
12464 struct nlmsghdr *nlh = nlmsg_hdr(skb);
12465
12466 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
12467 }
4c476991
JB		 12468}
12469
4534de83 12470static const struct genl_ops nl80211_ops[] = {
55682965
JB		 12471 {
12472 .cmd = NL80211_CMD_GET_WIPHY,
12473 .doit = nl80211_get_wiphy,
12474 .dumpit = nl80211_dump_wiphy,
86e8cf98 12475 .done = nl80211_dump_wiphy_done,
55682965
JB		 12476 .policy = nl80211_policy,
12477 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12478 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12479 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12480 },
12481 {
12482 .cmd = NL80211_CMD_SET_WIPHY,
12483 .doit = nl80211_set_wiphy,
12484 .policy = nl80211_policy,
5617c6cd 12485 .flags = GENL_UNS_ADMIN_PERM,
4c476991 12486 .internal_flags = NL80211_FLAG_NEED_RTNL,
55682965
JB		 12487 },
12488 {
12489 .cmd = NL80211_CMD_GET_INTERFACE,
12490 .doit = nl80211_get_interface,
12491 .dumpit = nl80211_dump_interface,
12492 .policy = nl80211_policy,
12493 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12494 .internal_flags = NL80211_FLAG_NEED_WDEV |
12495 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12496 },
12497 {
12498 .cmd = NL80211_CMD_SET_INTERFACE,
12499 .doit = nl80211_set_interface,
12500 .policy = nl80211_policy,
5617c6cd 12501 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12502 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12503 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12504 },
12505 {
12506 .cmd = NL80211_CMD_NEW_INTERFACE,
12507 .doit = nl80211_new_interface,
12508 .policy = nl80211_policy,
5617c6cd 12509 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12510 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12511 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12512 },
12513 {
12514 .cmd = NL80211_CMD_DEL_INTERFACE,
12515 .doit = nl80211_del_interface,
12516 .policy = nl80211_policy,
5617c6cd 12517 .flags = GENL_UNS_ADMIN_PERM,
84efbb84 12518 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12519 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12520 },
12521 {
12522 .cmd = NL80211_CMD_GET_KEY,
12523 .doit = nl80211_get_key,
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,
41ade00f
JB		 12528 },
12529 {
12530 .cmd = NL80211_CMD_SET_KEY,
12531 .doit = nl80211_set_key,
12532 .policy = nl80211_policy,
5617c6cd 12533 .flags = GENL_UNS_ADMIN_PERM,
41265714 12534 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12535 NL80211_FLAG_NEED_RTNL |
12536 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12537 },
12538 {
12539 .cmd = NL80211_CMD_NEW_KEY,
12540 .doit = nl80211_new_key,
12541 .policy = nl80211_policy,
5617c6cd 12542 .flags = GENL_UNS_ADMIN_PERM,
41265714 12543 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12544 NL80211_FLAG_NEED_RTNL |
12545 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12546 },
12547 {
12548 .cmd = NL80211_CMD_DEL_KEY,
12549 .doit = nl80211_del_key,
12550 .policy = nl80211_policy,
5617c6cd 12551 .flags = GENL_UNS_ADMIN_PERM,
41265714 12552 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12553 NL80211_FLAG_NEED_RTNL,
55682965 12554 },
ed1b6cc7
JB		 12555 {
12556 .cmd = NL80211_CMD_SET_BEACON,
12557 .policy = nl80211_policy,
5617c6cd 12558 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12559 .doit = nl80211_set_beacon,
2b5f8b0b 12560 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12561 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12562 },
12563 {
8860020e 12564 .cmd = NL80211_CMD_START_AP,
ed1b6cc7 12565 .policy = nl80211_policy,
5617c6cd 12566 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12567 .doit = nl80211_start_ap,
2b5f8b0b 12568 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12569 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12570 },
12571 {
8860020e 12572 .cmd = NL80211_CMD_STOP_AP,
ed1b6cc7 12573 .policy = nl80211_policy,
5617c6cd 12574 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12575 .doit = nl80211_stop_ap,
2b5f8b0b 12576 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12577 NL80211_FLAG_NEED_RTNL,
ed1b6cc7 12578 },
5727ef1b
JB		 12579 {
12580 .cmd = NL80211_CMD_GET_STATION,
12581 .doit = nl80211_get_station,
2ec600d6 12582 .dumpit = nl80211_dump_station,
5727ef1b 12583 .policy = nl80211_policy,
4c476991
JB		 12584 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12585 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12586 },
12587 {
12588 .cmd = NL80211_CMD_SET_STATION,
12589 .doit = nl80211_set_station,
12590 .policy = nl80211_policy,
5617c6cd 12591 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12592 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12593 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12594 },
12595 {
12596 .cmd = NL80211_CMD_NEW_STATION,
12597 .doit = nl80211_new_station,
12598 .policy = nl80211_policy,
5617c6cd 12599 .flags = GENL_UNS_ADMIN_PERM,
41265714 12600 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12601 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12602 },
12603 {
12604 .cmd = NL80211_CMD_DEL_STATION,
12605 .doit = nl80211_del_station,
12606 .policy = nl80211_policy,
5617c6cd 12607 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12608 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12609 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12610 },
12611 {
12612 .cmd = NL80211_CMD_GET_MPATH,
12613 .doit = nl80211_get_mpath,
12614 .dumpit = nl80211_dump_mpath,
12615 .policy = nl80211_policy,
5617c6cd 12616 .flags = GENL_UNS_ADMIN_PERM,
41265714 12617 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12618 NL80211_FLAG_NEED_RTNL,
2ec600d6 12619 },
66be7d2b
HR		 12620 {
12621 .cmd = NL80211_CMD_GET_MPP,
12622 .doit = nl80211_get_mpp,
12623 .dumpit = nl80211_dump_mpp,
12624 .policy = nl80211_policy,
5617c6cd 12625 .flags = GENL_UNS_ADMIN_PERM,
66be7d2b
HR		 12626 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12627 NL80211_FLAG_NEED_RTNL,
12628 },
2ec600d6
LCC		 12629 {
12630 .cmd = NL80211_CMD_SET_MPATH,
12631 .doit = nl80211_set_mpath,
12632 .policy = nl80211_policy,
5617c6cd 12633 .flags = GENL_UNS_ADMIN_PERM,
41265714 12634 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12635 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12636 },
12637 {
12638 .cmd = NL80211_CMD_NEW_MPATH,
12639 .doit = nl80211_new_mpath,
12640 .policy = nl80211_policy,
5617c6cd 12641 .flags = GENL_UNS_ADMIN_PERM,
41265714 12642 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12643 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12644 },
12645 {
12646 .cmd = NL80211_CMD_DEL_MPATH,
12647 .doit = nl80211_del_mpath,
12648 .policy = nl80211_policy,
5617c6cd 12649 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12650 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12651 NL80211_FLAG_NEED_RTNL,
9f1ba906
JM		 12652 },
12653 {
12654 .cmd = NL80211_CMD_SET_BSS,
12655 .doit = nl80211_set_bss,
12656 .policy = nl80211_policy,
5617c6cd 12657 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12658 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12659 NL80211_FLAG_NEED_RTNL,
b2e1b302 12660 },
f130347c
LR		 12661 {
12662 .cmd = NL80211_CMD_GET_REG,
ad30ca2c
AN		 12663 .doit = nl80211_get_reg_do,
12664 .dumpit = nl80211_get_reg_dump,
f130347c 12665 .policy = nl80211_policy,
5fe231e8 12666 .internal_flags = NL80211_FLAG_NEED_RTNL,
f130347c
LR		 12667 /* can be retrieved by unprivileged users */
12668 },
b6863036 12669#ifdef CONFIG_CFG80211_CRDA_SUPPORT
b2e1b302
LR		 12670 {
12671 .cmd = NL80211_CMD_SET_REG,
12672 .doit = nl80211_set_reg,
12673 .policy = nl80211_policy,
12674 .flags = GENL_ADMIN_PERM,
5fe231e8 12675 .internal_flags = NL80211_FLAG_NEED_RTNL,
b2e1b302 12676 },
b6863036 12677#endif
b2e1b302
LR		 12678 {
12679 .cmd = NL80211_CMD_REQ_SET_REG,
12680 .doit = nl80211_req_set_reg,
12681 .policy = nl80211_policy,
93da9cc1 12682 .flags = GENL_ADMIN_PERM,
12683 },
12684 {
24bdd9f4
JC		 12685 .cmd = NL80211_CMD_GET_MESH_CONFIG,
12686 .doit = nl80211_get_mesh_config,
93da9cc1 12687 .policy = nl80211_policy,
12688 /* can be retrieved by unprivileged users */
2b5f8b0b 12689 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12690 NL80211_FLAG_NEED_RTNL,
93da9cc1 12691 },
12692 {
24bdd9f4
JC		 12693 .cmd = NL80211_CMD_SET_MESH_CONFIG,
12694 .doit = nl80211_update_mesh_config,
93da9cc1 12695 .policy = nl80211_policy,
5617c6cd 12696 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c 12697 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12698 NL80211_FLAG_NEED_RTNL,
9aed3cc1 12699 },
2a519311
JB		 12700 {
12701 .cmd = NL80211_CMD_TRIGGER_SCAN,
12702 .doit = nl80211_trigger_scan,
12703 .policy = nl80211_policy,
5617c6cd 12704 .flags = GENL_UNS_ADMIN_PERM,
fd014284 12705 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12706 NL80211_FLAG_NEED_RTNL,
2a519311 12707 },
91d3ab46
VK		 12708 {
12709 .cmd = NL80211_CMD_ABORT_SCAN,
12710 .doit = nl80211_abort_scan,
12711 .policy = nl80211_policy,
5617c6cd 12712 .flags = GENL_UNS_ADMIN_PERM,
91d3ab46
VK		 12713 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12714 NL80211_FLAG_NEED_RTNL,
12715 },
2a519311
JB		 12716 {
12717 .cmd = NL80211_CMD_GET_SCAN,
12718 .policy = nl80211_policy,
12719 .dumpit = nl80211_dump_scan,
12720 },
807f8a8c
LC		 12721 {
12722 .cmd = NL80211_CMD_START_SCHED_SCAN,
12723 .doit = nl80211_start_sched_scan,
12724 .policy = nl80211_policy,
5617c6cd 12725 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12726 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12727 NL80211_FLAG_NEED_RTNL,
12728 },
12729 {
12730 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
12731 .doit = nl80211_stop_sched_scan,
12732 .policy = nl80211_policy,
5617c6cd 12733 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12734 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12735 NL80211_FLAG_NEED_RTNL,
12736 },
636a5d36
JM		 12737 {
12738 .cmd = NL80211_CMD_AUTHENTICATE,
12739 .doit = nl80211_authenticate,
12740 .policy = nl80211_policy,
5617c6cd 12741 .flags = GENL_UNS_ADMIN_PERM,
41265714 12742 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12743 NL80211_FLAG_NEED_RTNL |
12744 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 12745 },
12746 {
12747 .cmd = NL80211_CMD_ASSOCIATE,
12748 .doit = nl80211_associate,
12749 .policy = nl80211_policy,
5617c6cd 12750 .flags = GENL_UNS_ADMIN_PERM,
41265714 12751 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12752 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12753 },
12754 {
12755 .cmd = NL80211_CMD_DEAUTHENTICATE,
12756 .doit = nl80211_deauthenticate,
12757 .policy = nl80211_policy,
5617c6cd 12758 .flags = GENL_UNS_ADMIN_PERM,
41265714 12759 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12760 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12761 },
12762 {
12763 .cmd = NL80211_CMD_DISASSOCIATE,
12764 .doit = nl80211_disassociate,
12765 .policy = nl80211_policy,
5617c6cd 12766 .flags = GENL_UNS_ADMIN_PERM,
41265714 12767 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12768 NL80211_FLAG_NEED_RTNL,
636a5d36 12769 },
04a773ad
JB		 12770 {
12771 .cmd = NL80211_CMD_JOIN_IBSS,
12772 .doit = nl80211_join_ibss,
12773 .policy = nl80211_policy,
5617c6cd 12774 .flags = GENL_UNS_ADMIN_PERM,
41265714 12775 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12776 NL80211_FLAG_NEED_RTNL,
04a773ad
JB		 12777 },
12778 {
12779 .cmd = NL80211_CMD_LEAVE_IBSS,
12780 .doit = nl80211_leave_ibss,
12781 .policy = nl80211_policy,
5617c6cd 12782 .flags = GENL_UNS_ADMIN_PERM,
41265714 12783 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12784 NL80211_FLAG_NEED_RTNL,
04a773ad 12785 },
aff89a9b
JB		 12786#ifdef CONFIG_NL80211_TESTMODE
12787 {
12788 .cmd = NL80211_CMD_TESTMODE,
12789 .doit = nl80211_testmode_do,
71063f0e 12790 .dumpit = nl80211_testmode_dump,
aff89a9b 12791 .policy = nl80211_policy,
5617c6cd 12792 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12793 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12794 NL80211_FLAG_NEED_RTNL,
aff89a9b
JB		 12795 },
12796#endif
b23aa676
SO		 12797 {
12798 .cmd = NL80211_CMD_CONNECT,
12799 .doit = nl80211_connect,
12800 .policy = nl80211_policy,
5617c6cd 12801 .flags = GENL_UNS_ADMIN_PERM,
41265714 12802 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12803 NL80211_FLAG_NEED_RTNL,
b23aa676 12804 },
088e8df8 12805 {
12806 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
12807 .doit = nl80211_update_connect_params,
12808 .policy = nl80211_policy,
12809 .flags = GENL_ADMIN_PERM,
12810 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12811 NL80211_FLAG_NEED_RTNL,
12812 },
b23aa676
SO		 12813 {
12814 .cmd = NL80211_CMD_DISCONNECT,
12815 .doit = nl80211_disconnect,
12816 .policy = nl80211_policy,
5617c6cd 12817 .flags = GENL_UNS_ADMIN_PERM,
41265714 12818 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12819 NL80211_FLAG_NEED_RTNL,
b23aa676 12820 },
463d0183
JB		 12821 {
12822 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
12823 .doit = nl80211_wiphy_netns,
12824 .policy = nl80211_policy,
5617c6cd 12825 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12826 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12827 NL80211_FLAG_NEED_RTNL,
463d0183 12828 },
61fa713c
HS		 12829 {
12830 .cmd = NL80211_CMD_GET_SURVEY,
12831 .policy = nl80211_policy,
12832 .dumpit = nl80211_dump_survey,
12833 },
67fbb16b
SO		 12834 {
12835 .cmd = NL80211_CMD_SET_PMKSA,
12836 .doit = nl80211_setdel_pmksa,
12837 .policy = nl80211_policy,
5617c6cd 12838 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12839 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12840 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12841 },
12842 {
12843 .cmd = NL80211_CMD_DEL_PMKSA,
12844 .doit = nl80211_setdel_pmksa,
12845 .policy = nl80211_policy,
5617c6cd 12846 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12847 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12848 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12849 },
12850 {
12851 .cmd = NL80211_CMD_FLUSH_PMKSA,
12852 .doit = nl80211_flush_pmksa,
12853 .policy = nl80211_policy,
5617c6cd 12854 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12855 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12856 NL80211_FLAG_NEED_RTNL,
67fbb16b 12857 },
9588bbd5
JM		 12858 {
12859 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
12860 .doit = nl80211_remain_on_channel,
12861 .policy = nl80211_policy,
5617c6cd 12862 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12863 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12864 NL80211_FLAG_NEED_RTNL,
9588bbd5
JM		 12865 },
12866 {
12867 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
12868 .doit = nl80211_cancel_remain_on_channel,
12869 .policy = nl80211_policy,
5617c6cd 12870 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12871 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12872 NL80211_FLAG_NEED_RTNL,
9588bbd5 12873 },
13ae75b1
JM		 12874 {
12875 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
12876 .doit = nl80211_set_tx_bitrate_mask,
12877 .policy = nl80211_policy,
5617c6cd 12878 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12879 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12880 NL80211_FLAG_NEED_RTNL,
13ae75b1 12881 },
026331c4 12882 {
2e161f78
JB		 12883 .cmd = NL80211_CMD_REGISTER_FRAME,
12884 .doit = nl80211_register_mgmt,
026331c4 12885 .policy = nl80211_policy,
5617c6cd 12886 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12887 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12888 NL80211_FLAG_NEED_RTNL,
026331c4
JM		 12889 },
12890 {
2e161f78
JB		 12891 .cmd = NL80211_CMD_FRAME,
12892 .doit = nl80211_tx_mgmt,
026331c4 12893 .policy = nl80211_policy,
5617c6cd 12894 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12895 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
f7ca38df
JB		 12896 NL80211_FLAG_NEED_RTNL,
12897 },
12898 {
12899 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
12900 .doit = nl80211_tx_mgmt_cancel_wait,
12901 .policy = nl80211_policy,
5617c6cd 12902 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12903 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12904 NL80211_FLAG_NEED_RTNL,
026331c4 12905 },
ffb9eb3d
KV		 12906 {
12907 .cmd = NL80211_CMD_SET_POWER_SAVE,
12908 .doit = nl80211_set_power_save,
12909 .policy = nl80211_policy,
5617c6cd 12910 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12911 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12912 NL80211_FLAG_NEED_RTNL,
ffb9eb3d
KV		 12913 },
12914 {
12915 .cmd = NL80211_CMD_GET_POWER_SAVE,
12916 .doit = nl80211_get_power_save,
12917 .policy = nl80211_policy,
12918 /* can be retrieved by unprivileged users */
4c476991
JB		 12919 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12920 NL80211_FLAG_NEED_RTNL,
ffb9eb3d 12921 },
d6dc1a38
JO		 12922 {
12923 .cmd = NL80211_CMD_SET_CQM,
12924 .doit = nl80211_set_cqm,
12925 .policy = nl80211_policy,
5617c6cd 12926 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12927 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12928 NL80211_FLAG_NEED_RTNL,
d6dc1a38 12929 },
f444de05
JB		 12930 {
12931 .cmd = NL80211_CMD_SET_CHANNEL,
12932 .doit = nl80211_set_channel,
12933 .policy = nl80211_policy,
5617c6cd 12934 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12935 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12936 NL80211_FLAG_NEED_RTNL,
f444de05 12937 },
e8347eba
BJ		 12938 {
12939 .cmd = NL80211_CMD_SET_WDS_PEER,
12940 .doit = nl80211_set_wds_peer,
12941 .policy = nl80211_policy,
5617c6cd 12942 .flags = GENL_UNS_ADMIN_PERM,
43b19952
JB		 12943 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12944 NL80211_FLAG_NEED_RTNL,
e8347eba 12945 },
29cbe68c
JB		 12946 {
12947 .cmd = NL80211_CMD_JOIN_MESH,
12948 .doit = nl80211_join_mesh,
12949 .policy = nl80211_policy,
5617c6cd 12950 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12951 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12952 NL80211_FLAG_NEED_RTNL,
12953 },
12954 {
12955 .cmd = NL80211_CMD_LEAVE_MESH,
12956 .doit = nl80211_leave_mesh,
12957 .policy = nl80211_policy,
5617c6cd 12958 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12959 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12960 NL80211_FLAG_NEED_RTNL,
12961 },
6e0bd6c3
RL		 12962 {
12963 .cmd = NL80211_CMD_JOIN_OCB,
12964 .doit = nl80211_join_ocb,
12965 .policy = nl80211_policy,
5617c6cd 12966 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12967 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12968 NL80211_FLAG_NEED_RTNL,
12969 },
12970 {
12971 .cmd = NL80211_CMD_LEAVE_OCB,
12972 .doit = nl80211_leave_ocb,
12973 .policy = nl80211_policy,
5617c6cd 12974 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12975 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12976 NL80211_FLAG_NEED_RTNL,
12977 },
dfb89c56 12978#ifdef CONFIG_PM
ff1b6e69
JB		 12979 {
12980 .cmd = NL80211_CMD_GET_WOWLAN,
12981 .doit = nl80211_get_wowlan,
12982 .policy = nl80211_policy,
12983 /* can be retrieved by unprivileged users */
12984 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12985 NL80211_FLAG_NEED_RTNL,
12986 },
12987 {
12988 .cmd = NL80211_CMD_SET_WOWLAN,
12989 .doit = nl80211_set_wowlan,
12990 .policy = nl80211_policy,
5617c6cd 12991 .flags = GENL_UNS_ADMIN_PERM,
ff1b6e69
JB		 12992 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12993 NL80211_FLAG_NEED_RTNL,
12994 },
dfb89c56 12995#endif
e5497d76
JB		 12996 {
12997 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
12998 .doit = nl80211_set_rekey_data,
12999 .policy = nl80211_policy,
5617c6cd 13000 .flags = GENL_UNS_ADMIN_PERM,
e5497d76 13001 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 13002 NL80211_FLAG_NEED_RTNL |
13003 NL80211_FLAG_CLEAR_SKB,
e5497d76 13004 },
109086ce
AN		 13005 {
13006 .cmd = NL80211_CMD_TDLS_MGMT,
13007 .doit = nl80211_tdls_mgmt,
13008 .policy = nl80211_policy,
5617c6cd 13009 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 13010 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13011 NL80211_FLAG_NEED_RTNL,
13012 },
13013 {
13014 .cmd = NL80211_CMD_TDLS_OPER,
13015 .doit = nl80211_tdls_oper,
13016 .policy = nl80211_policy,
5617c6cd 13017 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 13018 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13019 NL80211_FLAG_NEED_RTNL,
13020 },
28946da7
JB		 13021 {
13022 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
13023 .doit = nl80211_register_unexpected_frame,
13024 .policy = nl80211_policy,
5617c6cd 13025 .flags = GENL_UNS_ADMIN_PERM,
28946da7
JB		 13026 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13027 NL80211_FLAG_NEED_RTNL,
13028 },
7f6cf311
JB		 13029 {
13030 .cmd = NL80211_CMD_PROBE_CLIENT,
13031 .doit = nl80211_probe_client,
13032 .policy = nl80211_policy,
5617c6cd 13033 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 13034 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7f6cf311
JB		 13035 NL80211_FLAG_NEED_RTNL,
13036 },
5e760230
JB		 13037 {
13038 .cmd = NL80211_CMD_REGISTER_BEACONS,
13039 .doit = nl80211_register_beacons,
13040 .policy = nl80211_policy,
5617c6cd 13041 .flags = GENL_UNS_ADMIN_PERM,
5e760230
JB		 13042 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13043 NL80211_FLAG_NEED_RTNL,
13044 },
1d9d9213
SW		 13045 {
13046 .cmd = NL80211_CMD_SET_NOACK_MAP,
13047 .doit = nl80211_set_noack_map,
13048 .policy = nl80211_policy,
5617c6cd 13049 .flags = GENL_UNS_ADMIN_PERM,
1d9d9213
SW		 13050 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13051 NL80211_FLAG_NEED_RTNL,
13052 },
98104fde
JB		 13053 {
13054 .cmd = NL80211_CMD_START_P2P_DEVICE,
13055 .doit = nl80211_start_p2p_device,
13056 .policy = nl80211_policy,
5617c6cd 13057 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 13058 .internal_flags = NL80211_FLAG_NEED_WDEV |
13059 NL80211_FLAG_NEED_RTNL,
13060 },
13061 {
13062 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
13063 .doit = nl80211_stop_p2p_device,
13064 .policy = nl80211_policy,
5617c6cd 13065 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 13066 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13067 NL80211_FLAG_NEED_RTNL,
cb3b7d87
AB		 13068 },
13069 {
13070 .cmd = NL80211_CMD_START_NAN,
13071 .doit = nl80211_start_nan,
13072 .policy = nl80211_policy,
13073 .flags = GENL_ADMIN_PERM,
13074 .internal_flags = NL80211_FLAG_NEED_WDEV |
13075 NL80211_FLAG_NEED_RTNL,
13076 },
13077 {
13078 .cmd = NL80211_CMD_STOP_NAN,
13079 .doit = nl80211_stop_nan,
13080 .policy = nl80211_policy,
13081 .flags = GENL_ADMIN_PERM,
13082 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13083 NL80211_FLAG_NEED_RTNL,
a442b761
AB		 13084 },
13085 {
13086 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
13087 .doit = nl80211_nan_add_func,
13088 .policy = nl80211_policy,
13089 .flags = GENL_ADMIN_PERM,
13090 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13091 NL80211_FLAG_NEED_RTNL,
13092 },
13093 {
13094 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
13095 .doit = nl80211_nan_del_func,
13096 .policy = nl80211_policy,
13097 .flags = GENL_ADMIN_PERM,
13098 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13099 NL80211_FLAG_NEED_RTNL,
a5a9dcf2
AB		 13100 },
13101 {
13102 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
13103 .doit = nl80211_nan_change_config,
13104 .policy = nl80211_policy,
13105 .flags = GENL_ADMIN_PERM,
13106 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13107 NL80211_FLAG_NEED_RTNL,
98104fde 13108 },
f4e583c8
AQ		 13109 {
13110 .cmd = NL80211_CMD_SET_MCAST_RATE,
13111 .doit = nl80211_set_mcast_rate,
77765eaf 13112 .policy = nl80211_policy,
5617c6cd 13113 .flags = GENL_UNS_ADMIN_PERM,
77765eaf
VT		 13114 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13115 NL80211_FLAG_NEED_RTNL,
13116 },
13117 {
13118 .cmd = NL80211_CMD_SET_MAC_ACL,
13119 .doit = nl80211_set_mac_acl,
f4e583c8 13120 .policy = nl80211_policy,
5617c6cd 13121 .flags = GENL_UNS_ADMIN_PERM,
f4e583c8
AQ		 13122 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13123 NL80211_FLAG_NEED_RTNL,
13124 },
04f39047
SW		 13125 {
13126 .cmd = NL80211_CMD_RADAR_DETECT,
13127 .doit = nl80211_start_radar_detection,
13128 .policy = nl80211_policy,
5617c6cd 13129 .flags = GENL_UNS_ADMIN_PERM,
04f39047
SW		 13130 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13131 NL80211_FLAG_NEED_RTNL,
13132 },
3713b4e3
JB		 13133 {
13134 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
13135 .doit = nl80211_get_protocol_features,
13136 .policy = nl80211_policy,
13137 },
355199e0
JM		 13138 {
13139 .cmd = NL80211_CMD_UPDATE_FT_IES,
13140 .doit = nl80211_update_ft_ies,
13141 .policy = nl80211_policy,
5617c6cd 13142 .flags = GENL_UNS_ADMIN_PERM,
355199e0
JM		 13143 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13144 NL80211_FLAG_NEED_RTNL,
13145 },
5de17984
AS		 13146 {
13147 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
13148 .doit = nl80211_crit_protocol_start,
13149 .policy = nl80211_policy,
5617c6cd 13150 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13151 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13152 NL80211_FLAG_NEED_RTNL,
13153 },
13154 {
13155 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
13156 .doit = nl80211_crit_protocol_stop,
13157 .policy = nl80211_policy,
5617c6cd 13158 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 13159 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13160 NL80211_FLAG_NEED_RTNL,
be29b99a
AK		 13161 },
13162 {
13163 .cmd = NL80211_CMD_GET_COALESCE,
13164 .doit = nl80211_get_coalesce,
13165 .policy = nl80211_policy,
13166 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13167 NL80211_FLAG_NEED_RTNL,
13168 },
13169 {
13170 .cmd = NL80211_CMD_SET_COALESCE,
13171 .doit = nl80211_set_coalesce,
13172 .policy = nl80211_policy,
5617c6cd 13173 .flags = GENL_UNS_ADMIN_PERM,
be29b99a
AK		 13174 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13175 NL80211_FLAG_NEED_RTNL,
16ef1fe2
SW		 13176 },
13177 {
13178 .cmd = NL80211_CMD_CHANNEL_SWITCH,
13179 .doit = nl80211_channel_switch,
13180 .policy = nl80211_policy,
5617c6cd 13181 .flags = GENL_UNS_ADMIN_PERM,
16ef1fe2
SW		 13182 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13183 NL80211_FLAG_NEED_RTNL,
13184 },
ad7e718c
JB		 13185 {
13186 .cmd = NL80211_CMD_VENDOR,
13187 .doit = nl80211_vendor_cmd,
7bdbe400 13188 .dumpit = nl80211_vendor_cmd_dump,
ad7e718c 13189 .policy = nl80211_policy,
5617c6cd 13190 .flags = GENL_UNS_ADMIN_PERM,
ad7e718c
JB		 13191 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13192 NL80211_FLAG_NEED_RTNL,
13193 },
fa9ffc74
KP		 13194 {
13195 .cmd = NL80211_CMD_SET_QOS_MAP,
13196 .doit = nl80211_set_qos_map,
13197 .policy = nl80211_policy,
5617c6cd 13198 .flags = GENL_UNS_ADMIN_PERM,
fa9ffc74
KP		 13199 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13200 NL80211_FLAG_NEED_RTNL,
13201 },
960d01ac
JB		 13202 {
13203 .cmd = NL80211_CMD_ADD_TX_TS,
13204 .doit = nl80211_add_tx_ts,
13205 .policy = nl80211_policy,
5617c6cd 13206 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13207 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13208 NL80211_FLAG_NEED_RTNL,
13209 },
13210 {
13211 .cmd = NL80211_CMD_DEL_TX_TS,
13212 .doit = nl80211_del_tx_ts,
13213 .policy = nl80211_policy,
5617c6cd 13214 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13215 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13216 NL80211_FLAG_NEED_RTNL,
13217 },
1057d35e
AN		 13218 {
13219 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
13220 .doit = nl80211_tdls_channel_switch,
13221 .policy = nl80211_policy,
5617c6cd 13222 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13223 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13224 NL80211_FLAG_NEED_RTNL,
13225 },
13226 {
13227 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
13228 .doit = nl80211_tdls_cancel_channel_switch,
13229 .policy = nl80211_policy,
5617c6cd 13230 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13231 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13232 NL80211_FLAG_NEED_RTNL,
13233 },
ce0ce13a
MB		 13234 {
13235 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
13236 .doit = nl80211_set_multicast_to_unicast,
13237 .policy = nl80211_policy,
13238 .flags = GENL_UNS_ADMIN_PERM,
13239 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13240 NL80211_FLAG_NEED_RTNL,
13241 },
3a00df57
AS		 13242 {
13243 .cmd = NL80211_CMD_SET_PMK,
13244 .doit = nl80211_set_pmk,
13245 .policy = nl80211_policy,
13246 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13247 NL80211_FLAG_NEED_RTNL,
13248 },
13249 {
13250 .cmd = NL80211_CMD_DEL_PMK,
13251 .doit = nl80211_del_pmk,
13252 .policy = nl80211_policy,
13253 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13254 NL80211_FLAG_NEED_RTNL,
13255 },
13256
55682965 13257};
9588bbd5 13258
56989f6d 13259static struct genl_family nl80211_fam __ro_after_init = {
489111e5
JB		 13260 .name = NL80211_GENL_NAME, /* have users key off the name instead */
13261 .hdrsize = 0, /* no private header */
13262 .version = 1, /* no particular meaning now */
13263 .maxattr = NL80211_ATTR_MAX,
13264 .netnsok = true,
13265 .pre_doit = nl80211_pre_doit,
13266 .post_doit = nl80211_post_doit,
13267 .module = THIS_MODULE,
13268 .ops = nl80211_ops,
13269 .n_ops = ARRAY_SIZE(nl80211_ops),
13270 .mcgrps = nl80211_mcgrps,
13271 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
13272};
13273
55682965
JB		 13274/* notification functions */
13275
3bb20556
JB		 13276void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
13277 enum nl80211_commands cmd)
55682965
JB		 13278{
13279 struct sk_buff *msg;
86e8cf98 13280 struct nl80211_dump_wiphy_state state = {};
55682965 13281
3bb20556
JB		 13282 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
13283 cmd != NL80211_CMD_DEL_WIPHY);
13284
fd2120ca 13285 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 13286 if (!msg)
13287 return;
13288
3bb20556 13289 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
55682965
JB		 13290 nlmsg_free(msg);
13291 return;
13292 }
13293
68eb5503 13294 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13295 NL80211_MCGRP_CONFIG, GFP_KERNEL);
55682965
JB		 13296}
13297
896ff063
DK		 13298void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
13299 struct wireless_dev *wdev,
13300 enum nl80211_commands cmd)
13301{
13302 struct sk_buff *msg;
13303
13304 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
13305 cmd != NL80211_CMD_DEL_INTERFACE);
13306
13307 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13308 if (!msg)
13309 return;
13310
13311 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev,
13312 cmd == NL80211_CMD_DEL_INTERFACE) < 0) {
13313 nlmsg_free(msg);
13314 return;
13315 }
13316
13317 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
13318 NL80211_MCGRP_CONFIG, GFP_KERNEL);
13319}
13320
362a415d
JB		 13321static int nl80211_add_scan_req(struct sk_buff *msg,
13322 struct cfg80211_registered_device *rdev)
13323{
13324 struct cfg80211_scan_request *req = rdev->scan_req;
13325 struct nlattr *nest;
13326 int i;
13327
13328 if (WARN_ON(!req))
13329 return 0;
13330
13331 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
13332 if (!nest)
13333 goto nla_put_failure;
9360ffd1
DM		 13334 for (i = 0; i < req->n_ssids; i++) {
13335 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
13336 goto nla_put_failure;
13337 }
362a415d
JB		 13338 nla_nest_end(msg, nest);
13339
13340 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
13341 if (!nest)
13342 goto nla_put_failure;
9360ffd1
DM		 13343 for (i = 0; i < req->n_channels; i++) {
13344 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
13345 goto nla_put_failure;
13346 }
362a415d
JB		 13347 nla_nest_end(msg, nest);
13348
9360ffd1
DM		 13349 if (req->ie &&
13350 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
13351 goto nla_put_failure;
362a415d 13352
ae917c9f
JB		 13353 if (req->flags &&
13354 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
13355 goto nla_put_failure;
ed473771 13356
1d76250b
AS		 13357 if (req->info.scan_start_tsf &&
13358 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
13359 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
13360 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
13361 req->info.tsf_bssid)))
13362 goto nla_put_failure;
13363
362a415d
JB		 13364 return 0;
13365 nla_put_failure:
13366 return -ENOBUFS;
13367}
13368
505a2e88 13369static int nl80211_prep_scan_msg(struct sk_buff *msg,
a538e2d5 13370 struct cfg80211_registered_device *rdev,
fd014284 13371 struct wireless_dev *wdev,
15e47304 13372 u32 portid, u32 seq, int flags,
a538e2d5 13373 u32 cmd)
2a519311
JB		 13374{
13375 void *hdr;
13376
15e47304 13377 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2a519311
JB		 13378 if (!hdr)
13379 return -1;
13380
9360ffd1 13381 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
fd014284
JB		 13382 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13383 wdev->netdev->ifindex)) ||
2dad624e
ND		 13384 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13385 NL80211_ATTR_PAD))
9360ffd1 13386 goto nla_put_failure;
2a519311 13387
362a415d
JB		 13388 /* ignore errors and send incomplete event anyway */
13389 nl80211_add_scan_req(msg, rdev);
2a519311 13390
053c095a
JB		 13391 genlmsg_end(msg, hdr);
13392 return 0;
2a519311
JB		 13393
13394 nla_put_failure:
13395 genlmsg_cancel(msg, hdr);
13396 return -EMSGSIZE;
13397}
13398
807f8a8c 13399static int
505a2e88 13400nl80211_prep_sched_scan_msg(struct sk_buff *msg,
96b08fd6 13401 struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13402{
13403 void *hdr;
13404
96b08fd6 13405 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
807f8a8c
LC		 13406 if (!hdr)
13407 return -1;
13408
96b08fd6
AVS		 13409 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
13410 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
13411 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
13412 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
13413 NL80211_ATTR_PAD))
9360ffd1 13414 goto nla_put_failure;
807f8a8c 13415
053c095a
JB		 13416 genlmsg_end(msg, hdr);
13417 return 0;
807f8a8c
LC		 13418
13419 nla_put_failure:
13420 genlmsg_cancel(msg, hdr);
13421 return -EMSGSIZE;
13422}
13423
a538e2d5 13424void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
fd014284 13425 struct wireless_dev *wdev)
a538e2d5
JB		 13426{
13427 struct sk_buff *msg;
13428
58050fce 13429 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
a538e2d5
JB		 13430 if (!msg)
13431 return;
13432
505a2e88 13433 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
a538e2d5
JB		 13434 NL80211_CMD_TRIGGER_SCAN) < 0) {
13435 nlmsg_free(msg);
13436 return;
13437 }
13438
68eb5503 13439 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13440 NL80211_MCGRP_SCAN, GFP_KERNEL);
a538e2d5
JB		 13441}
13442
f9d15d16
JB		 13443struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
13444 struct wireless_dev *wdev, bool aborted)
2a519311
JB		 13445{
13446 struct sk_buff *msg;
13447
fd2120ca 13448 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311 13449 if (!msg)
f9d15d16 13450 return NULL;
2a519311 13451
505a2e88 13452 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
f9d15d16
JB		 13453 aborted ? NL80211_CMD_SCAN_ABORTED :
13454 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311 13455 nlmsg_free(msg);
f9d15d16 13456 return NULL;
2a519311
JB		 13457 }
13458
f9d15d16 13459 return msg;
2a519311
JB		 13460}
13461
505a2e88
AVS		 13462/* send message created by nl80211_build_scan_msg() */
13463void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
13464 struct sk_buff *msg)
807f8a8c 13465{
807f8a8c
LC		 13466 if (!msg)
13467 return;
13468
68eb5503 13469 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13470 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13471}
13472
96b08fd6 13473void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13474{
13475 struct sk_buff *msg;
13476
58050fce 13477 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
807f8a8c
LC		 13478 if (!msg)
13479 return;
13480
96b08fd6 13481 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
807f8a8c
LC		 13482 nlmsg_free(msg);
13483 return;
13484 }
13485
96b08fd6 13486 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
2a94fe48 13487 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13488}
13489
b0d7aa59
JD		 13490static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
13491 struct regulatory_request *request)
73d54c9e 13492{
73d54c9e 13493 /* Userspace can always count this one always being set */
9360ffd1
DM		 13494 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
13495 goto nla_put_failure;
13496
13497 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
13498 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13499 NL80211_REGDOM_TYPE_WORLD))
13500 goto nla_put_failure;
13501 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
13502 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13503 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
13504 goto nla_put_failure;
13505 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
13506 request->intersect) {
13507 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13508 NL80211_REGDOM_TYPE_INTERSECTION))
13509 goto nla_put_failure;
13510 } else {
13511 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13512 NL80211_REGDOM_TYPE_COUNTRY) ||
13513 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
13514 request->alpha2))
13515 goto nla_put_failure;
13516 }
13517
ad30ca2c
AN		 13518 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
13519 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
13520
13521 if (wiphy &&
13522 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
13523 goto nla_put_failure;
1bdd716c
AN		 13524
13525 if (wiphy &&
13526 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
13527 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
13528 goto nla_put_failure;
ad30ca2c 13529 }
73d54c9e 13530
b0d7aa59
JD		 13531 return true;
13532
13533nla_put_failure:
13534 return false;
13535}
13536
13537/*
13538 * This can happen on global regulatory changes or device specific settings
13539 * based on custom regulatory domains.
13540 */
13541void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
13542 struct regulatory_request *request)
13543{
13544 struct sk_buff *msg;
13545 void *hdr;
13546
13547 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13548 if (!msg)
13549 return;
13550
13551 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
13552 if (!hdr) {
13553 nlmsg_free(msg);
13554 return;
13555 }
13556
13557 if (nl80211_reg_change_event_fill(msg, request) == false)
13558 goto nla_put_failure;
13559
3b7b72ee 13560 genlmsg_end(msg, hdr);
73d54c9e 13561
bc43b28c 13562 rcu_read_lock();
68eb5503 13563 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13564 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
bc43b28c 13565 rcu_read_unlock();
73d54c9e
LR		 13566
13567 return;
13568
13569nla_put_failure:
13570 genlmsg_cancel(msg, hdr);
13571 nlmsg_free(msg);
13572}
13573
6039f6d2
JM		 13574static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
13575 struct net_device *netdev,
13576 const u8 *buf, size_t len,
b0b6aa2c
EP		 13577 enum nl80211_commands cmd, gfp_t gfp,
13578 int uapsd_queues)
6039f6d2
JM		 13579{
13580 struct sk_buff *msg;
13581 void *hdr;
13582
4ef8c1c9 13583 msg = nlmsg_new(100 + len, gfp);
6039f6d2
JM		 13584 if (!msg)
13585 return;
13586
13587 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13588 if (!hdr) {
13589 nlmsg_free(msg);
13590 return;
13591 }
13592
9360ffd1
DM		 13593 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13594 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13595 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
13596 goto nla_put_failure;
6039f6d2 13597
b0b6aa2c
EP		 13598 if (uapsd_queues >= 0) {
13599 struct nlattr *nla_wmm =
13600 nla_nest_start(msg, NL80211_ATTR_STA_WME);
13601 if (!nla_wmm)
13602 goto nla_put_failure;
13603
13604 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
13605 uapsd_queues))
13606 goto nla_put_failure;
13607
13608 nla_nest_end(msg, nla_wmm);
13609 }
13610
3b7b72ee 13611 genlmsg_end(msg, hdr);
6039f6d2 13612
68eb5503 13613 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13614 NL80211_MCGRP_MLME, gfp);
6039f6d2
JM		 13615 return;
13616
13617 nla_put_failure:
13618 genlmsg_cancel(msg, hdr);
13619 nlmsg_free(msg);
13620}
13621
13622void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13623 struct net_device *netdev, const u8 *buf,
13624 size_t len, gfp_t gfp)
6039f6d2
JM		 13625{
13626 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13627 NL80211_CMD_AUTHENTICATE, gfp, -1);
6039f6d2
JM		 13628}
13629
13630void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
13631 struct net_device *netdev, const u8 *buf,
b0b6aa2c 13632 size_t len, gfp_t gfp, int uapsd_queues)
6039f6d2 13633{
e6d6e342 13634 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13635 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
6039f6d2
JM		 13636}
13637
53b46b84 13638void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13639 struct net_device *netdev, const u8 *buf,
13640 size_t len, gfp_t gfp)
6039f6d2
JM		 13641{
13642 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13643 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
6039f6d2
JM		 13644}
13645
53b46b84
JM		 13646void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
13647 struct net_device *netdev, const u8 *buf,
e6d6e342 13648 size_t len, gfp_t gfp)
6039f6d2
JM		 13649{
13650 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13651 NL80211_CMD_DISASSOCIATE, gfp, -1);
6039f6d2
JM		 13652}
13653
6ff57cf8
JB		 13654void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
13655 size_t len)
cf4e594e 13656{
947add36
JB		 13657 struct wireless_dev *wdev = dev->ieee80211_ptr;
13658 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13659 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
6ff57cf8
JB		 13660 const struct ieee80211_mgmt *mgmt = (void *)buf;
13661 u32 cmd;
947add36 13662
6ff57cf8
JB		 13663 if (WARN_ON(len < 2))
13664 return;
cf4e594e 13665
6ff57cf8
JB		 13666 if (ieee80211_is_deauth(mgmt->frame_control))
13667 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
13668 else
13669 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
947add36 13670
6ff57cf8 13671 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
b0b6aa2c 13672 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
cf4e594e 13673}
6ff57cf8 13674EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
cf4e594e 13675
1b06bb40
LR		 13676static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
13677 struct net_device *netdev, int cmd,
e6d6e342 13678 const u8 *addr, gfp_t gfp)
1965c853
JM		 13679{
13680 struct sk_buff *msg;
13681 void *hdr;
13682
e6d6e342 13683 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 13684 if (!msg)
13685 return;
13686
13687 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13688 if (!hdr) {
13689 nlmsg_free(msg);
13690 return;
13691 }
13692
9360ffd1
DM		 13693 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13694 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13695 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
13696 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
13697 goto nla_put_failure;
1965c853 13698
3b7b72ee 13699 genlmsg_end(msg, hdr);
1965c853 13700
68eb5503 13701 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13702 NL80211_MCGRP_MLME, gfp);
1965c853
JM		 13703 return;
13704
13705 nla_put_failure:
13706 genlmsg_cancel(msg, hdr);
13707 nlmsg_free(msg);
13708}
13709
13710void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13711 struct net_device *netdev, const u8 *addr,
13712 gfp_t gfp)
1965c853
JM		 13713{
13714 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 13715 addr, gfp);
1965c853
JM		 13716}
13717
13718void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13719 struct net_device *netdev, const u8 *addr,
13720 gfp_t gfp)
1965c853 13721{
e6d6e342
JB		 13722 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
13723 addr, gfp);
1965c853
JM		 13724}
13725
b23aa676 13726void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
5349a0f7
VK		 13727 struct net_device *netdev,
13728 struct cfg80211_connect_resp_params *cr,
3093ebbe 13729 gfp_t gfp)
b23aa676
SO		 13730{
13731 struct sk_buff *msg;
13732 void *hdr;
13733
a3caf744
VK		 13734 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
13735 cr->fils_kek_len + cr->pmk_len +
13736 (cr->pmkid ? WLAN_PMKID_LEN : 0), gfp);
b23aa676
SO		 13737 if (!msg)
13738 return;
13739
13740 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
13741 if (!hdr) {
13742 nlmsg_free(msg);
13743 return;
13744 }
13745
9360ffd1
DM		 13746 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13747 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
5349a0f7
VK		 13748 (cr->bssid &&
13749 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
bf1ecd21 13750 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
5349a0f7
VK		 13751 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
13752 cr->status) ||
13753 (cr->status < 0 &&
3093ebbe 13754 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
5349a0f7
VK		 13755 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
13756 cr->timeout_reason))) ||
13757 (cr->req_ie &&
13758 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
13759 (cr->resp_ie &&
13760 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
a3caf744
VK		 13761 cr->resp_ie)) ||
13762 (cr->update_erp_next_seq_num &&
13763 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
13764 cr->fils_erp_next_seq_num)) ||
13765 (cr->status == WLAN_STATUS_SUCCESS &&
13766 ((cr->fils_kek &&
13767 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils_kek_len,
13768 cr->fils_kek)) ||
13769 (cr->pmk &&
13770 nla_put(msg, NL80211_ATTR_PMK, cr->pmk_len, cr->pmk)) ||
13771 (cr->pmkid &&
13772 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->pmkid)))))
9360ffd1 13773 goto nla_put_failure;
b23aa676 13774
3b7b72ee 13775 genlmsg_end(msg, hdr);
b23aa676 13776
68eb5503 13777 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13778 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13779 return;
13780
13781 nla_put_failure:
13782 genlmsg_cancel(msg, hdr);
13783 nlmsg_free(msg);
b23aa676
SO		 13784}
13785
13786void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
29ce6ecb
AS		 13787 struct net_device *netdev,
13788 struct cfg80211_roam_info *info, gfp_t gfp)
b23aa676
SO		 13789{
13790 struct sk_buff *msg;
13791 void *hdr;
29ce6ecb 13792 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
b23aa676 13793
29ce6ecb 13794 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len, gfp);
b23aa676
SO		 13795 if (!msg)
13796 return;
13797
13798 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
13799 if (!hdr) {
13800 nlmsg_free(msg);
13801 return;
13802 }
13803
9360ffd1
DM		 13804 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13805 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13806 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
29ce6ecb
AS		 13807 (info->req_ie &&
13808 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
13809 info->req_ie)) ||
13810 (info->resp_ie &&
13811 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
f45cbe6e
AS		 13812 info->resp_ie)) ||
13813 (info->authorized &&
13814 nla_put_flag(msg, NL80211_ATTR_PORT_AUTHORIZED)))
9360ffd1 13815 goto nla_put_failure;
b23aa676 13816
3b7b72ee 13817 genlmsg_end(msg, hdr);
b23aa676 13818
68eb5503 13819 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13820 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13821 return;
13822
13823 nla_put_failure:
13824 genlmsg_cancel(msg, hdr);
13825 nlmsg_free(msg);
b23aa676
SO		 13826}
13827
13828void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
13829 struct net_device *netdev, u16 reason,
667503dd 13830 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 13831{
13832 struct sk_buff *msg;
13833 void *hdr;
13834
4ef8c1c9 13835 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
b23aa676
SO		 13836 if (!msg)
13837 return;
13838
13839 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
13840 if (!hdr) {
13841 nlmsg_free(msg);
13842 return;
13843 }
13844
9360ffd1
DM		 13845 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13846 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13847 (from_ap && reason &&
13848 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
13849 (from_ap &&
13850 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
13851 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
13852 goto nla_put_failure;
b23aa676 13853
3b7b72ee 13854 genlmsg_end(msg, hdr);
b23aa676 13855
68eb5503 13856 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13857 NL80211_MCGRP_MLME, GFP_KERNEL);
b23aa676
SO		 13858 return;
13859
13860 nla_put_failure:
13861 genlmsg_cancel(msg, hdr);
13862 nlmsg_free(msg);
b23aa676
SO		 13863}
13864
04a773ad
JB		 13865void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
13866 struct net_device *netdev, const u8 *bssid,
13867 gfp_t gfp)
13868{
13869 struct sk_buff *msg;
13870 void *hdr;
13871
fd2120ca 13872 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 13873 if (!msg)
13874 return;
13875
13876 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
13877 if (!hdr) {
13878 nlmsg_free(msg);
13879 return;
13880 }
13881
9360ffd1
DM		 13882 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13883 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13884 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
13885 goto nla_put_failure;
04a773ad 13886
3b7b72ee 13887 genlmsg_end(msg, hdr);
04a773ad 13888
68eb5503 13889 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13890 NL80211_MCGRP_MLME, gfp);
04a773ad
JB		 13891 return;
13892
13893 nla_put_failure:
13894 genlmsg_cancel(msg, hdr);
13895 nlmsg_free(msg);
13896}
13897
947add36
JB		 13898void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
13899 const u8* ie, u8 ie_len, gfp_t gfp)
c93b5e71 13900{
947add36 13901 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 13902 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
c93b5e71
JC		 13903 struct sk_buff *msg;
13904 void *hdr;
13905
947add36
JB		 13906 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
13907 return;
13908
13909 trace_cfg80211_notify_new_peer_candidate(dev, addr);
13910
4ef8c1c9 13911 msg = nlmsg_new(100 + ie_len, gfp);
c93b5e71
JC		 13912 if (!msg)
13913 return;
13914
13915 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
13916 if (!hdr) {
13917 nlmsg_free(msg);
13918 return;
13919 }
13920
9360ffd1 13921 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36
JB		 13922 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
13923 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9360ffd1
DM		 13924 (ie_len && ie &&
13925 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
13926 goto nla_put_failure;
c93b5e71 13927
3b7b72ee 13928 genlmsg_end(msg, hdr);
c93b5e71 13929
68eb5503 13930 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13931 NL80211_MCGRP_MLME, gfp);
c93b5e71
JC		 13932 return;
13933
13934 nla_put_failure:
13935 genlmsg_cancel(msg, hdr);
13936 nlmsg_free(msg);
13937}
947add36 13938EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
c93b5e71 13939
a3b8b056
JM		 13940void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
13941 struct net_device *netdev, const u8 *addr,
13942 enum nl80211_key_type key_type, int key_id,
e6d6e342 13943 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 13944{
13945 struct sk_buff *msg;
13946 void *hdr;
13947
e6d6e342 13948 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 13949 if (!msg)
13950 return;
13951
13952 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
13953 if (!hdr) {
13954 nlmsg_free(msg);
13955 return;
13956 }
13957
9360ffd1
DM		 13958 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13959 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13960 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
13961 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
13962 (key_id != -1 &&
13963 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
13964 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
13965 goto nla_put_failure;
a3b8b056 13966
3b7b72ee 13967 genlmsg_end(msg, hdr);
a3b8b056 13968
68eb5503 13969 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13970 NL80211_MCGRP_MLME, gfp);
a3b8b056
JM		 13971 return;
13972
13973 nla_put_failure:
13974 genlmsg_cancel(msg, hdr);
13975 nlmsg_free(msg);
13976}
13977
6bad8766
LR		 13978void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
13979 struct ieee80211_channel *channel_before,
13980 struct ieee80211_channel *channel_after)
13981{
13982 struct sk_buff *msg;
13983 void *hdr;
13984 struct nlattr *nl_freq;
13985
fd2120ca 13986 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 13987 if (!msg)
13988 return;
13989
13990 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
13991 if (!hdr) {
13992 nlmsg_free(msg);
13993 return;
13994 }
13995
13996 /*
13997 * Since we are applying the beacon hint to a wiphy we know its
13998 * wiphy_idx is valid
13999 */
9360ffd1
DM		 14000 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
14001 goto nla_put_failure;
6bad8766
LR		 14002
14003 /* Before */
14004 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
14005 if (!nl_freq)
14006 goto nla_put_failure;
cdc89b97 14007 if (nl80211_msg_put_channel(msg, channel_before, false))
6bad8766
LR		 14008 goto nla_put_failure;
14009 nla_nest_end(msg, nl_freq);
14010
14011 /* After */
14012 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
14013 if (!nl_freq)
14014 goto nla_put_failure;
cdc89b97 14015 if (nl80211_msg_put_channel(msg, channel_after, false))
6bad8766
LR		 14016 goto nla_put_failure;
14017 nla_nest_end(msg, nl_freq);
14018
3b7b72ee 14019 genlmsg_end(msg, hdr);
6bad8766 14020
463d0183 14021 rcu_read_lock();
68eb5503 14022 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 14023 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
463d0183 14024 rcu_read_unlock();
6bad8766
LR		 14025
14026 return;
14027
14028nla_put_failure:
14029 genlmsg_cancel(msg, hdr);
14030 nlmsg_free(msg);
14031}
14032
9588bbd5
JM		 14033static void nl80211_send_remain_on_chan_event(
14034 int cmd, struct cfg80211_registered_device *rdev,
71bbc994 14035 struct wireless_dev *wdev, u64 cookie,
9588bbd5 14036 struct ieee80211_channel *chan,
9588bbd5
JM		 14037 unsigned int duration, gfp_t gfp)
14038{
14039 struct sk_buff *msg;
14040 void *hdr;
14041
14042 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14043 if (!msg)
14044 return;
14045
14046 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14047 if (!hdr) {
14048 nlmsg_free(msg);
14049 return;
14050 }
14051
9360ffd1 14052 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14053 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14054 wdev->netdev->ifindex)) ||
2dad624e
ND		 14055 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14056 NL80211_ATTR_PAD) ||
9360ffd1 14057 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
42d97a59
JB		 14058 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
14059 NL80211_CHAN_NO_HT) ||
2dad624e
ND		 14060 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14061 NL80211_ATTR_PAD))
9360ffd1 14062 goto nla_put_failure;
9588bbd5 14063
9360ffd1
DM		 14064 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
14065 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
14066 goto nla_put_failure;
9588bbd5 14067
3b7b72ee 14068 genlmsg_end(msg, hdr);
9588bbd5 14069
68eb5503 14070 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14071 NL80211_MCGRP_MLME, gfp);
9588bbd5
JM		 14072 return;
14073
14074 nla_put_failure:
14075 genlmsg_cancel(msg, hdr);
14076 nlmsg_free(msg);
14077}
14078
947add36
JB		 14079void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
14080 struct ieee80211_channel *chan,
14081 unsigned int duration, gfp_t gfp)
9588bbd5 14082{
947add36 14083 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14084 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14085
14086 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9588bbd5 14087 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
71bbc994 14088 rdev, wdev, cookie, chan,
42d97a59 14089 duration, gfp);
9588bbd5 14090}
947add36 14091EXPORT_SYMBOL(cfg80211_ready_on_channel);
9588bbd5 14092
947add36
JB		 14093void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
14094 struct ieee80211_channel *chan,
14095 gfp_t gfp)
9588bbd5 14096{
947add36 14097 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14098 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14099
14100 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9588bbd5 14101 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
42d97a59 14102 rdev, wdev, cookie, chan, 0, gfp);
9588bbd5 14103}
947add36 14104EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9588bbd5 14105
947add36
JB		 14106void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
14107 struct station_info *sinfo, gfp_t gfp)
98b62183 14108{
947add36 14109 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14110 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
98b62183
JB		 14111 struct sk_buff *msg;
14112
947add36
JB		 14113 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
14114
58050fce 14115 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
98b62183
JB		 14116 if (!msg)
14117 return;
14118
cf5ead82 14119 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
66266b3a 14120 rdev, dev, mac_addr, sinfo) < 0) {
98b62183
JB		 14121 nlmsg_free(msg);
14122 return;
14123 }
14124
68eb5503 14125 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14126 NL80211_MCGRP_MLME, gfp);
98b62183 14127}
947add36 14128EXPORT_SYMBOL(cfg80211_new_sta);
98b62183 14129
cf5ead82
JB		 14130void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
14131 struct station_info *sinfo, gfp_t gfp)
ec15e68b 14132{
947add36 14133 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14134 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ec15e68b 14135 struct sk_buff *msg;
cf5ead82
JB		 14136 struct station_info empty_sinfo = {};
14137
14138 if (!sinfo)
14139 sinfo = &empty_sinfo;
ec15e68b 14140
947add36
JB		 14141 trace_cfg80211_del_sta(dev, mac_addr);
14142
58050fce 14143 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
ec15e68b
JM		 14144 if (!msg)
14145 return;
14146
cf5ead82 14147 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
57007121 14148 rdev, dev, mac_addr, sinfo) < 0) {
ec15e68b
JM		 14149 nlmsg_free(msg);
14150 return;
14151 }
14152
68eb5503 14153 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14154 NL80211_MCGRP_MLME, gfp);
ec15e68b 14155}
cf5ead82 14156EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
ec15e68b 14157
947add36
JB		 14158void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
14159 enum nl80211_connect_failed_reason reason,
14160 gfp_t gfp)
ed44a951 14161{
947add36 14162 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 14163 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ed44a951
PP		 14164 struct sk_buff *msg;
14165 void *hdr;
14166
14167 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
14168 if (!msg)
14169 return;
14170
14171 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
14172 if (!hdr) {
14173 nlmsg_free(msg);
14174 return;
14175 }
14176
14177 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14178 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
14179 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
14180 goto nla_put_failure;
14181
14182 genlmsg_end(msg, hdr);
14183
68eb5503 14184 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14185 NL80211_MCGRP_MLME, gfp);
ed44a951
PP		 14186 return;
14187
14188 nla_put_failure:
14189 genlmsg_cancel(msg, hdr);
14190 nlmsg_free(msg);
14191}
947add36 14192EXPORT_SYMBOL(cfg80211_conn_failed);
ed44a951 14193
b92ab5d8
JB		 14194static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
14195 const u8 *addr, gfp_t gfp)
28946da7
JB		 14196{
14197 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14198 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
28946da7
JB		 14199 struct sk_buff *msg;
14200 void *hdr;
15e47304 14201 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
28946da7 14202
15e47304 14203 if (!nlportid)
28946da7
JB		 14204 return false;
14205
14206 msg = nlmsg_new(100, gfp);
14207 if (!msg)
14208 return true;
14209
b92ab5d8 14210 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
28946da7
JB		 14211 if (!hdr) {
14212 nlmsg_free(msg);
14213 return true;
14214 }
14215
9360ffd1
DM		 14216 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14217 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14218 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
14219 goto nla_put_failure;
28946da7 14220
9c90a9f6 14221 genlmsg_end(msg, hdr);
15e47304 14222 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
28946da7
JB		 14223 return true;
14224
14225 nla_put_failure:
14226 genlmsg_cancel(msg, hdr);
14227 nlmsg_free(msg);
14228 return true;
14229}
14230
947add36
JB		 14231bool cfg80211_rx_spurious_frame(struct net_device *dev,
14232 const u8 *addr, gfp_t gfp)
b92ab5d8 14233{
947add36
JB		 14234 struct wireless_dev *wdev = dev->ieee80211_ptr;
14235 bool ret;
14236
14237 trace_cfg80211_rx_spurious_frame(dev, addr);
14238
14239 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14240 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
14241 trace_cfg80211_return_bool(false);
14242 return false;
14243 }
14244 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
14245 addr, gfp);
14246 trace_cfg80211_return_bool(ret);
14247 return ret;
b92ab5d8 14248}
947add36 14249EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
b92ab5d8 14250
947add36
JB		 14251bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
14252 const u8 *addr, gfp_t gfp)
b92ab5d8 14253{
947add36
JB		 14254 struct wireless_dev *wdev = dev->ieee80211_ptr;
14255 bool ret;
14256
14257 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
14258
14259 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14260 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
14261 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
14262 trace_cfg80211_return_bool(false);
14263 return false;
14264 }
14265 ret = __nl80211_unexpected_frame(dev,
14266 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
14267 addr, gfp);
14268 trace_cfg80211_return_bool(ret);
14269 return ret;
b92ab5d8 14270}
947add36 14271EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
b92ab5d8 14272
2e161f78 14273int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15e47304 14274 struct wireless_dev *wdev, u32 nlportid,
804483e9 14275 int freq, int sig_dbm,
19504cf5 14276 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
026331c4 14277{
71bbc994 14278 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14279 struct sk_buff *msg;
14280 void *hdr;
026331c4 14281
4ef8c1c9 14282 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14283 if (!msg)
14284 return -ENOMEM;
14285
2e161f78 14286 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
026331c4
JM		 14287 if (!hdr) {
14288 nlmsg_free(msg);
14289 return -ENOMEM;
14290 }
14291
9360ffd1 14292 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14293 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14294 netdev->ifindex)) ||
2dad624e
ND		 14295 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14296 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14297 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
14298 (sig_dbm &&
14299 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19504cf5
VK		 14300 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
14301 (flags &&
14302 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
9360ffd1 14303 goto nla_put_failure;
026331c4 14304
3b7b72ee 14305 genlmsg_end(msg, hdr);
026331c4 14306
15e47304 14307 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
026331c4
JM		 14308
14309 nla_put_failure:
14310 genlmsg_cancel(msg, hdr);
14311 nlmsg_free(msg);
14312 return -ENOBUFS;
14313}
14314
947add36
JB		 14315void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
14316 const u8 *buf, size_t len, bool ack, gfp_t gfp)
026331c4 14317{
947add36 14318 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14319 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
71bbc994 14320 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14321 struct sk_buff *msg;
14322 void *hdr;
14323
947add36
JB		 14324 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
14325
4ef8c1c9 14326 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14327 if (!msg)
14328 return;
14329
2e161f78 14330 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
026331c4
JM		 14331 if (!hdr) {
14332 nlmsg_free(msg);
14333 return;
14334 }
14335
9360ffd1 14336 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14337 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14338 netdev->ifindex)) ||
2dad624e
ND		 14339 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14340 NL80211_ATTR_PAD) ||
9360ffd1 14341 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
2dad624e
ND		 14342 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14343 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14344 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
14345 goto nla_put_failure;
026331c4 14346
3b7b72ee 14347 genlmsg_end(msg, hdr);
026331c4 14348
68eb5503 14349 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14350 NL80211_MCGRP_MLME, gfp);
026331c4
JM		 14351 return;
14352
14353 nla_put_failure:
14354 genlmsg_cancel(msg, hdr);
14355 nlmsg_free(msg);
14356}
947add36 14357EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
026331c4 14358
5b97f49d
JB		 14359static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
14360 const char *mac, gfp_t gfp)
d6dc1a38 14361{
947add36 14362 struct wireless_dev *wdev = dev->ieee80211_ptr;
5b97f49d
JB		 14363 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
14364 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14365 void **cb;
947add36 14366
d6dc1a38 14367 if (!msg)
5b97f49d 14368 return NULL;
d6dc1a38 14369
5b97f49d
JB		 14370 cb = (void **)msg->cb;
14371
14372 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
14373 if (!cb[0]) {
d6dc1a38 14374 nlmsg_free(msg);
5b97f49d 14375 return NULL;
d6dc1a38
JO		 14376 }
14377
9360ffd1 14378 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36 14379 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9360ffd1 14380 goto nla_put_failure;
d6dc1a38 14381
5b97f49d 14382 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
d6dc1a38
JO		 14383 goto nla_put_failure;
14384
5b97f49d
JB		 14385 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
14386 if (!cb[1])
9360ffd1 14387 goto nla_put_failure;
d6dc1a38 14388
5b97f49d 14389 cb[2] = rdev;
d6dc1a38 14390
5b97f49d
JB		 14391 return msg;
14392 nla_put_failure:
14393 nlmsg_free(msg);
14394 return NULL;
14395}
14396
14397static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
14398{
14399 void **cb = (void **)msg->cb;
14400 struct cfg80211_registered_device *rdev = cb[2];
14401
14402 nla_nest_end(msg, cb[1]);
14403 genlmsg_end(msg, cb[0]);
14404
14405 memset(msg->cb, 0, sizeof(msg->cb));
d6dc1a38 14406
68eb5503 14407 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14408 NL80211_MCGRP_MLME, gfp);
5b97f49d
JB		 14409}
14410
14411void cfg80211_cqm_rssi_notify(struct net_device *dev,
14412 enum nl80211_cqm_rssi_threshold_event rssi_event,
bee427b8 14413 s32 rssi_level, gfp_t gfp)
5b97f49d
JB		 14414{
14415 struct sk_buff *msg;
4a4b8169
AZ		 14416 struct wireless_dev *wdev = dev->ieee80211_ptr;
14417 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
5b97f49d 14418
bee427b8 14419 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
5b97f49d 14420
98f03342
JB		 14421 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
14422 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
14423 return;
14424
4a4b8169
AZ		 14425 if (wdev->cqm_config) {
14426 wdev->cqm_config->last_rssi_event_value = rssi_level;
14427
14428 cfg80211_cqm_rssi_update(rdev, dev);
14429
14430 if (rssi_level == 0)
14431 rssi_level = wdev->cqm_config->last_rssi_event_value;
14432 }
14433
5b97f49d
JB		 14434 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14435 if (!msg)
14436 return;
14437
14438 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
14439 rssi_event))
14440 goto nla_put_failure;
14441
bee427b8
AZ		 14442 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
14443 rssi_level))
14444 goto nla_put_failure;
14445
5b97f49d
JB		 14446 cfg80211_send_cqm(msg, gfp);
14447
d6dc1a38
JO		 14448 return;
14449
14450 nla_put_failure:
d6dc1a38
JO		 14451 nlmsg_free(msg);
14452}
947add36 14453EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
d6dc1a38 14454
5b97f49d
JB		 14455void cfg80211_cqm_txe_notify(struct net_device *dev,
14456 const u8 *peer, u32 num_packets,
14457 u32 rate, u32 intvl, gfp_t gfp)
14458{
14459 struct sk_buff *msg;
14460
14461 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14462 if (!msg)
14463 return;
14464
14465 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
14466 goto nla_put_failure;
14467
14468 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
14469 goto nla_put_failure;
14470
14471 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
14472 goto nla_put_failure;
14473
14474 cfg80211_send_cqm(msg, gfp);
14475 return;
14476
14477 nla_put_failure:
14478 nlmsg_free(msg);
14479}
14480EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
14481
14482void cfg80211_cqm_pktloss_notify(struct net_device *dev,
14483 const u8 *peer, u32 num_packets, gfp_t gfp)
14484{
14485 struct sk_buff *msg;
14486
14487 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
14488
14489 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14490 if (!msg)
14491 return;
14492
14493 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
14494 goto nla_put_failure;
14495
14496 cfg80211_send_cqm(msg, gfp);
14497 return;
14498
14499 nla_put_failure:
14500 nlmsg_free(msg);
14501}
14502EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
14503
98f03342
JB		 14504void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
14505{
14506 struct sk_buff *msg;
14507
14508 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14509 if (!msg)
14510 return;
14511
14512 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
14513 goto nla_put_failure;
14514
14515 cfg80211_send_cqm(msg, gfp);
14516 return;
14517
14518 nla_put_failure:
14519 nlmsg_free(msg);
14520}
14521EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
14522
947add36
JB		 14523static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
14524 struct net_device *netdev, const u8 *bssid,
14525 const u8 *replay_ctr, gfp_t gfp)
e5497d76
JB		 14526{
14527 struct sk_buff *msg;
14528 struct nlattr *rekey_attr;
14529 void *hdr;
14530
58050fce 14531 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
e5497d76
JB		 14532 if (!msg)
14533 return;
14534
14535 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
14536 if (!hdr) {
14537 nlmsg_free(msg);
14538 return;
14539 }
14540
9360ffd1
DM		 14541 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14542 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14543 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14544 goto nla_put_failure;
e5497d76
JB		 14545
14546 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
14547 if (!rekey_attr)
14548 goto nla_put_failure;
14549
9360ffd1
DM		 14550 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
14551 NL80211_REPLAY_CTR_LEN, replay_ctr))
14552 goto nla_put_failure;
e5497d76
JB		 14553
14554 nla_nest_end(msg, rekey_attr);
14555
3b7b72ee 14556 genlmsg_end(msg, hdr);
e5497d76 14557
68eb5503 14558 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14559 NL80211_MCGRP_MLME, gfp);
e5497d76
JB		 14560 return;
14561
14562 nla_put_failure:
14563 genlmsg_cancel(msg, hdr);
14564 nlmsg_free(msg);
14565}
14566
947add36
JB		 14567void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
14568 const u8 *replay_ctr, gfp_t gfp)
14569{
14570 struct wireless_dev *wdev = dev->ieee80211_ptr;
14571 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14572 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14573
14574 trace_cfg80211_gtk_rekey_notify(dev, bssid);
14575 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
14576}
14577EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
14578
14579static void
14580nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
14581 struct net_device *netdev, int index,
14582 const u8 *bssid, bool preauth, gfp_t gfp)
c9df56b4
JM		 14583{
14584 struct sk_buff *msg;
14585 struct nlattr *attr;
14586 void *hdr;
14587
58050fce 14588 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
c9df56b4
JM		 14589 if (!msg)
14590 return;
14591
14592 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
14593 if (!hdr) {
14594 nlmsg_free(msg);
14595 return;
14596 }
14597
9360ffd1
DM		 14598 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14599 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14600 goto nla_put_failure;
c9df56b4
JM		 14601
14602 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
14603 if (!attr)
14604 goto nla_put_failure;
14605
9360ffd1
DM		 14606 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
14607 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
14608 (preauth &&
14609 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
14610 goto nla_put_failure;
c9df56b4
JM		 14611
14612 nla_nest_end(msg, attr);
14613
3b7b72ee 14614 genlmsg_end(msg, hdr);
c9df56b4 14615
68eb5503 14616 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14617 NL80211_MCGRP_MLME, gfp);
c9df56b4
JM		 14618 return;
14619
14620 nla_put_failure:
14621 genlmsg_cancel(msg, hdr);
14622 nlmsg_free(msg);
14623}
14624
947add36
JB		 14625void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
14626 const u8 *bssid, bool preauth, gfp_t gfp)
14627{
14628 struct wireless_dev *wdev = dev->ieee80211_ptr;
14629 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14630 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14631
14632 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
14633 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
14634}
14635EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
14636
14637static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
14638 struct net_device *netdev,
14639 struct cfg80211_chan_def *chandef,
f8d7552e
LC		 14640 gfp_t gfp,
14641 enum nl80211_commands notif,
14642 u8 count)
5314526b
TP		 14643{
14644 struct sk_buff *msg;
14645 void *hdr;
14646
58050fce 14647 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5314526b
TP		 14648 if (!msg)
14649 return;
14650
f8d7552e 14651 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
5314526b
TP		 14652 if (!hdr) {
14653 nlmsg_free(msg);
14654 return;
14655 }
14656
683b6d3b
JB		 14657 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14658 goto nla_put_failure;
14659
14660 if (nl80211_send_chandef(msg, chandef))
7eab0f64 14661 goto nla_put_failure;
5314526b 14662
f8d7552e
LC		 14663 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
14664 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
14665 goto nla_put_failure;
14666
5314526b
TP		 14667 genlmsg_end(msg, hdr);
14668
68eb5503 14669 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14670 NL80211_MCGRP_MLME, gfp);
5314526b
TP		 14671 return;
14672
14673 nla_put_failure:
14674 genlmsg_cancel(msg, hdr);
14675 nlmsg_free(msg);
14676}
14677
947add36
JB		 14678void cfg80211_ch_switch_notify(struct net_device *dev,
14679 struct cfg80211_chan_def *chandef)
84f10708 14680{
947add36
JB		 14681 struct wireless_dev *wdev = dev->ieee80211_ptr;
14682 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14683 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36 14684
e487eaeb 14685 ASSERT_WDEV_LOCK(wdev);
947add36 14686
e487eaeb 14687 trace_cfg80211_ch_switch_notify(dev, chandef);
947add36 14688
9e0e2961 14689 wdev->chandef = *chandef;
96f55f12 14690 wdev->preset_chandef = *chandef;
f8d7552e
LC		 14691 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14692 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
947add36
JB		 14693}
14694EXPORT_SYMBOL(cfg80211_ch_switch_notify);
14695
f8d7552e
LC		 14696void cfg80211_ch_switch_started_notify(struct net_device *dev,
14697 struct cfg80211_chan_def *chandef,
14698 u8 count)
14699{
14700 struct wireless_dev *wdev = dev->ieee80211_ptr;
14701 struct wiphy *wiphy = wdev->wiphy;
14702 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14703
14704 trace_cfg80211_ch_switch_started_notify(dev, chandef);
14705
14706 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14707 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
14708}
14709EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
14710
04f39047
SW		 14711void
14712nl80211_radar_notify(struct cfg80211_registered_device *rdev,
d2859df5 14713 const struct cfg80211_chan_def *chandef,
04f39047
SW		 14714 enum nl80211_radar_event event,
14715 struct net_device *netdev, gfp_t gfp)
14716{
14717 struct sk_buff *msg;
14718 void *hdr;
14719
14720 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14721 if (!msg)
14722 return;
14723
14724 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
14725 if (!hdr) {
14726 nlmsg_free(msg);
14727 return;
14728 }
14729
14730 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
14731 goto nla_put_failure;
14732
14733 /* NOP and radar events don't need a netdev parameter */
14734 if (netdev) {
14735 struct wireless_dev *wdev = netdev->ieee80211_ptr;
14736
14737 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
2dad624e
ND		 14738 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14739 NL80211_ATTR_PAD))
04f39047
SW		 14740 goto nla_put_failure;
14741 }
14742
14743 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
14744 goto nla_put_failure;
14745
14746 if (nl80211_send_chandef(msg, chandef))
14747 goto nla_put_failure;
14748
9c90a9f6 14749 genlmsg_end(msg, hdr);
04f39047 14750
68eb5503 14751 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14752 NL80211_MCGRP_MLME, gfp);
04f39047
SW		 14753 return;
14754
14755 nla_put_failure:
14756 genlmsg_cancel(msg, hdr);
14757 nlmsg_free(msg);
14758}
14759
7f6cf311
JB		 14760void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
14761 u64 cookie, bool acked, gfp_t gfp)
14762{
14763 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14764 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
7f6cf311
JB		 14765 struct sk_buff *msg;
14766 void *hdr;
7f6cf311 14767
4ee3e063
BL		 14768 trace_cfg80211_probe_status(dev, addr, cookie, acked);
14769
58050fce 14770 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4ee3e063 14771
7f6cf311
JB		 14772 if (!msg)
14773 return;
14774
14775 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
14776 if (!hdr) {
14777 nlmsg_free(msg);
14778 return;
14779 }
14780
9360ffd1
DM		 14781 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14782 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14783 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
2dad624e
ND		 14784 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14785 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14786 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
14787 goto nla_put_failure;
7f6cf311 14788
9c90a9f6 14789 genlmsg_end(msg, hdr);
7f6cf311 14790
68eb5503 14791 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14792 NL80211_MCGRP_MLME, gfp);
7f6cf311
JB		 14793 return;
14794
14795 nla_put_failure:
14796 genlmsg_cancel(msg, hdr);
14797 nlmsg_free(msg);
14798}
14799EXPORT_SYMBOL(cfg80211_probe_status);
14800
5e760230
JB		 14801void cfg80211_report_obss_beacon(struct wiphy *wiphy,
14802 const u8 *frame, size_t len,
37c73b5f 14803 int freq, int sig_dbm)
5e760230 14804{
f26cbf40 14805 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5e760230
JB		 14806 struct sk_buff *msg;
14807 void *hdr;
37c73b5f 14808 struct cfg80211_beacon_registration *reg;
5e760230 14809
4ee3e063
BL		 14810 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
14811
37c73b5f
BG		 14812 spin_lock_bh(&rdev->beacon_registrations_lock);
14813 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
14814 msg = nlmsg_new(len + 100, GFP_ATOMIC);
14815 if (!msg) {
14816 spin_unlock_bh(&rdev->beacon_registrations_lock);
14817 return;
14818 }
5e760230 14819
37c73b5f
BG		 14820 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
14821 if (!hdr)
14822 goto nla_put_failure;
5e760230 14823
37c73b5f
BG		 14824 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14825 (freq &&
14826 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
14827 (sig_dbm &&
14828 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
14829 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
14830 goto nla_put_failure;
5e760230 14831
37c73b5f 14832 genlmsg_end(msg, hdr);
5e760230 14833
37c73b5f
BG		 14834 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
14835 }
14836 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 14837 return;
14838
14839 nla_put_failure:
37c73b5f
BG		 14840 spin_unlock_bh(&rdev->beacon_registrations_lock);
14841 if (hdr)
14842 genlmsg_cancel(msg, hdr);
5e760230
JB		 14843 nlmsg_free(msg);
14844}
14845EXPORT_SYMBOL(cfg80211_report_obss_beacon);
14846
cd8f7cb4 14847#ifdef CONFIG_PM
8cd4d456
LC		 14848static int cfg80211_net_detect_results(struct sk_buff *msg,
14849 struct cfg80211_wowlan_wakeup *wakeup)
14850{
14851 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
14852 struct nlattr *nl_results, *nl_match, *nl_freqs;
14853 int i, j;
14854
14855 nl_results = nla_nest_start(
14856 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
14857 if (!nl_results)
14858 return -EMSGSIZE;
14859
14860 for (i = 0; i < nd->n_matches; i++) {
14861 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
14862
14863 nl_match = nla_nest_start(msg, i);
14864 if (!nl_match)
14865 break;
14866
14867 /* The SSID attribute is optional in nl80211, but for
14868 * simplicity reasons it's always present in the
14869 * cfg80211 structure. If a driver can't pass the
14870 * SSID, that needs to be changed. A zero length SSID
14871 * is still a valid SSID (wildcard), so it cannot be
14872 * used for this purpose.
14873 */
14874 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
14875 match->ssid.ssid)) {
14876 nla_nest_cancel(msg, nl_match);
14877 goto out;
14878 }
14879
14880 if (match->n_channels) {
14881 nl_freqs = nla_nest_start(
14882 msg, NL80211_ATTR_SCAN_FREQUENCIES);
14883 if (!nl_freqs) {
14884 nla_nest_cancel(msg, nl_match);
14885 goto out;
14886 }
14887
14888 for (j = 0; j < match->n_channels; j++) {
5528fae8 14889 if (nla_put_u32(msg, j, match->channels[j])) {
8cd4d456
LC		 14890 nla_nest_cancel(msg, nl_freqs);
14891 nla_nest_cancel(msg, nl_match);
14892 goto out;
14893 }
14894 }
14895
14896 nla_nest_end(msg, nl_freqs);
14897 }
14898
14899 nla_nest_end(msg, nl_match);
14900 }
14901
14902out:
14903 nla_nest_end(msg, nl_results);
14904 return 0;
14905}
14906
cd8f7cb4
JB		 14907void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
14908 struct cfg80211_wowlan_wakeup *wakeup,
14909 gfp_t gfp)
14910{
f26cbf40 14911 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
cd8f7cb4
JB		 14912 struct sk_buff *msg;
14913 void *hdr;
9c90a9f6 14914 int size = 200;
cd8f7cb4
JB		 14915
14916 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
14917
14918 if (wakeup)
14919 size += wakeup->packet_present_len;
14920
14921 msg = nlmsg_new(size, gfp);
14922 if (!msg)
14923 return;
14924
14925 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
14926 if (!hdr)
14927 goto free_msg;
14928
14929 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 14930 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14931 NL80211_ATTR_PAD))
cd8f7cb4
JB		 14932 goto free_msg;
14933
14934 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14935 wdev->netdev->ifindex))
14936 goto free_msg;
14937
14938 if (wakeup) {
14939 struct nlattr *reasons;
14940
14941 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7fa322c8
JB		 14942 if (!reasons)
14943 goto free_msg;
cd8f7cb4
JB		 14944
14945 if (wakeup->disconnect &&
14946 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
14947 goto free_msg;
14948 if (wakeup->magic_pkt &&
14949 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
14950 goto free_msg;
14951 if (wakeup->gtk_rekey_failure &&
14952 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
14953 goto free_msg;
14954 if (wakeup->eap_identity_req &&
14955 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
14956 goto free_msg;
14957 if (wakeup->four_way_handshake &&
14958 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
14959 goto free_msg;
14960 if (wakeup->rfkill_release &&
14961 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
14962 goto free_msg;
14963
14964 if (wakeup->pattern_idx >= 0 &&
14965 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
14966 wakeup->pattern_idx))
14967 goto free_msg;
14968
ae917c9f
JB		 14969 if (wakeup->tcp_match &&
14970 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
14971 goto free_msg;
2a0e047e 14972
ae917c9f
JB		 14973 if (wakeup->tcp_connlost &&
14974 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
14975 goto free_msg;
2a0e047e 14976
ae917c9f
JB		 14977 if (wakeup->tcp_nomoretokens &&
14978 nla_put_flag(msg,
14979 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
14980 goto free_msg;
2a0e047e 14981
cd8f7cb4
JB		 14982 if (wakeup->packet) {
14983 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
14984 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
14985
14986 if (!wakeup->packet_80211) {
14987 pkt_attr =
14988 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
14989 len_attr =
14990 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
14991 }
14992
14993 if (wakeup->packet_len &&
14994 nla_put_u32(msg, len_attr, wakeup->packet_len))
14995 goto free_msg;
14996
14997 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
14998 wakeup->packet))
14999 goto free_msg;
15000 }
15001
8cd4d456
LC		 15002 if (wakeup->net_detect &&
15003 cfg80211_net_detect_results(msg, wakeup))
15004 goto free_msg;
15005
cd8f7cb4
JB		 15006 nla_nest_end(msg, reasons);
15007 }
15008
9c90a9f6 15009 genlmsg_end(msg, hdr);
cd8f7cb4 15010
68eb5503 15011 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15012 NL80211_MCGRP_MLME, gfp);
cd8f7cb4
JB		 15013 return;
15014
15015 free_msg:
15016 nlmsg_free(msg);
15017}
15018EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
15019#endif
15020
3475b094
JM		 15021void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
15022 enum nl80211_tdls_operation oper,
15023 u16 reason_code, gfp_t gfp)
15024{
15025 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 15026 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
3475b094
JM		 15027 struct sk_buff *msg;
15028 void *hdr;
3475b094
JM		 15029
15030 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
15031 reason_code);
15032
15033 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15034 if (!msg)
15035 return;
15036
15037 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
15038 if (!hdr) {
15039 nlmsg_free(msg);
15040 return;
15041 }
15042
15043 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15044 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15045 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
15046 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
15047 (reason_code > 0 &&
15048 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
15049 goto nla_put_failure;
15050
9c90a9f6 15051 genlmsg_end(msg, hdr);
3475b094 15052
68eb5503 15053 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15054 NL80211_MCGRP_MLME, gfp);
3475b094
JM		 15055 return;
15056
15057 nla_put_failure:
15058 genlmsg_cancel(msg, hdr);
15059 nlmsg_free(msg);
15060}
15061EXPORT_SYMBOL(cfg80211_tdls_oper_request);
15062
026331c4
JM		 15063static int nl80211_netlink_notify(struct notifier_block * nb,
15064 unsigned long state,
15065 void *_notify)
15066{
15067 struct netlink_notify *notify = _notify;
15068 struct cfg80211_registered_device *rdev;
15069 struct wireless_dev *wdev;
37c73b5f 15070 struct cfg80211_beacon_registration *reg, *tmp;
026331c4 15071
8f815cdd 15072 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
026331c4
JM		 15073 return NOTIFY_DONE;
15074
15075 rcu_read_lock();
15076
5e760230 15077 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
ca986ad9 15078 struct cfg80211_sched_scan_request *sched_scan_req;
753aacfd 15079
ca986ad9
AVS		 15080 list_for_each_entry_rcu(sched_scan_req,
15081 &rdev->sched_scan_req_list,
15082 list) {
15083 if (sched_scan_req->owner_nlportid == notify->portid) {
15084 sched_scan_req->nl_owner_dead = true;
753aacfd 15085 schedule_work(&rdev->sched_scan_stop_wk);
ca986ad9 15086 }
753aacfd 15087 }
78f22b6a 15088
53873f13 15089 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
15e47304 15090 cfg80211_mlme_unregister_socket(wdev, notify->portid);
37c73b5f 15091
ab81007a
JB		 15092 if (wdev->owner_nlportid == notify->portid) {
15093 wdev->nl_owner_dead = true;
15094 schedule_work(&rdev->destroy_work);
15095 } else if (wdev->conn_owner_nlportid == notify->portid) {
bd2522b1 15096 schedule_work(&wdev->disconnect_wk);
ab81007a 15097 }
78f22b6a
JB		 15098 }
15099
37c73b5f
BG		 15100 spin_lock_bh(&rdev->beacon_registrations_lock);
15101 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
15102 list) {
15103 if (reg->nlportid == notify->portid) {
15104 list_del(&reg->list);
15105 kfree(reg);
15106 break;
15107 }
15108 }
15109 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230 15110 }
026331c4
JM		 15111
15112 rcu_read_unlock();
15113
05050753
I		 15114 /*
15115 * It is possible that the user space process that is controlling the
15116 * indoor setting disappeared, so notify the regulatory core.
15117 */
15118 regulatory_netlink_notify(notify->portid);
6784c7db 15119 return NOTIFY_OK;
026331c4
JM		 15120}
15121
15122static struct notifier_block nl80211_netlink_notifier = {
15123 .notifier_call = nl80211_netlink_notify,
15124};
15125
355199e0
JM		 15126void cfg80211_ft_event(struct net_device *netdev,
15127 struct cfg80211_ft_event_params *ft_event)
15128{
15129 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
f26cbf40 15130 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
355199e0
JM		 15131 struct sk_buff *msg;
15132 void *hdr;
355199e0
JM		 15133
15134 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
15135
15136 if (!ft_event->target_ap)
15137 return;
15138
4ef8c1c9 15139 msg = nlmsg_new(100 + ft_event->ric_ies_len, GFP_KERNEL);
355199e0
JM		 15140 if (!msg)
15141 return;
15142
15143 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
ae917c9f
JB		 15144 if (!hdr)
15145 goto out;
355199e0 15146
ae917c9f
JB		 15147 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15148 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15149 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
15150 goto out;
355199e0 15151
ae917c9f
JB		 15152 if (ft_event->ies &&
15153 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
15154 goto out;
15155 if (ft_event->ric_ies &&
15156 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
15157 ft_event->ric_ies))
15158 goto out;
355199e0 15159
9c90a9f6 15160 genlmsg_end(msg, hdr);
355199e0 15161
68eb5503 15162 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 15163 NL80211_MCGRP_MLME, GFP_KERNEL);
ae917c9f
JB		 15164 return;
15165 out:
15166 nlmsg_free(msg);
355199e0
JM		 15167}
15168EXPORT_SYMBOL(cfg80211_ft_event);
15169
5de17984
AS		 15170void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
15171{
15172 struct cfg80211_registered_device *rdev;
15173 struct sk_buff *msg;
15174 void *hdr;
15175 u32 nlportid;
15176
f26cbf40 15177 rdev = wiphy_to_rdev(wdev->wiphy);
5de17984
AS		 15178 if (!rdev->crit_proto_nlportid)
15179 return;
15180
15181 nlportid = rdev->crit_proto_nlportid;
15182 rdev->crit_proto_nlportid = 0;
15183
15184 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15185 if (!msg)
15186 return;
15187
15188 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
15189 if (!hdr)
15190 goto nla_put_failure;
15191
15192 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 15193 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15194 NL80211_ATTR_PAD))
5de17984
AS		 15195 goto nla_put_failure;
15196
15197 genlmsg_end(msg, hdr);
15198
15199 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15200 return;
15201
15202 nla_put_failure:
15203 if (hdr)
15204 genlmsg_cancel(msg, hdr);
15205 nlmsg_free(msg);
5de17984
AS		 15206}
15207EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
15208
348baf0e
JB		 15209void nl80211_send_ap_stopped(struct wireless_dev *wdev)
15210{
15211 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 15212 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
348baf0e
JB		 15213 struct sk_buff *msg;
15214 void *hdr;
15215
15216 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15217 if (!msg)
15218 return;
15219
15220 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
15221 if (!hdr)
15222 goto out;
15223
15224 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15225 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
2dad624e
ND		 15226 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15227 NL80211_ATTR_PAD))
348baf0e
JB		 15228 goto out;
15229
15230 genlmsg_end(msg, hdr);
15231
15232 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
15233 NL80211_MCGRP_MLME, GFP_KERNEL);
15234 return;
15235 out:
15236 nlmsg_free(msg);
15237}
15238
55682965
JB		 15239/* initialisation/exit functions */
15240
56989f6d 15241int __init nl80211_init(void)
55682965 15242{
0d63cbb5 15243 int err;
55682965 15244
489111e5 15245 err = genl_register_family(&nl80211_fam);
55682965
JB		 15246 if (err)
15247 return err;
15248
026331c4
JM		 15249 err = netlink_register_notifier(&nl80211_netlink_notifier);
15250 if (err)
15251 goto err_out;
15252
55682965
JB		 15253 return 0;
15254 err_out:
15255 genl_unregister_family(&nl80211_fam);
15256 return err;
15257}
15258
15259void nl80211_exit(void)
15260{
026331c4 15261 netlink_unregister_notifier(&nl80211_netlink_notifier);
55682965
JB		 15262 genl_unregister_family(&nl80211_fam);
15263}
Ubuntu Artful kernel mirror