]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - net/wireless/nl80211.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: ibss: Fix channel type enum in ieee80211_sta_join_ibss()
[mirror_ubuntu-focal-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 },
67fbb16b
SO		 294 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
295 .len = WLAN_PMKID_LEN },
9588bbd5
JM		 296 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
297 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
13ae75b1 298 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
026331c4
JM		 299 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
300 .len = IEEE80211_MAX_DATA_LEN },
301 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
ffb9eb3d 302 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
d6dc1a38 303 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
d5cdfacb 304 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
fd8aaaf3 305 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
98d2ff8b
JO		 306 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
307 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
2e161f78 308 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
afe0cbf8
BR		 309 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
310 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
885a46d0 311 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
f7ca38df 312 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
dbd2fd65 313 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
ff1b6e69 314 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
9c3990aa 315 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
bbe6ad6d 316 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
e5497d76 317 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
34850ab2 318 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
32e9de84 319 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
9946ecfb
JM		 320 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
321 .len = IEEE80211_MAX_DATA_LEN },
322 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
323 .len = IEEE80211_MAX_DATA_LEN },
f4b34b55 324 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
a1f1c21c 325 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
e9f935e3 326 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
109086ce
AN		 327 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
328 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
329 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
330 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
331 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
31fa97c5 332 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
e247bd90 333 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
00f740e1
AN		 334 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
335 .len = IEEE80211_MAX_DATA_LEN },
8b60b078 336 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
7e7c8926
BG		 337 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
338 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
339 .len = NL80211_HT_CAPABILITY_LEN
340 },
1d9d9213 341 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
1b658f11 342 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
4486ea98 343 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
89a54e48 344 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
57b5ce07 345 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
11b6b5a4 346 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
f461be3e 347 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
ed473771 348 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
53cabad7
JB		 349 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
350 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
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 },
55682965
JB		 422};
423
e31b8213 424/* policy for the key attributes */
b54452b0 425static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
fffd0934 426 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 427 [NL80211_KEY_IDX] = { .type = NLA_U8 },
428 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
81962267 429 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
b9454e83
JB		 430 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
431 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
e31b8213 432 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
dbd2fd65
JB		 433 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
434};
435
436/* policy for the key default flags */
437static const struct nla_policy
438nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
439 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
440 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
b9454e83
JB		 441};
442
f83ace3b 443#ifdef CONFIG_PM
ff1b6e69
JB		 444/* policy for WoWLAN attributes */
445static const struct nla_policy
446nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
447 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
448 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
449 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
450 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
77dbbb13
JB		 451 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
452 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
453 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
454 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
2a0e047e 455 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
8cd4d456 456 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
2a0e047e
JB		 457};
458
459static const struct nla_policy
460nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
461 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
462 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
463 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
464 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
465 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
466 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
467 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
468 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
469 },
470 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
471 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
472 },
473 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
474 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
475 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
ff1b6e69 476};
f83ace3b 477#endif /* CONFIG_PM */
ff1b6e69 478
be29b99a
AK		 479/* policy for coalesce rule attributes */
480static const struct nla_policy
481nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
482 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
483 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
484 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
485};
486
e5497d76
JB		 487/* policy for GTK rekey offload attributes */
488static const struct nla_policy
489nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
490 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
491 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
492 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
493};
494
a1f1c21c
LC		 495static const struct nla_policy
496nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
4a4ab0d7 497 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
a1f1c21c 498 .len = IEEE80211_MAX_SSID_LEN },
88e920b4 499 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
a1f1c21c
LC		 500};
501
3b06d277
AS		 502static const struct nla_policy
503nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
504 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
505 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
506};
507
38de03d2
AS		 508static const struct nla_policy
509nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
510 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
511 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
512 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
513 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
514 },
515};
516
a442b761
AB		 517/* policy for NAN function attributes */
518static const struct nla_policy
519nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
520 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
521 [NL80211_NAN_FUNC_SERVICE_ID] = { .type = NLA_BINARY,
522 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
523 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
524 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
525 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
526 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
527 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
528 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { .len = ETH_ALEN },
529 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
530 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
531 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
532 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
533 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
534 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
535 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
536 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
537 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
538};
539
540/* policy for Service Response Filter attributes */
541static const struct nla_policy
542nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
543 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
544 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
545 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
546 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
547 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
548};
549
97990a06
JB		 550static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
551 struct netlink_callback *cb,
552 struct cfg80211_registered_device **rdev,
553 struct wireless_dev **wdev)
a043897a 554{
97990a06 555 int err;
a043897a 556
97990a06 557 rtnl_lock();
a043897a 558
97990a06
JB		 559 if (!cb->args[0]) {
560 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da
JB		 561 genl_family_attrbuf(&nl80211_fam),
562 nl80211_fam.maxattr, nl80211_policy);
97990a06
JB		 563 if (err)
564 goto out_unlock;
67748893 565
c90c39da
JB		 566 *wdev = __cfg80211_wdev_from_attrs(
567 sock_net(skb->sk),
568 genl_family_attrbuf(&nl80211_fam));
97990a06
JB		 569 if (IS_ERR(*wdev)) {
570 err = PTR_ERR(*wdev);
571 goto out_unlock;
572 }
f26cbf40 573 *rdev = wiphy_to_rdev((*wdev)->wiphy);
c319d50b
JB		 574 /* 0 is the first index - add 1 to parse only once */
575 cb->args[0] = (*rdev)->wiphy_idx + 1;
97990a06
JB		 576 cb->args[1] = (*wdev)->identifier;
577 } else {
c319d50b
JB		 578 /* subtract the 1 again here */
579 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
97990a06 580 struct wireless_dev *tmp;
67748893 581
97990a06
JB		 582 if (!wiphy) {
583 err = -ENODEV;
584 goto out_unlock;
585 }
f26cbf40 586 *rdev = wiphy_to_rdev(wiphy);
97990a06 587 *wdev = NULL;
67748893 588
53873f13 589 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
97990a06
JB		 590 if (tmp->identifier == cb->args[1]) {
591 *wdev = tmp;
592 break;
593 }
594 }
67748893 595
97990a06
JB		 596 if (!*wdev) {
597 err = -ENODEV;
598 goto out_unlock;
599 }
67748893
JB		 600 }
601
67748893 602 return 0;
97990a06 603 out_unlock:
67748893
JB		 604 rtnl_unlock();
605 return err;
606}
607
97990a06 608static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev)
67748893 609{
67748893
JB		 610 rtnl_unlock();
611}
612
f4a11bb0
JB		 613/* IE validation */
614static bool is_valid_ie_attr(const struct nlattr *attr)
615{
616 const u8 *pos;
617 int len;
618
619 if (!attr)
620 return true;
621
622 pos = nla_data(attr);
623 len = nla_len(attr);
624
625 while (len) {
626 u8 elemlen;
627
628 if (len < 2)
629 return false;
630 len -= 2;
631
632 elemlen = pos[1];
633 if (elemlen > len)
634 return false;
635
636 len -= elemlen;
637 pos += 2 + elemlen;
638 }
639
640 return true;
641}
642
55682965 643/* message building helper */
15e47304 644static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
55682965
JB		 645 int flags, u8 cmd)
646{
647 /* since there is no private header just add the generic one */
15e47304 648 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
55682965
JB		 649}
650
5dab3b8a 651static int nl80211_msg_put_channel(struct sk_buff *msg,
cdc89b97
JB		 652 struct ieee80211_channel *chan,
653 bool large)
5dab3b8a 654{
ea077c1c
RL		 655 /* Some channels must be completely excluded from the
656 * list to protect old user-space tools from breaking
657 */
658 if (!large && chan->flags &
659 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
660 return 0;
661
9360ffd1
DM		 662 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
663 chan->center_freq))
664 goto nla_put_failure;
5dab3b8a 665
9360ffd1
DM		 666 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
667 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
668 goto nla_put_failure;
8fe02e16
LR		 669 if (chan->flags & IEEE80211_CHAN_NO_IR) {
670 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
671 goto nla_put_failure;
672 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
673 goto nla_put_failure;
674 }
cdc89b97
JB		 675 if (chan->flags & IEEE80211_CHAN_RADAR) {
676 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
677 goto nla_put_failure;
678 if (large) {
679 u32 time;
680
681 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
682
683 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
684 chan->dfs_state))
685 goto nla_put_failure;
686 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
687 time))
688 goto nla_put_failure;
089027e5
JD		 689 if (nla_put_u32(msg,
690 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
691 chan->dfs_cac_ms))
692 goto nla_put_failure;
cdc89b97
JB		 693 }
694 }
5dab3b8a 695
fe1abafd
JB		 696 if (large) {
697 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
698 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
699 goto nla_put_failure;
700 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
701 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
702 goto nla_put_failure;
703 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
704 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
705 goto nla_put_failure;
706 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
707 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
708 goto nla_put_failure;
570dbde1
DS		 709 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
710 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
711 goto nla_put_failure;
06f207fc
AN		 712 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
713 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
570dbde1 714 goto nla_put_failure;
ea077c1c
RL		 715 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
716 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
717 goto nla_put_failure;
718 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
719 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
720 goto nla_put_failure;
fe1abafd
JB		 721 }
722
9360ffd1
DM		 723 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
724 DBM_TO_MBM(chan->max_power)))
725 goto nla_put_failure;
5dab3b8a
LR		 726
727 return 0;
728
729 nla_put_failure:
730 return -ENOBUFS;
731}
732
55682965
JB		 733/* netlink command implementations */
734
b9454e83
JB		 735struct key_parse {
736 struct key_params p;
737 int idx;
e31b8213 738 int type;
b9454e83 739 bool def, defmgmt;
dbd2fd65 740 bool def_uni, def_multi;
b9454e83
JB		 741};
742
743static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
744{
745 struct nlattr *tb[NL80211_KEY_MAX + 1];
746 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
747 nl80211_key_policy);
748 if (err)
749 return err;
750
751 k->def = !!tb[NL80211_KEY_DEFAULT];
752 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
753
dbd2fd65
JB		 754 if (k->def) {
755 k->def_uni = true;
756 k->def_multi = true;
757 }
758 if (k->defmgmt)
759 k->def_multi = true;
760
b9454e83
JB		 761 if (tb[NL80211_KEY_IDX])
762 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
763
764 if (tb[NL80211_KEY_DATA]) {
765 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
766 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
767 }
768
769 if (tb[NL80211_KEY_SEQ]) {
770 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
771 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
772 }
773
774 if (tb[NL80211_KEY_CIPHER])
775 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
776
e31b8213
JB		 777 if (tb[NL80211_KEY_TYPE]) {
778 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
779 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
780 return -EINVAL;
781 }
782
dbd2fd65
JB		 783 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
784 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
7a087e74 785
2da8f419
JB		 786 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
787 tb[NL80211_KEY_DEFAULT_TYPES],
788 nl80211_key_default_policy);
dbd2fd65
JB		 789 if (err)
790 return err;
791
792 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
793 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
794 }
795
b9454e83
JB		 796 return 0;
797}
798
799static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
800{
801 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
802 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
803 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
804 }
805
806 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
807 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
808 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
809 }
810
811 if (info->attrs[NL80211_ATTR_KEY_IDX])
812 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
813
814 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
815 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
816
817 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
818 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
819
dbd2fd65
JB		 820 if (k->def) {
821 k->def_uni = true;
822 k->def_multi = true;
823 }
824 if (k->defmgmt)
825 k->def_multi = true;
826
e31b8213
JB		 827 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
828 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
829 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
830 return -EINVAL;
831 }
832
dbd2fd65
JB		 833 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
834 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
835 int err = nla_parse_nested(
836 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
837 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
838 nl80211_key_default_policy);
839 if (err)
840 return err;
841
842 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
843 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
844 }
845
b9454e83
JB		 846 return 0;
847}
848
849static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
850{
851 int err;
852
853 memset(k, 0, sizeof(*k));
854 k->idx = -1;
e31b8213 855 k->type = -1;
b9454e83
JB		 856
857 if (info->attrs[NL80211_ATTR_KEY])
858 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
859 else
860 err = nl80211_parse_key_old(info, k);
861
862 if (err)
863 return err;
864
865 if (k->def && k->defmgmt)
866 return -EINVAL;
867
dbd2fd65
JB		 868 if (k->defmgmt) {
869 if (k->def_uni || !k->def_multi)
870 return -EINVAL;
871 }
872
b9454e83
JB		 873 if (k->idx != -1) {
874 if (k->defmgmt) {
875 if (k->idx < 4 || k->idx > 5)
876 return -EINVAL;
877 } else if (k->def) {
878 if (k->idx < 0 || k->idx > 3)
879 return -EINVAL;
880 } else {
881 if (k->idx < 0 || k->idx > 5)
882 return -EINVAL;
883 }
884 }
885
886 return 0;
887}
888
fffd0934
JB		 889static struct cfg80211_cached_keys *
890nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
de7044ee 891 struct nlattr *keys, bool *no_ht)
fffd0934
JB		 892{
893 struct key_parse parse;
894 struct nlattr *key;
895 struct cfg80211_cached_keys *result;
896 int rem, err, def = 0;
f1c1f17a
JB		 897 bool have_key = false;
898
899 nla_for_each_nested(key, keys, rem) {
900 have_key = true;
901 break;
902 }
903
904 if (!have_key)
905 return NULL;
fffd0934
JB		 906
907 result = kzalloc(sizeof(*result), GFP_KERNEL);
908 if (!result)
909 return ERR_PTR(-ENOMEM);
910
911 result->def = -1;
fffd0934
JB		 912
913 nla_for_each_nested(key, keys, rem) {
914 memset(&parse, 0, sizeof(parse));
915 parse.idx = -1;
916
917 err = nl80211_parse_key_new(key, &parse);
918 if (err)
919 goto error;
920 err = -EINVAL;
921 if (!parse.p.key)
922 goto error;
42ee231c 923 if (parse.idx < 0 || parse.idx > 3)
fffd0934
JB		 924 goto error;
925 if (parse.def) {
926 if (def)
927 goto error;
928 def = 1;
929 result->def = parse.idx;
dbd2fd65
JB		 930 if (!parse.def_uni || !parse.def_multi)
931 goto error;
fffd0934
JB		 932 } else if (parse.defmgmt)
933 goto error;
934 err = cfg80211_validate_key_settings(rdev, &parse.p,
e31b8213 935 parse.idx, false, NULL);
fffd0934
JB		 936 if (err)
937 goto error;
386b1f27
JB		 938 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
939 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
940 err = -EINVAL;
941 goto error;
942 }
fffd0934
JB		 943 result->params[parse.idx].cipher = parse.p.cipher;
944 result->params[parse.idx].key_len = parse.p.key_len;
945 result->params[parse.idx].key = result->data[parse.idx];
946 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
de7044ee 947
386b1f27
JB		 948 /* must be WEP key if we got here */
949 if (no_ht)
950 *no_ht = true;
fffd0934
JB		 951 }
952
f1c1f17a
JB		 953 if (result->def < 0) {
954 err = -EINVAL;
955 goto error;
956 }
957
fffd0934
JB		 958 return result;
959 error:
960 kfree(result);
961 return ERR_PTR(err);
962}
963
964static int nl80211_key_allowed(struct wireless_dev *wdev)
965{
966 ASSERT_WDEV_LOCK(wdev);
967
fffd0934
JB		 968 switch (wdev->iftype) {
969 case NL80211_IFTYPE_AP:
970 case NL80211_IFTYPE_AP_VLAN:
074ac8df 971 case NL80211_IFTYPE_P2P_GO:
ff973af7 972 case NL80211_IFTYPE_MESH_POINT:
fffd0934
JB		 973 break;
974 case NL80211_IFTYPE_ADHOC:
fffd0934 975 case NL80211_IFTYPE_STATION:
074ac8df 976 case NL80211_IFTYPE_P2P_CLIENT:
ceca7b71 977 if (!wdev->current_bss)
fffd0934
JB		 978 return -ENOLINK;
979 break;
de4fcbad 980 case NL80211_IFTYPE_UNSPECIFIED:
6e0bd6c3 981 case NL80211_IFTYPE_OCB:
de4fcbad 982 case NL80211_IFTYPE_MONITOR:
cb3b7d87 983 case NL80211_IFTYPE_NAN:
de4fcbad
JB		 984 case NL80211_IFTYPE_P2P_DEVICE:
985 case NL80211_IFTYPE_WDS:
986 case NUM_NL80211_IFTYPES:
fffd0934
JB		 987 return -EINVAL;
988 }
989
990 return 0;
991}
992
664834de
JM		 993static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
994 struct nlattr *tb)
995{
996 struct ieee80211_channel *chan;
997
998 if (tb == NULL)
999 return NULL;
1000 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
1001 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1002 return NULL;
1003 return chan;
1004}
1005
7527a782
JB		 1006static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1007{
1008 struct nlattr *nl_modes = nla_nest_start(msg, attr);
1009 int i;
1010
1011 if (!nl_modes)
1012 goto nla_put_failure;
1013
1014 i = 0;
1015 while (ifmodes) {
9360ffd1
DM		 1016 if ((ifmodes & 1) && nla_put_flag(msg, i))
1017 goto nla_put_failure;
7527a782
JB		 1018 ifmodes >>= 1;
1019 i++;
1020 }
1021
1022 nla_nest_end(msg, nl_modes);
1023 return 0;
1024
1025nla_put_failure:
1026 return -ENOBUFS;
1027}
1028
1029static int nl80211_put_iface_combinations(struct wiphy *wiphy,
cdc89b97
JB		 1030 struct sk_buff *msg,
1031 bool large)
7527a782
JB		 1032{
1033 struct nlattr *nl_combis;
1034 int i, j;
1035
1036 nl_combis = nla_nest_start(msg,
1037 NL80211_ATTR_INTERFACE_COMBINATIONS);
1038 if (!nl_combis)
1039 goto nla_put_failure;
1040
1041 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1042 const struct ieee80211_iface_combination *c;
1043 struct nlattr *nl_combi, *nl_limits;
1044
1045 c = &wiphy->iface_combinations[i];
1046
1047 nl_combi = nla_nest_start(msg, i + 1);
1048 if (!nl_combi)
1049 goto nla_put_failure;
1050
1051 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
1052 if (!nl_limits)
1053 goto nla_put_failure;
1054
1055 for (j = 0; j < c->n_limits; j++) {
1056 struct nlattr *nl_limit;
1057
1058 nl_limit = nla_nest_start(msg, j + 1);
1059 if (!nl_limit)
1060 goto nla_put_failure;
9360ffd1
DM		 1061 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1062 c->limits[j].max))
1063 goto nla_put_failure;
7527a782
JB		 1064 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1065 c->limits[j].types))
1066 goto nla_put_failure;
1067 nla_nest_end(msg, nl_limit);
1068 }
1069
1070 nla_nest_end(msg, nl_limits);
1071
9360ffd1
DM		 1072 if (c->beacon_int_infra_match &&
1073 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1074 goto nla_put_failure;
1075 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1076 c->num_different_channels) ||
1077 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1078 c->max_interfaces))
1079 goto nla_put_failure;
cdc89b97 1080 if (large &&
8c48b50a
FF		 1081 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1082 c->radar_detect_widths) ||
1083 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1084 c->radar_detect_regions)))
cdc89b97 1085 goto nla_put_failure;
0c317a02
PK		 1086 if (c->beacon_int_min_gcd &&
1087 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1088 c->beacon_int_min_gcd))
1089 goto nla_put_failure;
7527a782
JB		 1090
1091 nla_nest_end(msg, nl_combi);
1092 }
1093
1094 nla_nest_end(msg, nl_combis);
1095
1096 return 0;
1097nla_put_failure:
1098 return -ENOBUFS;
1099}
1100
3713b4e3 1101#ifdef CONFIG_PM
b56cf720
JB		 1102static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1103 struct sk_buff *msg)
1104{
964dc9e2 1105 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
b56cf720
JB		 1106 struct nlattr *nl_tcp;
1107
1108 if (!tcp)
1109 return 0;
1110
1111 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1112 if (!nl_tcp)
1113 return -ENOBUFS;
1114
1115 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1116 tcp->data_payload_max))
1117 return -ENOBUFS;
1118
1119 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1120 tcp->data_payload_max))
1121 return -ENOBUFS;
1122
1123 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1124 return -ENOBUFS;
1125
1126 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1127 sizeof(*tcp->tok), tcp->tok))
1128 return -ENOBUFS;
1129
1130 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1131 tcp->data_interval_max))
1132 return -ENOBUFS;
1133
1134 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1135 tcp->wake_payload_max))
1136 return -ENOBUFS;
1137
1138 nla_nest_end(msg, nl_tcp);
1139 return 0;
1140}
1141
3713b4e3 1142static int nl80211_send_wowlan(struct sk_buff *msg,
1b8ec87a 1143 struct cfg80211_registered_device *rdev,
b56cf720 1144 bool large)
55682965 1145{
3713b4e3 1146 struct nlattr *nl_wowlan;
55682965 1147
1b8ec87a 1148 if (!rdev->wiphy.wowlan)
3713b4e3 1149 return 0;
55682965 1150
3713b4e3
JB		 1151 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1152 if (!nl_wowlan)
1153 return -ENOBUFS;
9360ffd1 1154
1b8ec87a 1155 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
3713b4e3 1156 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1b8ec87a 1157 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
3713b4e3 1158 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1b8ec87a 1159 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
3713b4e3 1160 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1b8ec87a 1161 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
3713b4e3 1162 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1b8ec87a 1163 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
3713b4e3 1164 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1b8ec87a 1165 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
3713b4e3 1166 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1b8ec87a 1167 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
3713b4e3 1168 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1b8ec87a 1169 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
3713b4e3
JB		 1170 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1171 return -ENOBUFS;
9360ffd1 1172
1b8ec87a 1173 if (rdev->wiphy.wowlan->n_patterns) {
50ac6607 1174 struct nl80211_pattern_support pat = {
1b8ec87a
ZG		 1175 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1176 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1177 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1178 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
3713b4e3 1179 };
9360ffd1 1180
3713b4e3
JB		 1181 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1182 sizeof(pat), &pat))
1183 return -ENOBUFS;
1184 }
9360ffd1 1185
75453ccb
LC		 1186 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1187 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1188 rdev->wiphy.wowlan->max_nd_match_sets))
1189 return -ENOBUFS;
1190
1b8ec87a 1191 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
b56cf720
JB		 1192 return -ENOBUFS;
1193
3713b4e3 1194 nla_nest_end(msg, nl_wowlan);
9360ffd1 1195
3713b4e3
JB		 1196 return 0;
1197}
1198#endif
9360ffd1 1199
be29b99a 1200static int nl80211_send_coalesce(struct sk_buff *msg,
1b8ec87a 1201 struct cfg80211_registered_device *rdev)
be29b99a
AK		 1202{
1203 struct nl80211_coalesce_rule_support rule;
1204
1b8ec87a 1205 if (!rdev->wiphy.coalesce)
be29b99a
AK		 1206 return 0;
1207
1b8ec87a
ZG		 1208 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1209 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1210 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1211 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1212 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1213 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
be29b99a
AK		 1214
1215 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1216 return -ENOBUFS;
1217
1218 return 0;
1219}
1220
3713b4e3
JB		 1221static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1222 struct ieee80211_supported_band *sband)
1223{
1224 struct nlattr *nl_rates, *nl_rate;
1225 struct ieee80211_rate *rate;
1226 int i;
87bbbe22 1227
3713b4e3
JB		 1228 /* add HT info */
1229 if (sband->ht_cap.ht_supported &&
1230 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1231 sizeof(sband->ht_cap.mcs),
1232 &sband->ht_cap.mcs) ||
1233 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1234 sband->ht_cap.cap) ||
1235 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1236 sband->ht_cap.ampdu_factor) ||
1237 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1238 sband->ht_cap.ampdu_density)))
1239 return -ENOBUFS;
afe0cbf8 1240
3713b4e3
JB		 1241 /* add VHT info */
1242 if (sband->vht_cap.vht_supported &&
1243 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1244 sizeof(sband->vht_cap.vht_mcs),
1245 &sband->vht_cap.vht_mcs) ||
1246 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1247 sband->vht_cap.cap)))
1248 return -ENOBUFS;
f59ac048 1249
3713b4e3
JB		 1250 /* add bitrates */
1251 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1252 if (!nl_rates)
1253 return -ENOBUFS;
ee688b00 1254
3713b4e3
JB		 1255 for (i = 0; i < sband->n_bitrates; i++) {
1256 nl_rate = nla_nest_start(msg, i);
1257 if (!nl_rate)
1258 return -ENOBUFS;
ee688b00 1259
3713b4e3
JB		 1260 rate = &sband->bitrates[i];
1261 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1262 rate->bitrate))
1263 return -ENOBUFS;
1264 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1265 nla_put_flag(msg,
1266 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1267 return -ENOBUFS;
ee688b00 1268
3713b4e3
JB		 1269 nla_nest_end(msg, nl_rate);
1270 }
d51626df 1271
3713b4e3 1272 nla_nest_end(msg, nl_rates);
bf0c111e 1273
3713b4e3
JB		 1274 return 0;
1275}
ee688b00 1276
3713b4e3
JB		 1277static int
1278nl80211_send_mgmt_stypes(struct sk_buff *msg,
1279 const struct ieee80211_txrx_stypes *mgmt_stypes)
1280{
1281 u16 stypes;
1282 struct nlattr *nl_ftypes, *nl_ifs;
1283 enum nl80211_iftype ift;
1284 int i;
ee688b00 1285
3713b4e3
JB		 1286 if (!mgmt_stypes)
1287 return 0;
5dab3b8a 1288
3713b4e3
JB		 1289 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1290 if (!nl_ifs)
1291 return -ENOBUFS;
e2f367f2 1292
3713b4e3
JB		 1293 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1294 nl_ftypes = nla_nest_start(msg, ift);
1295 if (!nl_ftypes)
1296 return -ENOBUFS;
1297 i = 0;
1298 stypes = mgmt_stypes[ift].tx;
1299 while (stypes) {
1300 if ((stypes & 1) &&
1301 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1302 (i << 4) | IEEE80211_FTYPE_MGMT))
1303 return -ENOBUFS;
1304 stypes >>= 1;
1305 i++;
ee688b00 1306 }
3713b4e3
JB		 1307 nla_nest_end(msg, nl_ftypes);
1308 }
ee688b00 1309
3713b4e3 1310 nla_nest_end(msg, nl_ifs);
ee688b00 1311
3713b4e3
JB		 1312 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1313 if (!nl_ifs)
1314 return -ENOBUFS;
ee688b00 1315
3713b4e3
JB		 1316 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1317 nl_ftypes = nla_nest_start(msg, ift);
1318 if (!nl_ftypes)
1319 return -ENOBUFS;
1320 i = 0;
1321 stypes = mgmt_stypes[ift].rx;
1322 while (stypes) {
1323 if ((stypes & 1) &&
1324 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1325 (i << 4) | IEEE80211_FTYPE_MGMT))
1326 return -ENOBUFS;
1327 stypes >>= 1;
1328 i++;
1329 }
1330 nla_nest_end(msg, nl_ftypes);
1331 }
1332 nla_nest_end(msg, nl_ifs);
ee688b00 1333
3713b4e3
JB		 1334 return 0;
1335}
ee688b00 1336
1794899e
JB		 1337#define CMD(op, n) \
1338 do { \
1339 if (rdev->ops->op) { \
1340 i++; \
1341 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1342 goto nla_put_failure; \
1343 } \
1344 } while (0)
1345
1346static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1347 struct sk_buff *msg)
1348{
1349 int i = 0;
1350
1351 /*
1352 * do *NOT* add anything into this function, new things need to be
1353 * advertised only to new versions of userspace that can deal with
1354 * the split (and they can't possibly care about new features...
1355 */
1356 CMD(add_virtual_intf, NEW_INTERFACE);
1357 CMD(change_virtual_intf, SET_INTERFACE);
1358 CMD(add_key, NEW_KEY);
1359 CMD(start_ap, START_AP);
1360 CMD(add_station, NEW_STATION);
1361 CMD(add_mpath, NEW_MPATH);
1362 CMD(update_mesh_config, SET_MESH_CONFIG);
1363 CMD(change_bss, SET_BSS);
1364 CMD(auth, AUTHENTICATE);
1365 CMD(assoc, ASSOCIATE);
1366 CMD(deauth, DEAUTHENTICATE);
1367 CMD(disassoc, DISASSOCIATE);
1368 CMD(join_ibss, JOIN_IBSS);
1369 CMD(join_mesh, JOIN_MESH);
1370 CMD(set_pmksa, SET_PMKSA);
1371 CMD(del_pmksa, DEL_PMKSA);
1372 CMD(flush_pmksa, FLUSH_PMKSA);
1373 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1374 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1375 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1376 CMD(mgmt_tx, FRAME);
1377 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1378 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1379 i++;
1380 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1381 goto nla_put_failure;
1382 }
1383 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1384 rdev->ops->join_mesh) {
1385 i++;
1386 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1387 goto nla_put_failure;
1388 }
1389 CMD(set_wds_peer, SET_WDS_PEER);
1390 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1391 CMD(tdls_mgmt, TDLS_MGMT);
1392 CMD(tdls_oper, TDLS_OPER);
1393 }
1394 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
1395 CMD(sched_scan_start, START_SCHED_SCAN);
1396 CMD(probe_client, PROBE_CLIENT);
1397 CMD(set_noack_map, SET_NOACK_MAP);
1398 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1399 i++;
1400 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1401 goto nla_put_failure;
1402 }
1403 CMD(start_p2p_device, START_P2P_DEVICE);
1404 CMD(set_mcast_rate, SET_MCAST_RATE);
1405#ifdef CONFIG_NL80211_TESTMODE
1406 CMD(testmode_cmd, TESTMODE);
1407#endif
1408
1409 if (rdev->ops->connect || rdev->ops->auth) {
1410 i++;
1411 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1412 goto nla_put_failure;
1413 }
1414
1415 if (rdev->ops->disconnect || rdev->ops->deauth) {
1416 i++;
1417 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1418 goto nla_put_failure;
1419 }
1420
1421 return i;
1422 nla_put_failure:
1423 return -ENOBUFS;
1424}
1425
86e8cf98
JB		 1426struct nl80211_dump_wiphy_state {
1427 s64 filter_wiphy;
1428 long start;
019ae3a9 1429 long split_start, band_start, chan_start, capa_start;
86e8cf98
JB		 1430 bool split;
1431};
1432
1b8ec87a 1433static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
3bb20556 1434 enum nl80211_commands cmd,
3713b4e3 1435 struct sk_buff *msg, u32 portid, u32 seq,
86e8cf98 1436 int flags, struct nl80211_dump_wiphy_state *state)
3713b4e3
JB		 1437{
1438 void *hdr;
1439 struct nlattr *nl_bands, *nl_band;
1440 struct nlattr *nl_freqs, *nl_freq;
1441 struct nlattr *nl_cmds;
57fbcce3 1442 enum nl80211_band band;
3713b4e3
JB		 1443 struct ieee80211_channel *chan;
1444 int i;
1445 const struct ieee80211_txrx_stypes *mgmt_stypes =
1b8ec87a 1446 rdev->wiphy.mgmt_stypes;
fe1abafd 1447 u32 features;
ee688b00 1448
3bb20556 1449 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3713b4e3
JB		 1450 if (!hdr)
1451 return -ENOBUFS;
ee688b00 1452
86e8cf98
JB		 1453 if (WARN_ON(!state))
1454 return -EINVAL;
ee688b00 1455
1b8ec87a 1456 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3713b4e3 1457 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1b8ec87a 1458 wiphy_name(&rdev->wiphy)) ||
3713b4e3
JB		 1459 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1460 cfg80211_rdev_list_generation))
8fdc621d
JB		 1461 goto nla_put_failure;
1462
3bb20556
JB		 1463 if (cmd != NL80211_CMD_NEW_WIPHY)
1464 goto finish;
1465
86e8cf98 1466 switch (state->split_start) {
3713b4e3
JB		 1467 case 0:
1468 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1b8ec87a 1469 rdev->wiphy.retry_short) ||
3713b4e3 1470 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1b8ec87a 1471 rdev->wiphy.retry_long) ||
3713b4e3 1472 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1b8ec87a 1473 rdev->wiphy.frag_threshold) ||
3713b4e3 1474 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1b8ec87a 1475 rdev->wiphy.rts_threshold) ||
3713b4e3 1476 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1b8ec87a 1477 rdev->wiphy.coverage_class) ||
3713b4e3 1478 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1b8ec87a 1479 rdev->wiphy.max_scan_ssids) ||
3713b4e3 1480 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1b8ec87a 1481 rdev->wiphy.max_sched_scan_ssids) ||
3713b4e3 1482 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1b8ec87a 1483 rdev->wiphy.max_scan_ie_len) ||
3713b4e3 1484 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1b8ec87a 1485 rdev->wiphy.max_sched_scan_ie_len) ||
3713b4e3 1486 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
3b06d277
AS		 1487 rdev->wiphy.max_match_sets) ||
1488 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1489 rdev->wiphy.max_sched_scan_plans) ||
1490 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1491 rdev->wiphy.max_sched_scan_plan_interval) ||
1492 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1493 rdev->wiphy.max_sched_scan_plan_iterations))
9360ffd1 1494 goto nla_put_failure;
3713b4e3 1495
1b8ec87a 1496 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
3713b4e3 1497 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
aa430da4 1498 goto nla_put_failure;
1b8ec87a 1499 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
3713b4e3
JB		 1500 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1501 goto nla_put_failure;
1b8ec87a 1502 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3713b4e3
JB		 1503 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1504 goto nla_put_failure;
1b8ec87a 1505 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
3713b4e3
JB		 1506 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1507 goto nla_put_failure;
1b8ec87a 1508 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
3713b4e3
JB		 1509 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1510 goto nla_put_failure;
1b8ec87a 1511 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
3713b4e3 1512 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
9360ffd1 1513 goto nla_put_failure;
86e8cf98
JB		 1514 state->split_start++;
1515 if (state->split)
3713b4e3
JB		 1516 break;
1517 case 1:
1518 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1b8ec87a
ZG		 1519 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1520 rdev->wiphy.cipher_suites))
3713b4e3 1521 goto nla_put_failure;
4745fc09 1522
3713b4e3 1523 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1b8ec87a 1524 rdev->wiphy.max_num_pmkids))
3713b4e3 1525 goto nla_put_failure;
b23aa676 1526
1b8ec87a 1527 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
3713b4e3 1528 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
9360ffd1 1529 goto nla_put_failure;
b23aa676 1530
3713b4e3 1531 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1b8ec87a 1532 rdev->wiphy.available_antennas_tx) ||
3713b4e3 1533 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1b8ec87a 1534 rdev->wiphy.available_antennas_rx))
9360ffd1 1535 goto nla_put_failure;
b23aa676 1536
1b8ec87a 1537 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
3713b4e3 1538 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1b8ec87a 1539 rdev->wiphy.probe_resp_offload))
3713b4e3 1540 goto nla_put_failure;
8fdc621d 1541
1b8ec87a
ZG		 1542 if ((rdev->wiphy.available_antennas_tx ||
1543 rdev->wiphy.available_antennas_rx) &&
1544 rdev->ops->get_antenna) {
3713b4e3
JB		 1545 u32 tx_ant = 0, rx_ant = 0;
1546 int res;
7a087e74 1547
1b8ec87a 1548 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
3713b4e3
JB		 1549 if (!res) {
1550 if (nla_put_u32(msg,
1551 NL80211_ATTR_WIPHY_ANTENNA_TX,
1552 tx_ant) ||
1553 nla_put_u32(msg,
1554 NL80211_ATTR_WIPHY_ANTENNA_RX,
1555 rx_ant))
1556 goto nla_put_failure;
1557 }
1558 }
a293911d 1559
86e8cf98
JB		 1560 state->split_start++;
1561 if (state->split)
3713b4e3
JB		 1562 break;
1563 case 2:
1564 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1b8ec87a 1565 rdev->wiphy.interface_modes))
3713b4e3 1566 goto nla_put_failure;
86e8cf98
JB		 1567 state->split_start++;
1568 if (state->split)
3713b4e3
JB		 1569 break;
1570 case 3:
1571 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1572 if (!nl_bands)
1573 goto nla_put_failure;
f7ca38df 1574
86e8cf98 1575 for (band = state->band_start;
57fbcce3 1576 band < NUM_NL80211_BANDS; band++) {
3713b4e3 1577 struct ieee80211_supported_band *sband;
2e161f78 1578
1b8ec87a 1579 sband = rdev->wiphy.bands[band];
2e161f78 1580
3713b4e3
JB		 1581 if (!sband)
1582 continue;
1583
1584 nl_band = nla_nest_start(msg, band);
1585 if (!nl_band)
2e161f78 1586 goto nla_put_failure;
3713b4e3 1587
86e8cf98 1588 switch (state->chan_start) {
3713b4e3
JB		 1589 case 0:
1590 if (nl80211_send_band_rateinfo(msg, sband))
9360ffd1 1591 goto nla_put_failure;
86e8cf98
JB		 1592 state->chan_start++;
1593 if (state->split)
3713b4e3
JB		 1594 break;
1595 default:
1596 /* add frequencies */
1597 nl_freqs = nla_nest_start(
1598 msg, NL80211_BAND_ATTR_FREQS);
1599 if (!nl_freqs)
1600 goto nla_put_failure;
1601
86e8cf98 1602 for (i = state->chan_start - 1;
3713b4e3
JB		 1603 i < sband->n_channels;
1604 i++) {
1605 nl_freq = nla_nest_start(msg, i);
1606 if (!nl_freq)
1607 goto nla_put_failure;
1608
1609 chan = &sband->channels[i];
1610
86e8cf98
JB		 1611 if (nl80211_msg_put_channel(
1612 msg, chan,
1613 state->split))
3713b4e3
JB		 1614 goto nla_put_failure;
1615
1616 nla_nest_end(msg, nl_freq);
86e8cf98 1617 if (state->split)
3713b4e3
JB		 1618 break;
1619 }
1620 if (i < sband->n_channels)
86e8cf98 1621 state->chan_start = i + 2;
3713b4e3 1622 else
86e8cf98 1623 state->chan_start = 0;
3713b4e3
JB		 1624 nla_nest_end(msg, nl_freqs);
1625 }
1626
1627 nla_nest_end(msg, nl_band);
1628
86e8cf98 1629 if (state->split) {
3713b4e3 1630 /* start again here */
86e8cf98 1631 if (state->chan_start)
3713b4e3
JB		 1632 band--;
1633 break;
2e161f78 1634 }
2e161f78 1635 }
3713b4e3 1636 nla_nest_end(msg, nl_bands);
2e161f78 1637
57fbcce3 1638 if (band < NUM_NL80211_BANDS)
86e8cf98 1639 state->band_start = band + 1;
3713b4e3 1640 else
86e8cf98 1641 state->band_start = 0;
74b70a4e 1642
3713b4e3 1643 /* if bands & channels are done, continue outside */
86e8cf98
JB		 1644 if (state->band_start == 0 && state->chan_start == 0)
1645 state->split_start++;
1646 if (state->split)
3713b4e3
JB		 1647 break;
1648 case 4:
1649 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1650 if (!nl_cmds)
2e161f78
JB		 1651 goto nla_put_failure;
1652
1794899e
JB		 1653 i = nl80211_add_commands_unsplit(rdev, msg);
1654 if (i < 0)
1655 goto nla_put_failure;
86e8cf98 1656 if (state->split) {
5de17984
AS		 1657 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1658 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1b8ec87a 1659 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
16ef1fe2 1660 CMD(channel_switch, CHANNEL_SWITCH);
02df00eb 1661 CMD(set_qos_map, SET_QOS_MAP);
723e73ac
JB		 1662 if (rdev->wiphy.features &
1663 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
960d01ac 1664 CMD(add_tx_ts, ADD_TX_TS);
ce0ce13a 1665 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
088e8df8 1666 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
5de17984 1667 }
3713b4e3 1668#undef CMD
ff1b6e69 1669
3713b4e3 1670 nla_nest_end(msg, nl_cmds);
86e8cf98
JB		 1671 state->split_start++;
1672 if (state->split)
3713b4e3
JB		 1673 break;
1674 case 5:
1b8ec87a
ZG		 1675 if (rdev->ops->remain_on_channel &&
1676 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
3713b4e3
JB		 1677 nla_put_u32(msg,
1678 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1b8ec87a 1679 rdev->wiphy.max_remain_on_channel_duration))
3713b4e3
JB		 1680 goto nla_put_failure;
1681
1b8ec87a 1682 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
3713b4e3
JB		 1683 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1684 goto nla_put_failure;
1685
1686 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1687 goto nla_put_failure;
86e8cf98
JB		 1688 state->split_start++;
1689 if (state->split)
3713b4e3
JB		 1690 break;
1691 case 6:
1692#ifdef CONFIG_PM
1b8ec87a 1693 if (nl80211_send_wowlan(msg, rdev, state->split))
3713b4e3 1694 goto nla_put_failure;
86e8cf98
JB		 1695 state->split_start++;
1696 if (state->split)
3713b4e3
JB		 1697 break;
1698#else
86e8cf98 1699 state->split_start++;
dfb89c56 1700#endif
3713b4e3
JB		 1701 case 7:
1702 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1b8ec87a 1703 rdev->wiphy.software_iftypes))
3713b4e3 1704 goto nla_put_failure;
ff1b6e69 1705
1b8ec87a 1706 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
86e8cf98 1707 state->split))
3713b4e3 1708 goto nla_put_failure;
7527a782 1709
86e8cf98
JB		 1710 state->split_start++;
1711 if (state->split)
3713b4e3
JB		 1712 break;
1713 case 8:
1b8ec87a 1714 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
3713b4e3 1715 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1b8ec87a 1716 rdev->wiphy.ap_sme_capa))
3713b4e3 1717 goto nla_put_failure;
7527a782 1718
1b8ec87a 1719 features = rdev->wiphy.features;
fe1abafd
JB		 1720 /*
1721 * We can only add the per-channel limit information if the
1722 * dump is split, otherwise it makes it too big. Therefore
1723 * only advertise it in that case.
1724 */
86e8cf98 1725 if (state->split)
fe1abafd
JB		 1726 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1727 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
3713b4e3 1728 goto nla_put_failure;
562a7480 1729
1b8ec87a 1730 if (rdev->wiphy.ht_capa_mod_mask &&
3713b4e3 1731 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1b8ec87a
ZG		 1732 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1733 rdev->wiphy.ht_capa_mod_mask))
3713b4e3 1734 goto nla_put_failure;
1f074bd8 1735
1b8ec87a
ZG		 1736 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1737 rdev->wiphy.max_acl_mac_addrs &&
3713b4e3 1738 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1b8ec87a 1739 rdev->wiphy.max_acl_mac_addrs))
3713b4e3 1740 goto nla_put_failure;
7e7c8926 1741
3713b4e3
JB		 1742 /*
1743 * Any information below this point is only available to
1744 * applications that can deal with it being split. This
1745 * helps ensure that newly added capabilities don't break
1746 * older tools by overrunning their buffers.
1747 *
1748 * We still increment split_start so that in the split
1749 * case we'll continue with more data in the next round,
1750 * but break unconditionally so unsplit data stops here.
1751 */
86e8cf98 1752 state->split_start++;
3713b4e3
JB		 1753 break;
1754 case 9:
1b8ec87a 1755 if (rdev->wiphy.extended_capabilities &&
fe1abafd 1756 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1b8ec87a
ZG		 1757 rdev->wiphy.extended_capabilities_len,
1758 rdev->wiphy.extended_capabilities) ||
fe1abafd 1759 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1b8ec87a
ZG		 1760 rdev->wiphy.extended_capabilities_len,
1761 rdev->wiphy.extended_capabilities_mask)))
fe1abafd 1762 goto nla_put_failure;
a50df0c4 1763
1b8ec87a 1764 if (rdev->wiphy.vht_capa_mod_mask &&
ee2aca34 1765 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1b8ec87a
ZG		 1766 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1767 rdev->wiphy.vht_capa_mod_mask))
ee2aca34
JB		 1768 goto nla_put_failure;
1769
be29b99a
AK		 1770 state->split_start++;
1771 break;
1772 case 10:
1b8ec87a 1773 if (nl80211_send_coalesce(msg, rdev))
be29b99a
AK		 1774 goto nla_put_failure;
1775
1b8ec87a 1776 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
01e0daa4
FF		 1777 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1778 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1779 goto nla_put_failure;
b43504cf 1780
1b8ec87a 1781 if (rdev->wiphy.max_ap_assoc_sta &&
b43504cf 1782 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1b8ec87a 1783 rdev->wiphy.max_ap_assoc_sta))
b43504cf
JM		 1784 goto nla_put_failure;
1785
ad7e718c
JB		 1786 state->split_start++;
1787 break;
1788 case 11:
1b8ec87a 1789 if (rdev->wiphy.n_vendor_commands) {
567ffc35
JB		 1790 const struct nl80211_vendor_cmd_info *info;
1791 struct nlattr *nested;
1792
1793 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1794 if (!nested)
1795 goto nla_put_failure;
1796
1b8ec87a
ZG		 1797 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1798 info = &rdev->wiphy.vendor_commands[i].info;
567ffc35
JB		 1799 if (nla_put(msg, i + 1, sizeof(*info), info))
1800 goto nla_put_failure;
1801 }
1802 nla_nest_end(msg, nested);
1803 }
1804
1b8ec87a 1805 if (rdev->wiphy.n_vendor_events) {
567ffc35
JB		 1806 const struct nl80211_vendor_cmd_info *info;
1807 struct nlattr *nested;
ad7e718c 1808
567ffc35
JB		 1809 nested = nla_nest_start(msg,
1810 NL80211_ATTR_VENDOR_EVENTS);
1811 if (!nested)
ad7e718c 1812 goto nla_put_failure;
567ffc35 1813
1b8ec87a
ZG		 1814 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1815 info = &rdev->wiphy.vendor_events[i];
567ffc35
JB		 1816 if (nla_put(msg, i + 1, sizeof(*info), info))
1817 goto nla_put_failure;
1818 }
1819 nla_nest_end(msg, nested);
1820 }
9a774c78
AO		 1821 state->split_start++;
1822 break;
1823 case 12:
1824 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1825 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1826 rdev->wiphy.max_num_csa_counters))
1827 goto nla_put_failure;
01e0daa4 1828
1bdd716c
AN		 1829 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
1830 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
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);
86e8cf98
JB		 1920 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1921 tb, nl80211_fam.maxattr, nl80211_policy);
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,
2336 txq_params_policy);
ae811e21
JB		 2337 if (result)
2338 return result;
31888487
JM		 2339 result = parse_txq_params(tb, &txq_params);
2340 if (result)
7f2b8562 2341 return result;
31888487 2342
e35e4d28
HG		 2343 result = rdev_set_txq_params(rdev, netdev,
2344 &txq_params);
31888487 2345 if (result)
7f2b8562 2346 return result;
31888487
JM		 2347 }
2348 }
55682965 2349
72bdcf34 2350 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
e16821bc
JM		 2351 result = __nl80211_set_channel(
2352 rdev,
2353 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2354 info);
72bdcf34 2355 if (result)
7f2b8562 2356 return result;
72bdcf34
JM		 2357 }
2358
98d2ff8b 2359 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
c8442118 2360 struct wireless_dev *txp_wdev = wdev;
98d2ff8b
JO		 2361 enum nl80211_tx_power_setting type;
2362 int idx, mbm = 0;
2363
c8442118
JB		 2364 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2365 txp_wdev = NULL;
2366
7f2b8562
YX		 2367 if (!rdev->ops->set_tx_power)
2368 return -EOPNOTSUPP;
98d2ff8b
JO		 2369
2370 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2371 type = nla_get_u32(info->attrs[idx]);
2372
2373 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
7f2b8562
YX		 2374 (type != NL80211_TX_POWER_AUTOMATIC))
2375 return -EINVAL;
98d2ff8b
JO		 2376
2377 if (type != NL80211_TX_POWER_AUTOMATIC) {
2378 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2379 mbm = nla_get_u32(info->attrs[idx]);
2380 }
2381
c8442118 2382 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
98d2ff8b 2383 if (result)
7f2b8562 2384 return result;
98d2ff8b
JO		 2385 }
2386
afe0cbf8
BR		 2387 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2388 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2389 u32 tx_ant, rx_ant;
7a087e74 2390
7f531e03
BR		 2391 if ((!rdev->wiphy.available_antennas_tx &&
2392 !rdev->wiphy.available_antennas_rx) ||
7f2b8562
YX		 2393 !rdev->ops->set_antenna)
2394 return -EOPNOTSUPP;
afe0cbf8
BR		 2395
2396 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2397 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2398
a7ffac95 2399 /* reject antenna configurations which don't match the
7f531e03
BR		 2400 * available antenna masks, except for the "all" mask */
2401 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
7f2b8562
YX		 2402 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2403 return -EINVAL;
a7ffac95 2404
7f531e03
BR		 2405 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2406 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
a7ffac95 2407
e35e4d28 2408 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
afe0cbf8 2409 if (result)
7f2b8562 2410 return result;
afe0cbf8
BR		 2411 }
2412
b9a5f8ca
JM		 2413 changed = 0;
2414
2415 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2416 retry_short = nla_get_u8(
2417 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
7f2b8562
YX		 2418 if (retry_short == 0)
2419 return -EINVAL;
2420
b9a5f8ca
JM		 2421 changed |= WIPHY_PARAM_RETRY_SHORT;
2422 }
2423
2424 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2425 retry_long = nla_get_u8(
2426 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
7f2b8562
YX		 2427 if (retry_long == 0)
2428 return -EINVAL;
2429
b9a5f8ca
JM		 2430 changed |= WIPHY_PARAM_RETRY_LONG;
2431 }
2432
2433 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2434 frag_threshold = nla_get_u32(
2435 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
7f2b8562
YX		 2436 if (frag_threshold < 256)
2437 return -EINVAL;
2438
b9a5f8ca
JM		 2439 if (frag_threshold != (u32) -1) {
2440 /*
2441 * Fragments (apart from the last one) are required to
2442 * have even length. Make the fragmentation code
2443 * simpler by stripping LSB should someone try to use
2444 * odd threshold value.
2445 */
2446 frag_threshold &= ~0x1;
2447 }
2448 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2449 }
2450
2451 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2452 rts_threshold = nla_get_u32(
2453 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2454 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2455 }
2456
81077e82 2457 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3057dbfd
LB		 2458 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2459 return -EINVAL;
2460
81077e82
LT		 2461 coverage_class = nla_get_u8(
2462 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2463 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2464 }
2465
3057dbfd
LB		 2466 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2467 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2468 return -EOPNOTSUPP;
2469
2470 changed |= WIPHY_PARAM_DYN_ACK;
81077e82
LT		 2471 }
2472
b9a5f8ca
JM		 2473 if (changed) {
2474 u8 old_retry_short, old_retry_long;
2475 u32 old_frag_threshold, old_rts_threshold;
81077e82 2476 u8 old_coverage_class;
b9a5f8ca 2477
7f2b8562
YX		 2478 if (!rdev->ops->set_wiphy_params)
2479 return -EOPNOTSUPP;
b9a5f8ca
JM		 2480
2481 old_retry_short = rdev->wiphy.retry_short;
2482 old_retry_long = rdev->wiphy.retry_long;
2483 old_frag_threshold = rdev->wiphy.frag_threshold;
2484 old_rts_threshold = rdev->wiphy.rts_threshold;
81077e82 2485 old_coverage_class = rdev->wiphy.coverage_class;
b9a5f8ca
JM		 2486
2487 if (changed & WIPHY_PARAM_RETRY_SHORT)
2488 rdev->wiphy.retry_short = retry_short;
2489 if (changed & WIPHY_PARAM_RETRY_LONG)
2490 rdev->wiphy.retry_long = retry_long;
2491 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2492 rdev->wiphy.frag_threshold = frag_threshold;
2493 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2494 rdev->wiphy.rts_threshold = rts_threshold;
81077e82
LT		 2495 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2496 rdev->wiphy.coverage_class = coverage_class;
b9a5f8ca 2497
e35e4d28 2498 result = rdev_set_wiphy_params(rdev, changed);
b9a5f8ca
JM		 2499 if (result) {
2500 rdev->wiphy.retry_short = old_retry_short;
2501 rdev->wiphy.retry_long = old_retry_long;
2502 rdev->wiphy.frag_threshold = old_frag_threshold;
2503 rdev->wiphy.rts_threshold = old_rts_threshold;
81077e82 2504 rdev->wiphy.coverage_class = old_coverage_class;
9189ee31 2505 return result;
b9a5f8ca
JM		 2506 }
2507 }
7f2b8562 2508 return 0;
55682965
JB		 2509}
2510
71bbc994
JB		 2511static inline u64 wdev_id(struct wireless_dev *wdev)
2512{
2513 return (u64)wdev->identifier |
f26cbf40 2514 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
71bbc994 2515}
55682965 2516
683b6d3b 2517static int nl80211_send_chandef(struct sk_buff *msg,
d2859df5 2518 const struct cfg80211_chan_def *chandef)
683b6d3b 2519{
601555cd
JB		 2520 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2521 return -EINVAL;
3d9d1d66 2522
683b6d3b
JB		 2523 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2524 chandef->chan->center_freq))
2525 return -ENOBUFS;
3d9d1d66
JB		 2526 switch (chandef->width) {
2527 case NL80211_CHAN_WIDTH_20_NOHT:
2528 case NL80211_CHAN_WIDTH_20:
2529 case NL80211_CHAN_WIDTH_40:
2530 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2531 cfg80211_get_chandef_type(chandef)))
2532 return -ENOBUFS;
2533 break;
2534 default:
2535 break;
2536 }
2537 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2538 return -ENOBUFS;
2539 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2540 return -ENOBUFS;
2541 if (chandef->center_freq2 &&
2542 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
683b6d3b
JB		 2543 return -ENOBUFS;
2544 return 0;
2545}
2546
15e47304 2547static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
d726405a 2548 struct cfg80211_registered_device *rdev,
8f894be2 2549 struct wireless_dev *wdev, bool removal)
55682965 2550{
72fb2abc 2551 struct net_device *dev = wdev->netdev;
8f894be2 2552 u8 cmd = NL80211_CMD_NEW_INTERFACE;
55682965
JB		 2553 void *hdr;
2554
8f894be2
TB		 2555 if (removal)
2556 cmd = NL80211_CMD_DEL_INTERFACE;
2557
2558 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
55682965
JB		 2559 if (!hdr)
2560 return -1;
2561
72fb2abc
JB		 2562 if (dev &&
2563 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
98104fde 2564 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
72fb2abc
JB		 2565 goto nla_put_failure;
2566
2567 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2568 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2dad624e
ND		 2569 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
2570 NL80211_ATTR_PAD) ||
98104fde 2571 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
9360ffd1
DM		 2572 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2573 rdev->devlist_generation ^
2574 (cfg80211_rdev_list_generation << 2)))
2575 goto nla_put_failure;
f5ea9120 2576
5b7ccaf3 2577 if (rdev->ops->get_channel) {
683b6d3b
JB		 2578 int ret;
2579 struct cfg80211_chan_def chandef;
2580
2581 ret = rdev_get_channel(rdev, wdev, &chandef);
2582 if (ret == 0) {
2583 if (nl80211_send_chandef(msg, &chandef))
2584 goto nla_put_failure;
2585 }
d91df0e3
PF		 2586 }
2587
d55d0d59
RM		 2588 if (rdev->ops->get_tx_power) {
2589 int dbm, ret;
2590
2591 ret = rdev_get_tx_power(rdev, wdev, &dbm);
2592 if (ret == 0 &&
2593 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
2594 DBM_TO_MBM(dbm)))
2595 goto nla_put_failure;
2596 }
2597
b84e7a05
AQ		 2598 if (wdev->ssid_len) {
2599 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2600 goto nla_put_failure;
2601 }
2602
053c095a
JB		 2603 genlmsg_end(msg, hdr);
2604 return 0;
55682965
JB		 2605
2606 nla_put_failure:
bc3ed28c
TG		 2607 genlmsg_cancel(msg, hdr);
2608 return -EMSGSIZE;
55682965
JB		 2609}
2610
2611static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2612{
2613 int wp_idx = 0;
2614 int if_idx = 0;
2615 int wp_start = cb->args[0];
2616 int if_start = cb->args[1];
b7fb44da 2617 int filter_wiphy = -1;
f5ea9120 2618 struct cfg80211_registered_device *rdev;
55682965
JB		 2619 struct wireless_dev *wdev;
2620
5fe231e8 2621 rtnl_lock();
b7fb44da
DK		 2622 if (!cb->args[2]) {
2623 struct nl80211_dump_wiphy_state state = {
2624 .filter_wiphy = -1,
2625 };
2626 int ret;
2627
2628 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
2629 if (ret)
2630 return ret;
2631
2632 filter_wiphy = state.filter_wiphy;
2633
2634 /*
2635 * if filtering, set cb->args[2] to +1 since 0 is the default
2636 * value needed to determine that parsing is necessary.
2637 */
2638 if (filter_wiphy >= 0)
2639 cb->args[2] = filter_wiphy + 1;
2640 else
2641 cb->args[2] = -1;
2642 } else if (cb->args[2] > 0) {
2643 filter_wiphy = cb->args[2] - 1;
2644 }
2645
f5ea9120
JB		 2646 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2647 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2648 continue;
bba95fef
JB		 2649 if (wp_idx < wp_start) {
2650 wp_idx++;
55682965 2651 continue;
bba95fef 2652 }
b7fb44da
DK		 2653
2654 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
2655 continue;
2656
55682965
JB		 2657 if_idx = 0;
2658
53873f13 2659 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
bba95fef
JB		 2660 if (if_idx < if_start) {
2661 if_idx++;
55682965 2662 continue;
bba95fef 2663 }
15e47304 2664 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
55682965 2665 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8f894be2 2666 rdev, wdev, false) < 0) {
bba95fef
JB		 2667 goto out;
2668 }
2669 if_idx++;
55682965 2670 }
bba95fef
JB		 2671
2672 wp_idx++;
55682965 2673 }
bba95fef 2674 out:
5fe231e8 2675 rtnl_unlock();
55682965
JB		 2676
2677 cb->args[0] = wp_idx;
2678 cb->args[1] = if_idx;
2679
2680 return skb->len;
2681}
2682
2683static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2684{
2685 struct sk_buff *msg;
1b8ec87a 2686 struct cfg80211_registered_device *rdev = info->user_ptr[0];
72fb2abc 2687 struct wireless_dev *wdev = info->user_ptr[1];
55682965 2688
fd2120ca 2689 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965 2690 if (!msg)
4c476991 2691 return -ENOMEM;
55682965 2692
15e47304 2693 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2694 rdev, wdev, false) < 0) {
4c476991
JB		 2695 nlmsg_free(msg);
2696 return -ENOBUFS;
2697 }
55682965 2698
134e6375 2699 return genlmsg_reply(msg, info);
55682965
JB		 2700}
2701
66f7ac50
MW		 2702static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2703 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2704 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2705 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2706 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2707 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
e057d3c3 2708 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
66f7ac50
MW		 2709};
2710
2711static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2712{
2713 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2714 int flag;
2715
2716 *mntrflags = 0;
2717
2718 if (!nla)
2719 return -EINVAL;
2720
2721 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
2722 nla, mntr_flags_policy))
2723 return -EINVAL;
2724
2725 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2726 if (flags[flag])
2727 *mntrflags |= (1<<flag);
2728
818a986e
JB		 2729 *mntrflags |= MONITOR_FLAG_CHANGED;
2730
66f7ac50
MW		 2731 return 0;
2732}
2733
1db77596
JB		 2734static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
2735 enum nl80211_iftype type,
2736 struct genl_info *info,
2737 struct vif_params *params)
2738{
2739 bool change = false;
2740 int err;
2741
2742 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2743 if (type != NL80211_IFTYPE_MONITOR)
2744 return -EINVAL;
2745
2746 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2747 &params->flags);
2748 if (err)
2749 return err;
2750
2751 change = true;
2752 }
2753
2754 if (params->flags & MONITOR_FLAG_ACTIVE &&
2755 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2756 return -EOPNOTSUPP;
2757
2758 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
2759 const u8 *mumimo_groups;
2760 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2761
2762 if (type != NL80211_IFTYPE_MONITOR)
2763 return -EINVAL;
2764
2765 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2766 return -EOPNOTSUPP;
2767
2768 mumimo_groups =
2769 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
2770
2771 /* bits 0 and 63 are reserved and must be zero */
2772 if ((mumimo_groups[0] & BIT(7)) ||
2773 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(0)))
2774 return -EINVAL;
2775
2776 params->vht_mumimo_groups = mumimo_groups;
2777 change = true;
2778 }
2779
2780 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
2781 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
2782
2783 if (type != NL80211_IFTYPE_MONITOR)
2784 return -EINVAL;
2785
2786 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
2787 return -EOPNOTSUPP;
2788
2789 params->vht_mumimo_follow_addr =
2790 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
2791 change = true;
2792 }
2793
2794 return change ? 1 : 0;
2795}
2796
9bc383de 2797static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
ad4bb6f8
JB		 2798 struct net_device *netdev, u8 use_4addr,
2799 enum nl80211_iftype iftype)
9bc383de 2800{
ad4bb6f8 2801 if (!use_4addr) {
f350a0a8 2802 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
ad4bb6f8 2803 return -EBUSY;
9bc383de 2804 return 0;
ad4bb6f8 2805 }
9bc383de
JB		 2806
2807 switch (iftype) {
2808 case NL80211_IFTYPE_AP_VLAN:
2809 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2810 return 0;
2811 break;
2812 case NL80211_IFTYPE_STATION:
2813 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2814 return 0;
2815 break;
2816 default:
2817 break;
2818 }
2819
2820 return -EOPNOTSUPP;
2821}
2822
55682965
JB		 2823static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2824{
4c476991 2825 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2826 struct vif_params params;
e36d56b6 2827 int err;
04a773ad 2828 enum nl80211_iftype otype, ntype;
4c476991 2829 struct net_device *dev = info->user_ptr[1];
ac7f9cfa 2830 bool change = false;
55682965 2831
2ec600d6
LCC		 2832 memset(&params, 0, sizeof(params));
2833
04a773ad 2834 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 2835
723b038d 2836 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 2837 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 2838 if (otype != ntype)
ac7f9cfa 2839 change = true;
4c476991
JB		 2840 if (ntype > NL80211_IFTYPE_MAX)
2841 return -EINVAL;
723b038d
JB		 2842 }
2843
92ffe055 2844 if (info->attrs[NL80211_ATTR_MESH_ID]) {
29cbe68c
JB		 2845 struct wireless_dev *wdev = dev->ieee80211_ptr;
2846
4c476991
JB		 2847 if (ntype != NL80211_IFTYPE_MESH_POINT)
2848 return -EINVAL;
29cbe68c
JB		 2849 if (netif_running(dev))
2850 return -EBUSY;
2851
2852 wdev_lock(wdev);
2853 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2854 IEEE80211_MAX_MESH_ID_LEN);
2855 wdev->mesh_id_up_len =
2856 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2857 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2858 wdev->mesh_id_up_len);
2859 wdev_unlock(wdev);
2ec600d6
LCC		 2860 }
2861
8b787643
FF		 2862 if (info->attrs[NL80211_ATTR_4ADDR]) {
2863 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2864 change = true;
ad4bb6f8 2865 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
9bc383de 2866 if (err)
4c476991 2867 return err;
8b787643
FF		 2868 } else {
2869 params.use_4addr = -1;
2870 }
2871
1db77596
JB		 2872 err = nl80211_parse_mon_options(rdev, ntype, info, &params);
2873 if (err < 0)
2874 return err;
2875 if (err > 0)
c6e6a0c8 2876 change = true;
c6e6a0c8 2877
ac7f9cfa 2878 if (change)
818a986e 2879 err = cfg80211_change_iface(rdev, dev, ntype, &params);
ac7f9cfa
JB		 2880 else
2881 err = 0;
60719ffd 2882
9bc383de
JB		 2883 if (!err && params.use_4addr != -1)
2884 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2885
55682965
JB		 2886 return err;
2887}
2888
2889static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2890{
4c476991 2891 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2892 struct vif_params params;
84efbb84 2893 struct wireless_dev *wdev;
896ff063 2894 struct sk_buff *msg;
55682965
JB		 2895 int err;
2896 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2897
78f22b6a
JB		 2898 /* to avoid failing a new interface creation due to pending removal */
2899 cfg80211_destroy_ifaces(rdev);
2900
2ec600d6
LCC		 2901 memset(&params, 0, sizeof(params));
2902
55682965
JB		 2903 if (!info->attrs[NL80211_ATTR_IFNAME])
2904 return -EINVAL;
2905
2906 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2907 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2908 if (type > NL80211_IFTYPE_MAX)
2909 return -EINVAL;
2910 }
2911
79c97e97 2912 if (!rdev->ops->add_virtual_intf ||
4c476991
JB		 2913 !(rdev->wiphy.interface_modes & (1 << type)))
2914 return -EOPNOTSUPP;
55682965 2915
cb3b7d87 2916 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
e8f479b1
BG		 2917 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2918 info->attrs[NL80211_ATTR_MAC]) {
1c18f145
AS		 2919 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2920 ETH_ALEN);
2921 if (!is_valid_ether_addr(params.macaddr))
2922 return -EADDRNOTAVAIL;
2923 }
2924
9bc383de 2925 if (info->attrs[NL80211_ATTR_4ADDR]) {
8b787643 2926 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
ad4bb6f8 2927 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
9bc383de 2928 if (err)
4c476991 2929 return err;
9bc383de 2930 }
8b787643 2931
1db77596
JB		 2932 err = nl80211_parse_mon_options(rdev, type, info, &params);
2933 if (err < 0)
2934 return err;
e057d3c3 2935
a18c7192
JB		 2936 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2937 if (!msg)
2938 return -ENOMEM;
2939
e35e4d28
HG		 2940 wdev = rdev_add_virtual_intf(rdev,
2941 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
818a986e 2942 NET_NAME_USER, type, &params);
d687cbb7
RM		 2943 if (WARN_ON(!wdev)) {
2944 nlmsg_free(msg);
2945 return -EPROTO;
2946 } else if (IS_ERR(wdev)) {
1c90f9d4 2947 nlmsg_free(msg);
84efbb84 2948 return PTR_ERR(wdev);
1c90f9d4 2949 }
2ec600d6 2950
18e5ca65 2951 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
78f22b6a
JB		 2952 wdev->owner_nlportid = info->snd_portid;
2953
98104fde
JB		 2954 switch (type) {
2955 case NL80211_IFTYPE_MESH_POINT:
2956 if (!info->attrs[NL80211_ATTR_MESH_ID])
2957 break;
29cbe68c
JB		 2958 wdev_lock(wdev);
2959 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2960 IEEE80211_MAX_MESH_ID_LEN);
2961 wdev->mesh_id_up_len =
2962 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2963 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2964 wdev->mesh_id_up_len);
2965 wdev_unlock(wdev);
98104fde 2966 break;
cb3b7d87 2967 case NL80211_IFTYPE_NAN:
98104fde
JB		 2968 case NL80211_IFTYPE_P2P_DEVICE:
2969 /*
cb3b7d87 2970 * P2P Device and NAN do not have a netdev, so don't go
98104fde
JB		 2971 * through the netdev notifier and must be added here
2972 */
2973 mutex_init(&wdev->mtx);
2974 INIT_LIST_HEAD(&wdev->event_list);
2975 spin_lock_init(&wdev->event_lock);
2976 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2977 spin_lock_init(&wdev->mgmt_registrations_lock);
2978
98104fde 2979 wdev->identifier = ++rdev->wdev_id;
53873f13 2980 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
98104fde 2981 rdev->devlist_generation++;
98104fde
JB		 2982 break;
2983 default:
2984 break;
29cbe68c
JB		 2985 }
2986
15e47304 2987 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2988 rdev, wdev, false) < 0) {
1c90f9d4
JB		 2989 nlmsg_free(msg);
2990 return -ENOBUFS;
2991 }
2992
896ff063
DK		 2993 /*
2994 * For wdevs which have no associated netdev object (e.g. of type
2995 * NL80211_IFTYPE_P2P_DEVICE), emit the NEW_INTERFACE event here.
2996 * For all other types, the event will be generated from the
2997 * netdev notifier
2998 */
2999 if (!wdev->netdev)
3000 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
8f894be2 3001
1c90f9d4 3002 return genlmsg_reply(msg, info);
55682965
JB		 3003}
3004
3005static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3006{
4c476991 3007 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84efbb84 3008 struct wireless_dev *wdev = info->user_ptr[1];
55682965 3009
4c476991
JB		 3010 if (!rdev->ops->del_virtual_intf)
3011 return -EOPNOTSUPP;
55682965 3012
84efbb84
JB		 3013 /*
3014 * If we remove a wireless device without a netdev then clear
3015 * user_ptr[1] so that nl80211_post_doit won't dereference it
3016 * to check if it needs to do dev_put(). Otherwise it crashes
3017 * since the wdev has been freed, unlike with a netdev where
3018 * we need the dev_put() for the netdev to really be freed.
3019 */
3020 if (!wdev->netdev)
3021 info->user_ptr[1] = NULL;
3022
7f8ed01e 3023 return rdev_del_virtual_intf(rdev, wdev);
55682965
JB		 3024}
3025
1d9d9213
SW		 3026static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3027{
3028 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3029 struct net_device *dev = info->user_ptr[1];
3030 u16 noack_map;
3031
3032 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3033 return -EINVAL;
3034
3035 if (!rdev->ops->set_noack_map)
3036 return -EOPNOTSUPP;
3037
3038 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3039
e35e4d28 3040 return rdev_set_noack_map(rdev, dev, noack_map);
1d9d9213
SW		 3041}
3042
41ade00f
JB		 3043struct get_key_cookie {
3044 struct sk_buff *msg;
3045 int error;
b9454e83 3046 int idx;
41ade00f
JB		 3047};
3048
3049static void get_key_callback(void *c, struct key_params *params)
3050{
b9454e83 3051 struct nlattr *key;
41ade00f
JB		 3052 struct get_key_cookie *cookie = c;
3053
9360ffd1
DM		 3054 if ((params->key &&
3055 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3056 params->key_len, params->key)) ||
3057 (params->seq &&
3058 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3059 params->seq_len, params->seq)) ||
3060 (params->cipher &&
3061 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3062 params->cipher)))
3063 goto nla_put_failure;
41ade00f 3064
b9454e83
JB		 3065 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
3066 if (!key)
3067 goto nla_put_failure;
3068
9360ffd1
DM		 3069 if ((params->key &&
3070 nla_put(cookie->msg, NL80211_KEY_DATA,
3071 params->key_len, params->key)) ||
3072 (params->seq &&
3073 nla_put(cookie->msg, NL80211_KEY_SEQ,
3074 params->seq_len, params->seq)) ||
3075 (params->cipher &&
3076 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3077 params->cipher)))
3078 goto nla_put_failure;
b9454e83 3079
9360ffd1
DM		 3080 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
3081 goto nla_put_failure;
b9454e83
JB		 3082
3083 nla_nest_end(cookie->msg, key);
3084
41ade00f
JB		 3085 return;
3086 nla_put_failure:
3087 cookie->error = 1;
3088}
3089
3090static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3091{
4c476991 3092 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3093 int err;
4c476991 3094 struct net_device *dev = info->user_ptr[1];
41ade00f 3095 u8 key_idx = 0;
e31b8213
JB		 3096 const u8 *mac_addr = NULL;
3097 bool pairwise;
41ade00f
JB		 3098 struct get_key_cookie cookie = {
3099 .error = 0,
3100 };
3101 void *hdr;
3102 struct sk_buff *msg;
3103
3104 if (info->attrs[NL80211_ATTR_KEY_IDX])
3105 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3106
3cfcf6ac 3107 if (key_idx > 5)
41ade00f
JB		 3108 return -EINVAL;
3109
3110 if (info->attrs[NL80211_ATTR_MAC])
3111 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3112
e31b8213
JB		 3113 pairwise = !!mac_addr;
3114 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3115 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
7a087e74 3116
e31b8213
JB		 3117 if (kt >= NUM_NL80211_KEYTYPES)
3118 return -EINVAL;
3119 if (kt != NL80211_KEYTYPE_GROUP &&
3120 kt != NL80211_KEYTYPE_PAIRWISE)
3121 return -EINVAL;
3122 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3123 }
3124
4c476991
JB		 3125 if (!rdev->ops->get_key)
3126 return -EOPNOTSUPP;
41ade00f 3127
0fa7b391
JB		 3128 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3129 return -ENOENT;
3130
fd2120ca 3131 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 3132 if (!msg)
3133 return -ENOMEM;
41ade00f 3134
15e47304 3135 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
41ade00f 3136 NL80211_CMD_NEW_KEY);
cb35fba3 3137 if (!hdr)
9fe271af 3138 goto nla_put_failure;
41ade00f
JB		 3139
3140 cookie.msg = msg;
b9454e83 3141 cookie.idx = key_idx;
41ade00f 3142
9360ffd1
DM		 3143 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3144 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3145 goto nla_put_failure;
3146 if (mac_addr &&
3147 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3148 goto nla_put_failure;
41ade00f 3149
e35e4d28
HG		 3150 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3151 get_key_callback);
41ade00f
JB		 3152
3153 if (err)
6c95e2a2 3154 goto free_msg;
41ade00f
JB		 3155
3156 if (cookie.error)
3157 goto nla_put_failure;
3158
3159 genlmsg_end(msg, hdr);
4c476991 3160 return genlmsg_reply(msg, info);
41ade00f
JB		 3161
3162 nla_put_failure:
3163 err = -ENOBUFS;
6c95e2a2 3164 free_msg:
41ade00f 3165 nlmsg_free(msg);
41ade00f
JB		 3166 return err;
3167}
3168
3169static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3170{
4c476991 3171 struct cfg80211_registered_device *rdev = info->user_ptr[0];
b9454e83 3172 struct key_parse key;
41ade00f 3173 int err;
4c476991 3174 struct net_device *dev = info->user_ptr[1];
41ade00f 3175
b9454e83
JB		 3176 err = nl80211_parse_key(info, &key);
3177 if (err)
3178 return err;
41ade00f 3179
b9454e83 3180 if (key.idx < 0)
41ade00f
JB		 3181 return -EINVAL;
3182
b9454e83
JB		 3183 /* only support setting default key */
3184 if (!key.def && !key.defmgmt)
41ade00f
JB		 3185 return -EINVAL;
3186
dbd2fd65 3187 wdev_lock(dev->ieee80211_ptr);
3cfcf6ac 3188
dbd2fd65
JB		 3189 if (key.def) {
3190 if (!rdev->ops->set_default_key) {
3191 err = -EOPNOTSUPP;
3192 goto out;
3193 }
41ade00f 3194
dbd2fd65
JB		 3195 err = nl80211_key_allowed(dev->ieee80211_ptr);
3196 if (err)
3197 goto out;
3198
e35e4d28 3199 err = rdev_set_default_key(rdev, dev, key.idx,
dbd2fd65
JB		 3200 key.def_uni, key.def_multi);
3201
3202 if (err)
3203 goto out;
fffd0934 3204
3d23e349 3205#ifdef CONFIG_CFG80211_WEXT
dbd2fd65
JB		 3206 dev->ieee80211_ptr->wext.default_key = key.idx;
3207#endif
3208 } else {
3209 if (key.def_uni || !key.def_multi) {
3210 err = -EINVAL;
3211 goto out;
3212 }
3213
3214 if (!rdev->ops->set_default_mgmt_key) {
3215 err = -EOPNOTSUPP;
3216 goto out;
3217 }
3218
3219 err = nl80211_key_allowed(dev->ieee80211_ptr);
3220 if (err)
3221 goto out;
3222
e35e4d28 3223 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
dbd2fd65
JB		 3224 if (err)
3225 goto out;
3226
3227#ifdef CONFIG_CFG80211_WEXT
3228 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126 3229#endif
dbd2fd65
JB		 3230 }
3231
3232 out:
fffd0934 3233 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3234
41ade00f
JB		 3235 return err;
3236}
3237
3238static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3239{
4c476991 3240 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fffd0934 3241 int err;
4c476991 3242 struct net_device *dev = info->user_ptr[1];
b9454e83 3243 struct key_parse key;
e31b8213 3244 const u8 *mac_addr = NULL;
41ade00f 3245
b9454e83
JB		 3246 err = nl80211_parse_key(info, &key);
3247 if (err)
3248 return err;
41ade00f 3249
b9454e83 3250 if (!key.p.key)
41ade00f
JB		 3251 return -EINVAL;
3252
41ade00f
JB		 3253 if (info->attrs[NL80211_ATTR_MAC])
3254 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3255
e31b8213
JB		 3256 if (key.type == -1) {
3257 if (mac_addr)
3258 key.type = NL80211_KEYTYPE_PAIRWISE;
3259 else
3260 key.type = NL80211_KEYTYPE_GROUP;
3261 }
3262
3263 /* for now */
3264 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3265 key.type != NL80211_KEYTYPE_GROUP)
3266 return -EINVAL;
3267
4c476991
JB		 3268 if (!rdev->ops->add_key)
3269 return -EOPNOTSUPP;
25e47c18 3270
e31b8213
JB		 3271 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3272 key.type == NL80211_KEYTYPE_PAIRWISE,
3273 mac_addr))
4c476991 3274 return -EINVAL;
41ade00f 3275
fffd0934
JB		 3276 wdev_lock(dev->ieee80211_ptr);
3277 err = nl80211_key_allowed(dev->ieee80211_ptr);
3278 if (!err)
e35e4d28
HG		 3279 err = rdev_add_key(rdev, dev, key.idx,
3280 key.type == NL80211_KEYTYPE_PAIRWISE,
3281 mac_addr, &key.p);
fffd0934 3282 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3283
41ade00f
JB		 3284 return err;
3285}
3286
3287static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3288{
4c476991 3289 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3290 int err;
4c476991 3291 struct net_device *dev = info->user_ptr[1];
41ade00f 3292 u8 *mac_addr = NULL;
b9454e83 3293 struct key_parse key;
41ade00f 3294
b9454e83
JB		 3295 err = nl80211_parse_key(info, &key);
3296 if (err)
3297 return err;
41ade00f
JB		 3298
3299 if (info->attrs[NL80211_ATTR_MAC])
3300 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3301
e31b8213
JB		 3302 if (key.type == -1) {
3303 if (mac_addr)
3304 key.type = NL80211_KEYTYPE_PAIRWISE;
3305 else
3306 key.type = NL80211_KEYTYPE_GROUP;
3307 }
3308
3309 /* for now */
3310 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3311 key.type != NL80211_KEYTYPE_GROUP)
3312 return -EINVAL;
3313
4c476991
JB		 3314 if (!rdev->ops->del_key)
3315 return -EOPNOTSUPP;
41ade00f 3316
fffd0934
JB		 3317 wdev_lock(dev->ieee80211_ptr);
3318 err = nl80211_key_allowed(dev->ieee80211_ptr);
e31b8213 3319
0fa7b391 3320 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
e31b8213
JB		 3321 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3322 err = -ENOENT;
3323
fffd0934 3324 if (!err)
e35e4d28
HG		 3325 err = rdev_del_key(rdev, dev, key.idx,
3326 key.type == NL80211_KEYTYPE_PAIRWISE,
3327 mac_addr);
41ade00f 3328
3d23e349 3329#ifdef CONFIG_CFG80211_WEXT
08645126 3330 if (!err) {
b9454e83 3331 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 3332 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 3333 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 3334 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3335 }
3336#endif
fffd0934 3337 wdev_unlock(dev->ieee80211_ptr);
08645126 3338
41ade00f
JB		 3339 return err;
3340}
3341
77765eaf
VT		 3342/* This function returns an error or the number of nested attributes */
3343static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3344{
3345 struct nlattr *attr;
3346 int n_entries = 0, tmp;
3347
3348 nla_for_each_nested(attr, nl_attr, tmp) {
3349 if (nla_len(attr) != ETH_ALEN)
3350 return -EINVAL;
3351
3352 n_entries++;
3353 }
3354
3355 return n_entries;
3356}
3357
3358/*
3359 * This function parses ACL information and allocates memory for ACL data.
3360 * On successful return, the calling function is responsible to free the
3361 * ACL buffer returned by this function.
3362 */
3363static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3364 struct genl_info *info)
3365{
3366 enum nl80211_acl_policy acl_policy;
3367 struct nlattr *attr;
3368 struct cfg80211_acl_data *acl;
3369 int i = 0, n_entries, tmp;
3370
3371 if (!wiphy->max_acl_mac_addrs)
3372 return ERR_PTR(-EOPNOTSUPP);
3373
3374 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3375 return ERR_PTR(-EINVAL);
3376
3377 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3378 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3379 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3380 return ERR_PTR(-EINVAL);
3381
3382 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3383 return ERR_PTR(-EINVAL);
3384
3385 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3386 if (n_entries < 0)
3387 return ERR_PTR(n_entries);
3388
3389 if (n_entries > wiphy->max_acl_mac_addrs)
3390 return ERR_PTR(-ENOTSUPP);
3391
3392 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3393 GFP_KERNEL);
3394 if (!acl)
3395 return ERR_PTR(-ENOMEM);
3396
3397 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3398 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3399 i++;
3400 }
3401
3402 acl->n_acl_entries = n_entries;
3403 acl->acl_policy = acl_policy;
3404
3405 return acl;
3406}
3407
3408static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3409{
3410 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3411 struct net_device *dev = info->user_ptr[1];
3412 struct cfg80211_acl_data *acl;
3413 int err;
3414
3415 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3416 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3417 return -EOPNOTSUPP;
3418
3419 if (!dev->ieee80211_ptr->beacon_interval)
3420 return -EINVAL;
3421
3422 acl = parse_acl_data(&rdev->wiphy, info);
3423 if (IS_ERR(acl))
3424 return PTR_ERR(acl);
3425
3426 err = rdev_set_mac_acl(rdev, dev, acl);
3427
3428 kfree(acl);
3429
3430 return err;
3431}
3432
a7c7fbff
PK		 3433static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
3434 u8 *rates, u8 rates_len)
3435{
3436 u8 i;
3437 u32 mask = 0;
3438
3439 for (i = 0; i < rates_len; i++) {
3440 int rate = (rates[i] & 0x7f) * 5;
3441 int ridx;
3442
3443 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
3444 struct ieee80211_rate *srate =
3445 &sband->bitrates[ridx];
3446 if (rate == srate->bitrate) {
3447 mask |= 1 << ridx;
3448 break;
3449 }
3450 }
3451 if (ridx == sband->n_bitrates)
3452 return 0; /* rate not found */
3453 }
3454
3455 return mask;
3456}
3457
3458static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
3459 u8 *rates, u8 rates_len,
3460 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
3461{
3462 u8 i;
3463
3464 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
3465
3466 for (i = 0; i < rates_len; i++) {
3467 int ridx, rbit;
3468
3469 ridx = rates[i] / 8;
3470 rbit = BIT(rates[i] % 8);
3471
3472 /* check validity */
3473 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
3474 return false;
3475
3476 /* check availability */
3477 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
3478 mcs[ridx] |= rbit;
3479 else
3480 return false;
3481 }
3482
3483 return true;
3484}
3485
3486static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
3487{
3488 u16 mcs_mask = 0;
3489
3490 switch (vht_mcs_map) {
3491 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
3492 break;
3493 case IEEE80211_VHT_MCS_SUPPORT_0_7:
3494 mcs_mask = 0x00FF;
3495 break;
3496 case IEEE80211_VHT_MCS_SUPPORT_0_8:
3497 mcs_mask = 0x01FF;
3498 break;
3499 case IEEE80211_VHT_MCS_SUPPORT_0_9:
3500 mcs_mask = 0x03FF;
3501 break;
3502 default:
3503 break;
3504 }
3505
3506 return mcs_mask;
3507}
3508
3509static void vht_build_mcs_mask(u16 vht_mcs_map,
3510 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
3511{
3512 u8 nss;
3513
3514 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
3515 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
3516 vht_mcs_map >>= 2;
3517 }
3518}
3519
3520static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
3521 struct nl80211_txrate_vht *txrate,
3522 u16 mcs[NL80211_VHT_NSS_MAX])
3523{
3524 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3525 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
3526 u8 i;
3527
3528 if (!sband->vht_cap.vht_supported)
3529 return false;
3530
3531 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
3532
3533 /* Build vht_mcs_mask from VHT capabilities */
3534 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
3535
3536 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3537 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
3538 mcs[i] = txrate->mcs[i];
3539 else
3540 return false;
3541 }
3542
3543 return true;
3544}
3545
3546static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
3547 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
3548 .len = NL80211_MAX_SUPP_RATES },
3549 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
3550 .len = NL80211_MAX_SUPP_HT_RATES },
3551 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
3552 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
3553};
3554
3555static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
3556 struct cfg80211_bitrate_mask *mask)
3557{
3558 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
3559 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3560 int rem, i;
3561 struct nlattr *tx_rates;
3562 struct ieee80211_supported_band *sband;
3563 u16 vht_tx_mcs_map;
3564
3565 memset(mask, 0, sizeof(*mask));
3566 /* Default to all rates enabled */
3567 for (i = 0; i < NUM_NL80211_BANDS; i++) {
3568 sband = rdev->wiphy.bands[i];
3569
3570 if (!sband)
3571 continue;
3572
3573 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
3574 memcpy(mask->control[i].ht_mcs,
3575 sband->ht_cap.mcs.rx_mask,
3576 sizeof(mask->control[i].ht_mcs));
3577
3578 if (!sband->vht_cap.vht_supported)
3579 continue;
3580
3581 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3582 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
3583 }
3584
3585 /* if no rates are given set it back to the defaults */
3586 if (!info->attrs[NL80211_ATTR_TX_RATES])
3587 goto out;
3588
3589 /* The nested attribute uses enum nl80211_band as the index. This maps
3590 * directly to the enum nl80211_band values used in cfg80211.
3591 */
3592 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
3593 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
3594 enum nl80211_band band = nla_type(tx_rates);
3595 int err;
3596
3597 if (band < 0 || band >= NUM_NL80211_BANDS)
3598 return -EINVAL;
3599 sband = rdev->wiphy.bands[band];
3600 if (sband == NULL)
3601 return -EINVAL;
bfe2c7b1
JB		 3602 err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
3603 nl80211_txattr_policy);
a7c7fbff
PK		 3604 if (err)
3605 return err;
3606 if (tb[NL80211_TXRATE_LEGACY]) {
3607 mask->control[band].legacy = rateset_to_mask(
3608 sband,
3609 nla_data(tb[NL80211_TXRATE_LEGACY]),
3610 nla_len(tb[NL80211_TXRATE_LEGACY]));
3611 if ((mask->control[band].legacy == 0) &&
3612 nla_len(tb[NL80211_TXRATE_LEGACY]))
3613 return -EINVAL;
3614 }
3615 if (tb[NL80211_TXRATE_HT]) {
3616 if (!ht_rateset_to_mask(
3617 sband,
3618 nla_data(tb[NL80211_TXRATE_HT]),
3619 nla_len(tb[NL80211_TXRATE_HT]),
3620 mask->control[band].ht_mcs))
3621 return -EINVAL;
3622 }
3623 if (tb[NL80211_TXRATE_VHT]) {
3624 if (!vht_set_mcs_mask(
3625 sband,
3626 nla_data(tb[NL80211_TXRATE_VHT]),
3627 mask->control[band].vht_mcs))
3628 return -EINVAL;
3629 }
3630 if (tb[NL80211_TXRATE_GI]) {
3631 mask->control[band].gi =
3632 nla_get_u8(tb[NL80211_TXRATE_GI]);
3633 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
3634 return -EINVAL;
3635 }
3636
3637 if (mask->control[band].legacy == 0) {
3638 /* don't allow empty legacy rates if HT or VHT
3639 * are not even supported.
3640 */
3641 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
3642 rdev->wiphy.bands[band]->vht_cap.vht_supported))
3643 return -EINVAL;
3644
3645 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
3646 if (mask->control[band].ht_mcs[i])
3647 goto out;
3648
3649 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
3650 if (mask->control[band].vht_mcs[i])
3651 goto out;
3652
3653 /* legacy and mcs rates may not be both empty */
3654 return -EINVAL;
3655 }
3656 }
3657
3658out:
3659 return 0;
3660}
3661
8564e382
JB		 3662static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
3663 enum nl80211_band band,
3664 struct cfg80211_bitrate_mask *beacon_rate)
a7c7fbff 3665{
8564e382
JB		 3666 u32 count_ht, count_vht, i;
3667 u32 rate = beacon_rate->control[band].legacy;
a7c7fbff
PK		 3668
3669 /* Allow only one rate */
3670 if (hweight32(rate) > 1)
3671 return -EINVAL;
3672
3673 count_ht = 0;
3674 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
8564e382 3675 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
a7c7fbff 3676 return -EINVAL;
8564e382 3677 } else if (beacon_rate->control[band].ht_mcs[i]) {
a7c7fbff
PK		 3678 count_ht++;
3679 if (count_ht > 1)
3680 return -EINVAL;
3681 }
3682 if (count_ht && rate)
3683 return -EINVAL;
3684 }
3685
3686 count_vht = 0;
3687 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8564e382 3688 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
a7c7fbff 3689 return -EINVAL;
8564e382 3690 } else if (beacon_rate->control[band].vht_mcs[i]) {
a7c7fbff
PK		 3691 count_vht++;
3692 if (count_vht > 1)
3693 return -EINVAL;
3694 }
3695 if (count_vht && rate)
3696 return -EINVAL;
3697 }
3698
3699 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
3700 return -EINVAL;
3701
8564e382
JB		 3702 if (rate &&
3703 !wiphy_ext_feature_isset(&rdev->wiphy,
3704 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
3705 return -EINVAL;
3706 if (count_ht &&
3707 !wiphy_ext_feature_isset(&rdev->wiphy,
3708 NL80211_EXT_FEATURE_BEACON_RATE_HT))
3709 return -EINVAL;
3710 if (count_vht &&
3711 !wiphy_ext_feature_isset(&rdev->wiphy,
3712 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
3713 return -EINVAL;
3714
a7c7fbff
PK		 3715 return 0;
3716}
3717
a1193be8 3718static int nl80211_parse_beacon(struct nlattr *attrs[],
8860020e 3719 struct cfg80211_beacon_data *bcn)
ed1b6cc7 3720{
8860020e 3721 bool haveinfo = false;
ed1b6cc7 3722
a1193be8
SW		 3723 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3724 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3725 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3726 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
f4a11bb0
JB		 3727 return -EINVAL;
3728
8860020e 3729 memset(bcn, 0, sizeof(*bcn));
ed1b6cc7 3730
a1193be8
SW		 3731 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
3732 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3733 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
8860020e
JB		 3734 if (!bcn->head_len)
3735 return -EINVAL;
3736 haveinfo = true;
ed1b6cc7
JB		 3737 }
3738
a1193be8
SW		 3739 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3740 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3741 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
8860020e 3742 haveinfo = true;
ed1b6cc7
JB		 3743 }
3744
4c476991
JB		 3745 if (!haveinfo)
3746 return -EINVAL;
3b85875a 3747
a1193be8
SW		 3748 if (attrs[NL80211_ATTR_IE]) {
3749 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3750 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
9946ecfb
JM		 3751 }
3752
a1193be8 3753 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
8860020e 3754 bcn->proberesp_ies =
a1193be8 3755 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
8860020e 3756 bcn->proberesp_ies_len =
a1193be8 3757 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
9946ecfb
JM		 3758 }
3759
a1193be8 3760 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
8860020e 3761 bcn->assocresp_ies =
a1193be8 3762 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
8860020e 3763 bcn->assocresp_ies_len =
a1193be8 3764 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
9946ecfb
JM		 3765 }
3766
a1193be8
SW		 3767 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3768 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3769 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
00f740e1
AN		 3770 }
3771
8860020e
JB		 3772 return 0;
3773}
3774
66cd794e
JB		 3775static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
3776 const u8 *rates)
3777{
3778 int i;
3779
3780 if (!rates)
3781 return;
3782
3783 for (i = 0; i < rates[1]; i++) {
3784 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
3785 params->ht_required = true;
3786 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
3787 params->vht_required = true;
3788 }
3789}
3790
3791/*
3792 * Since the nl80211 API didn't include, from the beginning, attributes about
3793 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
3794 * benefit of drivers that rebuild IEs in the firmware.
3795 */
3796static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
3797{
3798 const struct cfg80211_beacon_data *bcn = &params->beacon;
3799 size_t ies_len = bcn->beacon_ies_len;
3800 const u8 *ies = bcn->beacon_ies;
3801 const u8 *rates;
3802 const u8 *cap;
3803
3804 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
3805 nl80211_check_ap_rate_selectors(params, rates);
3806
3807 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
3808 nl80211_check_ap_rate_selectors(params, rates);
3809
3810 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
3811 if (cap && cap[1] >= sizeof(*params->ht_cap))
3812 params->ht_cap = (void *)(cap + 2);
3813 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
3814 if (cap && cap[1] >= sizeof(*params->vht_cap))
3815 params->vht_cap = (void *)(cap + 2);
3816}
3817
46c1dd0c
FF		 3818static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3819 struct cfg80211_ap_settings *params)
3820{
3821 struct wireless_dev *wdev;
3822 bool ret = false;
3823
53873f13 3824 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
46c1dd0c
FF		 3825 if (wdev->iftype != NL80211_IFTYPE_AP &&
3826 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3827 continue;
3828
683b6d3b 3829 if (!wdev->preset_chandef.chan)
46c1dd0c
FF		 3830 continue;
3831
683b6d3b 3832 params->chandef = wdev->preset_chandef;
46c1dd0c
FF		 3833 ret = true;
3834 break;
3835 }
3836
46c1dd0c
FF		 3837 return ret;
3838}
3839
e39e5b5e
JM		 3840static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3841 enum nl80211_auth_type auth_type,
3842 enum nl80211_commands cmd)
3843{
3844 if (auth_type > NL80211_AUTHTYPE_MAX)
3845 return false;
3846
3847 switch (cmd) {
3848 case NL80211_CMD_AUTHENTICATE:
3849 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3850 auth_type == NL80211_AUTHTYPE_SAE)
3851 return false;
63181060
JM		 3852 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3853 NL80211_EXT_FEATURE_FILS_STA) &&
3854 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3855 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3856 auth_type == NL80211_AUTHTYPE_FILS_PK))
3857 return false;
e39e5b5e
JM		 3858 return true;
3859 case NL80211_CMD_CONNECT:
a3caf744
VK		 3860 /* SAE not supported yet */
3861 if (auth_type == NL80211_AUTHTYPE_SAE)
3862 return false;
3863 /* FILS with SK PFS or PK not supported yet */
3864 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3865 auth_type == NL80211_AUTHTYPE_FILS_PK)
3866 return false;
3867 if (!wiphy_ext_feature_isset(
3868 &rdev->wiphy,
3869 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
3870 auth_type == NL80211_AUTHTYPE_FILS_SK)
3871 return false;
3872 return true;
e39e5b5e
JM		 3873 case NL80211_CMD_START_AP:
3874 /* SAE not supported yet */
3875 if (auth_type == NL80211_AUTHTYPE_SAE)
3876 return false;
63181060
JM		 3877 /* FILS not supported yet */
3878 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
3879 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
3880 auth_type == NL80211_AUTHTYPE_FILS_PK)
3881 return false;
e39e5b5e
JM		 3882 return true;
3883 default:
3884 return false;
3885 }
3886}
3887
8860020e
JB		 3888static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3889{
3890 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3891 struct net_device *dev = info->user_ptr[1];
3892 struct wireless_dev *wdev = dev->ieee80211_ptr;
3893 struct cfg80211_ap_settings params;
3894 int err;
3895
3896 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3897 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3898 return -EOPNOTSUPP;
3899
3900 if (!rdev->ops->start_ap)
3901 return -EOPNOTSUPP;
3902
3903 if (wdev->beacon_interval)
3904 return -EALREADY;
3905
3906 memset(&params, 0, sizeof(params));
3907
3908 /* these are required for START_AP */
3909 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3910 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3911 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3912 return -EINVAL;
3913
a1193be8 3914 err = nl80211_parse_beacon(info->attrs, &params.beacon);
8860020e
JB		 3915 if (err)
3916 return err;
3917
3918 params.beacon_interval =
3919 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3920 params.dtim_period =
3921 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3922
0c317a02
PK		 3923 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
3924 params.beacon_interval);
8860020e
JB		 3925 if (err)
3926 return err;
3927
3928 /*
3929 * In theory, some of these attributes should be required here
3930 * but since they were not used when the command was originally
3931 * added, keep them optional for old user space programs to let
3932 * them continue to work with drivers that do not need the
3933 * additional information -- drivers must check!
3934 */
3935 if (info->attrs[NL80211_ATTR_SSID]) {
3936 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3937 params.ssid_len =
3938 nla_len(info->attrs[NL80211_ATTR_SSID]);
3939 if (params.ssid_len == 0 ||
3940 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3941 return -EINVAL;
3942 }
3943
3944 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3945 params.hidden_ssid = nla_get_u32(
3946 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3947 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3948 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3949 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3950 return -EINVAL;
3951 }
3952
3953 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3954
3955 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3956 params.auth_type = nla_get_u32(
3957 info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 3958 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3959 NL80211_CMD_START_AP))
8860020e
JB		 3960 return -EINVAL;
3961 } else
3962 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3963
3964 err = nl80211_crypto_settings(rdev, info, &params.crypto,
3965 NL80211_MAX_NR_CIPHER_SUITES);
3966 if (err)
3967 return err;
3968
1b658f11
VT		 3969 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3970 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3971 return -EOPNOTSUPP;
3972 params.inactivity_timeout = nla_get_u16(
3973 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3974 }
3975
53cabad7
JB		 3976 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3977 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3978 return -EINVAL;
3979 params.p2p_ctwindow =
3980 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3981 if (params.p2p_ctwindow > 127)
3982 return -EINVAL;
3983 if (params.p2p_ctwindow != 0 &&
3984 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3985 return -EINVAL;
3986 }
3987
3988 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3989 u8 tmp;
3990
3991 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3992 return -EINVAL;
3993 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3994 if (tmp > 1)
3995 return -EINVAL;
3996 params.p2p_opp_ps = tmp;
3997 if (params.p2p_opp_ps != 0 &&
3998 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3999 return -EINVAL;
4000 }
4001
aa430da4 4002 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 4003 err = nl80211_parse_chandef(rdev, info, &params.chandef);
4004 if (err)
4005 return err;
4006 } else if (wdev->preset_chandef.chan) {
4007 params.chandef = wdev->preset_chandef;
46c1dd0c 4008 } else if (!nl80211_get_ap_channel(rdev, &params))
aa430da4
JB		 4009 return -EINVAL;
4010
923b352f
AN		 4011 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
4012 wdev->iftype))
aa430da4
JB		 4013 return -EINVAL;
4014
a7c7fbff
PK		 4015 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4016 err = nl80211_parse_tx_bitrate_mask(info, &params.beacon_rate);
4017 if (err)
4018 return err;
4019
8564e382
JB		 4020 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4021 &params.beacon_rate);
a7c7fbff
PK		 4022 if (err)
4023 return err;
4024 }
4025
18998c38
EP		 4026 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4027 params.smps_mode =
4028 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4029 switch (params.smps_mode) {
4030 case NL80211_SMPS_OFF:
4031 break;
4032 case NL80211_SMPS_STATIC:
4033 if (!(rdev->wiphy.features &
4034 NL80211_FEATURE_STATIC_SMPS))
4035 return -EINVAL;
4036 break;
4037 case NL80211_SMPS_DYNAMIC:
4038 if (!(rdev->wiphy.features &
4039 NL80211_FEATURE_DYNAMIC_SMPS))
4040 return -EINVAL;
4041 break;
4042 default:
4043 return -EINVAL;
4044 }
4045 } else {
4046 params.smps_mode = NL80211_SMPS_OFF;
4047 }
4048
6e8ef842
PK		 4049 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4050 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4051 return -EOPNOTSUPP;
4052
4baf6bea
OO		 4053 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4054 params.acl = parse_acl_data(&rdev->wiphy, info);
4055 if (IS_ERR(params.acl))
4056 return PTR_ERR(params.acl);
4057 }
4058
66cd794e
JB		 4059 nl80211_calculate_ap_params(&params);
4060
c56589ed 4061 wdev_lock(wdev);
e35e4d28 4062 err = rdev_start_ap(rdev, dev, &params);
46c1dd0c 4063 if (!err) {
683b6d3b 4064 wdev->preset_chandef = params.chandef;
8860020e 4065 wdev->beacon_interval = params.beacon_interval;
9e0e2961 4066 wdev->chandef = params.chandef;
06e191e2
AQ		 4067 wdev->ssid_len = params.ssid_len;
4068 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
46c1dd0c 4069 }
c56589ed 4070 wdev_unlock(wdev);
77765eaf
VT		 4071
4072 kfree(params.acl);
4073
56d1893d 4074 return err;
ed1b6cc7
JB		 4075}
4076
8860020e
JB		 4077static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4078{
4079 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4080 struct net_device *dev = info->user_ptr[1];
4081 struct wireless_dev *wdev = dev->ieee80211_ptr;
4082 struct cfg80211_beacon_data params;
4083 int err;
4084
4085 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4086 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4087 return -EOPNOTSUPP;
4088
4089 if (!rdev->ops->change_beacon)
4090 return -EOPNOTSUPP;
4091
4092 if (!wdev->beacon_interval)
4093 return -EINVAL;
4094
a1193be8 4095 err = nl80211_parse_beacon(info->attrs, &params);
8860020e
JB		 4096 if (err)
4097 return err;
4098
c56589ed
SW		 4099 wdev_lock(wdev);
4100 err = rdev_change_beacon(rdev, dev, &params);
4101 wdev_unlock(wdev);
4102
4103 return err;
8860020e
JB		 4104}
4105
4106static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
ed1b6cc7 4107{
4c476991
JB		 4108 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4109 struct net_device *dev = info->user_ptr[1];
ed1b6cc7 4110
7c8d5e03 4111 return cfg80211_stop_ap(rdev, dev, false);
ed1b6cc7
JB		 4112}
4113
5727ef1b
JB		 4114static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4115 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4116 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4117 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 4118 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
b39c48fa 4119 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
d83023da 4120 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5727ef1b
JB		 4121};
4122
eccb8e8f 4123static int parse_station_flags(struct genl_info *info,
bdd3ae3d 4124 enum nl80211_iftype iftype,
eccb8e8f 4125 struct station_parameters *params)
5727ef1b
JB		 4126{
4127 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 4128 struct nlattr *nla;
5727ef1b
JB		 4129 int flag;
4130
eccb8e8f
JB		 4131 /*
4132 * Try parsing the new attribute first so userspace
4133 * can specify both for older kernels.
4134 */
4135 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4136 if (nla) {
4137 struct nl80211_sta_flag_update *sta_flags;
4138
4139 sta_flags = nla_data(nla);
4140 params->sta_flags_mask = sta_flags->mask;
4141 params->sta_flags_set = sta_flags->set;
77ee7c89 4142 params->sta_flags_set &= params->sta_flags_mask;
eccb8e8f
JB		 4143 if ((params->sta_flags_mask |
4144 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4145 return -EINVAL;
4146 return 0;
4147 }
4148
4149 /* if present, parse the old attribute */
5727ef1b 4150
eccb8e8f 4151 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 4152 if (!nla)
4153 return 0;
4154
4155 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
4156 nla, sta_flags_policy))
4157 return -EINVAL;
4158
bdd3ae3d
JB		 4159 /*
4160 * Only allow certain flags for interface types so that
4161 * other attributes are silently ignored. Remember that
4162 * this is backward compatibility code with old userspace
4163 * and shouldn't be hit in other cases anyway.
4164 */
4165 switch (iftype) {
4166 case NL80211_IFTYPE_AP:
4167 case NL80211_IFTYPE_AP_VLAN:
4168 case NL80211_IFTYPE_P2P_GO:
4169 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4170 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4171 BIT(NL80211_STA_FLAG_WME) |
4172 BIT(NL80211_STA_FLAG_MFP);
4173 break;
4174 case NL80211_IFTYPE_P2P_CLIENT:
4175 case NL80211_IFTYPE_STATION:
4176 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4177 BIT(NL80211_STA_FLAG_TDLS_PEER);
4178 break;
4179 case NL80211_IFTYPE_MESH_POINT:
4180 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4181 BIT(NL80211_STA_FLAG_MFP) |
4182 BIT(NL80211_STA_FLAG_AUTHORIZED);
4183 default:
4184 return -EINVAL;
4185 }
5727ef1b 4186
3383b5a6
JB		 4187 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4188 if (flags[flag]) {
eccb8e8f 4189 params->sta_flags_set |= (1<<flag);
5727ef1b 4190
3383b5a6
JB		 4191 /* no longer support new API additions in old API */
4192 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4193 return -EINVAL;
4194 }
4195 }
4196
5727ef1b
JB		 4197 return 0;
4198}
4199
c8dcfd8a
FF		 4200static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
4201 int attr)
4202{
4203 struct nlattr *rate;
8eb41c8d
VK		 4204 u32 bitrate;
4205 u16 bitrate_compat;
b51f3bee 4206 enum nl80211_attrs rate_flg;
c8dcfd8a
FF		 4207
4208 rate = nla_nest_start(msg, attr);
4209 if (!rate)
db9c64cf 4210 return false;
c8dcfd8a
FF		 4211
4212 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4213 bitrate = cfg80211_calculate_bitrate(info);
8eb41c8d
VK		 4214 /* report 16-bit bitrate only if we can */
4215 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
db9c64cf
JB		 4216 if (bitrate > 0 &&
4217 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4218 return false;
4219 if (bitrate_compat > 0 &&
4220 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4221 return false;
4222
b51f3bee
JB		 4223 switch (info->bw) {
4224 case RATE_INFO_BW_5:
4225 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4226 break;
4227 case RATE_INFO_BW_10:
4228 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4229 break;
4230 default:
4231 WARN_ON(1);
4232 /* fall through */
4233 case RATE_INFO_BW_20:
4234 rate_flg = 0;
4235 break;
4236 case RATE_INFO_BW_40:
4237 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4238 break;
4239 case RATE_INFO_BW_80:
4240 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4241 break;
4242 case RATE_INFO_BW_160:
4243 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4244 break;
4245 }
4246
4247 if (rate_flg && nla_put_flag(msg, rate_flg))
4248 return false;
4249
db9c64cf
JB		 4250 if (info->flags & RATE_INFO_FLAGS_MCS) {
4251 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4252 return false;
db9c64cf
JB		 4253 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4254 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4255 return false;
4256 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4257 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4258 return false;
4259 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4260 return false;
db9c64cf
JB		 4261 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4262 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4263 return false;
4264 }
c8dcfd8a
FF		 4265
4266 nla_nest_end(msg, rate);
4267 return true;
c8dcfd8a
FF		 4268}
4269
119363c7
FF		 4270static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4271 int id)
4272{
4273 void *attr;
4274 int i = 0;
4275
4276 if (!mask)
4277 return true;
4278
4279 attr = nla_nest_start(msg, id);
4280 if (!attr)
4281 return false;
4282
4283 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4284 if (!(mask & BIT(i)))
4285 continue;
4286
4287 if (nla_put_u8(msg, i, signal[i]))
4288 return false;
4289 }
4290
4291 nla_nest_end(msg, attr);
4292
4293 return true;
4294}
4295
cf5ead82
JB		 4296static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4297 u32 seq, int flags,
66266b3a
JL		 4298 struct cfg80211_registered_device *rdev,
4299 struct net_device *dev,
98b62183 4300 const u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 4301{
4302 void *hdr;
f4263c98 4303 struct nlattr *sinfoattr, *bss_param;
fd5b74dc 4304
cf5ead82 4305 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
fd5b74dc
JB		 4306 if (!hdr)
4307 return -1;
4308
9360ffd1
DM		 4309 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4310 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
4311 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
4312 goto nla_put_failure;
f5ea9120 4313
2ec600d6
LCC		 4314 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
4315 if (!sinfoattr)
fd5b74dc 4316 goto nla_put_failure;
319090bf
JB		 4317
4318#define PUT_SINFO(attr, memb, type) do { \
d686b920 4319 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
739960f1 4320 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
319090bf
JB		 4321 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
4322 sinfo->memb)) \
4323 goto nla_put_failure; \
4324 } while (0)
d686b920
JB		 4325#define PUT_SINFO_U64(attr, memb) do { \
4326 if (sinfo->filled & (1ULL << NL80211_STA_INFO_ ## attr) && \
4327 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
4328 sinfo->memb, NL80211_STA_INFO_PAD)) \
4329 goto nla_put_failure; \
4330 } while (0)
319090bf
JB		 4331
4332 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
4333 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
4334
4335 if (sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES) |
4336 BIT(NL80211_STA_INFO_RX_BYTES64)) &&
9360ffd1 4337 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
42745e03 4338 (u32)sinfo->rx_bytes))
9360ffd1 4339 goto nla_put_failure;
319090bf
JB		 4340
4341 if (sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES) |
4342 BIT(NL80211_STA_INFO_TX_BYTES64)) &&
9360ffd1 4343 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
42745e03
VK		 4344 (u32)sinfo->tx_bytes))
4345 goto nla_put_failure;
319090bf 4346
d686b920
JB		 4347 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
4348 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
319090bf
JB		 4349 PUT_SINFO(LLID, llid, u16);
4350 PUT_SINFO(PLID, plid, u16);
4351 PUT_SINFO(PLINK_STATE, plink_state, u8);
d686b920 4352 PUT_SINFO_U64(RX_DURATION, rx_duration);
319090bf 4353
66266b3a
JL		 4354 switch (rdev->wiphy.signal_type) {
4355 case CFG80211_SIGNAL_TYPE_MBM:
319090bf
JB		 4356 PUT_SINFO(SIGNAL, signal, u8);
4357 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
66266b3a
JL		 4358 break;
4359 default:
4360 break;
4361 }
319090bf 4362 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL)) {
119363c7
FF		 4363 if (!nl80211_put_signal(msg, sinfo->chains,
4364 sinfo->chain_signal,
4365 NL80211_STA_INFO_CHAIN_SIGNAL))
4366 goto nla_put_failure;
4367 }
319090bf 4368 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
119363c7
FF		 4369 if (!nl80211_put_signal(msg, sinfo->chains,
4370 sinfo->chain_signal_avg,
4371 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
4372 goto nla_put_failure;
4373 }
319090bf 4374 if (sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {
c8dcfd8a
FF		 4375 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
4376 NL80211_STA_INFO_TX_BITRATE))
4377 goto nla_put_failure;
4378 }
319090bf 4379 if (sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE)) {
c8dcfd8a
FF		 4380 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
4381 NL80211_STA_INFO_RX_BITRATE))
420e7fab 4382 goto nla_put_failure;
420e7fab 4383 }
319090bf
JB		 4384
4385 PUT_SINFO(RX_PACKETS, rx_packets, u32);
4386 PUT_SINFO(TX_PACKETS, tx_packets, u32);
4387 PUT_SINFO(TX_RETRIES, tx_retries, u32);
4388 PUT_SINFO(TX_FAILED, tx_failed, u32);
4389 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
4390 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
4391 PUT_SINFO(LOCAL_PM, local_pm, u32);
4392 PUT_SINFO(PEER_PM, peer_pm, u32);
4393 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
4394
4395 if (sinfo->filled & BIT(NL80211_STA_INFO_BSS_PARAM)) {
f4263c98
PS		 4396 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
4397 if (!bss_param)
4398 goto nla_put_failure;
4399
9360ffd1
DM		 4400 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
4401 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
4402 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
4403 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
4404 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
4405 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
4406 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
4407 sinfo->bss_param.dtim_period) ||
4408 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
4409 sinfo->bss_param.beacon_interval))
4410 goto nla_put_failure;
f4263c98
PS		 4411
4412 nla_nest_end(msg, bss_param);
4413 }
319090bf 4414 if ((sinfo->filled & BIT(NL80211_STA_INFO_STA_FLAGS)) &&
9360ffd1
DM		 4415 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
4416 sizeof(struct nl80211_sta_flag_update),
4417 &sinfo->sta_flags))
4418 goto nla_put_failure;
319090bf 4419
d686b920
JB		 4420 PUT_SINFO_U64(T_OFFSET, t_offset);
4421 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
4422 PUT_SINFO_U64(BEACON_RX, rx_beacon);
a76b1942 4423 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
319090bf
JB		 4424
4425#undef PUT_SINFO
d686b920 4426#undef PUT_SINFO_U64
6de39808
JB		 4427
4428 if (sinfo->filled & BIT(NL80211_STA_INFO_TID_STATS)) {
4429 struct nlattr *tidsattr;
4430 int tid;
4431
4432 tidsattr = nla_nest_start(msg, NL80211_STA_INFO_TID_STATS);
4433 if (!tidsattr)
4434 goto nla_put_failure;
4435
4436 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
4437 struct cfg80211_tid_stats *tidstats;
4438 struct nlattr *tidattr;
4439
4440 tidstats = &sinfo->pertid[tid];
4441
4442 if (!tidstats->filled)
4443 continue;
4444
4445 tidattr = nla_nest_start(msg, tid + 1);
4446 if (!tidattr)
4447 goto nla_put_failure;
4448
d686b920 4449#define PUT_TIDVAL_U64(attr, memb) do { \
6de39808 4450 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
d686b920
JB		 4451 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
4452 tidstats->memb, NL80211_TID_STATS_PAD)) \
6de39808
JB		 4453 goto nla_put_failure; \
4454 } while (0)
4455
d686b920
JB		 4456 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
4457 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
4458 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
4459 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
6de39808 4460
d686b920 4461#undef PUT_TIDVAL_U64
6de39808
JB		 4462 nla_nest_end(msg, tidattr);
4463 }
4464
4465 nla_nest_end(msg, tidsattr);
4466 }
4467
2ec600d6 4468 nla_nest_end(msg, sinfoattr);
fd5b74dc 4469
319090bf 4470 if (sinfo->assoc_req_ies_len &&
9360ffd1
DM		 4471 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
4472 sinfo->assoc_req_ies))
4473 goto nla_put_failure;
50d3dfb7 4474
053c095a
JB		 4475 genlmsg_end(msg, hdr);
4476 return 0;
fd5b74dc
JB		 4477
4478 nla_put_failure:
bc3ed28c
TG		 4479 genlmsg_cancel(msg, hdr);
4480 return -EMSGSIZE;
fd5b74dc
JB		 4481}
4482
2ec600d6 4483static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 4484 struct netlink_callback *cb)
2ec600d6 4485{
2ec600d6 4486 struct station_info sinfo;
1b8ec87a 4487 struct cfg80211_registered_device *rdev;
97990a06 4488 struct wireless_dev *wdev;
2ec600d6 4489 u8 mac_addr[ETH_ALEN];
97990a06 4490 int sta_idx = cb->args[2];
2ec600d6 4491 int err;
2ec600d6 4492
1b8ec87a 4493 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 4494 if (err)
4495 return err;
bba95fef 4496
97990a06
JB		 4497 if (!wdev->netdev) {
4498 err = -EINVAL;
4499 goto out_err;
4500 }
4501
1b8ec87a 4502 if (!rdev->ops->dump_station) {
eec60b03 4503 err = -EOPNOTSUPP;
bba95fef
JB		 4504 goto out_err;
4505 }
4506
bba95fef 4507 while (1) {
f612cedf 4508 memset(&sinfo, 0, sizeof(sinfo));
1b8ec87a 4509 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
e35e4d28 4510 mac_addr, &sinfo);
bba95fef
JB		 4511 if (err == -ENOENT)
4512 break;
4513 if (err)
3b85875a 4514 goto out_err;
bba95fef 4515
cf5ead82 4516 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
15e47304 4517 NETLINK_CB(cb->skb).portid,
bba95fef 4518 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1b8ec87a 4519 rdev, wdev->netdev, mac_addr,
bba95fef
JB		 4520 &sinfo) < 0)
4521 goto out;
4522
4523 sta_idx++;
4524 }
4525
bba95fef 4526 out:
97990a06 4527 cb->args[2] = sta_idx;
bba95fef 4528 err = skb->len;
bba95fef 4529 out_err:
1b8ec87a 4530 nl80211_finish_wdev_dump(rdev);
bba95fef
JB		 4531
4532 return err;
2ec600d6 4533}
fd5b74dc 4534
5727ef1b
JB		 4535static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
4536{
4c476991
JB		 4537 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4538 struct net_device *dev = info->user_ptr[1];
2ec600d6 4539 struct station_info sinfo;
fd5b74dc
JB		 4540 struct sk_buff *msg;
4541 u8 *mac_addr = NULL;
4c476991 4542 int err;
fd5b74dc 4543
2ec600d6 4544 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 4545
4546 if (!info->attrs[NL80211_ATTR_MAC])
4547 return -EINVAL;
4548
4549 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4550
4c476991
JB		 4551 if (!rdev->ops->get_station)
4552 return -EOPNOTSUPP;
3b85875a 4553
e35e4d28 4554 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
fd5b74dc 4555 if (err)
4c476991 4556 return err;
2ec600d6 4557
fd2120ca 4558 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc 4559 if (!msg)
4c476991 4560 return -ENOMEM;
fd5b74dc 4561
cf5ead82
JB		 4562 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
4563 info->snd_portid, info->snd_seq, 0,
66266b3a 4564 rdev, dev, mac_addr, &sinfo) < 0) {
4c476991
JB		 4565 nlmsg_free(msg);
4566 return -ENOBUFS;
4567 }
3b85875a 4568
4c476991 4569 return genlmsg_reply(msg, info);
5727ef1b
JB		 4570}
4571
77ee7c89
JB		 4572int cfg80211_check_station_change(struct wiphy *wiphy,
4573 struct station_parameters *params,
4574 enum cfg80211_station_type statype)
4575{
e4208427
AB		 4576 if (params->listen_interval != -1 &&
4577 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89 4578 return -EINVAL;
e4208427 4579
17b94247
AB		 4580 if (params->support_p2p_ps != -1 &&
4581 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
4582 return -EINVAL;
4583
c72e1140 4584 if (params->aid &&
e4208427
AB		 4585 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
4586 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
77ee7c89
JB		 4587 return -EINVAL;
4588
4589 /* When you run into this, adjust the code below for the new flag */
4590 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4591
4592 switch (statype) {
eef941e6
TP		 4593 case CFG80211_STA_MESH_PEER_KERNEL:
4594 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 4595 /*
4596 * No ignoring the TDLS flag here -- the userspace mesh
4597 * code doesn't have the bug of including TDLS in the
4598 * mask everywhere.
4599 */
4600 if (params->sta_flags_mask &
4601 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4602 BIT(NL80211_STA_FLAG_MFP) |
4603 BIT(NL80211_STA_FLAG_AUTHORIZED)))
4604 return -EINVAL;
4605 break;
4606 case CFG80211_STA_TDLS_PEER_SETUP:
4607 case CFG80211_STA_TDLS_PEER_ACTIVE:
4608 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4609 return -EINVAL;
4610 /* ignore since it can't change */
4611 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4612 break;
4613 default:
4614 /* disallow mesh-specific things */
4615 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
4616 return -EINVAL;
4617 if (params->local_pm)
4618 return -EINVAL;
4619 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4620 return -EINVAL;
4621 }
4622
4623 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4624 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
4625 /* TDLS can't be set, ... */
4626 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4627 return -EINVAL;
4628 /*
4629 * ... but don't bother the driver with it. This works around
4630 * a hostapd/wpa_supplicant issue -- it always includes the
4631 * TLDS_PEER flag in the mask even for AP mode.
4632 */
4633 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4634 }
4635
47edb11b
AB		 4636 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
4637 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4638 /* reject other things that can't change */
4639 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
4640 return -EINVAL;
4641 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
4642 return -EINVAL;
4643 if (params->supported_rates)
4644 return -EINVAL;
4645 if (params->ext_capab || params->ht_capa || params->vht_capa)
4646 return -EINVAL;
4647 }
4648
47edb11b
AB		 4649 if (statype != CFG80211_STA_AP_CLIENT &&
4650 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
77ee7c89
JB		 4651 if (params->vlan)
4652 return -EINVAL;
4653 }
4654
4655 switch (statype) {
4656 case CFG80211_STA_AP_MLME_CLIENT:
4657 /* Use this only for authorizing/unauthorizing a station */
4658 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4659 return -EOPNOTSUPP;
4660 break;
4661 case CFG80211_STA_AP_CLIENT:
47edb11b 4662 case CFG80211_STA_AP_CLIENT_UNASSOC:
77ee7c89
JB		 4663 /* accept only the listed bits */
4664 if (params->sta_flags_mask &
4665 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4666 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4667 BIT(NL80211_STA_FLAG_ASSOCIATED) |
4668 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4669 BIT(NL80211_STA_FLAG_WME) |
4670 BIT(NL80211_STA_FLAG_MFP)))
4671 return -EINVAL;
4672
4673 /* but authenticated/associated only if driver handles it */
4674 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4675 params->sta_flags_mask &
4676 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4677 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4678 return -EINVAL;
4679 break;
4680 case CFG80211_STA_IBSS:
4681 case CFG80211_STA_AP_STA:
4682 /* reject any changes other than AUTHORIZED */
4683 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
4684 return -EINVAL;
4685 break;
4686 case CFG80211_STA_TDLS_PEER_SETUP:
4687 /* reject any changes other than AUTHORIZED or WME */
4688 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
4689 BIT(NL80211_STA_FLAG_WME)))
4690 return -EINVAL;
4691 /* force (at least) rates when authorizing */
4692 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
4693 !params->supported_rates)
4694 return -EINVAL;
4695 break;
4696 case CFG80211_STA_TDLS_PEER_ACTIVE:
4697 /* reject any changes */
4698 return -EINVAL;
eef941e6 4699 case CFG80211_STA_MESH_PEER_KERNEL:
77ee7c89
JB		 4700 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
4701 return -EINVAL;
4702 break;
eef941e6 4703 case CFG80211_STA_MESH_PEER_USER:
42925040
CYY		 4704 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
4705 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
77ee7c89
JB		 4706 return -EINVAL;
4707 break;
4708 }
4709
06f7c88c
BL		 4710 /*
4711 * Older kernel versions ignored this attribute entirely, so don't
4712 * reject attempts to update it but mark it as unused instead so the
4713 * driver won't look at the data.
4714 */
4715 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
4716 statype != CFG80211_STA_TDLS_PEER_SETUP)
4717 params->opmode_notif_used = false;
4718
77ee7c89
JB		 4719 return 0;
4720}
4721EXPORT_SYMBOL(cfg80211_check_station_change);
4722
5727ef1b 4723/*
c258d2de 4724 * Get vlan interface making sure it is running and on the right wiphy.
5727ef1b 4725 */
80b99899
JB		 4726static struct net_device *get_vlan(struct genl_info *info,
4727 struct cfg80211_registered_device *rdev)
5727ef1b 4728{
463d0183 4729 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
80b99899
JB		 4730 struct net_device *v;
4731 int ret;
4732
4733 if (!vlanattr)
4734 return NULL;
4735
4736 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4737 if (!v)
4738 return ERR_PTR(-ENODEV);
4739
4740 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4741 ret = -EINVAL;
4742 goto error;
5727ef1b 4743 }
80b99899 4744
77ee7c89
JB		 4745 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4746 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4747 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4748 ret = -EINVAL;
4749 goto error;
4750 }
4751
80b99899
JB		 4752 if (!netif_running(v)) {
4753 ret = -ENETDOWN;
4754 goto error;
4755 }
4756
4757 return v;
4758 error:
4759 dev_put(v);
4760 return ERR_PTR(ret);
5727ef1b
JB		 4761}
4762
94e860f1
JB		 4763static const struct nla_policy
4764nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
df881293
JM		 4765 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4766 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4767};
4768
ff276691
JB		 4769static int nl80211_parse_sta_wme(struct genl_info *info,
4770 struct station_parameters *params)
df881293 4771{
df881293
JM		 4772 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4773 struct nlattr *nla;
4774 int err;
4775
df881293
JM		 4776 /* parse WME attributes if present */
4777 if (!info->attrs[NL80211_ATTR_STA_WME])
4778 return 0;
4779
4780 nla = info->attrs[NL80211_ATTR_STA_WME];
4781 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
4782 nl80211_sta_wme_policy);
4783 if (err)
4784 return err;
4785
4786 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4787 params->uapsd_queues = nla_get_u8(
4788 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4789 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4790 return -EINVAL;
4791
4792 if (tb[NL80211_STA_WME_MAX_SP])
4793 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4794
4795 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4796 return -EINVAL;
4797
4798 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4799
4800 return 0;
4801}
4802
c01fc9ad
SD		 4803static int nl80211_parse_sta_channel_info(struct genl_info *info,
4804 struct station_parameters *params)
4805{
4806 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4807 params->supported_channels =
4808 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4809 params->supported_channels_len =
4810 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4811 /*
4812 * Need to include at least one (first channel, number of
4813 * channels) tuple for each subband, and must have proper
4814 * tuples for the rest of the data as well.
4815 */
4816 if (params->supported_channels_len < 2)
4817 return -EINVAL;
4818 if (params->supported_channels_len % 2)
4819 return -EINVAL;
4820 }
4821
4822 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4823 params->supported_oper_classes =
4824 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4825 params->supported_oper_classes_len =
4826 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4827 /*
4828 * The value of the Length field of the Supported Operating
4829 * Classes element is between 2 and 253.
4830 */
4831 if (params->supported_oper_classes_len < 2 ||
4832 params->supported_oper_classes_len > 253)
4833 return -EINVAL;
4834 }
4835 return 0;
4836}
4837
ff276691
JB		 4838static int nl80211_set_station_tdls(struct genl_info *info,
4839 struct station_parameters *params)
4840{
c01fc9ad 4841 int err;
ff276691 4842 /* Dummy STA entry gets updated once the peer capabilities are known */
5e4b6f56
JM		 4843 if (info->attrs[NL80211_ATTR_PEER_AID])
4844 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
ff276691
JB		 4845 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4846 params->ht_capa =
4847 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4848 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4849 params->vht_capa =
4850 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4851
c01fc9ad
SD		 4852 err = nl80211_parse_sta_channel_info(info, params);
4853 if (err)
4854 return err;
4855
ff276691
JB		 4856 return nl80211_parse_sta_wme(info, params);
4857}
4858
5727ef1b
JB		 4859static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4860{
4c476991 4861 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4862 struct net_device *dev = info->user_ptr[1];
5727ef1b 4863 struct station_parameters params;
77ee7c89
JB		 4864 u8 *mac_addr;
4865 int err;
5727ef1b
JB		 4866
4867 memset(&params, 0, sizeof(params));
4868
77ee7c89
JB		 4869 if (!rdev->ops->change_station)
4870 return -EOPNOTSUPP;
4871
e4208427
AB		 4872 /*
4873 * AID and listen_interval properties can be set only for unassociated
4874 * station. Include these parameters here and will check them in
4875 * cfg80211_check_station_change().
4876 */
a9bc31e4
AB		 4877 if (info->attrs[NL80211_ATTR_STA_AID])
4878 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
e4208427
AB		 4879
4880 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4881 params.listen_interval =
4882 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
4883 else
4884 params.listen_interval = -1;
5727ef1b 4885
17b94247
AB		 4886 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
4887 u8 tmp;
4888
4889 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
4890 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
4891 return -EINVAL;
4892
4893 params.support_p2p_ps = tmp;
4894 } else {
4895 params.support_p2p_ps = -1;
4896 }
4897
5727ef1b
JB		 4898 if (!info->attrs[NL80211_ATTR_MAC])
4899 return -EINVAL;
4900
4901 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4902
4903 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4904 params.supported_rates =
4905 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4906 params.supported_rates_len =
4907 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4908 }
4909
9d62a986
JM		 4910 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4911 params.capability =
4912 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4913 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4914 }
4915
4916 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4917 params.ext_capab =
4918 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4919 params.ext_capab_len =
4920 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4921 }
4922
bdd3ae3d 4923 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 4924 return -EINVAL;
4925
f8bacc21 4926 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
2ec600d6 4927 params.plink_action =
f8bacc21
JB		 4928 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4929 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4930 return -EINVAL;
4931 }
2ec600d6 4932
f8bacc21 4933 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
9c3990aa 4934 params.plink_state =
f8bacc21
JB		 4935 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
4936 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
4937 return -EINVAL;
7d27a0ba
MH		 4938 if (info->attrs[NL80211_ATTR_MESH_PEER_AID]) {
4939 params.peer_aid = nla_get_u16(
4940 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
4941 if (params.peer_aid > IEEE80211_MAX_AID)
4942 return -EINVAL;
4943 }
f8bacc21
JB		 4944 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
4945 }
9c3990aa 4946
3b1c5a53
MP		 4947 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
4948 enum nl80211_mesh_power_mode pm = nla_get_u32(
4949 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
4950
4951 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
4952 pm > NL80211_MESH_POWER_MAX)
4953 return -EINVAL;
4954
4955 params.local_pm = pm;
4956 }
4957
06f7c88c
BL		 4958 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
4959 params.opmode_notif_used = true;
4960 params.opmode_notif =
4961 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
4962 }
4963
77ee7c89
JB		 4964 /* Include parameters for TDLS peer (will check later) */
4965 err = nl80211_set_station_tdls(info, &params);
4966 if (err)
4967 return err;
4968
4969 params.vlan = get_vlan(info, rdev);
4970 if (IS_ERR(params.vlan))
4971 return PTR_ERR(params.vlan);
4972
a97f4424
JB		 4973 switch (dev->ieee80211_ptr->iftype) {
4974 case NL80211_IFTYPE_AP:
4975 case NL80211_IFTYPE_AP_VLAN:
074ac8df 4976 case NL80211_IFTYPE_P2P_GO:
074ac8df 4977 case NL80211_IFTYPE_P2P_CLIENT:
a97f4424 4978 case NL80211_IFTYPE_STATION:
267335d6 4979 case NL80211_IFTYPE_ADHOC:
a97f4424 4980 case NL80211_IFTYPE_MESH_POINT:
a97f4424
JB		 4981 break;
4982 default:
77ee7c89
JB		 4983 err = -EOPNOTSUPP;
4984 goto out_put_vlan;
034d655e
JB		 4985 }
4986
77ee7c89 4987 /* driver will call cfg80211_check_station_change() */
e35e4d28 4988 err = rdev_change_station(rdev, dev, mac_addr, &params);
5727ef1b 4989
77ee7c89 4990 out_put_vlan:
5727ef1b
JB		 4991 if (params.vlan)
4992 dev_put(params.vlan);
3b85875a 4993
5727ef1b
JB		 4994 return err;
4995}
4996
4997static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
4998{
4c476991 4999 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5727ef1b 5000 int err;
4c476991 5001 struct net_device *dev = info->user_ptr[1];
5727ef1b
JB		 5002 struct station_parameters params;
5003 u8 *mac_addr = NULL;
bda95eb1
JB		 5004 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5005 BIT(NL80211_STA_FLAG_ASSOCIATED);
5727ef1b
JB		 5006
5007 memset(&params, 0, sizeof(params));
5008
984c311b
JB		 5009 if (!rdev->ops->add_station)
5010 return -EOPNOTSUPP;
5011
5727ef1b
JB		 5012 if (!info->attrs[NL80211_ATTR_MAC])
5013 return -EINVAL;
5014
5727ef1b
JB		 5015 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5016 return -EINVAL;
5017
5018 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5019 return -EINVAL;
5020
5e4b6f56
JM		 5021 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5022 !info->attrs[NL80211_ATTR_PEER_AID])
0e956c13
TLSC		 5023 return -EINVAL;
5024
5727ef1b
JB		 5025 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5026 params.supported_rates =
5027 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5028 params.supported_rates_len =
5029 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5030 params.listen_interval =
5031 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 5032
17b94247
AB		 5033 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5034 u8 tmp;
5035
5036 tmp = nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5037 if (tmp >= NUM_NL80211_P2P_PS_STATUS)
5038 return -EINVAL;
5039
5040 params.support_p2p_ps = tmp;
5041 } else {
5042 /*
5043 * if not specified, assume it's supported for P2P GO interface,
5044 * and is NOT supported for AP interface
5045 */
5046 params.support_p2p_ps =
5047 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5048 }
5049
3d124ea2 5050 if (info->attrs[NL80211_ATTR_PEER_AID])
5e4b6f56 5051 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
3d124ea2
JM		 5052 else
5053 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
0e956c13
TLSC		 5054 if (!params.aid || params.aid > IEEE80211_MAX_AID)
5055 return -EINVAL;
51b50fbe 5056
9d62a986
JM		 5057 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5058 params.capability =
5059 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5060 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5061 }
5062
5063 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5064 params.ext_capab =
5065 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5066 params.ext_capab_len =
5067 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5068 }
5069
36aedc90
JM		 5070 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5071 params.ht_capa =
5072 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 5073
f461be3e
MP		 5074 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5075 params.vht_capa =
5076 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5077
60f4a7b1
MK		 5078 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5079 params.opmode_notif_used = true;
5080 params.opmode_notif =
5081 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5082 }
5083
f8bacc21 5084 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
96b78dff 5085 params.plink_action =
f8bacc21
JB		 5086 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5087 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
5088 return -EINVAL;
5089 }
96b78dff 5090
c01fc9ad
SD		 5091 err = nl80211_parse_sta_channel_info(info, &params);
5092 if (err)
5093 return err;
5094
ff276691
JB		 5095 err = nl80211_parse_sta_wme(info, &params);
5096 if (err)
5097 return err;
bdd90d5e 5098
bdd3ae3d 5099 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 5100 return -EINVAL;
5101
496fcc29
JB		 5102 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5103 * as userspace might just pass through the capabilities from the IEs
5104 * directly, rather than enforcing this restriction and returning an
5105 * error in this case.
5106 */
5107 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5108 params.ht_capa = NULL;
5109 params.vht_capa = NULL;
5110 }
5111
77ee7c89
JB		 5112 /* When you run into this, adjust the code below for the new flag */
5113 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5114
bdd90d5e
JB		 5115 switch (dev->ieee80211_ptr->iftype) {
5116 case NL80211_IFTYPE_AP:
5117 case NL80211_IFTYPE_AP_VLAN:
5118 case NL80211_IFTYPE_P2P_GO:
984c311b
JB		 5119 /* ignore WME attributes if iface/sta is not capable */
5120 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5121 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5122 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
c75786c9 5123
bdd90d5e 5124 /* TDLS peers cannot be added */
3d124ea2
JM		 5125 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5126 info->attrs[NL80211_ATTR_PEER_AID])
4319e193 5127 return -EINVAL;
bdd90d5e
JB		 5128 /* but don't bother the driver with it */
5129 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3b9ce80c 5130
d582cffb
JB		 5131 /* allow authenticated/associated only if driver handles it */
5132 if (!(rdev->wiphy.features &
5133 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
bda95eb1 5134 params.sta_flags_mask & auth_assoc)
d582cffb
JB		 5135 return -EINVAL;
5136
bda95eb1
JB		 5137 /* Older userspace, or userspace wanting to be compatible with
5138 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5139 * and assoc flags in the mask, but assumes the station will be
5140 * added as associated anyway since this was the required driver
5141 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5142 * introduced.
5143 * In order to not bother drivers with this quirk in the API
5144 * set the flags in both the mask and set for new stations in
5145 * this case.
5146 */
5147 if (!(params.sta_flags_mask & auth_assoc)) {
5148 params.sta_flags_mask |= auth_assoc;
5149 params.sta_flags_set |= auth_assoc;
5150 }
5151
bdd90d5e
JB		 5152 /* must be last in here for error handling */
5153 params.vlan = get_vlan(info, rdev);
5154 if (IS_ERR(params.vlan))
5155 return PTR_ERR(params.vlan);
5156 break;
5157 case NL80211_IFTYPE_MESH_POINT:
984c311b
JB		 5158 /* ignore uAPSD data */
5159 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5160
d582cffb
JB		 5161 /* associated is disallowed */
5162 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5163 return -EINVAL;
bdd90d5e 5164 /* TDLS peers cannot be added */
3d124ea2
JM		 5165 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5166 info->attrs[NL80211_ATTR_PEER_AID])
bdd90d5e
JB		 5167 return -EINVAL;
5168 break;
5169 case NL80211_IFTYPE_STATION:
93d08f0b 5170 case NL80211_IFTYPE_P2P_CLIENT:
984c311b
JB		 5171 /* ignore uAPSD data */
5172 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5173
77ee7c89
JB		 5174 /* these are disallowed */
5175 if (params.sta_flags_mask &
5176 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5177 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
d582cffb 5178 return -EINVAL;
bdd90d5e
JB		 5179 /* Only TDLS peers can be added */
5180 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5181 return -EINVAL;
5182 /* Can only add if TDLS ... */
5183 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5184 return -EOPNOTSUPP;
5185 /* ... with external setup is supported */
5186 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5187 return -EOPNOTSUPP;
77ee7c89
JB		 5188 /*
5189 * Older wpa_supplicant versions always mark the TDLS peer
5190 * as authorized, but it shouldn't yet be.
5191 */
5192 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
bdd90d5e
JB		 5193 break;
5194 default:
5195 return -EOPNOTSUPP;
c75786c9
EP		 5196 }
5197
bdd90d5e 5198 /* be aware of params.vlan when changing code here */
5727ef1b 5199
e35e4d28 5200 err = rdev_add_station(rdev, dev, mac_addr, &params);
5727ef1b 5201
5727ef1b
JB		 5202 if (params.vlan)
5203 dev_put(params.vlan);
5727ef1b
JB		 5204 return err;
5205}
5206
5207static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5208{
4c476991
JB		 5209 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5210 struct net_device *dev = info->user_ptr[1];
89c771e5
JM		 5211 struct station_del_parameters params;
5212
5213 memset(&params, 0, sizeof(params));
5727ef1b
JB		 5214
5215 if (info->attrs[NL80211_ATTR_MAC])
89c771e5 5216 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5727ef1b 5217
e80cf853 5218 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
d5d9de02 5219 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
074ac8df 5220 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4c476991
JB		 5221 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5222 return -EINVAL;
5727ef1b 5223
4c476991
JB		 5224 if (!rdev->ops->del_station)
5225 return -EOPNOTSUPP;
3b85875a 5226
98856866
JM		 5227 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
5228 params.subtype =
5229 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
5230 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
5231 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
5232 return -EINVAL;
5233 } else {
5234 /* Default to Deauthentication frame */
5235 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
5236 }
5237
5238 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
5239 params.reason_code =
5240 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5241 if (params.reason_code == 0)
5242 return -EINVAL; /* 0 is reserved */
5243 } else {
5244 /* Default to reason code 2 */
5245 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
5246 }
5247
89c771e5 5248 return rdev_del_station(rdev, dev, &params);
5727ef1b
JB		 5249}
5250
15e47304 5251static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
2ec600d6
LCC		 5252 int flags, struct net_device *dev,
5253 u8 *dst, u8 *next_hop,
5254 struct mpath_info *pinfo)
5255{
5256 void *hdr;
5257 struct nlattr *pinfoattr;
5258
1ef4c850 5259 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
2ec600d6
LCC		 5260 if (!hdr)
5261 return -1;
5262
9360ffd1
DM		 5263 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5264 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
5265 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
5266 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
5267 goto nla_put_failure;
f5ea9120 5268
2ec600d6
LCC		 5269 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
5270 if (!pinfoattr)
5271 goto nla_put_failure;
9360ffd1
DM		 5272 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
5273 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
5274 pinfo->frame_qlen))
5275 goto nla_put_failure;
5276 if (((pinfo->filled & MPATH_INFO_SN) &&
5277 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
5278 ((pinfo->filled & MPATH_INFO_METRIC) &&
5279 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
5280 pinfo->metric)) ||
5281 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
5282 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
5283 pinfo->exptime)) ||
5284 ((pinfo->filled & MPATH_INFO_FLAGS) &&
5285 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
5286 pinfo->flags)) ||
5287 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
5288 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
5289 pinfo->discovery_timeout)) ||
5290 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
5291 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
5292 pinfo->discovery_retries)))
5293 goto nla_put_failure;
2ec600d6
LCC		 5294
5295 nla_nest_end(msg, pinfoattr);
5296
053c095a
JB		 5297 genlmsg_end(msg, hdr);
5298 return 0;
2ec600d6
LCC		 5299
5300 nla_put_failure:
bc3ed28c
TG		 5301 genlmsg_cancel(msg, hdr);
5302 return -EMSGSIZE;
2ec600d6
LCC		 5303}
5304
5305static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 5306 struct netlink_callback *cb)
2ec600d6 5307{
2ec600d6 5308 struct mpath_info pinfo;
1b8ec87a 5309 struct cfg80211_registered_device *rdev;
97990a06 5310 struct wireless_dev *wdev;
2ec600d6
LCC		 5311 u8 dst[ETH_ALEN];
5312 u8 next_hop[ETH_ALEN];
97990a06 5313 int path_idx = cb->args[2];
2ec600d6 5314 int err;
2ec600d6 5315
1b8ec87a 5316 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 5317 if (err)
5318 return err;
bba95fef 5319
1b8ec87a 5320 if (!rdev->ops->dump_mpath) {
eec60b03 5321 err = -EOPNOTSUPP;
bba95fef
JB		 5322 goto out_err;
5323 }
5324
97990a06 5325 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
eec60b03 5326 err = -EOPNOTSUPP;
0448b5fc 5327 goto out_err;
eec60b03
JM		 5328 }
5329
bba95fef 5330 while (1) {
1b8ec87a 5331 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
97990a06 5332 next_hop, &pinfo);
bba95fef 5333 if (err == -ENOENT)
2ec600d6 5334 break;
bba95fef 5335 if (err)
3b85875a 5336 goto out_err;
2ec600d6 5337
15e47304 5338 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
bba95fef 5339 cb->nlh->nlmsg_seq, NLM_F_MULTI,
97990a06 5340 wdev->netdev, dst, next_hop,
bba95fef
JB		 5341 &pinfo) < 0)
5342 goto out;
2ec600d6 5343
bba95fef 5344 path_idx++;
2ec600d6 5345 }
2ec600d6 5346
bba95fef 5347 out:
97990a06 5348 cb->args[2] = path_idx;
bba95fef 5349 err = skb->len;
bba95fef 5350 out_err:
1b8ec87a 5351 nl80211_finish_wdev_dump(rdev);
bba95fef 5352 return err;
2ec600d6
LCC		 5353}
5354
5355static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
5356{
4c476991 5357 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 5358 int err;
4c476991 5359 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5360 struct mpath_info pinfo;
5361 struct sk_buff *msg;
5362 u8 *dst = NULL;
5363 u8 next_hop[ETH_ALEN];
5364
5365 memset(&pinfo, 0, sizeof(pinfo));
5366
5367 if (!info->attrs[NL80211_ATTR_MAC])
5368 return -EINVAL;
5369
5370 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5371
4c476991
JB		 5372 if (!rdev->ops->get_mpath)
5373 return -EOPNOTSUPP;
2ec600d6 5374
4c476991
JB		 5375 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5376 return -EOPNOTSUPP;
eec60b03 5377
e35e4d28 5378 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
2ec600d6 5379 if (err)
4c476991 5380 return err;
2ec600d6 5381
fd2120ca 5382 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6 5383 if (!msg)
4c476991 5384 return -ENOMEM;
2ec600d6 5385
15e47304 5386 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4c476991
JB		 5387 dev, dst, next_hop, &pinfo) < 0) {
5388 nlmsg_free(msg);
5389 return -ENOBUFS;
5390 }
3b85875a 5391
4c476991 5392 return genlmsg_reply(msg, info);
2ec600d6
LCC		 5393}
5394
5395static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
5396{
4c476991
JB		 5397 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5398 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5399 u8 *dst = NULL;
5400 u8 *next_hop = NULL;
5401
5402 if (!info->attrs[NL80211_ATTR_MAC])
5403 return -EINVAL;
5404
5405 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5406 return -EINVAL;
5407
5408 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5409 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5410
4c476991
JB		 5411 if (!rdev->ops->change_mpath)
5412 return -EOPNOTSUPP;
35a8efe1 5413
4c476991
JB		 5414 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5415 return -EOPNOTSUPP;
2ec600d6 5416
e35e4d28 5417 return rdev_change_mpath(rdev, dev, dst, next_hop);
2ec600d6 5418}
4c476991 5419
2ec600d6
LCC		 5420static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
5421{
4c476991
JB		 5422 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5423 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5424 u8 *dst = NULL;
5425 u8 *next_hop = NULL;
5426
5427 if (!info->attrs[NL80211_ATTR_MAC])
5428 return -EINVAL;
5429
5430 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5431 return -EINVAL;
5432
5433 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5434 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5435
4c476991
JB		 5436 if (!rdev->ops->add_mpath)
5437 return -EOPNOTSUPP;
35a8efe1 5438
4c476991
JB		 5439 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5440 return -EOPNOTSUPP;
2ec600d6 5441
e35e4d28 5442 return rdev_add_mpath(rdev, dev, dst, next_hop);
2ec600d6
LCC		 5443}
5444
5445static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
5446{
4c476991
JB		 5447 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5448 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 5449 u8 *dst = NULL;
5450
5451 if (info->attrs[NL80211_ATTR_MAC])
5452 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5453
4c476991
JB		 5454 if (!rdev->ops->del_mpath)
5455 return -EOPNOTSUPP;
3b85875a 5456
e35e4d28 5457 return rdev_del_mpath(rdev, dev, dst);
2ec600d6
LCC		 5458}
5459
66be7d2b
HR		 5460static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
5461{
5462 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5463 int err;
5464 struct net_device *dev = info->user_ptr[1];
5465 struct mpath_info pinfo;
5466 struct sk_buff *msg;
5467 u8 *dst = NULL;
5468 u8 mpp[ETH_ALEN];
5469
5470 memset(&pinfo, 0, sizeof(pinfo));
5471
5472 if (!info->attrs[NL80211_ATTR_MAC])
5473 return -EINVAL;
5474
5475 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5476
5477 if (!rdev->ops->get_mpp)
5478 return -EOPNOTSUPP;
5479
5480 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5481 return -EOPNOTSUPP;
5482
5483 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
5484 if (err)
5485 return err;
5486
5487 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5488 if (!msg)
5489 return -ENOMEM;
5490
5491 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
5492 dev, dst, mpp, &pinfo) < 0) {
5493 nlmsg_free(msg);
5494 return -ENOBUFS;
5495 }
5496
5497 return genlmsg_reply(msg, info);
5498}
5499
5500static int nl80211_dump_mpp(struct sk_buff *skb,
5501 struct netlink_callback *cb)
5502{
5503 struct mpath_info pinfo;
5504 struct cfg80211_registered_device *rdev;
5505 struct wireless_dev *wdev;
5506 u8 dst[ETH_ALEN];
5507 u8 mpp[ETH_ALEN];
5508 int path_idx = cb->args[2];
5509 int err;
5510
5511 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5512 if (err)
5513 return err;
5514
5515 if (!rdev->ops->dump_mpp) {
5516 err = -EOPNOTSUPP;
5517 goto out_err;
5518 }
5519
5520 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
5521 err = -EOPNOTSUPP;
5522 goto out_err;
5523 }
5524
5525 while (1) {
5526 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
5527 mpp, &pinfo);
5528 if (err == -ENOENT)
5529 break;
5530 if (err)
5531 goto out_err;
5532
5533 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
5534 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5535 wdev->netdev, dst, mpp,
5536 &pinfo) < 0)
5537 goto out;
5538
5539 path_idx++;
5540 }
5541
5542 out:
5543 cb->args[2] = path_idx;
5544 err = skb->len;
5545 out_err:
5546 nl80211_finish_wdev_dump(rdev);
5547 return err;
5548}
5549
9f1ba906
JM		 5550static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
5551{
4c476991
JB		 5552 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5553 struct net_device *dev = info->user_ptr[1];
c56589ed 5554 struct wireless_dev *wdev = dev->ieee80211_ptr;
9f1ba906 5555 struct bss_parameters params;
c56589ed 5556 int err;
9f1ba906
JM		 5557
5558 memset(&params, 0, sizeof(params));
5559 /* default to not changing parameters */
5560 params.use_cts_prot = -1;
5561 params.use_short_preamble = -1;
5562 params.use_short_slot_time = -1;
fd8aaaf3 5563 params.ap_isolate = -1;
50b12f59 5564 params.ht_opmode = -1;
53cabad7
JB		 5565 params.p2p_ctwindow = -1;
5566 params.p2p_opp_ps = -1;
9f1ba906
JM		 5567
5568 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
5569 params.use_cts_prot =
5570 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
5571 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
5572 params.use_short_preamble =
5573 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
5574 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
5575 params.use_short_slot_time =
5576 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 5577 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5578 params.basic_rates =
5579 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5580 params.basic_rates_len =
5581 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5582 }
fd8aaaf3
FF		 5583 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
5584 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
50b12f59
HS		 5585 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
5586 params.ht_opmode =
5587 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9f1ba906 5588
53cabad7
JB		 5589 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
5590 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5591 return -EINVAL;
5592 params.p2p_ctwindow =
5593 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
5594 if (params.p2p_ctwindow < 0)
5595 return -EINVAL;
5596 if (params.p2p_ctwindow != 0 &&
5597 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
5598 return -EINVAL;
5599 }
5600
5601 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
5602 u8 tmp;
5603
5604 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5605 return -EINVAL;
5606 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
5607 if (tmp > 1)
5608 return -EINVAL;
5609 params.p2p_opp_ps = tmp;
5610 if (params.p2p_opp_ps &&
5611 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
5612 return -EINVAL;
5613 }
5614
4c476991
JB		 5615 if (!rdev->ops->change_bss)
5616 return -EOPNOTSUPP;
9f1ba906 5617
074ac8df 5618 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4c476991
JB		 5619 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5620 return -EOPNOTSUPP;
3b85875a 5621
c56589ed
SW		 5622 wdev_lock(wdev);
5623 err = rdev_change_bss(rdev, dev, &params);
5624 wdev_unlock(wdev);
5625
5626 return err;
9f1ba906
JM		 5627}
5628
b2e1b302
LR		 5629static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
5630{
b2e1b302 5631 char *data = NULL;
05050753 5632 bool is_indoor;
57b5ce07 5633 enum nl80211_user_reg_hint_type user_reg_hint_type;
05050753
I		 5634 u32 owner_nlportid;
5635
80778f18
LR		 5636 /*
5637 * You should only get this when cfg80211 hasn't yet initialized
5638 * completely when built-in to the kernel right between the time
5639 * window between nl80211_init() and regulatory_init(), if that is
5640 * even possible.
5641 */
458f4f9e 5642 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
fe33eb39 5643 return -EINPROGRESS;
80778f18 5644
57b5ce07
LR		 5645 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
5646 user_reg_hint_type =
5647 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
5648 else
5649 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
5650
5651 switch (user_reg_hint_type) {
5652 case NL80211_USER_REG_HINT_USER:
5653 case NL80211_USER_REG_HINT_CELL_BASE:
52616f2b
IP		 5654 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5655 return -EINVAL;
5656
5657 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5658 return regulatory_hint_user(data, user_reg_hint_type);
5659 case NL80211_USER_REG_HINT_INDOOR:
05050753
I		 5660 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
5661 owner_nlportid = info->snd_portid;
5662 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
5663 } else {
5664 owner_nlportid = 0;
5665 is_indoor = true;
5666 }
5667
5668 return regulatory_hint_indoor(is_indoor, owner_nlportid);
57b5ce07
LR		 5669 default:
5670 return -EINVAL;
5671 }
b2e1b302
LR		 5672}
5673
24bdd9f4 5674static int nl80211_get_mesh_config(struct sk_buff *skb,
29cbe68c 5675 struct genl_info *info)
93da9cc1 5676{
4c476991 5677 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 5678 struct net_device *dev = info->user_ptr[1];
29cbe68c
JB		 5679 struct wireless_dev *wdev = dev->ieee80211_ptr;
5680 struct mesh_config cur_params;
5681 int err = 0;
93da9cc1 5682 void *hdr;
5683 struct nlattr *pinfoattr;
5684 struct sk_buff *msg;
5685
29cbe68c
JB		 5686 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5687 return -EOPNOTSUPP;
5688
24bdd9f4 5689 if (!rdev->ops->get_mesh_config)
4c476991 5690 return -EOPNOTSUPP;
f3f92586 5691
29cbe68c
JB		 5692 wdev_lock(wdev);
5693 /* If not connected, get default parameters */
5694 if (!wdev->mesh_id_len)
5695 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
5696 else
e35e4d28 5697 err = rdev_get_mesh_config(rdev, dev, &cur_params);
29cbe68c
JB		 5698 wdev_unlock(wdev);
5699
93da9cc1 5700 if (err)
4c476991 5701 return err;
93da9cc1 5702
5703 /* Draw up a netlink message to send back */
fd2120ca 5704 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 5705 if (!msg)
5706 return -ENOMEM;
15e47304 5707 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
24bdd9f4 5708 NL80211_CMD_GET_MESH_CONFIG);
93da9cc1 5709 if (!hdr)
efe1cf0c 5710 goto out;
24bdd9f4 5711 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
93da9cc1 5712 if (!pinfoattr)
5713 goto nla_put_failure;
9360ffd1
DM		 5714 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5715 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
5716 cur_params.dot11MeshRetryTimeout) ||
5717 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5718 cur_params.dot11MeshConfirmTimeout) ||
5719 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
5720 cur_params.dot11MeshHoldingTimeout) ||
5721 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
5722 cur_params.dot11MeshMaxPeerLinks) ||
5723 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
5724 cur_params.dot11MeshMaxRetries) ||
5725 nla_put_u8(msg, NL80211_MESHCONF_TTL,
5726 cur_params.dot11MeshTTL) ||
5727 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
5728 cur_params.element_ttl) ||
5729 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5730 cur_params.auto_open_plinks) ||
7eab0f64
JL		 5731 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5732 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
9360ffd1
DM		 5733 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5734 cur_params.dot11MeshHWMPmaxPREQretries) ||
5735 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
5736 cur_params.path_refresh_time) ||
5737 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5738 cur_params.min_discovery_timeout) ||
5739 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5740 cur_params.dot11MeshHWMPactivePathTimeout) ||
5741 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
5742 cur_params.dot11MeshHWMPpreqMinInterval) ||
5743 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
5744 cur_params.dot11MeshHWMPperrMinInterval) ||
5745 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5746 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
5747 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
5748 cur_params.dot11MeshHWMPRootMode) ||
5749 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5750 cur_params.dot11MeshHWMPRannInterval) ||
5751 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5752 cur_params.dot11MeshGateAnnouncementProtocol) ||
5753 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
5754 cur_params.dot11MeshForwarding) ||
335d5349 5755 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
70c33eaa
AN		 5756 cur_params.rssi_threshold) ||
5757 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5758 cur_params.ht_opmode) ||
5759 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5760 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
5761 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5762 cur_params.dot11MeshHWMProotInterval) ||
5763 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3b1c5a53
MP		 5764 cur_params.dot11MeshHWMPconfirmationInterval) ||
5765 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5766 cur_params.power_mode) ||
5767 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8e7c0538
CT		 5768 cur_params.dot11MeshAwakeWindowDuration) ||
5769 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5770 cur_params.plink_timeout))
9360ffd1 5771 goto nla_put_failure;
93da9cc1 5772 nla_nest_end(msg, pinfoattr);
5773 genlmsg_end(msg, hdr);
4c476991 5774 return genlmsg_reply(msg, info);
93da9cc1 5775
3b85875a 5776 nla_put_failure:
93da9cc1 5777 genlmsg_cancel(msg, hdr);
efe1cf0c 5778 out:
d080e275 5779 nlmsg_free(msg);
4c476991 5780 return -ENOBUFS;
93da9cc1 5781}
5782
b54452b0 5783static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
93da9cc1 5784 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5785 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5786 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5787 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5788 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5789 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
45904f21 5790 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
93da9cc1 5791 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
d299a1f2 5792 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
93da9cc1 5793 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5794 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5795 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5796 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5797 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
dca7e943 5798 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
93da9cc1 5799 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
699403db 5800 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
0507e159 5801 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
16dd7267 5802 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
94f90656 5803 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
a4f606ea
CYY		 5804 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5805 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
ac1073a6
CYY		 5806 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5807 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
728b19e5 5808 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3b1c5a53
MP		 5809 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5810 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8e7c0538 5811 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
93da9cc1 5812};
5813
c80d545d
JC		 5814static const struct nla_policy
5815 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
d299a1f2 5816 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
c80d545d
JC		 5817 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5818 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
15d5dda6 5819 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6e16d90b 5820 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
bb2798d4 5821 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
581a8b0f 5822 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
a4f606ea 5823 .len = IEEE80211_MAX_DATA_LEN },
b130e5ce 5824 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
c80d545d
JC		 5825};
5826
f151d9db
AB		 5827static int nl80211_check_bool(const struct nlattr *nla, u8 min, u8 max, bool *out)
5828{
5829 u8 val = nla_get_u8(nla);
5830 if (val < min || val > max)
5831 return -EINVAL;
5832 *out = val;
5833 return 0;
5834}
5835
5836static int nl80211_check_u8(const struct nlattr *nla, u8 min, u8 max, u8 *out)
5837{
5838 u8 val = nla_get_u8(nla);
5839 if (val < min || val > max)
5840 return -EINVAL;
5841 *out = val;
5842 return 0;
5843}
5844
5845static int nl80211_check_u16(const struct nlattr *nla, u16 min, u16 max, u16 *out)
5846{
5847 u16 val = nla_get_u16(nla);
5848 if (val < min || val > max)
5849 return -EINVAL;
5850 *out = val;
5851 return 0;
5852}
5853
5854static int nl80211_check_u32(const struct nlattr *nla, u32 min, u32 max, u32 *out)
5855{
5856 u32 val = nla_get_u32(nla);
5857 if (val < min || val > max)
5858 return -EINVAL;
5859 *out = val;
5860 return 0;
5861}
5862
5863static int nl80211_check_s32(const struct nlattr *nla, s32 min, s32 max, s32 *out)
5864{
5865 s32 val = nla_get_s32(nla);
5866 if (val < min || val > max)
5867 return -EINVAL;
5868 *out = val;
5869 return 0;
5870}
5871
ff9a71af
JB		 5872static int nl80211_check_power_mode(const struct nlattr *nla,
5873 enum nl80211_mesh_power_mode min,
5874 enum nl80211_mesh_power_mode max,
5875 enum nl80211_mesh_power_mode *out)
5876{
5877 u32 val = nla_get_u32(nla);
5878 if (val < min || val > max)
5879 return -EINVAL;
5880 *out = val;
5881 return 0;
5882}
5883
24bdd9f4 5884static int nl80211_parse_mesh_config(struct genl_info *info,
bd90fdcc
JB		 5885 struct mesh_config *cfg,
5886 u32 *mask_out)
93da9cc1 5887{
93da9cc1 5888 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
bd90fdcc 5889 u32 mask = 0;
9757235f 5890 u16 ht_opmode;
93da9cc1 5891
ea54fba2
MP		 5892#define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5893do { \
5894 if (tb[attr]) { \
f151d9db 5895 if (fn(tb[attr], min, max, &cfg->param)) \
ea54fba2 5896 return -EINVAL; \
ea54fba2
MP		 5897 mask |= (1 << (attr - 1)); \
5898 } \
5899} while (0)
bd90fdcc 5900
24bdd9f4 5901 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
93da9cc1 5902 return -EINVAL;
5903 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
24bdd9f4 5904 info->attrs[NL80211_ATTR_MESH_CONFIG],
bd90fdcc 5905 nl80211_meshconf_params_policy))
93da9cc1 5906 return -EINVAL;
5907
93da9cc1 5908 /* This makes sure that there aren't more than 32 mesh config
5909 * parameters (otherwise our bitfield scheme would not work.) */
5910 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
5911
5912 /* Fill in the params struct */
ea54fba2 5913 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
a4f606ea 5914 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
f151d9db 5915 nl80211_check_u16);
ea54fba2 5916 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
a4f606ea 5917 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
f151d9db 5918 nl80211_check_u16);
ea54fba2 5919 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
a4f606ea 5920 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
f151d9db 5921 nl80211_check_u16);
ea54fba2 5922 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
a4f606ea 5923 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
f151d9db 5924 nl80211_check_u16);
ea54fba2 5925 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
a4f606ea 5926 mask, NL80211_MESHCONF_MAX_RETRIES,
f151d9db 5927 nl80211_check_u8);
ea54fba2 5928 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
f151d9db 5929 mask, NL80211_MESHCONF_TTL, nl80211_check_u8);
ea54fba2 5930 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
a4f606ea 5931 mask, NL80211_MESHCONF_ELEMENT_TTL,
f151d9db 5932 nl80211_check_u8);
ea54fba2 5933 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
a4f606ea 5934 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
f151d9db 5935 nl80211_check_bool);
ea54fba2
MP		 5936 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
5937 1, 255, mask,
a4f606ea 5938 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
f151d9db 5939 nl80211_check_u32);
ea54fba2 5940 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
a4f606ea 5941 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
f151d9db 5942 nl80211_check_u8);
ea54fba2 5943 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
a4f606ea 5944 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
f151d9db 5945 nl80211_check_u32);
ea54fba2 5946 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
a4f606ea 5947 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
f151d9db 5948 nl80211_check_u16);
ea54fba2
MP		 5949 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
5950 1, 65535, mask,
a4f606ea 5951 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
f151d9db 5952 nl80211_check_u32);
93da9cc1 5953 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
ea54fba2
MP		 5954 1, 65535, mask,
5955 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
f151d9db 5956 nl80211_check_u16);
dca7e943 5957 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
ea54fba2
MP		 5958 1, 65535, mask,
5959 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
f151d9db 5960 nl80211_check_u16);
93da9cc1 5961 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5962 dot11MeshHWMPnetDiameterTraversalTime,
5963 1, 65535, mask,
a4f606ea 5964 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
f151d9db 5965 nl80211_check_u16);
ea54fba2
MP		 5966 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
5967 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
f151d9db 5968 nl80211_check_u8);
ea54fba2
MP		 5969 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
5970 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
f151d9db 5971 nl80211_check_u16);
63c5723b 5972 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5973 dot11MeshGateAnnouncementProtocol, 0, 1,
5974 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
f151d9db 5975 nl80211_check_bool);
ea54fba2 5976 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
a4f606ea 5977 mask, NL80211_MESHCONF_FORWARDING,
f151d9db 5978 nl80211_check_bool);
83374fe9 5979 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
a4f606ea 5980 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
f151d9db 5981 nl80211_check_s32);
9757235f
MH		 5982 /*
5983 * Check HT operation mode based on
5984 * IEEE 802.11 2012 8.4.2.59 HT Operation element.
5985 */
5986 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
5987 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
5988
5989 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
5990 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
5991 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
5992 return -EINVAL;
5993
5994 if ((ht_opmode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
5995 (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
5996 return -EINVAL;
5997
5998 switch (ht_opmode & IEEE80211_HT_OP_MODE_PROTECTION) {
5999 case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
6000 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
6001 if (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT)
6002 return -EINVAL;
6003 break;
6004 case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
6005 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
6006 if (!(ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6007 return -EINVAL;
6008 break;
6009 }
6010 cfg->ht_opmode = ht_opmode;
fd551bac 6011 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
9757235f 6012 }
ac1073a6 6013 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
ea54fba2 6014 1, 65535, mask,
ac1073a6 6015 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
f151d9db 6016 nl80211_check_u32);
ea54fba2 6017 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
ac1073a6 6018 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
f151d9db 6019 nl80211_check_u16);
728b19e5 6020 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 6021 dot11MeshHWMPconfirmationInterval,
6022 1, 65535, mask,
728b19e5 6023 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
f151d9db 6024 nl80211_check_u16);
3b1c5a53
MP		 6025 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
6026 NL80211_MESH_POWER_ACTIVE,
6027 NL80211_MESH_POWER_MAX,
6028 mask, NL80211_MESHCONF_POWER_MODE,
ff9a71af 6029 nl80211_check_power_mode);
3b1c5a53
MP		 6030 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
6031 0, 65535, mask,
f151d9db 6032 NL80211_MESHCONF_AWAKE_WINDOW, nl80211_check_u16);
31f909a2 6033 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 0, 0xffffffff,
8e7c0538 6034 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
f151d9db 6035 nl80211_check_u32);
bd90fdcc
JB		 6036 if (mask_out)
6037 *mask_out = mask;
c80d545d 6038
bd90fdcc
JB		 6039 return 0;
6040
6041#undef FILL_IN_MESH_PARAM_IF_SET
6042}
6043
c80d545d
JC		 6044static int nl80211_parse_mesh_setup(struct genl_info *info,
6045 struct mesh_setup *setup)
6046{
bb2798d4 6047 struct cfg80211_registered_device *rdev = info->user_ptr[0];
c80d545d
JC		 6048 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6049
6050 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6051 return -EINVAL;
6052 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
6053 info->attrs[NL80211_ATTR_MESH_SETUP],
6054 nl80211_mesh_setup_params_policy))
6055 return -EINVAL;
6056
d299a1f2
JC		 6057 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6058 setup->sync_method =
6059 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6060 IEEE80211_SYNC_METHOD_VENDOR :
6061 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6062
c80d545d
JC		 6063 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6064 setup->path_sel_proto =
6065 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6066 IEEE80211_PATH_PROTOCOL_VENDOR :
6067 IEEE80211_PATH_PROTOCOL_HWMP;
6068
6069 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6070 setup->path_metric =
6071 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6072 IEEE80211_PATH_METRIC_VENDOR :
6073 IEEE80211_PATH_METRIC_AIRTIME;
6074
581a8b0f 6075 if (tb[NL80211_MESH_SETUP_IE]) {
c80d545d 6076 struct nlattr *ieattr =
581a8b0f 6077 tb[NL80211_MESH_SETUP_IE];
c80d545d
JC		 6078 if (!is_valid_ie_attr(ieattr))
6079 return -EINVAL;
581a8b0f
JC		 6080 setup->ie = nla_data(ieattr);
6081 setup->ie_len = nla_len(ieattr);
c80d545d 6082 }
bb2798d4
TP		 6083 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6084 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6085 return -EINVAL;
6086 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
b130e5ce
JC		 6087 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6088 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
bb2798d4
TP		 6089 if (setup->is_secure)
6090 setup->user_mpm = true;
c80d545d 6091
6e16d90b
CT		 6092 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6093 if (!setup->user_mpm)
6094 return -EINVAL;
6095 setup->auth_id =
6096 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6097 }
6098
c80d545d
JC		 6099 return 0;
6100}
6101
24bdd9f4 6102static int nl80211_update_mesh_config(struct sk_buff *skb,
29cbe68c 6103 struct genl_info *info)
bd90fdcc
JB		 6104{
6105 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6106 struct net_device *dev = info->user_ptr[1];
29cbe68c 6107 struct wireless_dev *wdev = dev->ieee80211_ptr;
bd90fdcc
JB		 6108 struct mesh_config cfg;
6109 u32 mask;
6110 int err;
6111
29cbe68c
JB		 6112 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6113 return -EOPNOTSUPP;
6114
24bdd9f4 6115 if (!rdev->ops->update_mesh_config)
bd90fdcc
JB		 6116 return -EOPNOTSUPP;
6117
24bdd9f4 6118 err = nl80211_parse_mesh_config(info, &cfg, &mask);
bd90fdcc
JB		 6119 if (err)
6120 return err;
6121
29cbe68c
JB		 6122 wdev_lock(wdev);
6123 if (!wdev->mesh_id_len)
6124 err = -ENOLINK;
6125
6126 if (!err)
e35e4d28 6127 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
29cbe68c
JB		 6128
6129 wdev_unlock(wdev);
6130
6131 return err;
93da9cc1 6132}
6133
ad30ca2c
AN		 6134static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6135 struct sk_buff *msg)
f130347c 6136{
f130347c
LR		 6137 struct nlattr *nl_reg_rules;
6138 unsigned int i;
f130347c 6139
458f4f9e
JB		 6140 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6141 (regdom->dfs_region &&
6142 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
ad30ca2c 6143 goto nla_put_failure;
458f4f9e 6144
f130347c
LR		 6145 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
6146 if (!nl_reg_rules)
ad30ca2c 6147 goto nla_put_failure;
f130347c 6148
458f4f9e 6149 for (i = 0; i < regdom->n_reg_rules; i++) {
f130347c
LR		 6150 struct nlattr *nl_reg_rule;
6151 const struct ieee80211_reg_rule *reg_rule;
6152 const struct ieee80211_freq_range *freq_range;
6153 const struct ieee80211_power_rule *power_rule;
97524820 6154 unsigned int max_bandwidth_khz;
f130347c 6155
458f4f9e 6156 reg_rule = &regdom->reg_rules[i];
f130347c
LR		 6157 freq_range = &reg_rule->freq_range;
6158 power_rule = &reg_rule->power_rule;
6159
6160 nl_reg_rule = nla_nest_start(msg, i);
6161 if (!nl_reg_rule)
ad30ca2c 6162 goto nla_put_failure;
f130347c 6163
97524820
JD		 6164 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6165 if (!max_bandwidth_khz)
6166 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6167 reg_rule);
6168
9360ffd1
DM		 6169 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6170 reg_rule->flags) ||
6171 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6172 freq_range->start_freq_khz) ||
6173 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6174 freq_range->end_freq_khz) ||
6175 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
97524820 6176 max_bandwidth_khz) ||
9360ffd1
DM		 6177 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6178 power_rule->max_antenna_gain) ||
6179 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
089027e5
JD		 6180 power_rule->max_eirp) ||
6181 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6182 reg_rule->dfs_cac_ms))
ad30ca2c 6183 goto nla_put_failure;
f130347c
LR		 6184
6185 nla_nest_end(msg, nl_reg_rule);
6186 }
6187
6188 nla_nest_end(msg, nl_reg_rules);
ad30ca2c
AN		 6189 return 0;
6190
6191nla_put_failure:
6192 return -EMSGSIZE;
6193}
6194
6195static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6196{
6197 const struct ieee80211_regdomain *regdom = NULL;
6198 struct cfg80211_registered_device *rdev;
6199 struct wiphy *wiphy = NULL;
6200 struct sk_buff *msg;
6201 void *hdr;
6202
6203 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6204 if (!msg)
6205 return -ENOBUFS;
6206
6207 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6208 NL80211_CMD_GET_REG);
6209 if (!hdr)
6210 goto put_failure;
6211
6212 if (info->attrs[NL80211_ATTR_WIPHY]) {
1bdd716c
AN		 6213 bool self_managed;
6214
ad30ca2c
AN		 6215 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6216 if (IS_ERR(rdev)) {
6217 nlmsg_free(msg);
6218 return PTR_ERR(rdev);
6219 }
6220
6221 wiphy = &rdev->wiphy;
1bdd716c
AN		 6222 self_managed = wiphy->regulatory_flags &
6223 REGULATORY_WIPHY_SELF_MANAGED;
ad30ca2c
AN		 6224 regdom = get_wiphy_regdom(wiphy);
6225
1bdd716c
AN		 6226 /* a self-managed-reg device must have a private regdom */
6227 if (WARN_ON(!regdom && self_managed)) {
6228 nlmsg_free(msg);
6229 return -EINVAL;
6230 }
6231
ad30ca2c
AN		 6232 if (regdom &&
6233 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6234 goto nla_put_failure;
6235 }
6236
6237 if (!wiphy && reg_last_request_cell_base() &&
6238 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6239 NL80211_USER_REG_HINT_CELL_BASE))
6240 goto nla_put_failure;
6241
6242 rcu_read_lock();
6243
6244 if (!regdom)
6245 regdom = rcu_dereference(cfg80211_regdomain);
6246
6247 if (nl80211_put_regdom(regdom, msg))
6248 goto nla_put_failure_rcu;
6249
6250 rcu_read_unlock();
f130347c
LR		 6251
6252 genlmsg_end(msg, hdr);
5fe231e8 6253 return genlmsg_reply(msg, info);
f130347c 6254
458f4f9e
JB		 6255nla_put_failure_rcu:
6256 rcu_read_unlock();
f130347c
LR		 6257nla_put_failure:
6258 genlmsg_cancel(msg, hdr);
efe1cf0c 6259put_failure:
d080e275 6260 nlmsg_free(msg);
5fe231e8 6261 return -EMSGSIZE;
f130347c
LR		 6262}
6263
ad30ca2c
AN		 6264static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6265 u32 seq, int flags, struct wiphy *wiphy,
6266 const struct ieee80211_regdomain *regdom)
6267{
6268 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6269 NL80211_CMD_GET_REG);
6270
6271 if (!hdr)
6272 return -1;
6273
6274 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
6275
6276 if (nl80211_put_regdom(regdom, msg))
6277 goto nla_put_failure;
6278
6279 if (!wiphy && reg_last_request_cell_base() &&
6280 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6281 NL80211_USER_REG_HINT_CELL_BASE))
6282 goto nla_put_failure;
6283
6284 if (wiphy &&
6285 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6286 goto nla_put_failure;
6287
1bdd716c
AN		 6288 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
6289 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
6290 goto nla_put_failure;
6291
053c095a
JB		 6292 genlmsg_end(msg, hdr);
6293 return 0;
ad30ca2c
AN		 6294
6295nla_put_failure:
6296 genlmsg_cancel(msg, hdr);
6297 return -EMSGSIZE;
6298}
6299
6300static int nl80211_get_reg_dump(struct sk_buff *skb,
6301 struct netlink_callback *cb)
6302{
6303 const struct ieee80211_regdomain *regdom = NULL;
6304 struct cfg80211_registered_device *rdev;
6305 int err, reg_idx, start = cb->args[2];
6306
6307 rtnl_lock();
6308
6309 if (cfg80211_regdomain && start == 0) {
6310 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6311 NLM_F_MULTI, NULL,
6312 rtnl_dereference(cfg80211_regdomain));
6313 if (err < 0)
6314 goto out_err;
6315 }
6316
6317 /* the global regdom is idx 0 */
6318 reg_idx = 1;
6319 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
6320 regdom = get_wiphy_regdom(&rdev->wiphy);
6321 if (!regdom)
6322 continue;
6323
6324 if (++reg_idx <= start)
6325 continue;
6326
6327 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6328 NLM_F_MULTI, &rdev->wiphy, regdom);
6329 if (err < 0) {
6330 reg_idx--;
6331 break;
6332 }
6333 }
6334
6335 cb->args[2] = reg_idx;
6336 err = skb->len;
6337out_err:
6338 rtnl_unlock();
6339 return err;
6340}
6341
b6863036
JB		 6342#ifdef CONFIG_CFG80211_CRDA_SUPPORT
6343static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
6344 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6345 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6346 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6347 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6348 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6349 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6350 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
6351};
6352
6353static int parse_reg_rule(struct nlattr *tb[],
6354 struct ieee80211_reg_rule *reg_rule)
6355{
6356 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
6357 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
6358
6359 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
6360 return -EINVAL;
6361 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
6362 return -EINVAL;
6363 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
6364 return -EINVAL;
6365 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
6366 return -EINVAL;
6367 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
6368 return -EINVAL;
6369
6370 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
6371
6372 freq_range->start_freq_khz =
6373 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
6374 freq_range->end_freq_khz =
6375 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
6376 freq_range->max_bandwidth_khz =
6377 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
6378
6379 power_rule->max_eirp =
6380 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
6381
6382 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
6383 power_rule->max_antenna_gain =
6384 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
6385
6386 if (tb[NL80211_ATTR_DFS_CAC_TIME])
6387 reg_rule->dfs_cac_ms =
6388 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
6389
6390 return 0;
6391}
6392
b2e1b302
LR		 6393static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
6394{
6395 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
6396 struct nlattr *nl_reg_rule;
ea372c54
JB		 6397 char *alpha2;
6398 int rem_reg_rules, r;
b2e1b302 6399 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4c7d3982 6400 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
ea372c54 6401 struct ieee80211_regdomain *rd;
b2e1b302
LR		 6402
6403 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6404 return -EINVAL;
6405
6406 if (!info->attrs[NL80211_ATTR_REG_RULES])
6407 return -EINVAL;
6408
6409 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6410
8b60b078
LR		 6411 if (info->attrs[NL80211_ATTR_DFS_REGION])
6412 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
6413
b2e1b302 6414 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6415 rem_reg_rules) {
b2e1b302
LR		 6416 num_rules++;
6417 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 6418 return -EINVAL;
b2e1b302
LR		 6419 }
6420
e438768f
LR		 6421 if (!reg_is_valid_request(alpha2))
6422 return -EINVAL;
6423
b2e1b302 6424 size_of_regd = sizeof(struct ieee80211_regdomain) +
1a919318 6425 num_rules * sizeof(struct ieee80211_reg_rule);
b2e1b302
LR		 6426
6427 rd = kzalloc(size_of_regd, GFP_KERNEL);
6913b49a
JB		 6428 if (!rd)
6429 return -ENOMEM;
b2e1b302
LR		 6430
6431 rd->n_reg_rules = num_rules;
6432 rd->alpha2[0] = alpha2[0];
6433 rd->alpha2[1] = alpha2[1];
6434
8b60b078
LR		 6435 /*
6436 * Disable DFS master mode if the DFS region was
6437 * not supported or known on this kernel.
6438 */
6439 if (reg_supported_dfs_region(dfs_region))
6440 rd->dfs_region = dfs_region;
6441
b2e1b302 6442 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 6443 rem_reg_rules) {
bfe2c7b1
JB		 6444 r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
6445 nl_reg_rule, reg_rule_policy);
ae811e21
JB		 6446 if (r)
6447 goto bad_reg;
b2e1b302
LR		 6448 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
6449 if (r)
6450 goto bad_reg;
6451
6452 rule_idx++;
6453
d0e18f83
LR		 6454 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
6455 r = -EINVAL;
b2e1b302 6456 goto bad_reg;
d0e18f83 6457 }
b2e1b302
LR		 6458 }
6459
06627990
JB		 6460 /* set_regdom takes ownership of rd */
6461 return set_regdom(rd, REGD_SOURCE_CRDA);
d2372b31 6462 bad_reg:
b2e1b302 6463 kfree(rd);
d0e18f83 6464 return r;
b2e1b302 6465}
b6863036 6466#endif /* CONFIG_CFG80211_CRDA_SUPPORT */
b2e1b302 6467
83f5e2cf
JB		 6468static int validate_scan_freqs(struct nlattr *freqs)
6469{
6470 struct nlattr *attr1, *attr2;
6471 int n_channels = 0, tmp1, tmp2;
6472
6473 nla_for_each_nested(attr1, freqs, tmp1) {
6474 n_channels++;
6475 /*
6476 * Some hardware has a limited channel list for
6477 * scanning, and it is pretty much nonsensical
6478 * to scan for a channel twice, so disallow that
6479 * and don't require drivers to check that the
6480 * channel list they get isn't longer than what
6481 * they can scan, as long as they can scan all
6482 * the channels they registered at once.
6483 */
6484 nla_for_each_nested(attr2, freqs, tmp2)
6485 if (attr1 != attr2 &&
6486 nla_get_u32(attr1) == nla_get_u32(attr2))
6487 return 0;
6488 }
6489
6490 return n_channels;
6491}
6492
57fbcce3 6493static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
38de03d2 6494{
57fbcce3 6495 return b < NUM_NL80211_BANDS && wiphy->bands[b];
38de03d2
AS		 6496}
6497
6498static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
6499 struct cfg80211_bss_selection *bss_select)
6500{
6501 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
6502 struct nlattr *nest;
6503 int err;
6504 bool found = false;
6505 int i;
6506
6507 /* only process one nested attribute */
6508 nest = nla_data(nla);
6509 if (!nla_ok(nest, nla_len(nest)))
6510 return -EINVAL;
6511
bfe2c7b1
JB		 6512 err = nla_parse_nested(attr, NL80211_BSS_SELECT_ATTR_MAX, nest,
6513 nl80211_bss_select_policy);
38de03d2
AS		 6514 if (err)
6515 return err;
6516
6517 /* only one attribute may be given */
6518 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
6519 if (attr[i]) {
6520 if (found)
6521 return -EINVAL;
6522 found = true;
6523 }
6524 }
6525
6526 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
6527
6528 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
6529 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
6530
6531 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
6532 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
6533 bss_select->param.band_pref =
6534 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
6535 if (!is_band_valid(wiphy, bss_select->param.band_pref))
6536 return -EINVAL;
6537 }
6538
6539 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
6540 struct nl80211_bss_select_rssi_adjust *adj_param;
6541
6542 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
6543 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
6544 bss_select->param.adjust.band = adj_param->band;
6545 bss_select->param.adjust.delta = adj_param->delta;
6546 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
6547 return -EINVAL;
6548 }
6549
6550 /* user-space did not provide behaviour attribute */
6551 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
6552 return -EINVAL;
6553
6554 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
6555 return -EINVAL;
6556
6557 return 0;
6558}
6559
ad2b26ab
JB		 6560static int nl80211_parse_random_mac(struct nlattr **attrs,
6561 u8 *mac_addr, u8 *mac_addr_mask)
6562{
6563 int i;
6564
6565 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
d2beae10
JP		 6566 eth_zero_addr(mac_addr);
6567 eth_zero_addr(mac_addr_mask);
ad2b26ab
JB		 6568 mac_addr[0] = 0x2;
6569 mac_addr_mask[0] = 0x3;
6570
6571 return 0;
6572 }
6573
6574 /* need both or none */
6575 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
6576 return -EINVAL;
6577
6578 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
6579 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
6580
6581 /* don't allow or configure an mcast address */
6582 if (!is_multicast_ether_addr(mac_addr_mask) ||
6583 is_multicast_ether_addr(mac_addr))
6584 return -EINVAL;
6585
6586 /*
6587 * allow users to pass a MAC address that has bits set outside
6588 * of the mask, but don't bother drivers with having to deal
6589 * with such bits
6590 */
6591 for (i = 0; i < ETH_ALEN; i++)
6592 mac_addr[i] &= mac_addr_mask[i];
6593
6594 return 0;
6595}
6596
34373d12
VT		 6597static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
6598{
6599 ASSERT_WDEV_LOCK(wdev);
6600
6601 if (!cfg80211_beaconing_iface_active(wdev))
6602 return true;
6603
6604 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
6605 return true;
6606
6607 return regulatory_pre_cac_allowed(wdev->wiphy);
6608}
6609
2a519311
JB		 6610static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
6611{
4c476991 6612 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd014284 6613 struct wireless_dev *wdev = info->user_ptr[1];
2a519311 6614 struct cfg80211_scan_request *request;
2a519311
JB		 6615 struct nlattr *attr;
6616 struct wiphy *wiphy;
83f5e2cf 6617 int err, tmp, n_ssids = 0, n_channels, i;
70692ad2 6618 size_t ie_len;
2a519311 6619
f4a11bb0
JB		 6620 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6621 return -EINVAL;
6622
79c97e97 6623 wiphy = &rdev->wiphy;
2a519311 6624
cb3b7d87
AB		 6625 if (wdev->iftype == NL80211_IFTYPE_NAN)
6626 return -EOPNOTSUPP;
6627
4c476991
JB		 6628 if (!rdev->ops->scan)
6629 return -EOPNOTSUPP;
2a519311 6630
f9d15d16 6631 if (rdev->scan_req || rdev->scan_msg) {
f9f47529
JB		 6632 err = -EBUSY;
6633 goto unlock;
6634 }
2a519311
JB		 6635
6636 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 6637 n_channels = validate_scan_freqs(
6638 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
f9f47529
JB		 6639 if (!n_channels) {
6640 err = -EINVAL;
6641 goto unlock;
6642 }
2a519311 6643 } else {
bdfbec2d 6644 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311
JB		 6645 }
6646
6647 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
6648 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
6649 n_ssids++;
6650
f9f47529
JB		 6651 if (n_ssids > wiphy->max_scan_ssids) {
6652 err = -EINVAL;
6653 goto unlock;
6654 }
2a519311 6655
70692ad2
JM		 6656 if (info->attrs[NL80211_ATTR_IE])
6657 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6658 else
6659 ie_len = 0;
6660
f9f47529
JB		 6661 if (ie_len > wiphy->max_scan_ie_len) {
6662 err = -EINVAL;
6663 goto unlock;
6664 }
18a83659 6665
2a519311 6666 request = kzalloc(sizeof(*request)
a2cd43c5
LC		 6667 + sizeof(*request->ssids) * n_ssids
6668 + sizeof(*request->channels) * n_channels
70692ad2 6669 + ie_len, GFP_KERNEL);
f9f47529
JB		 6670 if (!request) {
6671 err = -ENOMEM;
6672 goto unlock;
6673 }
2a519311 6674
2a519311 6675 if (n_ssids)
5ba63533 6676 request->ssids = (void *)&request->channels[n_channels];
2a519311 6677 request->n_ssids = n_ssids;
70692ad2 6678 if (ie_len) {
13874e4b 6679 if (n_ssids)
70692ad2
JM		 6680 request->ie = (void *)(request->ssids + n_ssids);
6681 else
6682 request->ie = (void *)(request->channels + n_channels);
6683 }
2a519311 6684
584991dc 6685 i = 0;
2a519311
JB		 6686 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
6687 /* user specified, bail out if channel not found */
2a519311 6688 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
584991dc
JB		 6689 struct ieee80211_channel *chan;
6690
6691 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
6692
6693 if (!chan) {
2a519311
JB		 6694 err = -EINVAL;
6695 goto out_free;
6696 }
584991dc
JB		 6697
6698 /* ignore disabled channels */
6699 if (chan->flags & IEEE80211_CHAN_DISABLED)
6700 continue;
6701
6702 request->channels[i] = chan;
2a519311
JB		 6703 i++;
6704 }
6705 } else {
57fbcce3 6706 enum nl80211_band band;
34850ab2 6707
2a519311 6708 /* all channels */
57fbcce3 6709 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2a519311 6710 int j;
7a087e74 6711
2a519311
JB		 6712 if (!wiphy->bands[band])
6713 continue;
6714 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dc
JB		 6715 struct ieee80211_channel *chan;
6716
6717 chan = &wiphy->bands[band]->channels[j];
6718
6719 if (chan->flags & IEEE80211_CHAN_DISABLED)
6720 continue;
6721
6722 request->channels[i] = chan;
2a519311
JB		 6723 i++;
6724 }
6725 }
6726 }
6727
584991dc
JB		 6728 if (!i) {
6729 err = -EINVAL;
6730 goto out_free;
6731 }
6732
6733 request->n_channels = i;
6734
34373d12
VT		 6735 wdev_lock(wdev);
6736 if (!cfg80211_off_channel_oper_allowed(wdev)) {
6737 struct ieee80211_channel *chan;
6738
6739 if (request->n_channels != 1) {
6740 wdev_unlock(wdev);
6741 err = -EBUSY;
6742 goto out_free;
6743 }
6744
6745 chan = request->channels[0];
6746 if (chan->center_freq != wdev->chandef.chan->center_freq) {
6747 wdev_unlock(wdev);
6748 err = -EBUSY;
6749 goto out_free;
6750 }
6751 }
6752 wdev_unlock(wdev);
6753
2a519311 6754 i = 0;
13874e4b 6755 if (n_ssids) {
2a519311 6756 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d 6757 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311
JB		 6758 err = -EINVAL;
6759 goto out_free;
6760 }
57a27e1d 6761 request->ssids[i].ssid_len = nla_len(attr);
2a519311 6762 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2a519311
JB		 6763 i++;
6764 }
6765 }
6766
70692ad2
JM		 6767 if (info->attrs[NL80211_ATTR_IE]) {
6768 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 6769 memcpy((void *)request->ie,
6770 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 6771 request->ie_len);
6772 }
6773
57fbcce3 6774 for (i = 0; i < NUM_NL80211_BANDS; i++)
a401d2bb
JB		 6775 if (wiphy->bands[i])
6776 request->rates[i] =
6777 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab2
JB		 6778
6779 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
6780 nla_for_each_nested(attr,
6781 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
6782 tmp) {
57fbcce3 6783 enum nl80211_band band = nla_type(attr);
34850ab2 6784
57fbcce3 6785 if (band < 0 || band >= NUM_NL80211_BANDS) {
34850ab2
JB		 6786 err = -EINVAL;
6787 goto out_free;
6788 }
1b09cd82
FF		 6789
6790 if (!wiphy->bands[band])
6791 continue;
6792
34850ab2
JB		 6793 err = ieee80211_get_ratemask(wiphy->bands[band],
6794 nla_data(attr),
6795 nla_len(attr),
6796 &request->rates[band]);
6797 if (err)
6798 goto out_free;
6799 }
6800 }
6801
1d76250b
AS		 6802 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
6803 if (!wiphy_ext_feature_isset(wiphy,
6804 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
6805 err = -EOPNOTSUPP;
6806 goto out_free;
6807 }
6808
6809 request->duration =
6810 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
6811 request->duration_mandatory =
6812 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
6813 }
6814
46856bbf 6815 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771
SL		 6816 request->flags = nla_get_u32(
6817 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 6818 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
6819 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 6820 err = -EOPNOTSUPP;
6821 goto out_free;
6822 }
ad2b26ab
JB		 6823
6824 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6825 if (!(wiphy->features &
6826 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)) {
6827 err = -EOPNOTSUPP;
6828 goto out_free;
6829 }
6830
6831 if (wdev->current_bss) {
6832 err = -EOPNOTSUPP;
6833 goto out_free;
6834 }
6835
6836 err = nl80211_parse_random_mac(info->attrs,
6837 request->mac_addr,
6838 request->mac_addr_mask);
6839 if (err)
6840 goto out_free;
6841 }
46856bbf 6842 }
ed473771 6843
e9f935e3
RM		 6844 request->no_cck =
6845 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
6846
2fa436b3
VK		 6847 /* Initial implementation used NL80211_ATTR_MAC to set the specific
6848 * BSSID to scan for. This was problematic because that same attribute
6849 * was already used for another purpose (local random MAC address). The
6850 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
6851 * compatibility with older userspace components, also use the
6852 * NL80211_ATTR_MAC value here if it can be determined to be used for
6853 * the specific BSSID use case instead of the random MAC address
6854 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
6855 */
6856 if (info->attrs[NL80211_ATTR_BSSID])
6857 memcpy(request->bssid,
6858 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
6859 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
6860 info->attrs[NL80211_ATTR_MAC])
818965d3
JM		 6861 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
6862 ETH_ALEN);
6863 else
6864 eth_broadcast_addr(request->bssid);
6865
fd014284 6866 request->wdev = wdev;
79c97e97 6867 request->wiphy = &rdev->wiphy;
15d6030b 6868 request->scan_start = jiffies;
2a519311 6869
79c97e97 6870 rdev->scan_req = request;
e35e4d28 6871 err = rdev_scan(rdev, request);
2a519311 6872
463d0183 6873 if (!err) {
fd014284
JB		 6874 nl80211_send_scan_start(rdev, wdev);
6875 if (wdev->netdev)
6876 dev_hold(wdev->netdev);
4c476991 6877 } else {
2a519311 6878 out_free:
79c97e97 6879 rdev->scan_req = NULL;
2a519311
JB		 6880 kfree(request);
6881 }
3b85875a 6882
f9f47529 6883 unlock:
2a519311
JB		 6884 return err;
6885}
6886
91d3ab46
VK		 6887static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
6888{
6889 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6890 struct wireless_dev *wdev = info->user_ptr[1];
6891
6892 if (!rdev->ops->abort_scan)
6893 return -EOPNOTSUPP;
6894
6895 if (rdev->scan_msg)
6896 return 0;
6897
6898 if (!rdev->scan_req)
6899 return -ENOENT;
6900
6901 rdev_abort_scan(rdev, wdev);
6902 return 0;
6903}
6904
3b06d277
AS		 6905static int
6906nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
6907 struct cfg80211_sched_scan_request *request,
6908 struct nlattr **attrs)
6909{
6910 int tmp, err, i = 0;
6911 struct nlattr *attr;
6912
6913 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
6914 u32 interval;
6915
6916 /*
6917 * If scan plans are not specified,
5a88de53 6918 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
3b06d277
AS		 6919 * case one scan plan will be set with the specified scan
6920 * interval and infinite number of iterations.
6921 */
3b06d277
AS		 6922 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
6923 if (!interval)
6924 return -EINVAL;
6925
6926 request->scan_plans[0].interval =
6927 DIV_ROUND_UP(interval, MSEC_PER_SEC);
6928 if (!request->scan_plans[0].interval)
6929 return -EINVAL;
6930
6931 if (request->scan_plans[0].interval >
6932 wiphy->max_sched_scan_plan_interval)
6933 request->scan_plans[0].interval =
6934 wiphy->max_sched_scan_plan_interval;
6935
6936 return 0;
6937 }
6938
6939 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
6940 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
6941
6942 if (WARN_ON(i >= n_plans))
6943 return -EINVAL;
6944
bfe2c7b1
JB		 6945 err = nla_parse_nested(plan, NL80211_SCHED_SCAN_PLAN_MAX,
6946 attr, nl80211_plan_policy);
3b06d277
AS		 6947 if (err)
6948 return err;
6949
6950 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
6951 return -EINVAL;
6952
6953 request->scan_plans[i].interval =
6954 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
6955 if (!request->scan_plans[i].interval ||
6956 request->scan_plans[i].interval >
6957 wiphy->max_sched_scan_plan_interval)
6958 return -EINVAL;
6959
6960 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
6961 request->scan_plans[i].iterations =
6962 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
6963 if (!request->scan_plans[i].iterations ||
6964 (request->scan_plans[i].iterations >
6965 wiphy->max_sched_scan_plan_iterations))
6966 return -EINVAL;
6967 } else if (i < n_plans - 1) {
6968 /*
6969 * All scan plans but the last one must specify
6970 * a finite number of iterations
6971 */
6972 return -EINVAL;
6973 }
6974
6975 i++;
6976 }
6977
6978 /*
6979 * The last scan plan must not specify the number of
6980 * iterations, it is supposed to run infinitely
6981 */
6982 if (request->scan_plans[n_plans - 1].iterations)
6983 return -EINVAL;
6984
6985 return 0;
6986}
6987
256da02d 6988static struct cfg80211_sched_scan_request *
ad2b26ab 6989nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
aad1e812 6990 struct nlattr **attrs, int max_match_sets)
807f8a8c
LC		 6991{
6992 struct cfg80211_sched_scan_request *request;
807f8a8c 6993 struct nlattr *attr;
3b06d277 6994 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
57fbcce3 6995 enum nl80211_band band;
807f8a8c 6996 size_t ie_len;
a1f1c21c 6997 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
ea73cbce 6998 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
807f8a8c 6999
256da02d
LC		 7000 if (!is_valid_ie_attr(attrs[NL80211_ATTR_IE]))
7001 return ERR_PTR(-EINVAL);
807f8a8c 7002
256da02d 7003 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c 7004 n_channels = validate_scan_freqs(
256da02d 7005 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
807f8a8c 7006 if (!n_channels)
256da02d 7007 return ERR_PTR(-EINVAL);
807f8a8c 7008 } else {
bdfbec2d 7009 n_channels = ieee80211_get_num_supported_channels(wiphy);
807f8a8c
LC		 7010 }
7011
256da02d
LC		 7012 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7013 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c
LC		 7014 tmp)
7015 n_ssids++;
7016
93b6aa69 7017 if (n_ssids > wiphy->max_sched_scan_ssids)
256da02d 7018 return ERR_PTR(-EINVAL);
807f8a8c 7019
ea73cbce
JB		 7020 /*
7021 * First, count the number of 'real' matchsets. Due to an issue with
7022 * the old implementation, matchsets containing only the RSSI attribute
7023 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7024 * RSSI for all matchsets, rather than their own matchset for reporting
7025 * all APs with a strong RSSI. This is needed to be compatible with
7026 * older userspace that treated a matchset with only the RSSI as the
7027 * global RSSI for all other matchsets - if there are other matchsets.
7028 */
256da02d 7029 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7030 nla_for_each_nested(attr,
256da02d 7031 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
ea73cbce
JB		 7032 tmp) {
7033 struct nlattr *rssi;
7034
bfe2c7b1
JB		 7035 err = nla_parse_nested(tb,
7036 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
7037 attr, nl80211_match_policy);
ea73cbce 7038 if (err)
256da02d 7039 return ERR_PTR(err);
ea73cbce
JB		 7040 /* add other standalone attributes here */
7041 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID]) {
7042 n_match_sets++;
7043 continue;
7044 }
7045 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7046 if (rssi)
7047 default_match_rssi = nla_get_s32(rssi);
7048 }
7049 }
7050
7051 /* However, if there's no other matchset, add the RSSI one */
7052 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7053 n_match_sets = 1;
a1f1c21c 7054
aad1e812 7055 if (n_match_sets > max_match_sets)
256da02d 7056 return ERR_PTR(-EINVAL);
a1f1c21c 7057
256da02d
LC		 7058 if (attrs[NL80211_ATTR_IE])
7059 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
807f8a8c
LC		 7060 else
7061 ie_len = 0;
7062
5a865bad 7063 if (ie_len > wiphy->max_sched_scan_ie_len)
256da02d 7064 return ERR_PTR(-EINVAL);
c10841ca 7065
3b06d277
AS		 7066 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7067 /*
7068 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7069 * each scan plan already specifies its own interval
7070 */
7071 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7072 return ERR_PTR(-EINVAL);
7073
7074 nla_for_each_nested(attr,
7075 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7076 n_plans++;
7077 } else {
7078 /*
7079 * The scan interval attribute is kept for backward
7080 * compatibility. If no scan plans are specified and sched scan
7081 * interval is specified, one scan plan will be set with this
7082 * scan interval and infinite number of iterations.
7083 */
7084 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7085 return ERR_PTR(-EINVAL);
7086
7087 n_plans = 1;
7088 }
7089
7090 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7091 return ERR_PTR(-EINVAL);
7092
bf95ecdb 7093 if (!wiphy_ext_feature_isset(
7094 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7095 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7096 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7097 return ERR_PTR(-EINVAL);
7098
807f8a8c 7099 request = kzalloc(sizeof(*request)
a2cd43c5 7100 + sizeof(*request->ssids) * n_ssids
a1f1c21c 7101 + sizeof(*request->match_sets) * n_match_sets
3b06d277 7102 + sizeof(*request->scan_plans) * n_plans
a2cd43c5 7103 + sizeof(*request->channels) * n_channels
807f8a8c 7104 + ie_len, GFP_KERNEL);
256da02d
LC		 7105 if (!request)
7106 return ERR_PTR(-ENOMEM);
807f8a8c
LC		 7107
7108 if (n_ssids)
7109 request->ssids = (void *)&request->channels[n_channels];
7110 request->n_ssids = n_ssids;
7111 if (ie_len) {
13874e4b 7112 if (n_ssids)
807f8a8c
LC		 7113 request->ie = (void *)(request->ssids + n_ssids);
7114 else
7115 request->ie = (void *)(request->channels + n_channels);
7116 }
7117
a1f1c21c
LC		 7118 if (n_match_sets) {
7119 if (request->ie)
7120 request->match_sets = (void *)(request->ie + ie_len);
13874e4b 7121 else if (n_ssids)
a1f1c21c
LC		 7122 request->match_sets =
7123 (void *)(request->ssids + n_ssids);
7124 else
7125 request->match_sets =
7126 (void *)(request->channels + n_channels);
7127 }
7128 request->n_match_sets = n_match_sets;
7129
3b06d277
AS		 7130 if (n_match_sets)
7131 request->scan_plans = (void *)(request->match_sets +
7132 n_match_sets);
7133 else if (request->ie)
7134 request->scan_plans = (void *)(request->ie + ie_len);
7135 else if (n_ssids)
7136 request->scan_plans = (void *)(request->ssids + n_ssids);
7137 else
7138 request->scan_plans = (void *)(request->channels + n_channels);
7139
7140 request->n_scan_plans = n_plans;
7141
807f8a8c 7142 i = 0;
256da02d 7143 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c
LC		 7144 /* user specified, bail out if channel not found */
7145 nla_for_each_nested(attr,
256da02d 7146 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
807f8a8c
LC		 7147 tmp) {
7148 struct ieee80211_channel *chan;
7149
7150 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7151
7152 if (!chan) {
7153 err = -EINVAL;
7154 goto out_free;
7155 }
7156
7157 /* ignore disabled channels */
7158 if (chan->flags & IEEE80211_CHAN_DISABLED)
7159 continue;
7160
7161 request->channels[i] = chan;
7162 i++;
7163 }
7164 } else {
7165 /* all channels */
57fbcce3 7166 for (band = 0; band < NUM_NL80211_BANDS; band++) {
807f8a8c 7167 int j;
7a087e74 7168
807f8a8c
LC		 7169 if (!wiphy->bands[band])
7170 continue;
7171 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7172 struct ieee80211_channel *chan;
7173
7174 chan = &wiphy->bands[band]->channels[j];
7175
7176 if (chan->flags & IEEE80211_CHAN_DISABLED)
7177 continue;
7178
7179 request->channels[i] = chan;
7180 i++;
7181 }
7182 }
7183 }
7184
7185 if (!i) {
7186 err = -EINVAL;
7187 goto out_free;
7188 }
7189
7190 request->n_channels = i;
7191
7192 i = 0;
13874e4b 7193 if (n_ssids) {
256da02d 7194 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c 7195 tmp) {
57a27e1d 7196 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
807f8a8c
LC		 7197 err = -EINVAL;
7198 goto out_free;
7199 }
57a27e1d 7200 request->ssids[i].ssid_len = nla_len(attr);
807f8a8c
LC		 7201 memcpy(request->ssids[i].ssid, nla_data(attr),
7202 nla_len(attr));
807f8a8c
LC		 7203 i++;
7204 }
7205 }
7206
a1f1c21c 7207 i = 0;
256da02d 7208 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 7209 nla_for_each_nested(attr,
256da02d 7210 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
a1f1c21c 7211 tmp) {
88e920b4 7212 struct nlattr *ssid, *rssi;
a1f1c21c 7213
bfe2c7b1
JB		 7214 err = nla_parse_nested(tb,
7215 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
7216 attr, nl80211_match_policy);
ae811e21
JB		 7217 if (err)
7218 goto out_free;
4a4ab0d7 7219 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
a1f1c21c 7220 if (ssid) {
ea73cbce
JB		 7221 if (WARN_ON(i >= n_match_sets)) {
7222 /* this indicates a programming error,
7223 * the loop above should have verified
7224 * things properly
7225 */
7226 err = -EINVAL;
7227 goto out_free;
7228 }
7229
a1f1c21c
LC		 7230 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
7231 err = -EINVAL;
7232 goto out_free;
7233 }
7234 memcpy(request->match_sets[i].ssid.ssid,
7235 nla_data(ssid), nla_len(ssid));
7236 request->match_sets[i].ssid.ssid_len =
7237 nla_len(ssid);
56ab364f 7238 /* special attribute - old implementation w/a */
ea73cbce
JB		 7239 request->match_sets[i].rssi_thold =
7240 default_match_rssi;
7241 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7242 if (rssi)
7243 request->match_sets[i].rssi_thold =
7244 nla_get_s32(rssi);
a1f1c21c
LC		 7245 }
7246 i++;
7247 }
ea73cbce
JB		 7248
7249 /* there was no other matchset, so the RSSI one is alone */
f89f46cf 7250 if (i == 0 && n_match_sets)
ea73cbce
JB		 7251 request->match_sets[0].rssi_thold = default_match_rssi;
7252
7253 request->min_rssi_thold = INT_MAX;
7254 for (i = 0; i < n_match_sets; i++)
7255 request->min_rssi_thold =
7256 min(request->match_sets[i].rssi_thold,
7257 request->min_rssi_thold);
7258 } else {
7259 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
a1f1c21c
LC		 7260 }
7261
9900e484
JB		 7262 if (ie_len) {
7263 request->ie_len = ie_len;
807f8a8c 7264 memcpy((void *)request->ie,
256da02d 7265 nla_data(attrs[NL80211_ATTR_IE]),
807f8a8c
LC		 7266 request->ie_len);
7267 }
7268
256da02d 7269 if (attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771 7270 request->flags = nla_get_u32(
256da02d 7271 attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 7272 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7273 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 7274 err = -EOPNOTSUPP;
7275 goto out_free;
7276 }
ad2b26ab
JB		 7277
7278 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7279 u32 flg = NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
7280
7281 if (!wdev) /* must be net-detect */
7282 flg = NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7283
7284 if (!(wiphy->features & flg)) {
7285 err = -EOPNOTSUPP;
7286 goto out_free;
7287 }
7288
7289 if (wdev && wdev->current_bss) {
7290 err = -EOPNOTSUPP;
7291 goto out_free;
7292 }
7293
7294 err = nl80211_parse_random_mac(attrs, request->mac_addr,
7295 request->mac_addr_mask);
7296 if (err)
7297 goto out_free;
7298 }
46856bbf 7299 }
ed473771 7300
9c748934
LC		 7301 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
7302 request->delay =
7303 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
7304
bf95ecdb 7305 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
7306 request->relative_rssi = nla_get_s8(
7307 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
7308 request->relative_rssi_set = true;
7309 }
7310
7311 if (request->relative_rssi_set &&
7312 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
7313 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
7314
7315 rssi_adjust = nla_data(
7316 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
7317 request->rssi_adjust.band = rssi_adjust->band;
7318 request->rssi_adjust.delta = rssi_adjust->delta;
7319 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
7320 err = -EINVAL;
7321 goto out_free;
7322 }
7323 }
7324
3b06d277
AS		 7325 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
7326 if (err)
7327 goto out_free;
7328
15d6030b 7329 request->scan_start = jiffies;
807f8a8c 7330
256da02d 7331 return request;
807f8a8c
LC		 7332
7333out_free:
7334 kfree(request);
256da02d
LC		 7335 return ERR_PTR(err);
7336}
7337
7338static int nl80211_start_sched_scan(struct sk_buff *skb,
7339 struct genl_info *info)
7340{
7341 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7342 struct net_device *dev = info->user_ptr[1];
ad2b26ab 7343 struct wireless_dev *wdev = dev->ieee80211_ptr;
31a60ed1 7344 struct cfg80211_sched_scan_request *sched_scan_req;
256da02d
LC		 7345 int err;
7346
7347 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
7348 !rdev->ops->sched_scan_start)
7349 return -EOPNOTSUPP;
7350
7351 if (rdev->sched_scan_req)
7352 return -EINPROGRESS;
7353
31a60ed1 7354 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
aad1e812
AVS		 7355 info->attrs,
7356 rdev->wiphy.max_match_sets);
31a60ed1
JR		 7357
7358 err = PTR_ERR_OR_ZERO(sched_scan_req);
256da02d
LC		 7359 if (err)
7360 goto out_err;
7361
31a60ed1 7362 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
256da02d
LC		 7363 if (err)
7364 goto out_free;
7365
31a60ed1
JR		 7366 sched_scan_req->dev = dev;
7367 sched_scan_req->wiphy = &rdev->wiphy;
7368
93a1e86c
JR		 7369 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
7370 sched_scan_req->owner_nlportid = info->snd_portid;
7371
31a60ed1 7372 rcu_assign_pointer(rdev->sched_scan_req, sched_scan_req);
256da02d 7373
96b08fd6 7374 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
256da02d
LC		 7375 return 0;
7376
7377out_free:
31a60ed1 7378 kfree(sched_scan_req);
256da02d 7379out_err:
807f8a8c
LC		 7380 return err;
7381}
7382
7383static int nl80211_stop_sched_scan(struct sk_buff *skb,
7384 struct genl_info *info)
7385{
7386 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7387
7388 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
7389 !rdev->ops->sched_scan_stop)
7390 return -EOPNOTSUPP;
7391
5fe231e8 7392 return __cfg80211_stop_sched_scan(rdev, false);
807f8a8c
LC		 7393}
7394
04f39047
SW		 7395static int nl80211_start_radar_detection(struct sk_buff *skb,
7396 struct genl_info *info)
7397{
7398 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7399 struct net_device *dev = info->user_ptr[1];
7400 struct wireless_dev *wdev = dev->ieee80211_ptr;
7401 struct cfg80211_chan_def chandef;
55f7435c 7402 enum nl80211_dfs_regions dfs_region;
31559f35 7403 unsigned int cac_time_ms;
04f39047
SW		 7404 int err;
7405
55f7435c
LR		 7406 dfs_region = reg_get_dfs_region(wdev->wiphy);
7407 if (dfs_region == NL80211_DFS_UNSET)
7408 return -EINVAL;
7409
04f39047
SW		 7410 err = nl80211_parse_chandef(rdev, info, &chandef);
7411 if (err)
7412 return err;
7413
ff311bc1
SW		 7414 if (netif_carrier_ok(dev))
7415 return -EBUSY;
7416
04f39047
SW		 7417 if (wdev->cac_started)
7418 return -EBUSY;
7419
2beb6dab 7420 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
00ec75fc 7421 wdev->iftype);
04f39047
SW		 7422 if (err < 0)
7423 return err;
7424
7425 if (err == 0)
7426 return -EINVAL;
7427
fe7c3a1f 7428 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
04f39047
SW		 7429 return -EINVAL;
7430
7431 if (!rdev->ops->start_radar_detection)
7432 return -EOPNOTSUPP;
7433
31559f35
JD		 7434 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
7435 if (WARN_ON(!cac_time_ms))
7436 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
7437
a1056b1b 7438 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
04f39047 7439 if (!err) {
9e0e2961 7440 wdev->chandef = chandef;
04f39047
SW		 7441 wdev->cac_started = true;
7442 wdev->cac_start_time = jiffies;
31559f35 7443 wdev->cac_time_ms = cac_time_ms;
04f39047 7444 }
04f39047
SW		 7445 return err;
7446}
7447
16ef1fe2
SW		 7448static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
7449{
7450 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7451 struct net_device *dev = info->user_ptr[1];
7452 struct wireless_dev *wdev = dev->ieee80211_ptr;
7453 struct cfg80211_csa_settings params;
7454 /* csa_attrs is defined static to avoid waste of stack size - this
7455 * function is called under RTNL lock, so this should not be a problem.
7456 */
7457 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
16ef1fe2 7458 int err;
ee4bc9e7 7459 bool need_new_beacon = false;
9a774c78 7460 int len, i;
252e07ca 7461 u32 cs_count;
16ef1fe2
SW		 7462
7463 if (!rdev->ops->channel_switch ||
7464 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
7465 return -EOPNOTSUPP;
7466
ee4bc9e7
SW		 7467 switch (dev->ieee80211_ptr->iftype) {
7468 case NL80211_IFTYPE_AP:
7469 case NL80211_IFTYPE_P2P_GO:
7470 need_new_beacon = true;
7471
7472 /* useless if AP is not running */
7473 if (!wdev->beacon_interval)
1ff79dfa 7474 return -ENOTCONN;
ee4bc9e7
SW		 7475 break;
7476 case NL80211_IFTYPE_ADHOC:
1ff79dfa
JB		 7477 if (!wdev->ssid_len)
7478 return -ENOTCONN;
7479 break;
c6da674a 7480 case NL80211_IFTYPE_MESH_POINT:
1ff79dfa
JB		 7481 if (!wdev->mesh_id_len)
7482 return -ENOTCONN;
ee4bc9e7
SW		 7483 break;
7484 default:
16ef1fe2 7485 return -EOPNOTSUPP;
ee4bc9e7 7486 }
16ef1fe2
SW		 7487
7488 memset(&params, 0, sizeof(params));
7489
7490 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7491 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
7492 return -EINVAL;
7493
7494 /* only important for AP, IBSS and mesh create IEs internally */
d0a361a5 7495 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
16ef1fe2
SW		 7496 return -EINVAL;
7497
252e07ca
LC		 7498 /* Even though the attribute is u32, the specification says
7499 * u8, so let's make sure we don't overflow.
7500 */
7501 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
7502 if (cs_count > 255)
7503 return -EINVAL;
7504
7505 params.count = cs_count;
16ef1fe2 7506
ee4bc9e7
SW		 7507 if (!need_new_beacon)
7508 goto skip_beacons;
7509
16ef1fe2
SW		 7510 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
7511 if (err)
7512 return err;
7513
7514 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
7515 info->attrs[NL80211_ATTR_CSA_IES],
7516 nl80211_policy);
7517 if (err)
7518 return err;
7519
7520 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
7521 if (err)
7522 return err;
7523
7524 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
7525 return -EINVAL;
7526
9a774c78
AO		 7527 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7528 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7529 return -EINVAL;
7530
9a774c78
AO		 7531 params.n_counter_offsets_beacon = len / sizeof(u16);
7532 if (rdev->wiphy.max_num_csa_counters &&
7533 (params.n_counter_offsets_beacon >
7534 rdev->wiphy.max_num_csa_counters))
16ef1fe2
SW		 7535 return -EINVAL;
7536
9a774c78
AO		 7537 params.counter_offsets_beacon =
7538 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
7539
7540 /* sanity checks - counters should fit and be the same */
7541 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
7542 u16 offset = params.counter_offsets_beacon[i];
7543
7544 if (offset >= params.beacon_csa.tail_len)
7545 return -EINVAL;
7546
7547 if (params.beacon_csa.tail[offset] != params.count)
7548 return -EINVAL;
7549 }
7550
16ef1fe2 7551 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
9a774c78
AO		 7552 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7553 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 7554 return -EINVAL;
7555
9a774c78
AO		 7556 params.n_counter_offsets_presp = len / sizeof(u16);
7557 if (rdev->wiphy.max_num_csa_counters &&
ad5987b4 7558 (params.n_counter_offsets_presp >
9a774c78 7559 rdev->wiphy.max_num_csa_counters))
16ef1fe2 7560 return -EINVAL;
9a774c78
AO		 7561
7562 params.counter_offsets_presp =
7563 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
7564
7565 /* sanity checks - counters should fit and be the same */
7566 for (i = 0; i < params.n_counter_offsets_presp; i++) {
7567 u16 offset = params.counter_offsets_presp[i];
7568
7569 if (offset >= params.beacon_csa.probe_resp_len)
7570 return -EINVAL;
7571
7572 if (params.beacon_csa.probe_resp[offset] !=
7573 params.count)
7574 return -EINVAL;
7575 }
16ef1fe2
SW		 7576 }
7577
ee4bc9e7 7578skip_beacons:
16ef1fe2
SW		 7579 err = nl80211_parse_chandef(rdev, info, &params.chandef);
7580 if (err)
7581 return err;
7582
923b352f
AN		 7583 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
7584 wdev->iftype))
16ef1fe2
SW		 7585 return -EINVAL;
7586
2beb6dab
LC		 7587 err = cfg80211_chandef_dfs_required(wdev->wiphy,
7588 &params.chandef,
7589 wdev->iftype);
7590 if (err < 0)
7591 return err;
7592
dcc6c2f5 7593 if (err > 0)
2beb6dab 7594 params.radar_required = true;
16ef1fe2 7595
16ef1fe2
SW		 7596 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
7597 params.block_tx = true;
7598
c56589ed
SW		 7599 wdev_lock(wdev);
7600 err = rdev_channel_switch(rdev, dev, &params);
7601 wdev_unlock(wdev);
7602
7603 return err;
16ef1fe2
SW		 7604}
7605
9720bb3a
JB		 7606static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
7607 u32 seq, int flags,
2a519311 7608 struct cfg80211_registered_device *rdev,
48ab905d
JB		 7609 struct wireless_dev *wdev,
7610 struct cfg80211_internal_bss *intbss)
2a519311 7611{
48ab905d 7612 struct cfg80211_bss *res = &intbss->pub;
9caf0364 7613 const struct cfg80211_bss_ies *ies;
2a519311
JB		 7614 void *hdr;
7615 struct nlattr *bss;
48ab905d
JB		 7616
7617 ASSERT_WDEV_LOCK(wdev);
2a519311 7618
15e47304 7619 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
2a519311
JB		 7620 NL80211_CMD_NEW_SCAN_RESULTS);
7621 if (!hdr)
7622 return -1;
7623
9720bb3a
JB		 7624 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
7625
97990a06
JB		 7626 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
7627 goto nla_put_failure;
7628 if (wdev->netdev &&
9360ffd1
DM		 7629 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
7630 goto nla_put_failure;
2dad624e
ND		 7631 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
7632 NL80211_ATTR_PAD))
97990a06 7633 goto nla_put_failure;
2a519311
JB		 7634
7635 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
7636 if (!bss)
7637 goto nla_put_failure;
9360ffd1 7638 if ((!is_zero_ether_addr(res->bssid) &&
9caf0364 7639 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9360ffd1 7640 goto nla_put_failure;
9caf0364
JB		 7641
7642 rcu_read_lock();
0e227084
JB		 7643 /* indicate whether we have probe response data or not */
7644 if (rcu_access_pointer(res->proberesp_ies) &&
7645 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
7646 goto fail_unlock_rcu;
7647
7648 /* this pointer prefers to be pointed to probe response data
7649 * but is always valid
7650 */
9caf0364 7651 ies = rcu_dereference(res->ies);
8cef2c9d 7652 if (ies) {
2dad624e
ND		 7653 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
7654 NL80211_BSS_PAD))
8cef2c9d 7655 goto fail_unlock_rcu;
8cef2c9d
JB		 7656 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
7657 ies->len, ies->data))
7658 goto fail_unlock_rcu;
9caf0364 7659 }
0e227084
JB		 7660
7661 /* and this pointer is always (unless driver didn't know) beacon data */
9caf0364 7662 ies = rcu_dereference(res->beacon_ies);
0e227084 7663 if (ies && ies->from_beacon) {
2dad624e
ND		 7664 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
7665 NL80211_BSS_PAD))
8cef2c9d
JB		 7666 goto fail_unlock_rcu;
7667 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
7668 ies->len, ies->data))
7669 goto fail_unlock_rcu;
9caf0364
JB		 7670 }
7671 rcu_read_unlock();
7672
9360ffd1
DM		 7673 if (res->beacon_interval &&
7674 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
7675 goto nla_put_failure;
7676 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
7677 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
dcd6eac1 7678 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9360ffd1
DM		 7679 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
7680 jiffies_to_msecs(jiffies - intbss->ts)))
7681 goto nla_put_failure;
2a519311 7682
1d76250b
AS		 7683 if (intbss->parent_tsf &&
7684 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
7685 intbss->parent_tsf, NL80211_BSS_PAD) ||
7686 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
7687 intbss->parent_bssid)))
7688 goto nla_put_failure;
7689
6e19bc4b 7690 if (intbss->ts_boottime &&
2dad624e
ND		 7691 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
7692 intbss->ts_boottime, NL80211_BSS_PAD))
6e19bc4b
DS		 7693 goto nla_put_failure;
7694
77965c97 7695 switch (rdev->wiphy.signal_type) {
2a519311 7696 case CFG80211_SIGNAL_TYPE_MBM:
9360ffd1
DM		 7697 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
7698 goto nla_put_failure;
2a519311
JB		 7699 break;
7700 case CFG80211_SIGNAL_TYPE_UNSPEC:
9360ffd1
DM		 7701 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
7702 goto nla_put_failure;
2a519311
JB		 7703 break;
7704 default:
7705 break;
7706 }
7707
48ab905d 7708 switch (wdev->iftype) {
074ac8df 7709 case NL80211_IFTYPE_P2P_CLIENT:
48ab905d 7710 case NL80211_IFTYPE_STATION:
9360ffd1
DM		 7711 if (intbss == wdev->current_bss &&
7712 nla_put_u32(msg, NL80211_BSS_STATUS,
7713 NL80211_BSS_STATUS_ASSOCIATED))
7714 goto nla_put_failure;
48ab905d
JB		 7715 break;
7716 case NL80211_IFTYPE_ADHOC:
9360ffd1
DM		 7717 if (intbss == wdev->current_bss &&
7718 nla_put_u32(msg, NL80211_BSS_STATUS,
7719 NL80211_BSS_STATUS_IBSS_JOINED))
7720 goto nla_put_failure;
48ab905d
JB		 7721 break;
7722 default:
7723 break;
7724 }
7725
2a519311
JB		 7726 nla_nest_end(msg, bss);
7727
053c095a
JB		 7728 genlmsg_end(msg, hdr);
7729 return 0;
2a519311 7730
8cef2c9d
JB		 7731 fail_unlock_rcu:
7732 rcu_read_unlock();
2a519311
JB		 7733 nla_put_failure:
7734 genlmsg_cancel(msg, hdr);
7735 return -EMSGSIZE;
7736}
7737
97990a06 7738static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
2a519311 7739{
48ab905d 7740 struct cfg80211_registered_device *rdev;
2a519311 7741 struct cfg80211_internal_bss *scan;
48ab905d 7742 struct wireless_dev *wdev;
97990a06 7743 int start = cb->args[2], idx = 0;
2a519311
JB		 7744 int err;
7745
97990a06 7746 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 7747 if (err)
7748 return err;
2a519311 7749
48ab905d
JB		 7750 wdev_lock(wdev);
7751 spin_lock_bh(&rdev->bss_lock);
7752 cfg80211_bss_expire(rdev);
7753
9720bb3a
JB		 7754 cb->seq = rdev->bss_generation;
7755
48ab905d 7756 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 7757 if (++idx <= start)
7758 continue;
9720bb3a 7759 if (nl80211_send_bss(skb, cb,
2a519311 7760 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 7761 rdev, wdev, scan) < 0) {
2a519311 7762 idx--;
67748893 7763 break;
2a519311
JB		 7764 }
7765 }
7766
48ab905d
JB		 7767 spin_unlock_bh(&rdev->bss_lock);
7768 wdev_unlock(wdev);
2a519311 7769
97990a06
JB		 7770 cb->args[2] = idx;
7771 nl80211_finish_wdev_dump(rdev);
2a519311 7772
67748893 7773 return skb->len;
2a519311
JB		 7774}
7775
15e47304 7776static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
11f78ac3
JB		 7777 int flags, struct net_device *dev,
7778 bool allow_radio_stats,
7779 struct survey_info *survey)
61fa713c
HS		 7780{
7781 void *hdr;
7782 struct nlattr *infoattr;
7783
11f78ac3
JB		 7784 /* skip radio stats if userspace didn't request them */
7785 if (!survey->channel && !allow_radio_stats)
7786 return 0;
7787
15e47304 7788 hdr = nl80211hdr_put(msg, portid, seq, flags,
61fa713c
HS		 7789 NL80211_CMD_NEW_SURVEY_RESULTS);
7790 if (!hdr)
7791 return -ENOMEM;
7792
9360ffd1
DM		 7793 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
7794 goto nla_put_failure;
61fa713c
HS		 7795
7796 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
7797 if (!infoattr)
7798 goto nla_put_failure;
7799
11f78ac3
JB		 7800 if (survey->channel &&
7801 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9360ffd1
DM		 7802 survey->channel->center_freq))
7803 goto nla_put_failure;
7804
7805 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
7806 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
7807 goto nla_put_failure;
7808 if ((survey->filled & SURVEY_INFO_IN_USE) &&
7809 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
7810 goto nla_put_failure;
4ed20beb 7811 if ((survey->filled & SURVEY_INFO_TIME) &&
2dad624e
ND		 7812 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
7813 survey->time, NL80211_SURVEY_INFO_PAD))
9360ffd1 7814 goto nla_put_failure;
4ed20beb 7815 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
2dad624e
ND		 7816 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
7817 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7818 goto nla_put_failure;
4ed20beb 7819 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
2dad624e
ND		 7820 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
7821 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9360ffd1 7822 goto nla_put_failure;
4ed20beb 7823 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
2dad624e
ND		 7824 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
7825 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7826 goto nla_put_failure;
4ed20beb 7827 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
2dad624e
ND		 7828 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
7829 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9360ffd1 7830 goto nla_put_failure;
052536ab 7831 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
2dad624e
ND		 7832 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
7833 survey->time_scan, NL80211_SURVEY_INFO_PAD))
052536ab 7834 goto nla_put_failure;
61fa713c
HS		 7835
7836 nla_nest_end(msg, infoattr);
7837
053c095a
JB		 7838 genlmsg_end(msg, hdr);
7839 return 0;
61fa713c
HS		 7840
7841 nla_put_failure:
7842 genlmsg_cancel(msg, hdr);
7843 return -EMSGSIZE;
7844}
7845
11f78ac3 7846static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
61fa713c 7847{
c90c39da 7848 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
61fa713c 7849 struct survey_info survey;
1b8ec87a 7850 struct cfg80211_registered_device *rdev;
97990a06
JB		 7851 struct wireless_dev *wdev;
7852 int survey_idx = cb->args[2];
61fa713c 7853 int res;
11f78ac3 7854 bool radio_stats;
61fa713c 7855
1b8ec87a 7856 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 7857 if (res)
7858 return res;
61fa713c 7859
11f78ac3 7860 /* prepare_wdev_dump parsed the attributes */
c90c39da 7861 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
11f78ac3 7862
97990a06
JB		 7863 if (!wdev->netdev) {
7864 res = -EINVAL;
7865 goto out_err;
7866 }
7867
1b8ec87a 7868 if (!rdev->ops->dump_survey) {
61fa713c
HS		 7869 res = -EOPNOTSUPP;
7870 goto out_err;
7871 }
7872
7873 while (1) {
1b8ec87a 7874 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
61fa713c
HS		 7875 if (res == -ENOENT)
7876 break;
7877 if (res)
7878 goto out_err;
7879
11f78ac3
JB		 7880 /* don't send disabled channels, but do send non-channel data */
7881 if (survey.channel &&
7882 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
180cdc79
LR		 7883 survey_idx++;
7884 continue;
7885 }
7886
61fa713c 7887 if (nl80211_send_survey(skb,
15e47304 7888 NETLINK_CB(cb->skb).portid,
61fa713c 7889 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11f78ac3 7890 wdev->netdev, radio_stats, &survey) < 0)
61fa713c
HS		 7891 goto out;
7892 survey_idx++;
7893 }
7894
7895 out:
97990a06 7896 cb->args[2] = survey_idx;
61fa713c
HS		 7897 res = skb->len;
7898 out_err:
1b8ec87a 7899 nl80211_finish_wdev_dump(rdev);
61fa713c
HS		 7900 return res;
7901}
7902
b23aa676
SO		 7903static bool nl80211_valid_wpa_versions(u32 wpa_versions)
7904{
7905 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
7906 NL80211_WPA_VERSION_2));
7907}
7908
636a5d36
JM		 7909static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
7910{
4c476991
JB		 7911 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7912 struct net_device *dev = info->user_ptr[1];
19957bb3 7913 struct ieee80211_channel *chan;
11b6b5a4
JM		 7914 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
7915 int err, ssid_len, ie_len = 0, auth_data_len = 0;
19957bb3 7916 enum nl80211_auth_type auth_type;
fffd0934 7917 struct key_parse key;
d5cdfacb 7918 bool local_state_change;
636a5d36 7919
f4a11bb0
JB		 7920 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7921 return -EINVAL;
7922
7923 if (!info->attrs[NL80211_ATTR_MAC])
7924 return -EINVAL;
7925
1778092e
JM		 7926 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
7927 return -EINVAL;
7928
19957bb3
JB		 7929 if (!info->attrs[NL80211_ATTR_SSID])
7930 return -EINVAL;
7931
7932 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
7933 return -EINVAL;
7934
fffd0934
JB		 7935 err = nl80211_parse_key(info, &key);
7936 if (err)
7937 return err;
7938
7939 if (key.idx >= 0) {
e31b8213
JB		 7940 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
7941 return -EINVAL;
fffd0934
JB		 7942 if (!key.p.key || !key.p.key_len)
7943 return -EINVAL;
7944 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
7945 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
7946 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
7947 key.p.key_len != WLAN_KEY_LEN_WEP104))
7948 return -EINVAL;
b6b5555b 7949 if (key.idx > 3)
fffd0934
JB		 7950 return -EINVAL;
7951 } else {
7952 key.p.key_len = 0;
7953 key.p.key = NULL;
7954 }
7955
afea0b7a
JB		 7956 if (key.idx >= 0) {
7957 int i;
7958 bool ok = false;
7a087e74 7959
afea0b7a
JB		 7960 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
7961 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
7962 ok = true;
7963 break;
7964 }
7965 }
4c476991
JB		 7966 if (!ok)
7967 return -EINVAL;
afea0b7a
JB		 7968 }
7969
4c476991
JB		 7970 if (!rdev->ops->auth)
7971 return -EOPNOTSUPP;
636a5d36 7972
074ac8df 7973 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7974 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7975 return -EOPNOTSUPP;
eec60b03 7976
19957bb3 7977 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
664834de
JM		 7978 chan = nl80211_get_valid_chan(&rdev->wiphy,
7979 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
7980 if (!chan)
4c476991 7981 return -EINVAL;
636a5d36 7982
19957bb3
JB		 7983 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
7984 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 7985
7986 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 7987 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7988 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 7989 }
7990
19957bb3 7991 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e 7992 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
4c476991 7993 return -EINVAL;
636a5d36 7994
63181060
JM		 7995 if ((auth_type == NL80211_AUTHTYPE_SAE ||
7996 auth_type == NL80211_AUTHTYPE_FILS_SK ||
7997 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
7998 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
11b6b5a4 7999 !info->attrs[NL80211_ATTR_AUTH_DATA])
e39e5b5e
JM		 8000 return -EINVAL;
8001
11b6b5a4 8002 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
63181060
JM		 8003 if (auth_type != NL80211_AUTHTYPE_SAE &&
8004 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8005 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8006 auth_type != NL80211_AUTHTYPE_FILS_PK)
e39e5b5e 8007 return -EINVAL;
11b6b5a4
JM		 8008 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8009 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
e39e5b5e 8010 /* need to include at least Auth Transaction and Status Code */
11b6b5a4 8011 if (auth_data_len < 4)
e39e5b5e
JM		 8012 return -EINVAL;
8013 }
8014
d5cdfacb
JM		 8015 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8016
95de817b
JB		 8017 /*
8018 * Since we no longer track auth state, ignore
8019 * requests to only change local state.
8020 */
8021 if (local_state_change)
8022 return 0;
8023
91bf9b26
JB		 8024 wdev_lock(dev->ieee80211_ptr);
8025 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8026 ssid, ssid_len, ie, ie_len,
8027 key.p.key, key.p.key_len, key.idx,
11b6b5a4 8028 auth_data, auth_data_len);
91bf9b26
JB		 8029 wdev_unlock(dev->ieee80211_ptr);
8030 return err;
636a5d36
JM		 8031}
8032
c0692b8f
JB		 8033static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8034 struct genl_info *info,
3dc27d25
JB		 8035 struct cfg80211_crypto_settings *settings,
8036 int cipher_limit)
b23aa676 8037{
c0b2bbd8
JB		 8038 memset(settings, 0, sizeof(*settings));
8039
b23aa676
SO		 8040 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
8041
c0692b8f
JB		 8042 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
8043 u16 proto;
7a087e74 8044
c0692b8f
JB		 8045 proto = nla_get_u16(
8046 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
8047 settings->control_port_ethertype = cpu_to_be16(proto);
8048 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
8049 proto != ETH_P_PAE)
8050 return -EINVAL;
8051 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
8052 settings->control_port_no_encrypt = true;
8053 } else
8054 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
8055
b23aa676
SO		 8056 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
8057 void *data;
8058 int len, i;
8059
8060 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8061 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8062 settings->n_ciphers_pairwise = len / sizeof(u32);
8063
8064 if (len % sizeof(u32))
8065 return -EINVAL;
8066
3dc27d25 8067 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 8068 return -EINVAL;
8069
8070 memcpy(settings->ciphers_pairwise, data, len);
8071
8072 for (i = 0; i < settings->n_ciphers_pairwise; i++)
38ba3c57
JM		 8073 if (!cfg80211_supported_cipher_suite(
8074 &rdev->wiphy,
b23aa676
SO		 8075 settings->ciphers_pairwise[i]))
8076 return -EINVAL;
8077 }
8078
8079 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
8080 settings->cipher_group =
8081 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
38ba3c57
JM		 8082 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
8083 settings->cipher_group))
b23aa676
SO		 8084 return -EINVAL;
8085 }
8086
8087 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
8088 settings->wpa_versions =
8089 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
8090 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
8091 return -EINVAL;
8092 }
8093
8094 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
8095 void *data;
6d30240e 8096 int len;
b23aa676
SO		 8097
8098 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
8099 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
8100 settings->n_akm_suites = len / sizeof(u32);
8101
8102 if (len % sizeof(u32))
8103 return -EINVAL;
8104
1b9ca027
JM		 8105 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
8106 return -EINVAL;
8107
b23aa676 8108 memcpy(settings->akm_suites, data, len);
b23aa676
SO		 8109 }
8110
8111 return 0;
8112}
8113
636a5d36
JM		 8114static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
8115{
4c476991
JB		 8116 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8117 struct net_device *dev = info->user_ptr[1];
f444de05 8118 struct ieee80211_channel *chan;
f62fab73
JB		 8119 struct cfg80211_assoc_request req = {};
8120 const u8 *bssid, *ssid;
8121 int err, ssid_len = 0;
636a5d36 8122
f4a11bb0
JB		 8123 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8124 return -EINVAL;
8125
8126 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 8127 !info->attrs[NL80211_ATTR_SSID] ||
8128 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 8129 return -EINVAL;
8130
4c476991
JB		 8131 if (!rdev->ops->assoc)
8132 return -EOPNOTSUPP;
636a5d36 8133
074ac8df 8134 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8135 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8136 return -EOPNOTSUPP;
eec60b03 8137
19957bb3 8138 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8139
664834de
JM		 8140 chan = nl80211_get_valid_chan(&rdev->wiphy,
8141 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8142 if (!chan)
4c476991 8143 return -EINVAL;
636a5d36 8144
19957bb3
JB		 8145 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8146 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 8147
8148 if (info->attrs[NL80211_ATTR_IE]) {
f62fab73
JB		 8149 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8150 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8151 }
8152
dc6382ce 8153 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 8154 enum nl80211_mfp mfp =
dc6382ce 8155 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 8156 if (mfp == NL80211_MFP_REQUIRED)
f62fab73 8157 req.use_mfp = true;
4c476991
JB		 8158 else if (mfp != NL80211_MFP_NO)
8159 return -EINVAL;
dc6382ce
JM		 8160 }
8161
3e5d7649 8162 if (info->attrs[NL80211_ATTR_PREV_BSSID])
f62fab73 8163 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3e5d7649 8164
7e7c8926 8165 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
f62fab73 8166 req.flags |= ASSOC_REQ_DISABLE_HT;
7e7c8926
BG		 8167
8168 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
f62fab73
JB		 8169 memcpy(&req.ht_capa_mask,
8170 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8171 sizeof(req.ht_capa_mask));
7e7c8926
BG		 8172
8173 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
f62fab73 8174 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7e7c8926 8175 return -EINVAL;
f62fab73
JB		 8176 memcpy(&req.ht_capa,
8177 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8178 sizeof(req.ht_capa));
7e7c8926
BG		 8179 }
8180
ee2aca34 8181 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
f62fab73 8182 req.flags |= ASSOC_REQ_DISABLE_VHT;
ee2aca34
JB		 8183
8184 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
f62fab73
JB		 8185 memcpy(&req.vht_capa_mask,
8186 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8187 sizeof(req.vht_capa_mask));
ee2aca34
JB		 8188
8189 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
f62fab73 8190 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
ee2aca34 8191 return -EINVAL;
f62fab73
JB		 8192 memcpy(&req.vht_capa,
8193 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8194 sizeof(req.vht_capa));
ee2aca34
JB		 8195 }
8196
bab5ab7d 8197 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8198 if (!((rdev->wiphy.features &
8199 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8200 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8201 !wiphy_ext_feature_isset(&rdev->wiphy,
8202 NL80211_EXT_FEATURE_RRM))
bab5ab7d
AK		 8203 return -EINVAL;
8204 req.flags |= ASSOC_REQ_USE_RRM;
8205 }
8206
348bd456
JM		 8207 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
8208 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
8209 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
8210 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
8211 return -EINVAL;
8212 req.fils_nonces =
8213 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
8214 }
8215
f62fab73 8216 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
91bf9b26
JB		 8217 if (!err) {
8218 wdev_lock(dev->ieee80211_ptr);
bd2522b1 8219
f62fab73
JB		 8220 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
8221 ssid, ssid_len, &req);
bd2522b1
AZ		 8222
8223 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8224 dev->ieee80211_ptr->conn_owner_nlportid =
8225 info->snd_portid;
8226 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8227 bssid, ETH_ALEN);
8228 }
8229
91bf9b26
JB		 8230 wdev_unlock(dev->ieee80211_ptr);
8231 }
636a5d36 8232
636a5d36
JM		 8233 return err;
8234}
8235
8236static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
8237{
4c476991
JB		 8238 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8239 struct net_device *dev = info->user_ptr[1];
19957bb3 8240 const u8 *ie = NULL, *bssid;
91bf9b26 8241 int ie_len = 0, err;
19957bb3 8242 u16 reason_code;
d5cdfacb 8243 bool local_state_change;
636a5d36 8244
f4a11bb0
JB		 8245 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8246 return -EINVAL;
8247
8248 if (!info->attrs[NL80211_ATTR_MAC])
8249 return -EINVAL;
8250
8251 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8252 return -EINVAL;
8253
4c476991
JB		 8254 if (!rdev->ops->deauth)
8255 return -EOPNOTSUPP;
636a5d36 8256
074ac8df 8257 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8258 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8259 return -EOPNOTSUPP;
eec60b03 8260
19957bb3 8261 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8262
19957bb3
JB		 8263 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8264 if (reason_code == 0) {
f4a11bb0 8265 /* Reason Code 0 is reserved */
4c476991 8266 return -EINVAL;
255e737e 8267 }
636a5d36
JM		 8268
8269 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8270 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8271 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8272 }
8273
d5cdfacb
JM		 8274 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8275
91bf9b26
JB		 8276 wdev_lock(dev->ieee80211_ptr);
8277 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
8278 local_state_change);
8279 wdev_unlock(dev->ieee80211_ptr);
8280 return err;
636a5d36
JM		 8281}
8282
8283static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
8284{
4c476991
JB		 8285 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8286 struct net_device *dev = info->user_ptr[1];
19957bb3 8287 const u8 *ie = NULL, *bssid;
91bf9b26 8288 int ie_len = 0, err;
19957bb3 8289 u16 reason_code;
d5cdfacb 8290 bool local_state_change;
636a5d36 8291
f4a11bb0
JB		 8292 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8293 return -EINVAL;
8294
8295 if (!info->attrs[NL80211_ATTR_MAC])
8296 return -EINVAL;
8297
8298 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8299 return -EINVAL;
8300
4c476991
JB		 8301 if (!rdev->ops->disassoc)
8302 return -EOPNOTSUPP;
636a5d36 8303
074ac8df 8304 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8305 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8306 return -EOPNOTSUPP;
eec60b03 8307
19957bb3 8308 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 8309
19957bb3
JB		 8310 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8311 if (reason_code == 0) {
f4a11bb0 8312 /* Reason Code 0 is reserved */
4c476991 8313 return -EINVAL;
255e737e 8314 }
636a5d36
JM		 8315
8316 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 8317 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8318 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 8319 }
8320
d5cdfacb
JM		 8321 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8322
91bf9b26
JB		 8323 wdev_lock(dev->ieee80211_ptr);
8324 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
8325 local_state_change);
8326 wdev_unlock(dev->ieee80211_ptr);
8327 return err;
636a5d36
JM		 8328}
8329
dd5b4cc7
FF		 8330static bool
8331nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
57fbcce3 8332 int mcast_rate[NUM_NL80211_BANDS],
dd5b4cc7
FF		 8333 int rateval)
8334{
8335 struct wiphy *wiphy = &rdev->wiphy;
8336 bool found = false;
8337 int band, i;
8338
57fbcce3 8339 for (band = 0; band < NUM_NL80211_BANDS; band++) {
dd5b4cc7
FF		 8340 struct ieee80211_supported_band *sband;
8341
8342 sband = wiphy->bands[band];
8343 if (!sband)
8344 continue;
8345
8346 for (i = 0; i < sband->n_bitrates; i++) {
8347 if (sband->bitrates[i].bitrate == rateval) {
8348 mcast_rate[band] = i + 1;
8349 found = true;
8350 break;
8351 }
8352 }
8353 }
8354
8355 return found;
8356}
8357
04a773ad
JB		 8358static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
8359{
4c476991
JB		 8360 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8361 struct net_device *dev = info->user_ptr[1];
04a773ad
JB		 8362 struct cfg80211_ibss_params ibss;
8363 struct wiphy *wiphy;
fffd0934 8364 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 8365 int err;
8366
8e30bc55
JB		 8367 memset(&ibss, 0, sizeof(ibss));
8368
04a773ad
JB		 8369 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8370 return -EINVAL;
8371
683b6d3b 8372 if (!info->attrs[NL80211_ATTR_SSID] ||
04a773ad
JB		 8373 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8374 return -EINVAL;
8375
8e30bc55
JB		 8376 ibss.beacon_interval = 100;
8377
12d20fc9 8378 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
8e30bc55
JB		 8379 ibss.beacon_interval =
8380 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 8381
0c317a02
PK		 8382 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
8383 ibss.beacon_interval);
12d20fc9
PK		 8384 if (err)
8385 return err;
8e30bc55 8386
4c476991
JB		 8387 if (!rdev->ops->join_ibss)
8388 return -EOPNOTSUPP;
04a773ad 8389
4c476991
JB		 8390 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8391 return -EOPNOTSUPP;
04a773ad 8392
79c97e97 8393 wiphy = &rdev->wiphy;
04a773ad 8394
39193498 8395 if (info->attrs[NL80211_ATTR_MAC]) {
04a773ad 8396 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
39193498
JB		 8397
8398 if (!is_valid_ether_addr(ibss.bssid))
8399 return -EINVAL;
8400 }
04a773ad
JB		 8401 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8402 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8403
8404 if (info->attrs[NL80211_ATTR_IE]) {
8405 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8406 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8407 }
8408
683b6d3b
JB		 8409 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
8410 if (err)
8411 return err;
04a773ad 8412
174e0cd2
IP		 8413 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
8414 NL80211_IFTYPE_ADHOC))
54858ee5
AS		 8415 return -EINVAL;
8416
2f301ab2 8417 switch (ibss.chandef.width) {
bf372645
SW		 8418 case NL80211_CHAN_WIDTH_5:
8419 case NL80211_CHAN_WIDTH_10:
2f301ab2
SW		 8420 case NL80211_CHAN_WIDTH_20_NOHT:
8421 break;
8422 case NL80211_CHAN_WIDTH_20:
8423 case NL80211_CHAN_WIDTH_40:
ffc11991
JD		 8424 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8425 return -EINVAL;
8426 break;
8427 case NL80211_CHAN_WIDTH_80:
8428 case NL80211_CHAN_WIDTH_80P80:
8429 case NL80211_CHAN_WIDTH_160:
8430 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
8431 return -EINVAL;
8432 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8433 NL80211_EXT_FEATURE_VHT_IBSS))
8434 return -EINVAL;
8435 break;
2f301ab2 8436 default:
c04d6150 8437 return -EINVAL;
2f301ab2 8438 }
db9c64cf 8439
04a773ad 8440 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 8441 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
8442
fbd2c8dc
TP		 8443 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8444 u8 *rates =
8445 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8446 int n_rates =
8447 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8448 struct ieee80211_supported_band *sband =
683b6d3b 8449 wiphy->bands[ibss.chandef.chan->band];
fbd2c8dc 8450
34850ab2
JB		 8451 err = ieee80211_get_ratemask(sband, rates, n_rates,
8452 &ibss.basic_rates);
8453 if (err)
8454 return err;
fbd2c8dc 8455 }
dd5b4cc7 8456
803768f5
SW		 8457 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8458 memcpy(&ibss.ht_capa_mask,
8459 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8460 sizeof(ibss.ht_capa_mask));
8461
8462 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
8463 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8464 return -EINVAL;
8465 memcpy(&ibss.ht_capa,
8466 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8467 sizeof(ibss.ht_capa));
8468 }
8469
dd5b4cc7
FF		 8470 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8471 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
8472 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8473 return -EINVAL;
fbd2c8dc 8474
4c476991 8475 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
de7044ee
SM		 8476 bool no_ht = false;
8477
4c476991 8478 connkeys = nl80211_parse_connkeys(rdev,
de7044ee
SM		 8479 info->attrs[NL80211_ATTR_KEYS],
8480 &no_ht);
4c476991
JB		 8481 if (IS_ERR(connkeys))
8482 return PTR_ERR(connkeys);
de7044ee 8483
3d9d1d66
JB		 8484 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
8485 no_ht) {
5e950a78 8486 kzfree(connkeys);
de7044ee
SM		 8487 return -EINVAL;
8488 }
4c476991 8489 }
04a773ad 8490
267335d6
AQ		 8491 ibss.control_port =
8492 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
8493
5336fa88
SW		 8494 ibss.userspace_handles_dfs =
8495 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
8496
4c476991 8497 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
fffd0934 8498 if (err)
b47f610b 8499 kzfree(connkeys);
04a773ad
JB		 8500 return err;
8501}
8502
8503static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
8504{
4c476991
JB		 8505 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8506 struct net_device *dev = info->user_ptr[1];
04a773ad 8507
4c476991
JB		 8508 if (!rdev->ops->leave_ibss)
8509 return -EOPNOTSUPP;
04a773ad 8510
4c476991
JB		 8511 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
8512 return -EOPNOTSUPP;
04a773ad 8513
4c476991 8514 return cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 8515}
8516
f4e583c8
AQ		 8517static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
8518{
8519 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8520 struct net_device *dev = info->user_ptr[1];
57fbcce3 8521 int mcast_rate[NUM_NL80211_BANDS];
f4e583c8
AQ		 8522 u32 nla_rate;
8523 int err;
8524
8525 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
876dc930
BVB		 8526 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
8527 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
f4e583c8
AQ		 8528 return -EOPNOTSUPP;
8529
8530 if (!rdev->ops->set_mcast_rate)
8531 return -EOPNOTSUPP;
8532
8533 memset(mcast_rate, 0, sizeof(mcast_rate));
8534
8535 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
8536 return -EINVAL;
8537
8538 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
8539 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
8540 return -EINVAL;
8541
a1056b1b 8542 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
f4e583c8
AQ		 8543
8544 return err;
8545}
8546
ad7e718c
JB		 8547static struct sk_buff *
8548__cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
6c09e791
AK		 8549 struct wireless_dev *wdev, int approxlen,
8550 u32 portid, u32 seq, enum nl80211_commands cmd,
567ffc35
JB		 8551 enum nl80211_attrs attr,
8552 const struct nl80211_vendor_cmd_info *info,
8553 gfp_t gfp)
ad7e718c
JB		 8554{
8555 struct sk_buff *skb;
8556 void *hdr;
8557 struct nlattr *data;
8558
8559 skb = nlmsg_new(approxlen + 100, gfp);
8560 if (!skb)
8561 return NULL;
8562
8563 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
8564 if (!hdr) {
8565 kfree_skb(skb);
8566 return NULL;
8567 }
8568
8569 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
8570 goto nla_put_failure;
567ffc35
JB		 8571
8572 if (info) {
8573 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
8574 info->vendor_id))
8575 goto nla_put_failure;
8576 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
8577 info->subcmd))
8578 goto nla_put_failure;
8579 }
8580
6c09e791 8581 if (wdev) {
2dad624e
ND		 8582 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
8583 wdev_id(wdev), NL80211_ATTR_PAD))
6c09e791
AK		 8584 goto nla_put_failure;
8585 if (wdev->netdev &&
8586 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
8587 wdev->netdev->ifindex))
8588 goto nla_put_failure;
8589 }
8590
ad7e718c 8591 data = nla_nest_start(skb, attr);
76e1fb4b
JB		 8592 if (!data)
8593 goto nla_put_failure;
ad7e718c
JB		 8594
8595 ((void **)skb->cb)[0] = rdev;
8596 ((void **)skb->cb)[1] = hdr;
8597 ((void **)skb->cb)[2] = data;
8598
8599 return skb;
8600
8601 nla_put_failure:
8602 kfree_skb(skb);
8603 return NULL;
8604}
f4e583c8 8605
e03ad6ea 8606struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
6c09e791 8607 struct wireless_dev *wdev,
e03ad6ea
JB		 8608 enum nl80211_commands cmd,
8609 enum nl80211_attrs attr,
8610 int vendor_event_idx,
8611 int approxlen, gfp_t gfp)
8612{
f26cbf40 8613 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
e03ad6ea
JB		 8614 const struct nl80211_vendor_cmd_info *info;
8615
8616 switch (cmd) {
8617 case NL80211_CMD_TESTMODE:
8618 if (WARN_ON(vendor_event_idx != -1))
8619 return NULL;
8620 info = NULL;
8621 break;
8622 case NL80211_CMD_VENDOR:
8623 if (WARN_ON(vendor_event_idx < 0 ||
8624 vendor_event_idx >= wiphy->n_vendor_events))
8625 return NULL;
8626 info = &wiphy->vendor_events[vendor_event_idx];
8627 break;
8628 default:
8629 WARN_ON(1);
8630 return NULL;
8631 }
8632
6c09e791 8633 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, 0, 0,
e03ad6ea
JB		 8634 cmd, attr, info, gfp);
8635}
8636EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
8637
8638void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
8639{
8640 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
8641 void *hdr = ((void **)skb->cb)[1];
8642 struct nlattr *data = ((void **)skb->cb)[2];
8643 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
8644
bd8c78e7
JB		 8645 /* clear CB data for netlink core to own from now on */
8646 memset(skb->cb, 0, sizeof(skb->cb));
8647
e03ad6ea
JB		 8648 nla_nest_end(skb, data);
8649 genlmsg_end(skb, hdr);
8650
8651 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
8652 mcgrp = NL80211_MCGRP_VENDOR;
8653
8654 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
8655 mcgrp, gfp);
8656}
8657EXPORT_SYMBOL(__cfg80211_send_event_skb);
8658
aff89a9b 8659#ifdef CONFIG_NL80211_TESTMODE
aff89a9b
JB		 8660static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
8661{
4c476991 8662 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fc73f11f
DS		 8663 struct wireless_dev *wdev =
8664 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
aff89a9b
JB		 8665 int err;
8666
fc73f11f
DS		 8667 if (!rdev->ops->testmode_cmd)
8668 return -EOPNOTSUPP;
8669
8670 if (IS_ERR(wdev)) {
8671 err = PTR_ERR(wdev);
8672 if (err != -EINVAL)
8673 return err;
8674 wdev = NULL;
8675 } else if (wdev->wiphy != &rdev->wiphy) {
8676 return -EINVAL;
8677 }
8678
aff89a9b
JB		 8679 if (!info->attrs[NL80211_ATTR_TESTDATA])
8680 return -EINVAL;
8681
ad7e718c 8682 rdev->cur_cmd_info = info;
fc73f11f 8683 err = rdev_testmode_cmd(rdev, wdev,
aff89a9b
JB		 8684 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
8685 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
ad7e718c 8686 rdev->cur_cmd_info = NULL;
aff89a9b 8687
aff89a9b
JB		 8688 return err;
8689}
8690
71063f0e
WYG		 8691static int nl80211_testmode_dump(struct sk_buff *skb,
8692 struct netlink_callback *cb)
8693{
00918d33 8694 struct cfg80211_registered_device *rdev;
71063f0e
WYG		 8695 int err;
8696 long phy_idx;
8697 void *data = NULL;
8698 int data_len = 0;
8699
5fe231e8
JB		 8700 rtnl_lock();
8701
71063f0e
WYG		 8702 if (cb->args[0]) {
8703 /*
8704 * 0 is a valid index, but not valid for args[0],
8705 * so we need to offset by 1.
8706 */
8707 phy_idx = cb->args[0] - 1;
a4956dca
LC		 8708
8709 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
8710 if (!rdev) {
8711 err = -ENOENT;
8712 goto out_err;
8713 }
71063f0e 8714 } else {
c90c39da
JB		 8715 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
8716
71063f0e 8717 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da 8718 attrbuf, nl80211_fam.maxattr, nl80211_policy);
71063f0e 8719 if (err)
5fe231e8 8720 goto out_err;
00918d33 8721
c90c39da 8722 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
2bd7e35d 8723 if (IS_ERR(rdev)) {
5fe231e8
JB		 8724 err = PTR_ERR(rdev);
8725 goto out_err;
00918d33 8726 }
2bd7e35d 8727 phy_idx = rdev->wiphy_idx;
2bd7e35d 8728
c90c39da
JB		 8729 if (attrbuf[NL80211_ATTR_TESTDATA])
8730 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
71063f0e
WYG		 8731 }
8732
8733 if (cb->args[1]) {
8734 data = nla_data((void *)cb->args[1]);
8735 data_len = nla_len((void *)cb->args[1]);
8736 }
8737
00918d33 8738 if (!rdev->ops->testmode_dump) {
71063f0e
WYG		 8739 err = -EOPNOTSUPP;
8740 goto out_err;
8741 }
8742
8743 while (1) {
15e47304 8744 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
71063f0e
WYG		 8745 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8746 NL80211_CMD_TESTMODE);
8747 struct nlattr *tmdata;
8748
cb35fba3
DC		 8749 if (!hdr)
8750 break;
8751
9360ffd1 8752 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
71063f0e
WYG		 8753 genlmsg_cancel(skb, hdr);
8754 break;
8755 }
8756
8757 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
8758 if (!tmdata) {
8759 genlmsg_cancel(skb, hdr);
8760 break;
8761 }
e35e4d28 8762 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
71063f0e
WYG		 8763 nla_nest_end(skb, tmdata);
8764
8765 if (err == -ENOBUFS || err == -ENOENT) {
8766 genlmsg_cancel(skb, hdr);
8767 break;
8768 } else if (err) {
8769 genlmsg_cancel(skb, hdr);
8770 goto out_err;
8771 }
8772
8773 genlmsg_end(skb, hdr);
8774 }
8775
8776 err = skb->len;
8777 /* see above */
8778 cb->args[0] = phy_idx + 1;
8779 out_err:
5fe231e8 8780 rtnl_unlock();
71063f0e
WYG		 8781 return err;
8782}
aff89a9b
JB		 8783#endif
8784
b23aa676
SO		 8785static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
8786{
4c476991
JB		 8787 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8788 struct net_device *dev = info->user_ptr[1];
b23aa676
SO		 8789 struct cfg80211_connect_params connect;
8790 struct wiphy *wiphy;
fffd0934 8791 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 8792 int err;
8793
8794 memset(&connect, 0, sizeof(connect));
8795
8796 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8797 return -EINVAL;
8798
8799 if (!info->attrs[NL80211_ATTR_SSID] ||
8800 !nla_len(info->attrs[NL80211_ATTR_SSID]))
8801 return -EINVAL;
8802
8803 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
8804 connect.auth_type =
8805 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 8806 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
8807 NL80211_CMD_CONNECT))
b23aa676
SO		 8808 return -EINVAL;
8809 } else
8810 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
8811
8812 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
8813
c0692b8f 8814 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
3dc27d25 8815 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 8816 if (err)
8817 return err;
b23aa676 8818
074ac8df 8819 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8820 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8821 return -EOPNOTSUPP;
b23aa676 8822
79c97e97 8823 wiphy = &rdev->wiphy;
b23aa676 8824
4486ea98
BS		 8825 connect.bg_scan_period = -1;
8826 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
8827 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
8828 connect.bg_scan_period =
8829 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
8830 }
8831
b23aa676
SO		 8832 if (info->attrs[NL80211_ATTR_MAC])
8833 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1df4a510
JM		 8834 else if (info->attrs[NL80211_ATTR_MAC_HINT])
8835 connect.bssid_hint =
8836 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
b23aa676
SO		 8837 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8838 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8839
8840 if (info->attrs[NL80211_ATTR_IE]) {
8841 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8842 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8843 }
8844
cee00a95
JM		 8845 if (info->attrs[NL80211_ATTR_USE_MFP]) {
8846 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
8847 if (connect.mfp != NL80211_MFP_REQUIRED &&
8848 connect.mfp != NL80211_MFP_NO)
8849 return -EINVAL;
8850 } else {
8851 connect.mfp = NL80211_MFP_NO;
8852 }
8853
ba6fbacf
JM		 8854 if (info->attrs[NL80211_ATTR_PREV_BSSID])
8855 connect.prev_bssid =
8856 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
8857
b23aa676 8858 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
664834de
JM		 8859 connect.channel = nl80211_get_valid_chan(
8860 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8861 if (!connect.channel)
1df4a510
JM		 8862 return -EINVAL;
8863 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
664834de
JM		 8864 connect.channel_hint = nl80211_get_valid_chan(
8865 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
8866 if (!connect.channel_hint)
4c476991 8867 return -EINVAL;
b23aa676
SO		 8868 }
8869
fffd0934
JB		 8870 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
8871 connkeys = nl80211_parse_connkeys(rdev,
de7044ee 8872 info->attrs[NL80211_ATTR_KEYS], NULL);
4c476991
JB		 8873 if (IS_ERR(connkeys))
8874 return PTR_ERR(connkeys);
fffd0934
JB		 8875 }
8876
7e7c8926
BG		 8877 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
8878 connect.flags |= ASSOC_REQ_DISABLE_HT;
8879
8880 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8881 memcpy(&connect.ht_capa_mask,
8882 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8883 sizeof(connect.ht_capa_mask));
8884
8885 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
b4e4f47e 8886 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
b47f610b 8887 kzfree(connkeys);
7e7c8926 8888 return -EINVAL;
b4e4f47e 8889 }
7e7c8926
BG		 8890 memcpy(&connect.ht_capa,
8891 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8892 sizeof(connect.ht_capa));
8893 }
8894
ee2aca34
JB		 8895 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
8896 connect.flags |= ASSOC_REQ_DISABLE_VHT;
8897
8898 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
8899 memcpy(&connect.vht_capa_mask,
8900 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8901 sizeof(connect.vht_capa_mask));
8902
8903 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
8904 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
b47f610b 8905 kzfree(connkeys);
ee2aca34
JB		 8906 return -EINVAL;
8907 }
8908 memcpy(&connect.vht_capa,
8909 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8910 sizeof(connect.vht_capa));
8911 }
8912
bab5ab7d 8913 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
0c9ca11b
BL		 8914 if (!((rdev->wiphy.features &
8915 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8916 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8917 !wiphy_ext_feature_isset(&rdev->wiphy,
8918 NL80211_EXT_FEATURE_RRM)) {
707554b4 8919 kzfree(connkeys);
bab5ab7d 8920 return -EINVAL;
707554b4 8921 }
bab5ab7d
AK		 8922 connect.flags |= ASSOC_REQ_USE_RRM;
8923 }
8924
34d50519 8925 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
57fbcce3 8926 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
34d50519
LD		 8927 kzfree(connkeys);
8928 return -EOPNOTSUPP;
8929 }
8930
38de03d2
AS		 8931 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
8932 /* bss selection makes no sense if bssid is set */
8933 if (connect.bssid) {
8934 kzfree(connkeys);
8935 return -EINVAL;
8936 }
8937
8938 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
8939 wiphy, &connect.bss_select);
8940 if (err) {
8941 kzfree(connkeys);
8942 return err;
8943 }
8944 }
8945
a3caf744
VK		 8946 if (wiphy_ext_feature_isset(&rdev->wiphy,
8947 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
8948 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
8949 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
8950 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
8951 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
8952 connect.fils_erp_username =
8953 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
8954 connect.fils_erp_username_len =
8955 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
8956 connect.fils_erp_realm =
8957 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
8958 connect.fils_erp_realm_len =
8959 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
8960 connect.fils_erp_next_seq_num =
8961 nla_get_u16(
8962 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
8963 connect.fils_erp_rrk =
8964 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
8965 connect.fils_erp_rrk_len =
8966 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
8967 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
8968 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
8969 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
8970 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
8971 kzfree(connkeys);
8972 return -EINVAL;
8973 }
8974
83739b03 8975 wdev_lock(dev->ieee80211_ptr);
bd2522b1 8976
4ce2bd9c
JM		 8977 err = cfg80211_connect(rdev, dev, &connect, connkeys,
8978 connect.prev_bssid);
fffd0934 8979 if (err)
b47f610b 8980 kzfree(connkeys);
bd2522b1
AZ		 8981
8982 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8983 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
8984 if (connect.bssid)
8985 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8986 connect.bssid, ETH_ALEN);
8987 else
8988 memset(dev->ieee80211_ptr->disconnect_bssid,
8989 0, ETH_ALEN);
8990 }
8991
8992 wdev_unlock(dev->ieee80211_ptr);
8993
b23aa676
SO		 8994 return err;
8995}
8996
088e8df8 8997static int nl80211_update_connect_params(struct sk_buff *skb,
8998 struct genl_info *info)
8999{
9000 struct cfg80211_connect_params connect = {};
9001 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9002 struct net_device *dev = info->user_ptr[1];
9003 struct wireless_dev *wdev = dev->ieee80211_ptr;
9004 u32 changed = 0;
9005 int ret;
9006
9007 if (!rdev->ops->update_connect_params)
9008 return -EOPNOTSUPP;
9009
9010 if (info->attrs[NL80211_ATTR_IE]) {
9011 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9012 return -EINVAL;
9013 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9014 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9015 changed |= UPDATE_ASSOC_IES;
9016 }
9017
9018 wdev_lock(dev->ieee80211_ptr);
9019 if (!wdev->current_bss)
9020 ret = -ENOLINK;
9021 else
9022 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
9023 wdev_unlock(dev->ieee80211_ptr);
9024
9025 return ret;
9026}
9027
b23aa676
SO		 9028static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
9029{
4c476991
JB		 9030 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9031 struct net_device *dev = info->user_ptr[1];
b23aa676 9032 u16 reason;
83739b03 9033 int ret;
b23aa676
SO		 9034
9035 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9036 reason = WLAN_REASON_DEAUTH_LEAVING;
9037 else
9038 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9039
9040 if (reason == 0)
9041 return -EINVAL;
9042
074ac8df 9043 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9044 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9045 return -EOPNOTSUPP;
b23aa676 9046
83739b03
JB		 9047 wdev_lock(dev->ieee80211_ptr);
9048 ret = cfg80211_disconnect(rdev, dev, reason, true);
9049 wdev_unlock(dev->ieee80211_ptr);
9050 return ret;
b23aa676
SO		 9051}
9052
463d0183
JB		 9053static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
9054{
4c476991 9055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
463d0183
JB		 9056 struct net *net;
9057 int err;
463d0183 9058
4b681c82
VK		 9059 if (info->attrs[NL80211_ATTR_PID]) {
9060 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
9061
9062 net = get_net_ns_by_pid(pid);
9063 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
9064 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
463d0183 9065
4b681c82
VK		 9066 net = get_net_ns_by_fd(fd);
9067 } else {
9068 return -EINVAL;
9069 }
463d0183 9070
4c476991
JB		 9071 if (IS_ERR(net))
9072 return PTR_ERR(net);
463d0183
JB		 9073
9074 err = 0;
9075
9076 /* check if anything to do */
4c476991
JB		 9077 if (!net_eq(wiphy_net(&rdev->wiphy), net))
9078 err = cfg80211_switch_netns(rdev, net);
463d0183 9079
463d0183 9080 put_net(net);
463d0183
JB		 9081 return err;
9082}
9083
67fbb16b
SO		 9084static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
9085{
4c476991 9086 struct cfg80211_registered_device *rdev = info->user_ptr[0];
67fbb16b
SO		 9087 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
9088 struct cfg80211_pmksa *pmksa) = NULL;
4c476991 9089 struct net_device *dev = info->user_ptr[1];
67fbb16b
SO		 9090 struct cfg80211_pmksa pmksa;
9091
9092 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
9093
67fbb16b
SO		 9094 if (!info->attrs[NL80211_ATTR_PMKID])
9095 return -EINVAL;
9096
67fbb16b 9097 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
a3caf744
VK		 9098
9099 if (info->attrs[NL80211_ATTR_MAC]) {
9100 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9101 } else if (info->attrs[NL80211_ATTR_SSID] &&
9102 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
9103 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
9104 info->attrs[NL80211_ATTR_PMK])) {
9105 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9106 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9107 pmksa.cache_id =
9108 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
9109 } else {
9110 return -EINVAL;
9111 }
9112 if (info->attrs[NL80211_ATTR_PMK]) {
9113 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9114 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
9115 }
67fbb16b 9116
074ac8df 9117 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9118 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9119 return -EOPNOTSUPP;
67fbb16b
SO		 9120
9121 switch (info->genlhdr->cmd) {
9122 case NL80211_CMD_SET_PMKSA:
9123 rdev_ops = rdev->ops->set_pmksa;
9124 break;
9125 case NL80211_CMD_DEL_PMKSA:
9126 rdev_ops = rdev->ops->del_pmksa;
9127 break;
9128 default:
9129 WARN_ON(1);
9130 break;
9131 }
9132
4c476991
JB		 9133 if (!rdev_ops)
9134 return -EOPNOTSUPP;
67fbb16b 9135
4c476991 9136 return rdev_ops(&rdev->wiphy, dev, &pmksa);
67fbb16b
SO		 9137}
9138
9139static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
9140{
4c476991
JB		 9141 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9142 struct net_device *dev = info->user_ptr[1];
67fbb16b 9143
074ac8df 9144 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9145 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9146 return -EOPNOTSUPP;
67fbb16b 9147
4c476991
JB		 9148 if (!rdev->ops->flush_pmksa)
9149 return -EOPNOTSUPP;
67fbb16b 9150
e35e4d28 9151 return rdev_flush_pmksa(rdev, dev);
67fbb16b
SO		 9152}
9153
109086ce
AN		 9154static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
9155{
9156 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9157 struct net_device *dev = info->user_ptr[1];
9158 u8 action_code, dialog_token;
df942e7b 9159 u32 peer_capability = 0;
109086ce
AN		 9160 u16 status_code;
9161 u8 *peer;
31fa97c5 9162 bool initiator;
109086ce
AN		 9163
9164 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9165 !rdev->ops->tdls_mgmt)
9166 return -EOPNOTSUPP;
9167
9168 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
9169 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
9170 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
9171 !info->attrs[NL80211_ATTR_IE] ||
9172 !info->attrs[NL80211_ATTR_MAC])
9173 return -EINVAL;
9174
9175 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9176 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
9177 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
9178 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
31fa97c5 9179 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
df942e7b
SDU		 9180 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
9181 peer_capability =
9182 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
109086ce 9183
e35e4d28 9184 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
df942e7b 9185 dialog_token, status_code, peer_capability,
31fa97c5 9186 initiator,
e35e4d28
HG		 9187 nla_data(info->attrs[NL80211_ATTR_IE]),
9188 nla_len(info->attrs[NL80211_ATTR_IE]));
109086ce
AN		 9189}
9190
9191static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
9192{
9193 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9194 struct net_device *dev = info->user_ptr[1];
9195 enum nl80211_tdls_operation operation;
9196 u8 *peer;
9197
9198 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9199 !rdev->ops->tdls_oper)
9200 return -EOPNOTSUPP;
9201
9202 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
9203 !info->attrs[NL80211_ATTR_MAC])
9204 return -EINVAL;
9205
9206 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
9207 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9208
e35e4d28 9209 return rdev_tdls_oper(rdev, dev, peer, operation);
109086ce
AN		 9210}
9211
9588bbd5
JM		 9212static int nl80211_remain_on_channel(struct sk_buff *skb,
9213 struct genl_info *info)
9214{
4c476991 9215 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9216 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9217 struct cfg80211_chan_def chandef;
34373d12 9218 const struct cfg80211_chan_def *compat_chandef;
9588bbd5
JM		 9219 struct sk_buff *msg;
9220 void *hdr;
9221 u64 cookie;
683b6d3b 9222 u32 duration;
9588bbd5
JM		 9223 int err;
9224
9225 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9226 !info->attrs[NL80211_ATTR_DURATION])
9227 return -EINVAL;
9228
9229 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
9230
ebf348fc
JB		 9231 if (!rdev->ops->remain_on_channel ||
9232 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
9233 return -EOPNOTSUPP;
9234
9588bbd5 9235 /*
ebf348fc
JB		 9236 * We should be on that channel for at least a minimum amount of
9237 * time (10ms) but no longer than the driver supports.
9588bbd5 9238 */
ebf348fc 9239 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
a293911d 9240 duration > rdev->wiphy.max_remain_on_channel_duration)
9588bbd5
JM		 9241 return -EINVAL;
9242
683b6d3b
JB		 9243 err = nl80211_parse_chandef(rdev, info, &chandef);
9244 if (err)
9245 return err;
9588bbd5 9246
34373d12
VT		 9247 wdev_lock(wdev);
9248 if (!cfg80211_off_channel_oper_allowed(wdev) &&
9249 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
9250 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
9251 &chandef);
9252 if (compat_chandef != &chandef) {
9253 wdev_unlock(wdev);
9254 return -EBUSY;
9255 }
9256 }
9257 wdev_unlock(wdev);
9258
9588bbd5 9259 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9260 if (!msg)
9261 return -ENOMEM;
9588bbd5 9262
15e47304 9263 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9588bbd5 9264 NL80211_CMD_REMAIN_ON_CHANNEL);
cb35fba3
DC		 9265 if (!hdr) {
9266 err = -ENOBUFS;
9588bbd5
JM		 9267 goto free_msg;
9268 }
9269
683b6d3b
JB		 9270 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
9271 duration, &cookie);
9588bbd5
JM		 9272
9273 if (err)
9274 goto free_msg;
9275
2dad624e
ND		 9276 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9277 NL80211_ATTR_PAD))
9360ffd1 9278 goto nla_put_failure;
9588bbd5
JM		 9279
9280 genlmsg_end(msg, hdr);
4c476991
JB		 9281
9282 return genlmsg_reply(msg, info);
9588bbd5
JM		 9283
9284 nla_put_failure:
9285 err = -ENOBUFS;
9286 free_msg:
9287 nlmsg_free(msg);
9588bbd5
JM		 9288 return err;
9289}
9290
9291static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
9292 struct genl_info *info)
9293{
4c476991 9294 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9295 struct wireless_dev *wdev = info->user_ptr[1];
9588bbd5 9296 u64 cookie;
9588bbd5
JM		 9297
9298 if (!info->attrs[NL80211_ATTR_COOKIE])
9299 return -EINVAL;
9300
4c476991
JB		 9301 if (!rdev->ops->cancel_remain_on_channel)
9302 return -EOPNOTSUPP;
9588bbd5 9303
9588bbd5
JM		 9304 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9305
e35e4d28 9306 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
9588bbd5
JM		 9307}
9308
13ae75b1
JM		 9309static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
9310 struct genl_info *info)
9311{
13ae75b1 9312 struct cfg80211_bitrate_mask mask;
a7c7fbff 9313 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9314 struct net_device *dev = info->user_ptr[1];
a7c7fbff 9315 int err;
13ae75b1 9316
4c476991
JB		 9317 if (!rdev->ops->set_bitrate_mask)
9318 return -EOPNOTSUPP;
13ae75b1 9319
a7c7fbff
PK		 9320 err = nl80211_parse_tx_bitrate_mask(info, &mask);
9321 if (err)
9322 return err;
13ae75b1 9323
e35e4d28 9324 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
13ae75b1
JM		 9325}
9326
2e161f78 9327static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9328{
4c476991 9329 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9330 struct wireless_dev *wdev = info->user_ptr[1];
2e161f78 9331 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
026331c4
JM		 9332
9333 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
9334 return -EINVAL;
9335
2e161f78
JB		 9336 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
9337 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
026331c4 9338
71bbc994
JB		 9339 switch (wdev->iftype) {
9340 case NL80211_IFTYPE_STATION:
9341 case NL80211_IFTYPE_ADHOC:
9342 case NL80211_IFTYPE_P2P_CLIENT:
9343 case NL80211_IFTYPE_AP:
9344 case NL80211_IFTYPE_AP_VLAN:
9345 case NL80211_IFTYPE_MESH_POINT:
9346 case NL80211_IFTYPE_P2P_GO:
98104fde 9347 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9348 break;
cb3b7d87 9349 case NL80211_IFTYPE_NAN:
71bbc994 9350 default:
4c476991 9351 return -EOPNOTSUPP;
71bbc994 9352 }
026331c4
JM		 9353
9354 /* not much point in registering if we can't reply */
4c476991
JB		 9355 if (!rdev->ops->mgmt_tx)
9356 return -EOPNOTSUPP;
026331c4 9357
15e47304 9358 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
026331c4
JM		 9359 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
9360 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
026331c4
JM		 9361}
9362
2e161f78 9363static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 9364{
4c476991 9365 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9366 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 9367 struct cfg80211_chan_def chandef;
026331c4 9368 int err;
d64d373f 9369 void *hdr = NULL;
026331c4 9370 u64 cookie;
e247bd90 9371 struct sk_buff *msg = NULL;
b176e629
AO		 9372 struct cfg80211_mgmt_tx_params params = {
9373 .dont_wait_for_ack =
9374 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
9375 };
026331c4 9376
683b6d3b 9377 if (!info->attrs[NL80211_ATTR_FRAME])
026331c4
JM		 9378 return -EINVAL;
9379
4c476991
JB		 9380 if (!rdev->ops->mgmt_tx)
9381 return -EOPNOTSUPP;
026331c4 9382
71bbc994 9383 switch (wdev->iftype) {
ea141b75
AQ		 9384 case NL80211_IFTYPE_P2P_DEVICE:
9385 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9386 return -EINVAL;
71bbc994
JB		 9387 case NL80211_IFTYPE_STATION:
9388 case NL80211_IFTYPE_ADHOC:
9389 case NL80211_IFTYPE_P2P_CLIENT:
9390 case NL80211_IFTYPE_AP:
9391 case NL80211_IFTYPE_AP_VLAN:
9392 case NL80211_IFTYPE_MESH_POINT:
9393 case NL80211_IFTYPE_P2P_GO:
9394 break;
cb3b7d87 9395 case NL80211_IFTYPE_NAN:
71bbc994 9396 default:
4c476991 9397 return -EOPNOTSUPP;
71bbc994 9398 }
026331c4 9399
f7ca38df 9400 if (info->attrs[NL80211_ATTR_DURATION]) {
7c4ef712 9401 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
f7ca38df 9402 return -EINVAL;
b176e629 9403 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
ebf348fc
JB		 9404
9405 /*
9406 * We should wait on the channel for at least a minimum amount
9407 * of time (10ms) but no longer than the driver supports.
9408 */
b176e629
AO		 9409 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
9410 params.wait > rdev->wiphy.max_remain_on_channel_duration)
ebf348fc 9411 return -EINVAL;
f7ca38df
JB		 9412 }
9413
b176e629 9414 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
f7ca38df 9415
b176e629 9416 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7c4ef712
JB		 9417 return -EINVAL;
9418
b176e629 9419 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3 9420
ea141b75
AQ		 9421 /* get the channel if any has been specified, otherwise pass NULL to
9422 * the driver. The latter will use the current one
9423 */
9424 chandef.chan = NULL;
9425 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9426 err = nl80211_parse_chandef(rdev, info, &chandef);
9427 if (err)
9428 return err;
9429 }
9430
b176e629 9431 if (!chandef.chan && params.offchan)
ea141b75 9432 return -EINVAL;
026331c4 9433
34373d12
VT		 9434 wdev_lock(wdev);
9435 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
9436 wdev_unlock(wdev);
9437 return -EBUSY;
9438 }
9439 wdev_unlock(wdev);
9440
34d22ce2
AO		 9441 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
9442 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
9443
9444 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
9445 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9446 int i;
9447
9448 if (len % sizeof(u16))
9449 return -EINVAL;
9450
9451 params.n_csa_offsets = len / sizeof(u16);
9452 params.csa_offsets =
9453 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
9454
9455 /* check that all the offsets fit the frame */
9456 for (i = 0; i < params.n_csa_offsets; i++) {
9457 if (params.csa_offsets[i] >= params.len)
9458 return -EINVAL;
9459 }
9460 }
9461
b176e629 9462 if (!params.dont_wait_for_ack) {
e247bd90
JB		 9463 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9464 if (!msg)
9465 return -ENOMEM;
026331c4 9466
15e47304 9467 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
e247bd90 9468 NL80211_CMD_FRAME);
cb35fba3
DC		 9469 if (!hdr) {
9470 err = -ENOBUFS;
e247bd90
JB		 9471 goto free_msg;
9472 }
026331c4 9473 }
e247bd90 9474
b176e629
AO		 9475 params.chan = chandef.chan;
9476 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
026331c4
JM		 9477 if (err)
9478 goto free_msg;
9479
e247bd90 9480 if (msg) {
2dad624e
ND		 9481 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
9482 NL80211_ATTR_PAD))
9360ffd1 9483 goto nla_put_failure;
026331c4 9484
e247bd90
JB		 9485 genlmsg_end(msg, hdr);
9486 return genlmsg_reply(msg, info);
9487 }
9488
9489 return 0;
026331c4
JM		 9490
9491 nla_put_failure:
9492 err = -ENOBUFS;
9493 free_msg:
9494 nlmsg_free(msg);
026331c4
JM		 9495 return err;
9496}
9497
f7ca38df
JB		 9498static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
9499{
9500 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 9501 struct wireless_dev *wdev = info->user_ptr[1];
f7ca38df
JB		 9502 u64 cookie;
9503
9504 if (!info->attrs[NL80211_ATTR_COOKIE])
9505 return -EINVAL;
9506
9507 if (!rdev->ops->mgmt_tx_cancel_wait)
9508 return -EOPNOTSUPP;
9509
71bbc994
JB		 9510 switch (wdev->iftype) {
9511 case NL80211_IFTYPE_STATION:
9512 case NL80211_IFTYPE_ADHOC:
9513 case NL80211_IFTYPE_P2P_CLIENT:
9514 case NL80211_IFTYPE_AP:
9515 case NL80211_IFTYPE_AP_VLAN:
9516 case NL80211_IFTYPE_P2P_GO:
98104fde 9517 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994 9518 break;
cb3b7d87 9519 case NL80211_IFTYPE_NAN:
71bbc994 9520 default:
f7ca38df 9521 return -EOPNOTSUPP;
71bbc994 9522 }
f7ca38df
JB		 9523
9524 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9525
e35e4d28 9526 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
f7ca38df
JB		 9527}
9528
ffb9eb3d
KV		 9529static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
9530{
4c476991 9531 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d 9532 struct wireless_dev *wdev;
4c476991 9533 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9534 u8 ps_state;
9535 bool state;
9536 int err;
9537
4c476991
JB		 9538 if (!info->attrs[NL80211_ATTR_PS_STATE])
9539 return -EINVAL;
ffb9eb3d
KV		 9540
9541 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
9542
4c476991
JB		 9543 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
9544 return -EINVAL;
ffb9eb3d
KV		 9545
9546 wdev = dev->ieee80211_ptr;
9547
4c476991
JB		 9548 if (!rdev->ops->set_power_mgmt)
9549 return -EOPNOTSUPP;
ffb9eb3d
KV		 9550
9551 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
9552
9553 if (state == wdev->ps)
4c476991 9554 return 0;
ffb9eb3d 9555
e35e4d28 9556 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
4c476991
JB		 9557 if (!err)
9558 wdev->ps = state;
ffb9eb3d
KV		 9559 return err;
9560}
9561
9562static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
9563{
4c476991 9564 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d
KV		 9565 enum nl80211_ps_state ps_state;
9566 struct wireless_dev *wdev;
4c476991 9567 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 9568 struct sk_buff *msg;
9569 void *hdr;
9570 int err;
9571
ffb9eb3d
KV		 9572 wdev = dev->ieee80211_ptr;
9573
4c476991
JB		 9574 if (!rdev->ops->set_power_mgmt)
9575 return -EOPNOTSUPP;
ffb9eb3d
KV		 9576
9577 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 9578 if (!msg)
9579 return -ENOMEM;
ffb9eb3d 9580
15e47304 9581 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ffb9eb3d
KV		 9582 NL80211_CMD_GET_POWER_SAVE);
9583 if (!hdr) {
4c476991 9584 err = -ENOBUFS;
ffb9eb3d
KV		 9585 goto free_msg;
9586 }
9587
9588 if (wdev->ps)
9589 ps_state = NL80211_PS_ENABLED;
9590 else
9591 ps_state = NL80211_PS_DISABLED;
9592
9360ffd1
DM		 9593 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
9594 goto nla_put_failure;
ffb9eb3d
KV		 9595
9596 genlmsg_end(msg, hdr);
4c476991 9597 return genlmsg_reply(msg, info);
ffb9eb3d 9598
4c476991 9599 nla_put_failure:
ffb9eb3d 9600 err = -ENOBUFS;
4c476991 9601 free_msg:
ffb9eb3d 9602 nlmsg_free(msg);
ffb9eb3d
KV		 9603 return err;
9604}
9605
94e860f1
JB		 9606static const struct nla_policy
9607nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
4a4b8169 9608 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
d6dc1a38
JO		 9609 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
9610 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
84f10708
TP		 9611 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
9612 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
9613 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
bee427b8 9614 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
d6dc1a38
JO		 9615};
9616
84f10708 9617static int nl80211_set_cqm_txe(struct genl_info *info,
d9d8b019 9618 u32 rate, u32 pkts, u32 intvl)
84f10708
TP		 9619{
9620 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84f10708 9621 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9622 struct wireless_dev *wdev = dev->ieee80211_ptr;
84f10708 9623
d9d8b019 9624 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
84f10708
TP		 9625 return -EINVAL;
9626
84f10708
TP		 9627 if (!rdev->ops->set_cqm_txe_config)
9628 return -EOPNOTSUPP;
9629
9630 if (wdev->iftype != NL80211_IFTYPE_STATION &&
9631 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9632 return -EOPNOTSUPP;
9633
e35e4d28 9634 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
84f10708
TP		 9635}
9636
4a4b8169
AZ		 9637static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
9638 struct net_device *dev)
9639{
9640 struct wireless_dev *wdev = dev->ieee80211_ptr;
9641 s32 last, low, high;
9642 u32 hyst;
9643 int i, n;
9644 int err;
9645
9646 /* RSSI reporting disabled? */
9647 if (!wdev->cqm_config)
9648 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
9649
9650 /*
9651 * Obtain current RSSI value if possible, if not and no RSSI threshold
9652 * event has been received yet, we should receive an event after a
9653 * connection is established and enough beacons received to calculate
9654 * the average.
9655 */
9656 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
9657 rdev->ops->get_station) {
9658 struct station_info sinfo;
9659 u8 *mac_addr;
9660
9661 mac_addr = wdev->current_bss->pub.bssid;
9662
9663 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
9664 if (err)
9665 return err;
9666
9667 if (sinfo.filled & BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
9668 wdev->cqm_config->last_rssi_event_value =
9669 (s8) sinfo.rx_beacon_signal_avg;
9670 }
9671
9672 last = wdev->cqm_config->last_rssi_event_value;
9673 hyst = wdev->cqm_config->rssi_hyst;
9674 n = wdev->cqm_config->n_rssi_thresholds;
9675
9676 for (i = 0; i < n; i++)
9677 if (last < wdev->cqm_config->rssi_thresholds[i])
9678 break;
9679
9680 low = i > 0 ?
9681 (wdev->cqm_config->rssi_thresholds[i - 1] - hyst) : S32_MIN;
9682 high = i < n ?
9683 (wdev->cqm_config->rssi_thresholds[i] + hyst - 1) : S32_MAX;
9684
9685 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
9686}
9687
d6dc1a38 9688static int nl80211_set_cqm_rssi(struct genl_info *info,
4a4b8169
AZ		 9689 const s32 *thresholds, int n_thresholds,
9690 u32 hysteresis)
d6dc1a38 9691{
4c476991 9692 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 9693 struct net_device *dev = info->user_ptr[1];
1da5fcc8 9694 struct wireless_dev *wdev = dev->ieee80211_ptr;
4a4b8169
AZ		 9695 int i, err;
9696 s32 prev = S32_MIN;
d6dc1a38 9697
4a4b8169
AZ		 9698 /* Check all values negative and sorted */
9699 for (i = 0; i < n_thresholds; i++) {
9700 if (thresholds[i] > 0 || thresholds[i] <= prev)
9701 return -EINVAL;
d6dc1a38 9702
4a4b8169
AZ		 9703 prev = thresholds[i];
9704 }
d6dc1a38 9705
074ac8df 9706 if (wdev->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 9707 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
9708 return -EOPNOTSUPP;
d6dc1a38 9709
4a4b8169
AZ		 9710 wdev_lock(wdev);
9711 cfg80211_cqm_config_free(wdev);
9712 wdev_unlock(wdev);
9713
9714 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
9715 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
9716 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
9717
9718 return rdev_set_cqm_rssi_config(rdev, dev,
9719 thresholds[0], hysteresis);
9720 }
9721
9722 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9723 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
9724 return -EOPNOTSUPP;
9725
9726 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
9727 n_thresholds = 0;
9728
9729 wdev_lock(wdev);
9730 if (n_thresholds) {
9731 struct cfg80211_cqm_config *cqm_config;
9732
9733 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
9734 n_thresholds * sizeof(s32), GFP_KERNEL);
9735 if (!cqm_config) {
9736 err = -ENOMEM;
9737 goto unlock;
9738 }
9739
9740 cqm_config->rssi_hyst = hysteresis;
9741 cqm_config->n_rssi_thresholds = n_thresholds;
9742 memcpy(cqm_config->rssi_thresholds, thresholds,
9743 n_thresholds * sizeof(s32));
9744
9745 wdev->cqm_config = cqm_config;
9746 }
9747
9748 err = cfg80211_cqm_rssi_update(rdev, dev);
9749
9750unlock:
9751 wdev_unlock(wdev);
9752
9753 return err;
d6dc1a38
JO		 9754}
9755
9756static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
9757{
9758 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
9759 struct nlattr *cqm;
9760 int err;
9761
9762 cqm = info->attrs[NL80211_ATTR_CQM];
1da5fcc8
JB		 9763 if (!cqm)
9764 return -EINVAL;
d6dc1a38
JO		 9765
9766 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
9767 nl80211_attr_cqm_policy);
9768 if (err)
1da5fcc8 9769 return err;
d6dc1a38
JO		 9770
9771 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
9772 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
4a4b8169
AZ		 9773 const s32 *thresholds =
9774 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
9775 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
1da5fcc8 9776 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
d6dc1a38 9777
4a4b8169
AZ		 9778 if (len % 4)
9779 return -EINVAL;
9780
9781 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
9782 hysteresis);
1da5fcc8
JB		 9783 }
9784
9785 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
9786 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
9787 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
9788 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
9789 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
9790 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
9791
9792 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
9793 }
9794
9795 return -EINVAL;
d6dc1a38
JO		 9796}
9797
6e0bd6c3
RL		 9798static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
9799{
9800 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9801 struct net_device *dev = info->user_ptr[1];
9802 struct ocb_setup setup = {};
9803 int err;
9804
9805 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9806 if (err)
9807 return err;
9808
9809 return cfg80211_join_ocb(rdev, dev, &setup);
9810}
9811
9812static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
9813{
9814 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9815 struct net_device *dev = info->user_ptr[1];
9816
9817 return cfg80211_leave_ocb(rdev, dev);
9818}
9819
29cbe68c
JB		 9820static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
9821{
9822 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9823 struct net_device *dev = info->user_ptr[1];
9824 struct mesh_config cfg;
c80d545d 9825 struct mesh_setup setup;
29cbe68c
JB		 9826 int err;
9827
9828 /* start with default */
9829 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
c80d545d 9830 memcpy(&setup, &default_mesh_setup, sizeof(setup));
29cbe68c 9831
24bdd9f4 9832 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
29cbe68c 9833 /* and parse parameters if given */
24bdd9f4 9834 err = nl80211_parse_mesh_config(info, &cfg, NULL);
29cbe68c
JB		 9835 if (err)
9836 return err;
9837 }
9838
9839 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
9840 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
9841 return -EINVAL;
9842
c80d545d
JC		 9843 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
9844 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
9845
4bb62344
CYY		 9846 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9847 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
9848 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9849 return -EINVAL;
9850
9bdbf04d
MP		 9851 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
9852 setup.beacon_interval =
9853 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12d20fc9 9854
0c317a02
PK		 9855 err = cfg80211_validate_beacon_int(rdev,
9856 NL80211_IFTYPE_MESH_POINT,
9857 setup.beacon_interval);
12d20fc9
PK		 9858 if (err)
9859 return err;
9bdbf04d
MP		 9860 }
9861
9862 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
9863 setup.dtim_period =
9864 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
9865 if (setup.dtim_period < 1 || setup.dtim_period > 100)
9866 return -EINVAL;
9867 }
9868
c80d545d
JC		 9869 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
9870 /* parse additional setup parameters if given */
9871 err = nl80211_parse_mesh_setup(info, &setup);
9872 if (err)
9873 return err;
9874 }
9875
d37bb18a
TP		 9876 if (setup.user_mpm)
9877 cfg.auto_open_plinks = false;
9878
cc1d2806 9879 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 9880 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
9881 if (err)
9882 return err;
cc1d2806
JB		 9883 } else {
9884 /* cfg80211_join_mesh() will sort it out */
683b6d3b 9885 setup.chandef.chan = NULL;
cc1d2806
JB		 9886 }
9887
ffb3cf30
AN		 9888 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9889 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9890 int n_rates =
9891 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9892 struct ieee80211_supported_band *sband;
9893
9894 if (!setup.chandef.chan)
9895 return -EINVAL;
9896
9897 sband = rdev->wiphy.bands[setup.chandef.chan->band];
9898
9899 err = ieee80211_get_ratemask(sband, rates, n_rates,
9900 &setup.basic_rates);
9901 if (err)
9902 return err;
9903 }
9904
8564e382
JB		 9905 if (info->attrs[NL80211_ATTR_TX_RATES]) {
9906 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
9907 if (err)
9908 return err;
9909
9910 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
9911 &setup.beacon_rate);
9912 if (err)
9913 return err;
9914 }
9915
c80d545d 9916 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
29cbe68c
JB		 9917}
9918
9919static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
9920{
9921 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9922 struct net_device *dev = info->user_ptr[1];
9923
9924 return cfg80211_leave_mesh(rdev, dev);
9925}
9926
dfb89c56 9927#ifdef CONFIG_PM
bb92d199
AK		 9928static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
9929 struct cfg80211_registered_device *rdev)
9930{
6abb9cb9 9931 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
bb92d199
AK		 9932 struct nlattr *nl_pats, *nl_pat;
9933 int i, pat_len;
9934
6abb9cb9 9935 if (!wowlan->n_patterns)
bb92d199
AK		 9936 return 0;
9937
9938 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
9939 if (!nl_pats)
9940 return -ENOBUFS;
9941
6abb9cb9 9942 for (i = 0; i < wowlan->n_patterns; i++) {
bb92d199
AK		 9943 nl_pat = nla_nest_start(msg, i + 1);
9944 if (!nl_pat)
9945 return -ENOBUFS;
6abb9cb9 9946 pat_len = wowlan->patterns[i].pattern_len;
50ac6607 9947 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
6abb9cb9 9948 wowlan->patterns[i].mask) ||
50ac6607
AK		 9949 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
9950 wowlan->patterns[i].pattern) ||
9951 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
6abb9cb9 9952 wowlan->patterns[i].pkt_offset))
bb92d199
AK		 9953 return -ENOBUFS;
9954 nla_nest_end(msg, nl_pat);
9955 }
9956 nla_nest_end(msg, nl_pats);
9957
9958 return 0;
9959}
9960
2a0e047e
JB		 9961static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
9962 struct cfg80211_wowlan_tcp *tcp)
9963{
9964 struct nlattr *nl_tcp;
9965
9966 if (!tcp)
9967 return 0;
9968
9969 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
9970 if (!nl_tcp)
9971 return -ENOBUFS;
9972
930345ea
JB		 9973 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
9974 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
2a0e047e
JB		 9975 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
9976 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
9977 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
9978 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
9979 tcp->payload_len, tcp->payload) ||
9980 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
9981 tcp->data_interval) ||
9982 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
9983 tcp->wake_len, tcp->wake_data) ||
9984 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
9985 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
9986 return -ENOBUFS;
9987
9988 if (tcp->payload_seq.len &&
9989 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
9990 sizeof(tcp->payload_seq), &tcp->payload_seq))
9991 return -ENOBUFS;
9992
9993 if (tcp->payload_tok.len &&
9994 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
9995 sizeof(tcp->payload_tok) + tcp->tokens_size,
9996 &tcp->payload_tok))
9997 return -ENOBUFS;
9998
e248ad30
JB		 9999 nla_nest_end(msg, nl_tcp);
10000
2a0e047e
JB		 10001 return 0;
10002}
10003
75453ccb
LC		 10004static int nl80211_send_wowlan_nd(struct sk_buff *msg,
10005 struct cfg80211_sched_scan_request *req)
10006{
3b06d277 10007 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
75453ccb
LC		 10008 int i;
10009
10010 if (!req)
10011 return 0;
10012
10013 nd = nla_nest_start(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
10014 if (!nd)
10015 return -ENOBUFS;
10016
3b06d277
AS		 10017 if (req->n_scan_plans == 1 &&
10018 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
10019 req->scan_plans[0].interval * 1000))
75453ccb
LC		 10020 return -ENOBUFS;
10021
21fea567
LC		 10022 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
10023 return -ENOBUFS;
10024
bf95ecdb 10025 if (req->relative_rssi_set) {
10026 struct nl80211_bss_select_rssi_adjust rssi_adjust;
10027
10028 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
10029 req->relative_rssi))
10030 return -ENOBUFS;
10031
10032 rssi_adjust.band = req->rssi_adjust.band;
10033 rssi_adjust.delta = req->rssi_adjust.delta;
10034 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
10035 sizeof(rssi_adjust), &rssi_adjust))
10036 return -ENOBUFS;
10037 }
10038
75453ccb
LC		 10039 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10040 if (!freqs)
10041 return -ENOBUFS;
10042
53b18980
JB		 10043 for (i = 0; i < req->n_channels; i++) {
10044 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10045 return -ENOBUFS;
10046 }
75453ccb
LC		 10047
10048 nla_nest_end(msg, freqs);
10049
10050 if (req->n_match_sets) {
10051 matches = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
76e1fb4b
JB		 10052 if (!matches)
10053 return -ENOBUFS;
10054
75453ccb
LC		 10055 for (i = 0; i < req->n_match_sets; i++) {
10056 match = nla_nest_start(msg, i);
76e1fb4b
JB		 10057 if (!match)
10058 return -ENOBUFS;
10059
53b18980
JB		 10060 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
10061 req->match_sets[i].ssid.ssid_len,
10062 req->match_sets[i].ssid.ssid))
10063 return -ENOBUFS;
75453ccb
LC		 10064 nla_nest_end(msg, match);
10065 }
10066 nla_nest_end(msg, matches);
10067 }
10068
3b06d277
AS		 10069 scan_plans = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
10070 if (!scan_plans)
10071 return -ENOBUFS;
10072
10073 for (i = 0; i < req->n_scan_plans; i++) {
10074 scan_plan = nla_nest_start(msg, i + 1);
76e1fb4b
JB		 10075 if (!scan_plan)
10076 return -ENOBUFS;
10077
3b06d277
AS		 10078 if (!scan_plan ||
10079 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
10080 req->scan_plans[i].interval) ||
10081 (req->scan_plans[i].iterations &&
10082 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
10083 req->scan_plans[i].iterations)))
10084 return -ENOBUFS;
10085 nla_nest_end(msg, scan_plan);
10086 }
10087 nla_nest_end(msg, scan_plans);
10088
75453ccb
LC		 10089 nla_nest_end(msg, nd);
10090
10091 return 0;
10092}
10093
ff1b6e69
JB		 10094static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
10095{
10096 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10097 struct sk_buff *msg;
10098 void *hdr;
2a0e047e 10099 u32 size = NLMSG_DEFAULT_SIZE;
ff1b6e69 10100
964dc9e2 10101 if (!rdev->wiphy.wowlan)
ff1b6e69
JB		 10102 return -EOPNOTSUPP;
10103
6abb9cb9 10104 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
2a0e047e 10105 /* adjust size to have room for all the data */
6abb9cb9
JB		 10106 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
10107 rdev->wiphy.wowlan_config->tcp->payload_len +
10108 rdev->wiphy.wowlan_config->tcp->wake_len +
10109 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
2a0e047e
JB		 10110 }
10111
10112 msg = nlmsg_new(size, GFP_KERNEL);
ff1b6e69
JB		 10113 if (!msg)
10114 return -ENOMEM;
10115
15e47304 10116 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ff1b6e69
JB		 10117 NL80211_CMD_GET_WOWLAN);
10118 if (!hdr)
10119 goto nla_put_failure;
10120
6abb9cb9 10121 if (rdev->wiphy.wowlan_config) {
ff1b6e69
JB		 10122 struct nlattr *nl_wowlan;
10123
10124 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10125 if (!nl_wowlan)
10126 goto nla_put_failure;
10127
6abb9cb9 10128 if ((rdev->wiphy.wowlan_config->any &&
9360ffd1 10129 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6abb9cb9 10130 (rdev->wiphy.wowlan_config->disconnect &&
9360ffd1 10131 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6abb9cb9 10132 (rdev->wiphy.wowlan_config->magic_pkt &&
9360ffd1 10133 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6abb9cb9 10134 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
9360ffd1 10135 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6abb9cb9 10136 (rdev->wiphy.wowlan_config->eap_identity_req &&
9360ffd1 10137 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6abb9cb9 10138 (rdev->wiphy.wowlan_config->four_way_handshake &&
9360ffd1 10139 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6abb9cb9 10140 (rdev->wiphy.wowlan_config->rfkill_release &&
9360ffd1
DM		 10141 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
10142 goto nla_put_failure;
2a0e047e 10143
bb92d199
AK		 10144 if (nl80211_send_wowlan_patterns(msg, rdev))
10145 goto nla_put_failure;
2a0e047e 10146
6abb9cb9
JB		 10147 if (nl80211_send_wowlan_tcp(msg,
10148 rdev->wiphy.wowlan_config->tcp))
2a0e047e 10149 goto nla_put_failure;
75453ccb
LC		 10150
10151 if (nl80211_send_wowlan_nd(
10152 msg,
10153 rdev->wiphy.wowlan_config->nd_config))
10154 goto nla_put_failure;
2a0e047e 10155
ff1b6e69
JB		 10156 nla_nest_end(msg, nl_wowlan);
10157 }
10158
10159 genlmsg_end(msg, hdr);
10160 return genlmsg_reply(msg, info);
10161
10162nla_put_failure:
10163 nlmsg_free(msg);
10164 return -ENOBUFS;
10165}
10166
2a0e047e
JB		 10167static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
10168 struct nlattr *attr,
10169 struct cfg80211_wowlan *trig)
10170{
10171 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
10172 struct cfg80211_wowlan_tcp *cfg;
10173 struct nl80211_wowlan_tcp_data_token *tok = NULL;
10174 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
10175 u32 size;
10176 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
10177 int err, port;
10178
964dc9e2 10179 if (!rdev->wiphy.wowlan->tcp)
2a0e047e
JB		 10180 return -EINVAL;
10181
bfe2c7b1
JB		 10182 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TCP, attr,
10183 nl80211_wowlan_tcp_policy);
2a0e047e
JB		 10184 if (err)
10185 return err;
10186
10187 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
10188 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
10189 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
10190 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
10191 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
10192 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
10193 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
10194 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
10195 return -EINVAL;
10196
10197 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
964dc9e2 10198 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
2a0e047e
JB		 10199 return -EINVAL;
10200
10201 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
964dc9e2 10202 rdev->wiphy.wowlan->tcp->data_interval_max ||
723d568a 10203 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
2a0e047e
JB		 10204 return -EINVAL;
10205
10206 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
964dc9e2 10207 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
2a0e047e
JB		 10208 return -EINVAL;
10209
10210 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
10211 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
10212 return -EINVAL;
10213
10214 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
10215 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10216
10217 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10218 tokens_size = tokln - sizeof(*tok);
10219
10220 if (!tok->len || tokens_size % tok->len)
10221 return -EINVAL;
964dc9e2 10222 if (!rdev->wiphy.wowlan->tcp->tok)
2a0e047e 10223 return -EINVAL;
964dc9e2 10224 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
2a0e047e 10225 return -EINVAL;
964dc9e2 10226 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
2a0e047e 10227 return -EINVAL;
964dc9e2 10228 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
2a0e047e
JB		 10229 return -EINVAL;
10230 if (tok->offset + tok->len > data_size)
10231 return -EINVAL;
10232 }
10233
10234 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
10235 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
964dc9e2 10236 if (!rdev->wiphy.wowlan->tcp->seq)
2a0e047e
JB		 10237 return -EINVAL;
10238 if (seq->len == 0 || seq->len > 4)
10239 return -EINVAL;
10240 if (seq->len + seq->offset > data_size)
10241 return -EINVAL;
10242 }
10243
10244 size = sizeof(*cfg);
10245 size += data_size;
10246 size += wake_size + wake_mask_size;
10247 size += tokens_size;
10248
10249 cfg = kzalloc(size, GFP_KERNEL);
10250 if (!cfg)
10251 return -ENOMEM;
67b61f6c
JB		 10252 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
10253 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
2a0e047e
JB		 10254 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
10255 ETH_ALEN);
10256 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
10257 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
10258 else
10259 port = 0;
10260#ifdef CONFIG_INET
10261 /* allocate a socket and port for it and use it */
10262 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
10263 IPPROTO_TCP, &cfg->sock, 1);
10264 if (err) {
10265 kfree(cfg);
10266 return err;
10267 }
10268 if (inet_csk_get_port(cfg->sock->sk, port)) {
10269 sock_release(cfg->sock);
10270 kfree(cfg);
10271 return -EADDRINUSE;
10272 }
10273 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
10274#else
10275 if (!port) {
10276 kfree(cfg);
10277 return -EINVAL;
10278 }
10279 cfg->src_port = port;
10280#endif
10281
10282 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
10283 cfg->payload_len = data_size;
10284 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
10285 memcpy((void *)cfg->payload,
10286 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
10287 data_size);
10288 if (seq)
10289 cfg->payload_seq = *seq;
10290 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
10291 cfg->wake_len = wake_size;
10292 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
10293 memcpy((void *)cfg->wake_data,
10294 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
10295 wake_size);
10296 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
10297 data_size + wake_size;
10298 memcpy((void *)cfg->wake_mask,
10299 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
10300 wake_mask_size);
10301 if (tok) {
10302 cfg->tokens_size = tokens_size;
10303 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
10304 }
10305
10306 trig->tcp = cfg;
10307
10308 return 0;
10309}
10310
8cd4d456
LC		 10311static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
10312 const struct wiphy_wowlan_support *wowlan,
10313 struct nlattr *attr,
10314 struct cfg80211_wowlan *trig)
10315{
10316 struct nlattr **tb;
10317 int err;
10318
10319 tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL);
10320 if (!tb)
10321 return -ENOMEM;
10322
10323 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
10324 err = -EOPNOTSUPP;
10325 goto out;
10326 }
10327
bfe2c7b1 10328 err = nla_parse_nested(tb, NL80211_ATTR_MAX, attr, nl80211_policy);
8cd4d456
LC		 10329 if (err)
10330 goto out;
10331
aad1e812
AVS		 10332 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
10333 wowlan->max_nd_match_sets);
8cd4d456
LC		 10334 err = PTR_ERR_OR_ZERO(trig->nd_config);
10335 if (err)
10336 trig->nd_config = NULL;
10337
10338out:
10339 kfree(tb);
10340 return err;
10341}
10342
ff1b6e69
JB		 10343static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
10344{
10345 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10346 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
ff1b6e69 10347 struct cfg80211_wowlan new_triggers = {};
ae33bd81 10348 struct cfg80211_wowlan *ntrig;
964dc9e2 10349 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
ff1b6e69 10350 int err, i;
6abb9cb9 10351 bool prev_enabled = rdev->wiphy.wowlan_config;
98fc4386 10352 bool regular = false;
ff1b6e69 10353
964dc9e2 10354 if (!wowlan)
ff1b6e69
JB		 10355 return -EOPNOTSUPP;
10356
ae33bd81
JB		 10357 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
10358 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10359 rdev->wiphy.wowlan_config = NULL;
ae33bd81
JB		 10360 goto set_wakeup;
10361 }
ff1b6e69 10362
bfe2c7b1
JB		 10363 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
10364 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
10365 nl80211_wowlan_policy);
ff1b6e69
JB		 10366 if (err)
10367 return err;
10368
10369 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
10370 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
10371 return -EINVAL;
10372 new_triggers.any = true;
10373 }
10374
10375 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
10376 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
10377 return -EINVAL;
10378 new_triggers.disconnect = true;
98fc4386 10379 regular = true;
ff1b6e69
JB		 10380 }
10381
10382 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
10383 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
10384 return -EINVAL;
10385 new_triggers.magic_pkt = true;
98fc4386 10386 regular = true;
ff1b6e69
JB		 10387 }
10388
77dbbb13
JB		 10389 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
10390 return -EINVAL;
10391
10392 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
10393 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
10394 return -EINVAL;
10395 new_triggers.gtk_rekey_failure = true;
98fc4386 10396 regular = true;
77dbbb13
JB		 10397 }
10398
10399 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
10400 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
10401 return -EINVAL;
10402 new_triggers.eap_identity_req = true;
98fc4386 10403 regular = true;
77dbbb13
JB		 10404 }
10405
10406 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
10407 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
10408 return -EINVAL;
10409 new_triggers.four_way_handshake = true;
98fc4386 10410 regular = true;
77dbbb13
JB		 10411 }
10412
10413 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
10414 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
10415 return -EINVAL;
10416 new_triggers.rfkill_release = true;
98fc4386 10417 regular = true;
77dbbb13
JB		 10418 }
10419
ff1b6e69
JB		 10420 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
10421 struct nlattr *pat;
10422 int n_patterns = 0;
bb92d199 10423 int rem, pat_len, mask_len, pkt_offset;
50ac6607 10424 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
ff1b6e69 10425
98fc4386
JB		 10426 regular = true;
10427
ff1b6e69
JB		 10428 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10429 rem)
10430 n_patterns++;
10431 if (n_patterns > wowlan->n_patterns)
10432 return -EINVAL;
10433
10434 new_triggers.patterns = kcalloc(n_patterns,
10435 sizeof(new_triggers.patterns[0]),
10436 GFP_KERNEL);
10437 if (!new_triggers.patterns)
10438 return -ENOMEM;
10439
10440 new_triggers.n_patterns = n_patterns;
10441 i = 0;
10442
10443 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
10444 rem) {
922bd80f
JB		 10445 u8 *mask_pat;
10446
bfe2c7b1
JB		 10447 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
10448 NULL);
ff1b6e69 10449 err = -EINVAL;
50ac6607
AK		 10450 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10451 !pat_tb[NL80211_PKTPAT_PATTERN])
ff1b6e69 10452 goto error;
50ac6607 10453 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
ff1b6e69 10454 mask_len = DIV_ROUND_UP(pat_len, 8);
50ac6607 10455 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
ff1b6e69
JB		 10456 goto error;
10457 if (pat_len > wowlan->pattern_max_len ||
10458 pat_len < wowlan->pattern_min_len)
10459 goto error;
10460
50ac6607 10461 if (!pat_tb[NL80211_PKTPAT_OFFSET])
bb92d199
AK		 10462 pkt_offset = 0;
10463 else
10464 pkt_offset = nla_get_u32(
50ac6607 10465 pat_tb[NL80211_PKTPAT_OFFSET]);
bb92d199
AK		 10466 if (pkt_offset > wowlan->max_pkt_offset)
10467 goto error;
10468 new_triggers.patterns[i].pkt_offset = pkt_offset;
10469
922bd80f
JB		 10470 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10471 if (!mask_pat) {
ff1b6e69
JB		 10472 err = -ENOMEM;
10473 goto error;
10474 }
922bd80f
JB		 10475 new_triggers.patterns[i].mask = mask_pat;
10476 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
ff1b6e69 10477 mask_len);
922bd80f
JB		 10478 mask_pat += mask_len;
10479 new_triggers.patterns[i].pattern = mask_pat;
ff1b6e69 10480 new_triggers.patterns[i].pattern_len = pat_len;
922bd80f 10481 memcpy(mask_pat,
50ac6607 10482 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
ff1b6e69
JB		 10483 pat_len);
10484 i++;
10485 }
10486 }
10487
2a0e047e 10488 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
98fc4386 10489 regular = true;
2a0e047e
JB		 10490 err = nl80211_parse_wowlan_tcp(
10491 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
10492 &new_triggers);
10493 if (err)
10494 goto error;
10495 }
10496
8cd4d456 10497 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
98fc4386 10498 regular = true;
8cd4d456
LC		 10499 err = nl80211_parse_wowlan_nd(
10500 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
10501 &new_triggers);
10502 if (err)
10503 goto error;
10504 }
10505
98fc4386
JB		 10506 /* The 'any' trigger means the device continues operating more or less
10507 * as in its normal operation mode and wakes up the host on most of the
10508 * normal interrupts (like packet RX, ...)
10509 * It therefore makes little sense to combine with the more constrained
10510 * wakeup trigger modes.
10511 */
10512 if (new_triggers.any && regular) {
10513 err = -EINVAL;
10514 goto error;
10515 }
10516
ae33bd81
JB		 10517 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
10518 if (!ntrig) {
10519 err = -ENOMEM;
10520 goto error;
ff1b6e69 10521 }
ae33bd81 10522 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 10523 rdev->wiphy.wowlan_config = ntrig;
ff1b6e69 10524
ae33bd81 10525 set_wakeup:
6abb9cb9
JB		 10526 if (rdev->ops->set_wakeup &&
10527 prev_enabled != !!rdev->wiphy.wowlan_config)
10528 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
6d52563f 10529
ff1b6e69
JB		 10530 return 0;
10531 error:
10532 for (i = 0; i < new_triggers.n_patterns; i++)
10533 kfree(new_triggers.patterns[i].mask);
10534 kfree(new_triggers.patterns);
2a0e047e
JB		 10535 if (new_triggers.tcp && new_triggers.tcp->sock)
10536 sock_release(new_triggers.tcp->sock);
10537 kfree(new_triggers.tcp);
e5dbe070 10538 kfree(new_triggers.nd_config);
ff1b6e69
JB		 10539 return err;
10540}
dfb89c56 10541#endif
ff1b6e69 10542
be29b99a
AK		 10543static int nl80211_send_coalesce_rules(struct sk_buff *msg,
10544 struct cfg80211_registered_device *rdev)
10545{
10546 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
10547 int i, j, pat_len;
10548 struct cfg80211_coalesce_rules *rule;
10549
10550 if (!rdev->coalesce->n_rules)
10551 return 0;
10552
10553 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
10554 if (!nl_rules)
10555 return -ENOBUFS;
10556
10557 for (i = 0; i < rdev->coalesce->n_rules; i++) {
10558 nl_rule = nla_nest_start(msg, i + 1);
10559 if (!nl_rule)
10560 return -ENOBUFS;
10561
10562 rule = &rdev->coalesce->rules[i];
10563 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
10564 rule->delay))
10565 return -ENOBUFS;
10566
10567 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
10568 rule->condition))
10569 return -ENOBUFS;
10570
10571 nl_pats = nla_nest_start(msg,
10572 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
10573 if (!nl_pats)
10574 return -ENOBUFS;
10575
10576 for (j = 0; j < rule->n_patterns; j++) {
10577 nl_pat = nla_nest_start(msg, j + 1);
10578 if (!nl_pat)
10579 return -ENOBUFS;
10580 pat_len = rule->patterns[j].pattern_len;
10581 if (nla_put(msg, NL80211_PKTPAT_MASK,
10582 DIV_ROUND_UP(pat_len, 8),
10583 rule->patterns[j].mask) ||
10584 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10585 rule->patterns[j].pattern) ||
10586 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
10587 rule->patterns[j].pkt_offset))
10588 return -ENOBUFS;
10589 nla_nest_end(msg, nl_pat);
10590 }
10591 nla_nest_end(msg, nl_pats);
10592 nla_nest_end(msg, nl_rule);
10593 }
10594 nla_nest_end(msg, nl_rules);
10595
10596 return 0;
10597}
10598
10599static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
10600{
10601 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10602 struct sk_buff *msg;
10603 void *hdr;
10604
10605 if (!rdev->wiphy.coalesce)
10606 return -EOPNOTSUPP;
10607
10608 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10609 if (!msg)
10610 return -ENOMEM;
10611
10612 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10613 NL80211_CMD_GET_COALESCE);
10614 if (!hdr)
10615 goto nla_put_failure;
10616
10617 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
10618 goto nla_put_failure;
10619
10620 genlmsg_end(msg, hdr);
10621 return genlmsg_reply(msg, info);
10622
10623nla_put_failure:
10624 nlmsg_free(msg);
10625 return -ENOBUFS;
10626}
10627
10628void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
10629{
10630 struct cfg80211_coalesce *coalesce = rdev->coalesce;
10631 int i, j;
10632 struct cfg80211_coalesce_rules *rule;
10633
10634 if (!coalesce)
10635 return;
10636
10637 for (i = 0; i < coalesce->n_rules; i++) {
10638 rule = &coalesce->rules[i];
10639 for (j = 0; j < rule->n_patterns; j++)
10640 kfree(rule->patterns[j].mask);
10641 kfree(rule->patterns);
10642 }
10643 kfree(coalesce->rules);
10644 kfree(coalesce);
10645 rdev->coalesce = NULL;
10646}
10647
10648static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
10649 struct nlattr *rule,
10650 struct cfg80211_coalesce_rules *new_rule)
10651{
10652 int err, i;
10653 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10654 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
10655 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
10656 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
10657
bfe2c7b1
JB		 10658 err = nla_parse_nested(tb, NL80211_ATTR_COALESCE_RULE_MAX, rule,
10659 nl80211_coalesce_policy);
be29b99a
AK		 10660 if (err)
10661 return err;
10662
10663 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
10664 new_rule->delay =
10665 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
10666 if (new_rule->delay > coalesce->max_delay)
10667 return -EINVAL;
10668
10669 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
10670 new_rule->condition =
10671 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
10672 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
10673 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
10674 return -EINVAL;
10675
10676 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
10677 return -EINVAL;
10678
10679 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10680 rem)
10681 n_patterns++;
10682 if (n_patterns > coalesce->n_patterns)
10683 return -EINVAL;
10684
10685 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
10686 GFP_KERNEL);
10687 if (!new_rule->patterns)
10688 return -ENOMEM;
10689
10690 new_rule->n_patterns = n_patterns;
10691 i = 0;
10692
10693 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
10694 rem) {
922bd80f
JB		 10695 u8 *mask_pat;
10696
bfe2c7b1 10697 nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat, NULL);
be29b99a
AK		 10698 if (!pat_tb[NL80211_PKTPAT_MASK] ||
10699 !pat_tb[NL80211_PKTPAT_PATTERN])
10700 return -EINVAL;
10701 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
10702 mask_len = DIV_ROUND_UP(pat_len, 8);
10703 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
10704 return -EINVAL;
10705 if (pat_len > coalesce->pattern_max_len ||
10706 pat_len < coalesce->pattern_min_len)
10707 return -EINVAL;
10708
10709 if (!pat_tb[NL80211_PKTPAT_OFFSET])
10710 pkt_offset = 0;
10711 else
10712 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
10713 if (pkt_offset > coalesce->max_pkt_offset)
10714 return -EINVAL;
10715 new_rule->patterns[i].pkt_offset = pkt_offset;
10716
922bd80f
JB		 10717 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
10718 if (!mask_pat)
be29b99a 10719 return -ENOMEM;
922bd80f
JB		 10720
10721 new_rule->patterns[i].mask = mask_pat;
10722 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
10723 mask_len);
10724
10725 mask_pat += mask_len;
10726 new_rule->patterns[i].pattern = mask_pat;
be29b99a 10727 new_rule->patterns[i].pattern_len = pat_len;
922bd80f
JB		 10728 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
10729 pat_len);
be29b99a
AK		 10730 i++;
10731 }
10732
10733 return 0;
10734}
10735
10736static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
10737{
10738 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10739 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
10740 struct cfg80211_coalesce new_coalesce = {};
10741 struct cfg80211_coalesce *n_coalesce;
10742 int err, rem_rule, n_rules = 0, i, j;
10743 struct nlattr *rule;
10744 struct cfg80211_coalesce_rules *tmp_rule;
10745
10746 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
10747 return -EOPNOTSUPP;
10748
10749 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
10750 cfg80211_rdev_free_coalesce(rdev);
a1056b1b 10751 rdev_set_coalesce(rdev, NULL);
be29b99a
AK		 10752 return 0;
10753 }
10754
10755 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10756 rem_rule)
10757 n_rules++;
10758 if (n_rules > coalesce->n_rules)
10759 return -EINVAL;
10760
10761 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
10762 GFP_KERNEL);
10763 if (!new_coalesce.rules)
10764 return -ENOMEM;
10765
10766 new_coalesce.n_rules = n_rules;
10767 i = 0;
10768
10769 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
10770 rem_rule) {
10771 err = nl80211_parse_coalesce_rule(rdev, rule,
10772 &new_coalesce.rules[i]);
10773 if (err)
10774 goto error;
10775
10776 i++;
10777 }
10778
a1056b1b 10779 err = rdev_set_coalesce(rdev, &new_coalesce);
be29b99a
AK		 10780 if (err)
10781 goto error;
10782
10783 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
10784 if (!n_coalesce) {
10785 err = -ENOMEM;
10786 goto error;
10787 }
10788 cfg80211_rdev_free_coalesce(rdev);
10789 rdev->coalesce = n_coalesce;
10790
10791 return 0;
10792error:
10793 for (i = 0; i < new_coalesce.n_rules; i++) {
10794 tmp_rule = &new_coalesce.rules[i];
10795 for (j = 0; j < tmp_rule->n_patterns; j++)
10796 kfree(tmp_rule->patterns[j].mask);
10797 kfree(tmp_rule->patterns);
10798 }
10799 kfree(new_coalesce.rules);
10800
10801 return err;
10802}
10803
e5497d76
JB		 10804static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
10805{
10806 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10807 struct net_device *dev = info->user_ptr[1];
10808 struct wireless_dev *wdev = dev->ieee80211_ptr;
10809 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
10810 struct cfg80211_gtk_rekey_data rekey_data;
10811 int err;
10812
10813 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
10814 return -EINVAL;
10815
bfe2c7b1
JB		 10816 err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
10817 info->attrs[NL80211_ATTR_REKEY_DATA],
10818 nl80211_rekey_policy);
e5497d76
JB		 10819 if (err)
10820 return err;
10821
10822 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
10823 return -ERANGE;
10824 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
10825 return -ERANGE;
10826 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
10827 return -ERANGE;
10828
78f686ca
JB		 10829 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
10830 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
10831 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
e5497d76
JB		 10832
10833 wdev_lock(wdev);
10834 if (!wdev->current_bss) {
10835 err = -ENOTCONN;
10836 goto out;
10837 }
10838
10839 if (!rdev->ops->set_rekey_data) {
10840 err = -EOPNOTSUPP;
10841 goto out;
10842 }
10843
e35e4d28 10844 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
e5497d76
JB		 10845 out:
10846 wdev_unlock(wdev);
10847 return err;
10848}
10849
28946da7
JB		 10850static int nl80211_register_unexpected_frame(struct sk_buff *skb,
10851 struct genl_info *info)
10852{
10853 struct net_device *dev = info->user_ptr[1];
10854 struct wireless_dev *wdev = dev->ieee80211_ptr;
10855
10856 if (wdev->iftype != NL80211_IFTYPE_AP &&
10857 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10858 return -EINVAL;
10859
15e47304 10860 if (wdev->ap_unexpected_nlportid)
28946da7
JB		 10861 return -EBUSY;
10862
15e47304 10863 wdev->ap_unexpected_nlportid = info->snd_portid;
28946da7
JB		 10864 return 0;
10865}
10866
7f6cf311
JB		 10867static int nl80211_probe_client(struct sk_buff *skb,
10868 struct genl_info *info)
10869{
10870 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10871 struct net_device *dev = info->user_ptr[1];
10872 struct wireless_dev *wdev = dev->ieee80211_ptr;
10873 struct sk_buff *msg;
10874 void *hdr;
10875 const u8 *addr;
10876 u64 cookie;
10877 int err;
10878
10879 if (wdev->iftype != NL80211_IFTYPE_AP &&
10880 wdev->iftype != NL80211_IFTYPE_P2P_GO)
10881 return -EOPNOTSUPP;
10882
10883 if (!info->attrs[NL80211_ATTR_MAC])
10884 return -EINVAL;
10885
10886 if (!rdev->ops->probe_client)
10887 return -EOPNOTSUPP;
10888
10889 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10890 if (!msg)
10891 return -ENOMEM;
10892
15e47304 10893 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7f6cf311 10894 NL80211_CMD_PROBE_CLIENT);
cb35fba3
DC		 10895 if (!hdr) {
10896 err = -ENOBUFS;
7f6cf311
JB		 10897 goto free_msg;
10898 }
10899
10900 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
10901
e35e4d28 10902 err = rdev_probe_client(rdev, dev, addr, &cookie);
7f6cf311
JB		 10903 if (err)
10904 goto free_msg;
10905
2dad624e
ND		 10906 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10907 NL80211_ATTR_PAD))
9360ffd1 10908 goto nla_put_failure;
7f6cf311
JB		 10909
10910 genlmsg_end(msg, hdr);
10911
10912 return genlmsg_reply(msg, info);
10913
10914 nla_put_failure:
10915 err = -ENOBUFS;
10916 free_msg:
10917 nlmsg_free(msg);
10918 return err;
10919}
10920
5e760230
JB		 10921static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
10922{
10923 struct cfg80211_registered_device *rdev = info->user_ptr[0];
37c73b5f
BG		 10924 struct cfg80211_beacon_registration *reg, *nreg;
10925 int rv;
5e760230
JB		 10926
10927 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
10928 return -EOPNOTSUPP;
10929
37c73b5f
BG		 10930 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
10931 if (!nreg)
10932 return -ENOMEM;
10933
10934 /* First, check if already registered. */
10935 spin_lock_bh(&rdev->beacon_registrations_lock);
10936 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
10937 if (reg->nlportid == info->snd_portid) {
10938 rv = -EALREADY;
10939 goto out_err;
10940 }
10941 }
10942 /* Add it to the list */
10943 nreg->nlportid = info->snd_portid;
10944 list_add(&nreg->list, &rdev->beacon_registrations);
5e760230 10945
37c73b5f 10946 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 10947
10948 return 0;
37c73b5f
BG		 10949out_err:
10950 spin_unlock_bh(&rdev->beacon_registrations_lock);
10951 kfree(nreg);
10952 return rv;
5e760230
JB		 10953}
10954
98104fde
JB		 10955static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
10956{
10957 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10958 struct wireless_dev *wdev = info->user_ptr[1];
10959 int err;
10960
10961 if (!rdev->ops->start_p2p_device)
10962 return -EOPNOTSUPP;
10963
10964 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
10965 return -EOPNOTSUPP;
10966
73c7da3d 10967 if (wdev_running(wdev))
98104fde
JB		 10968 return 0;
10969
b6a55015
LC		 10970 if (rfkill_blocked(rdev->rfkill))
10971 return -ERFKILL;
98104fde 10972
eeb126e9 10973 err = rdev_start_p2p_device(rdev, wdev);
98104fde
JB		 10974 if (err)
10975 return err;
10976
73c7da3d 10977 wdev->is_running = true;
98104fde 10978 rdev->opencount++;
98104fde
JB		 10979
10980 return 0;
10981}
10982
10983static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
10984{
10985 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10986 struct wireless_dev *wdev = info->user_ptr[1];
10987
10988 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
10989 return -EOPNOTSUPP;
10990
10991 if (!rdev->ops->stop_p2p_device)
10992 return -EOPNOTSUPP;
10993
f9f47529 10994 cfg80211_stop_p2p_device(rdev, wdev);
98104fde
JB		 10995
10996 return 0;
10997}
10998
cb3b7d87
AB		 10999static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
11000{
11001 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11002 struct wireless_dev *wdev = info->user_ptr[1];
11003 struct cfg80211_nan_conf conf = {};
11004 int err;
11005
11006 if (wdev->iftype != NL80211_IFTYPE_NAN)
11007 return -EOPNOTSUPP;
11008
eeb04a96 11009 if (wdev_running(wdev))
cb3b7d87
AB		 11010 return -EEXIST;
11011
11012 if (rfkill_blocked(rdev->rfkill))
11013 return -ERFKILL;
11014
11015 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
11016 return -EINVAL;
11017
cb3b7d87
AB		 11018 conf.master_pref =
11019 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11020 if (!conf.master_pref)
11021 return -EINVAL;
11022
8585989d
LC		 11023 if (info->attrs[NL80211_ATTR_BANDS]) {
11024 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11025
11026 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11027 return -EOPNOTSUPP;
11028
11029 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11030 return -EINVAL;
11031
11032 conf.bands = bands;
11033 }
cb3b7d87
AB		 11034
11035 err = rdev_start_nan(rdev, wdev, &conf);
11036 if (err)
11037 return err;
11038
73c7da3d 11039 wdev->is_running = true;
cb3b7d87
AB		 11040 rdev->opencount++;
11041
11042 return 0;
11043}
11044
11045static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
11046{
11047 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11048 struct wireless_dev *wdev = info->user_ptr[1];
11049
11050 if (wdev->iftype != NL80211_IFTYPE_NAN)
11051 return -EOPNOTSUPP;
11052
11053 cfg80211_stop_nan(rdev, wdev);
11054
11055 return 0;
11056}
11057
a442b761
AB		 11058static int validate_nan_filter(struct nlattr *filter_attr)
11059{
11060 struct nlattr *attr;
11061 int len = 0, n_entries = 0, rem;
11062
11063 nla_for_each_nested(attr, filter_attr, rem) {
11064 len += nla_len(attr);
11065 n_entries++;
11066 }
11067
11068 if (len >= U8_MAX)
11069 return -EINVAL;
11070
11071 return n_entries;
11072}
11073
11074static int handle_nan_filter(struct nlattr *attr_filter,
11075 struct cfg80211_nan_func *func,
11076 bool tx)
11077{
11078 struct nlattr *attr;
11079 int n_entries, rem, i;
11080 struct cfg80211_nan_func_filter *filter;
11081
11082 n_entries = validate_nan_filter(attr_filter);
11083 if (n_entries < 0)
11084 return n_entries;
11085
11086 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
11087
11088 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
11089 if (!filter)
11090 return -ENOMEM;
11091
11092 i = 0;
11093 nla_for_each_nested(attr, attr_filter, rem) {
b15ca182 11094 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
a442b761
AB		 11095 filter[i].len = nla_len(attr);
11096 i++;
11097 }
11098 if (tx) {
11099 func->num_tx_filters = n_entries;
11100 func->tx_filters = filter;
11101 } else {
11102 func->num_rx_filters = n_entries;
11103 func->rx_filters = filter;
11104 }
11105
11106 return 0;
11107}
11108
11109static int nl80211_nan_add_func(struct sk_buff *skb,
11110 struct genl_info *info)
11111{
11112 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11113 struct wireless_dev *wdev = info->user_ptr[1];
11114 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
11115 struct cfg80211_nan_func *func;
11116 struct sk_buff *msg = NULL;
11117 void *hdr = NULL;
11118 int err = 0;
11119
11120 if (wdev->iftype != NL80211_IFTYPE_NAN)
11121 return -EOPNOTSUPP;
11122
73c7da3d 11123 if (!wdev_running(wdev))
a442b761
AB		 11124 return -ENOTCONN;
11125
11126 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
11127 return -EINVAL;
11128
11129 if (wdev->owner_nlportid &&
11130 wdev->owner_nlportid != info->snd_portid)
11131 return -ENOTCONN;
11132
bfe2c7b1
JB		 11133 err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
11134 info->attrs[NL80211_ATTR_NAN_FUNC],
11135 nl80211_nan_func_policy);
a442b761
AB		 11136 if (err)
11137 return err;
11138
11139 func = kzalloc(sizeof(*func), GFP_KERNEL);
11140 if (!func)
11141 return -ENOMEM;
11142
11143 func->cookie = wdev->wiphy->cookie_counter++;
11144
11145 if (!tb[NL80211_NAN_FUNC_TYPE] ||
11146 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
11147 err = -EINVAL;
11148 goto out;
11149 }
11150
11151
11152 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
11153
11154 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
11155 err = -EINVAL;
11156 goto out;
11157 }
11158
11159 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
11160 sizeof(func->service_id));
11161
11162 func->close_range =
11163 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
11164
11165 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
11166 func->serv_spec_info_len =
11167 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
11168 func->serv_spec_info =
11169 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
11170 func->serv_spec_info_len,
11171 GFP_KERNEL);
11172 if (!func->serv_spec_info) {
11173 err = -ENOMEM;
11174 goto out;
11175 }
11176 }
11177
11178 if (tb[NL80211_NAN_FUNC_TTL])
11179 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
11180
11181 switch (func->type) {
11182 case NL80211_NAN_FUNC_PUBLISH:
11183 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
11184 err = -EINVAL;
11185 goto out;
11186 }
11187
11188 func->publish_type =
11189 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
11190 func->publish_bcast =
11191 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
11192
11193 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
11194 func->publish_bcast) {
11195 err = -EINVAL;
11196 goto out;
11197 }
11198 break;
11199 case NL80211_NAN_FUNC_SUBSCRIBE:
11200 func->subscribe_active =
11201 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
11202 break;
11203 case NL80211_NAN_FUNC_FOLLOW_UP:
11204 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
11205 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]) {
11206 err = -EINVAL;
11207 goto out;
11208 }
11209
11210 func->followup_id =
11211 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
11212 func->followup_reqid =
11213 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
11214 memcpy(func->followup_dest.addr,
11215 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
11216 sizeof(func->followup_dest.addr));
11217 if (func->ttl) {
11218 err = -EINVAL;
11219 goto out;
11220 }
11221 break;
11222 default:
11223 err = -EINVAL;
11224 goto out;
11225 }
11226
11227 if (tb[NL80211_NAN_FUNC_SRF]) {
11228 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
11229
bfe2c7b1
JB		 11230 err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
11231 tb[NL80211_NAN_FUNC_SRF],
11232 nl80211_nan_srf_policy);
a442b761
AB		 11233 if (err)
11234 goto out;
11235
11236 func->srf_include =
11237 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
11238
11239 if (srf_tb[NL80211_NAN_SRF_BF]) {
11240 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
11241 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
11242 err = -EINVAL;
11243 goto out;
11244 }
11245
11246 func->srf_bf_len =
11247 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
11248 func->srf_bf =
11249 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
11250 func->srf_bf_len, GFP_KERNEL);
11251 if (!func->srf_bf) {
11252 err = -ENOMEM;
11253 goto out;
11254 }
11255
11256 func->srf_bf_idx =
11257 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
11258 } else {
11259 struct nlattr *attr, *mac_attr =
11260 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
11261 int n_entries, rem, i = 0;
11262
11263 if (!mac_attr) {
11264 err = -EINVAL;
11265 goto out;
11266 }
11267
11268 n_entries = validate_acl_mac_addrs(mac_attr);
11269 if (n_entries <= 0) {
11270 err = -EINVAL;
11271 goto out;
11272 }
11273
11274 func->srf_num_macs = n_entries;
11275 func->srf_macs =
11276 kzalloc(sizeof(*func->srf_macs) * n_entries,
11277 GFP_KERNEL);
11278 if (!func->srf_macs) {
11279 err = -ENOMEM;
11280 goto out;
11281 }
11282
11283 nla_for_each_nested(attr, mac_attr, rem)
11284 memcpy(func->srf_macs[i++].addr, nla_data(attr),
11285 sizeof(*func->srf_macs));
11286 }
11287 }
11288
11289 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
11290 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
11291 func, true);
11292 if (err)
11293 goto out;
11294 }
11295
11296 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
11297 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
11298 func, false);
11299 if (err)
11300 goto out;
11301 }
11302
11303 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11304 if (!msg) {
11305 err = -ENOMEM;
11306 goto out;
11307 }
11308
11309 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11310 NL80211_CMD_ADD_NAN_FUNCTION);
11311 /* This can't really happen - we just allocated 4KB */
11312 if (WARN_ON(!hdr)) {
11313 err = -ENOMEM;
11314 goto out;
11315 }
11316
11317 err = rdev_add_nan_func(rdev, wdev, func);
11318out:
11319 if (err < 0) {
11320 cfg80211_free_nan_func(func);
11321 nlmsg_free(msg);
11322 return err;
11323 }
11324
11325 /* propagate the instance id and cookie to userspace */
11326 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
11327 NL80211_ATTR_PAD))
11328 goto nla_put_failure;
11329
11330 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11331 if (!func_attr)
11332 goto nla_put_failure;
11333
11334 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
11335 func->instance_id))
11336 goto nla_put_failure;
11337
11338 nla_nest_end(msg, func_attr);
11339
11340 genlmsg_end(msg, hdr);
11341 return genlmsg_reply(msg, info);
11342
11343nla_put_failure:
11344 nlmsg_free(msg);
11345 return -ENOBUFS;
11346}
11347
11348static int nl80211_nan_del_func(struct sk_buff *skb,
11349 struct genl_info *info)
11350{
11351 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11352 struct wireless_dev *wdev = info->user_ptr[1];
11353 u64 cookie;
11354
11355 if (wdev->iftype != NL80211_IFTYPE_NAN)
11356 return -EOPNOTSUPP;
11357
73c7da3d 11358 if (!wdev_running(wdev))
a442b761
AB		 11359 return -ENOTCONN;
11360
11361 if (!info->attrs[NL80211_ATTR_COOKIE])
11362 return -EINVAL;
11363
11364 if (wdev->owner_nlportid &&
11365 wdev->owner_nlportid != info->snd_portid)
11366 return -ENOTCONN;
11367
11368 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11369
11370 rdev_del_nan_func(rdev, wdev, cookie);
11371
11372 return 0;
11373}
11374
a5a9dcf2
AB		 11375static int nl80211_nan_change_config(struct sk_buff *skb,
11376 struct genl_info *info)
11377{
11378 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11379 struct wireless_dev *wdev = info->user_ptr[1];
11380 struct cfg80211_nan_conf conf = {};
11381 u32 changed = 0;
11382
11383 if (wdev->iftype != NL80211_IFTYPE_NAN)
11384 return -EOPNOTSUPP;
11385
73c7da3d 11386 if (!wdev_running(wdev))
a5a9dcf2
AB		 11387 return -ENOTCONN;
11388
11389 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
11390 conf.master_pref =
11391 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11392 if (conf.master_pref <= 1 || conf.master_pref == 255)
11393 return -EINVAL;
11394
11395 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
11396 }
11397
8585989d
LC		 11398 if (info->attrs[NL80211_ATTR_BANDS]) {
11399 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11400
11401 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11402 return -EOPNOTSUPP;
11403
11404 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11405 return -EINVAL;
11406
11407 conf.bands = bands;
11408 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
a5a9dcf2
AB		 11409 }
11410
11411 if (!changed)
11412 return -EINVAL;
11413
11414 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
11415}
11416
50bcd31d
AB		 11417void cfg80211_nan_match(struct wireless_dev *wdev,
11418 struct cfg80211_nan_match_params *match, gfp_t gfp)
11419{
11420 struct wiphy *wiphy = wdev->wiphy;
11421 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11422 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
11423 struct sk_buff *msg;
11424 void *hdr;
11425
11426 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
11427 return;
11428
11429 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11430 if (!msg)
11431 return;
11432
11433 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
11434 if (!hdr) {
11435 nlmsg_free(msg);
11436 return;
11437 }
11438
11439 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11440 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11441 wdev->netdev->ifindex)) ||
11442 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11443 NL80211_ATTR_PAD))
11444 goto nla_put_failure;
11445
11446 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
11447 NL80211_ATTR_PAD) ||
11448 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
11449 goto nla_put_failure;
11450
11451 match_attr = nla_nest_start(msg, NL80211_ATTR_NAN_MATCH);
11452 if (!match_attr)
11453 goto nla_put_failure;
11454
11455 local_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_LOCAL);
11456 if (!local_func_attr)
11457 goto nla_put_failure;
11458
11459 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
11460 goto nla_put_failure;
11461
11462 nla_nest_end(msg, local_func_attr);
11463
11464 peer_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_PEER);
11465 if (!peer_func_attr)
11466 goto nla_put_failure;
11467
11468 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
11469 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
11470 goto nla_put_failure;
11471
11472 if (match->info && match->info_len &&
11473 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
11474 match->info))
11475 goto nla_put_failure;
11476
11477 nla_nest_end(msg, peer_func_attr);
11478 nla_nest_end(msg, match_attr);
11479 genlmsg_end(msg, hdr);
11480
11481 if (!wdev->owner_nlportid)
11482 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11483 msg, 0, NL80211_MCGRP_NAN, gfp);
11484 else
11485 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11486 wdev->owner_nlportid);
11487
11488 return;
11489
11490nla_put_failure:
11491 nlmsg_free(msg);
11492}
11493EXPORT_SYMBOL(cfg80211_nan_match);
11494
368e5a7b
AB		 11495void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
11496 u8 inst_id,
11497 enum nl80211_nan_func_term_reason reason,
11498 u64 cookie, gfp_t gfp)
11499{
11500 struct wiphy *wiphy = wdev->wiphy;
11501 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11502 struct sk_buff *msg;
11503 struct nlattr *func_attr;
11504 void *hdr;
11505
11506 if (WARN_ON(!inst_id))
11507 return;
11508
11509 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11510 if (!msg)
11511 return;
11512
11513 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
11514 if (!hdr) {
11515 nlmsg_free(msg);
11516 return;
11517 }
11518
11519 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11520 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11521 wdev->netdev->ifindex)) ||
11522 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
11523 NL80211_ATTR_PAD))
11524 goto nla_put_failure;
11525
11526 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11527 NL80211_ATTR_PAD))
11528 goto nla_put_failure;
11529
11530 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
11531 if (!func_attr)
11532 goto nla_put_failure;
11533
11534 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
11535 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
11536 goto nla_put_failure;
11537
11538 nla_nest_end(msg, func_attr);
11539 genlmsg_end(msg, hdr);
11540
11541 if (!wdev->owner_nlportid)
11542 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11543 msg, 0, NL80211_MCGRP_NAN, gfp);
11544 else
11545 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
11546 wdev->owner_nlportid);
11547
11548 return;
11549
11550nla_put_failure:
11551 nlmsg_free(msg);
11552}
11553EXPORT_SYMBOL(cfg80211_nan_func_terminated);
11554
3713b4e3
JB		 11555static int nl80211_get_protocol_features(struct sk_buff *skb,
11556 struct genl_info *info)
11557{
11558 void *hdr;
11559 struct sk_buff *msg;
11560
11561 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11562 if (!msg)
11563 return -ENOMEM;
11564
11565 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11566 NL80211_CMD_GET_PROTOCOL_FEATURES);
11567 if (!hdr)
11568 goto nla_put_failure;
11569
11570 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
11571 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
11572 goto nla_put_failure;
11573
11574 genlmsg_end(msg, hdr);
11575 return genlmsg_reply(msg, info);
11576
11577 nla_put_failure:
11578 kfree_skb(msg);
11579 return -ENOBUFS;
11580}
11581
355199e0
JM		 11582static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
11583{
11584 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11585 struct cfg80211_update_ft_ies_params ft_params;
11586 struct net_device *dev = info->user_ptr[1];
11587
11588 if (!rdev->ops->update_ft_ies)
11589 return -EOPNOTSUPP;
11590
11591 if (!info->attrs[NL80211_ATTR_MDID] ||
11592 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
11593 return -EINVAL;
11594
11595 memset(&ft_params, 0, sizeof(ft_params));
11596 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
11597 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11598 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11599
11600 return rdev_update_ft_ies(rdev, dev, &ft_params);
11601}
11602
5de17984
AS		 11603static int nl80211_crit_protocol_start(struct sk_buff *skb,
11604 struct genl_info *info)
11605{
11606 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11607 struct wireless_dev *wdev = info->user_ptr[1];
11608 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
11609 u16 duration;
11610 int ret;
11611
11612 if (!rdev->ops->crit_proto_start)
11613 return -EOPNOTSUPP;
11614
11615 if (WARN_ON(!rdev->ops->crit_proto_stop))
11616 return -EINVAL;
11617
11618 if (rdev->crit_proto_nlportid)
11619 return -EBUSY;
11620
11621 /* determine protocol if provided */
11622 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
11623 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
11624
11625 if (proto >= NUM_NL80211_CRIT_PROTO)
11626 return -EINVAL;
11627
11628 /* timeout must be provided */
11629 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
11630 return -EINVAL;
11631
11632 duration =
11633 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
11634
11635 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
11636 return -ERANGE;
11637
11638 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
11639 if (!ret)
11640 rdev->crit_proto_nlportid = info->snd_portid;
11641
11642 return ret;
11643}
11644
11645static int nl80211_crit_protocol_stop(struct sk_buff *skb,
11646 struct genl_info *info)
11647{
11648 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11649 struct wireless_dev *wdev = info->user_ptr[1];
11650
11651 if (!rdev->ops->crit_proto_stop)
11652 return -EOPNOTSUPP;
11653
11654 if (rdev->crit_proto_nlportid) {
11655 rdev->crit_proto_nlportid = 0;
11656 rdev_crit_proto_stop(rdev, wdev);
11657 }
11658 return 0;
11659}
11660
ad7e718c
JB		 11661static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
11662{
11663 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11664 struct wireless_dev *wdev =
11665 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
11666 int i, err;
11667 u32 vid, subcmd;
11668
11669 if (!rdev->wiphy.vendor_commands)
11670 return -EOPNOTSUPP;
11671
11672 if (IS_ERR(wdev)) {
11673 err = PTR_ERR(wdev);
11674 if (err != -EINVAL)
11675 return err;
11676 wdev = NULL;
11677 } else if (wdev->wiphy != &rdev->wiphy) {
11678 return -EINVAL;
11679 }
11680
11681 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
11682 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
11683 return -EINVAL;
11684
11685 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
11686 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
11687 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
11688 const struct wiphy_vendor_command *vcmd;
11689 void *data = NULL;
11690 int len = 0;
11691
11692 vcmd = &rdev->wiphy.vendor_commands[i];
11693
11694 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11695 continue;
11696
11697 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11698 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
11699 if (!wdev)
11700 return -EINVAL;
11701 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
11702 !wdev->netdev)
11703 return -EINVAL;
11704
11705 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
73c7da3d 11706 if (!wdev_running(wdev))
ad7e718c
JB		 11707 return -ENETDOWN;
11708 }
7bdbe400
JB		 11709
11710 if (!vcmd->doit)
11711 return -EOPNOTSUPP;
ad7e718c
JB		 11712 } else {
11713 wdev = NULL;
11714 }
11715
11716 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
11717 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11718 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
11719 }
11720
11721 rdev->cur_cmd_info = info;
11722 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
11723 data, len);
11724 rdev->cur_cmd_info = NULL;
11725 return err;
11726 }
11727
11728 return -EOPNOTSUPP;
11729}
11730
7bdbe400
JB		 11731static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
11732 struct netlink_callback *cb,
11733 struct cfg80211_registered_device **rdev,
11734 struct wireless_dev **wdev)
11735{
c90c39da 11736 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
7bdbe400
JB		 11737 u32 vid, subcmd;
11738 unsigned int i;
11739 int vcmd_idx = -1;
11740 int err;
11741 void *data = NULL;
11742 unsigned int data_len = 0;
11743
11744 rtnl_lock();
11745
11746 if (cb->args[0]) {
11747 /* subtract the 1 again here */
11748 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
11749 struct wireless_dev *tmp;
11750
11751 if (!wiphy) {
11752 err = -ENODEV;
11753 goto out_unlock;
11754 }
11755 *rdev = wiphy_to_rdev(wiphy);
11756 *wdev = NULL;
11757
11758 if (cb->args[1]) {
53873f13 11759 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
7bdbe400
JB		 11760 if (tmp->identifier == cb->args[1] - 1) {
11761 *wdev = tmp;
11762 break;
11763 }
11764 }
11765 }
11766
11767 /* keep rtnl locked in successful case */
11768 return 0;
11769 }
11770
11771 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
c90c39da 11772 attrbuf, nl80211_fam.maxattr, nl80211_policy);
7bdbe400
JB		 11773 if (err)
11774 goto out_unlock;
11775
c90c39da
JB		 11776 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
11777 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) {
7bdbe400
JB		 11778 err = -EINVAL;
11779 goto out_unlock;
11780 }
11781
c90c39da 11782 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
7bdbe400
JB		 11783 if (IS_ERR(*wdev))
11784 *wdev = NULL;
11785
c90c39da 11786 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
7bdbe400
JB		 11787 if (IS_ERR(*rdev)) {
11788 err = PTR_ERR(*rdev);
11789 goto out_unlock;
11790 }
11791
c90c39da
JB		 11792 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
11793 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
7bdbe400
JB		 11794
11795 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
11796 const struct wiphy_vendor_command *vcmd;
11797
11798 vcmd = &(*rdev)->wiphy.vendor_commands[i];
11799
11800 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
11801 continue;
11802
11803 if (!vcmd->dumpit) {
11804 err = -EOPNOTSUPP;
11805 goto out_unlock;
11806 }
11807
11808 vcmd_idx = i;
11809 break;
11810 }
11811
11812 if (vcmd_idx < 0) {
11813 err = -EOPNOTSUPP;
11814 goto out_unlock;
11815 }
11816
c90c39da
JB		 11817 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
11818 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
11819 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
7bdbe400
JB		 11820 }
11821
11822 /* 0 is the first index - add 1 to parse only once */
11823 cb->args[0] = (*rdev)->wiphy_idx + 1;
11824 /* add 1 to know if it was NULL */
11825 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
11826 cb->args[2] = vcmd_idx;
11827 cb->args[3] = (unsigned long)data;
11828 cb->args[4] = data_len;
11829
11830 /* keep rtnl locked in successful case */
11831 return 0;
11832 out_unlock:
11833 rtnl_unlock();
11834 return err;
11835}
11836
11837static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
11838 struct netlink_callback *cb)
11839{
11840 struct cfg80211_registered_device *rdev;
11841 struct wireless_dev *wdev;
11842 unsigned int vcmd_idx;
11843 const struct wiphy_vendor_command *vcmd;
11844 void *data;
11845 int data_len;
11846 int err;
11847 struct nlattr *vendor_data;
11848
11849 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
11850 if (err)
11851 return err;
11852
11853 vcmd_idx = cb->args[2];
11854 data = (void *)cb->args[3];
11855 data_len = cb->args[4];
11856 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
11857
11858 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
11859 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
11860 if (!wdev)
11861 return -EINVAL;
11862 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
11863 !wdev->netdev)
11864 return -EINVAL;
11865
11866 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
73c7da3d 11867 if (!wdev_running(wdev))
7bdbe400
JB		 11868 return -ENETDOWN;
11869 }
11870 }
11871
11872 while (1) {
11873 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
11874 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11875 NL80211_CMD_VENDOR);
11876 if (!hdr)
11877 break;
11878
11879 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 11880 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
11881 wdev_id(wdev),
11882 NL80211_ATTR_PAD))) {
7bdbe400
JB		 11883 genlmsg_cancel(skb, hdr);
11884 break;
11885 }
11886
11887 vendor_data = nla_nest_start(skb, NL80211_ATTR_VENDOR_DATA);
11888 if (!vendor_data) {
11889 genlmsg_cancel(skb, hdr);
11890 break;
11891 }
11892
11893 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
11894 (unsigned long *)&cb->args[5]);
11895 nla_nest_end(skb, vendor_data);
11896
11897 if (err == -ENOBUFS || err == -ENOENT) {
11898 genlmsg_cancel(skb, hdr);
11899 break;
11900 } else if (err) {
11901 genlmsg_cancel(skb, hdr);
11902 goto out;
11903 }
11904
11905 genlmsg_end(skb, hdr);
11906 }
11907
11908 err = skb->len;
11909 out:
11910 rtnl_unlock();
11911 return err;
11912}
11913
ad7e718c
JB		 11914struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
11915 enum nl80211_commands cmd,
11916 enum nl80211_attrs attr,
11917 int approxlen)
11918{
f26cbf40 11919 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ad7e718c
JB		 11920
11921 if (WARN_ON(!rdev->cur_cmd_info))
11922 return NULL;
11923
6c09e791 11924 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
ad7e718c
JB		 11925 rdev->cur_cmd_info->snd_portid,
11926 rdev->cur_cmd_info->snd_seq,
567ffc35 11927 cmd, attr, NULL, GFP_KERNEL);
ad7e718c
JB		 11928}
11929EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
11930
11931int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
11932{
11933 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
11934 void *hdr = ((void **)skb->cb)[1];
11935 struct nlattr *data = ((void **)skb->cb)[2];
11936
bd8c78e7
JB		 11937 /* clear CB data for netlink core to own from now on */
11938 memset(skb->cb, 0, sizeof(skb->cb));
11939
ad7e718c
JB		 11940 if (WARN_ON(!rdev->cur_cmd_info)) {
11941 kfree_skb(skb);
11942 return -EINVAL;
11943 }
11944
11945 nla_nest_end(skb, data);
11946 genlmsg_end(skb, hdr);
11947 return genlmsg_reply(skb, rdev->cur_cmd_info);
11948}
11949EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
11950
fa9ffc74
KP		 11951static int nl80211_set_qos_map(struct sk_buff *skb,
11952 struct genl_info *info)
11953{
11954 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11955 struct cfg80211_qos_map *qos_map = NULL;
11956 struct net_device *dev = info->user_ptr[1];
11957 u8 *pos, len, num_des, des_len, des;
11958 int ret;
11959
11960 if (!rdev->ops->set_qos_map)
11961 return -EOPNOTSUPP;
11962
11963 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
11964 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
11965 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
11966
11967 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
11968 len > IEEE80211_QOS_MAP_LEN_MAX)
11969 return -EINVAL;
11970
11971 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
11972 if (!qos_map)
11973 return -ENOMEM;
11974
11975 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
11976 if (num_des) {
11977 des_len = num_des *
11978 sizeof(struct cfg80211_dscp_exception);
11979 memcpy(qos_map->dscp_exception, pos, des_len);
11980 qos_map->num_des = num_des;
11981 for (des = 0; des < num_des; des++) {
11982 if (qos_map->dscp_exception[des].up > 7) {
11983 kfree(qos_map);
11984 return -EINVAL;
11985 }
11986 }
11987 pos += des_len;
11988 }
11989 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
11990 }
11991
11992 wdev_lock(dev->ieee80211_ptr);
11993 ret = nl80211_key_allowed(dev->ieee80211_ptr);
11994 if (!ret)
11995 ret = rdev_set_qos_map(rdev, dev, qos_map);
11996 wdev_unlock(dev->ieee80211_ptr);
11997
11998 kfree(qos_map);
11999 return ret;
12000}
12001
960d01ac
JB		 12002static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
12003{
12004 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12005 struct net_device *dev = info->user_ptr[1];
12006 struct wireless_dev *wdev = dev->ieee80211_ptr;
12007 const u8 *peer;
12008 u8 tsid, up;
12009 u16 admitted_time = 0;
12010 int err;
12011
723e73ac 12012 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
960d01ac
JB		 12013 return -EOPNOTSUPP;
12014
12015 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
12016 !info->attrs[NL80211_ATTR_USER_PRIO])
12017 return -EINVAL;
12018
12019 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12020 if (tsid >= IEEE80211_NUM_TIDS)
12021 return -EINVAL;
12022
12023 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
12024 if (up >= IEEE80211_NUM_UPS)
12025 return -EINVAL;
12026
12027 /* WMM uses TIDs 0-7 even for TSPEC */
723e73ac 12028 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
960d01ac 12029 /* TODO: handle 802.11 TSPEC/admission control
723e73ac
JB		 12030 * need more attributes for that (e.g. BA session requirement);
12031 * change the WMM adminssion test above to allow both then
960d01ac
JB		 12032 */
12033 return -EINVAL;
12034 }
12035
12036 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12037
12038 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
12039 admitted_time =
12040 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
12041 if (!admitted_time)
12042 return -EINVAL;
12043 }
12044
12045 wdev_lock(wdev);
12046 switch (wdev->iftype) {
12047 case NL80211_IFTYPE_STATION:
12048 case NL80211_IFTYPE_P2P_CLIENT:
12049 if (wdev->current_bss)
12050 break;
12051 err = -ENOTCONN;
12052 goto out;
12053 default:
12054 err = -EOPNOTSUPP;
12055 goto out;
12056 }
12057
12058 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
12059
12060 out:
12061 wdev_unlock(wdev);
12062 return err;
12063}
12064
12065static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
12066{
12067 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12068 struct net_device *dev = info->user_ptr[1];
12069 struct wireless_dev *wdev = dev->ieee80211_ptr;
12070 const u8 *peer;
12071 u8 tsid;
12072 int err;
12073
12074 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
12075 return -EINVAL;
12076
12077 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12078 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12079
12080 wdev_lock(wdev);
12081 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
12082 wdev_unlock(wdev);
12083
12084 return err;
12085}
12086
1057d35e
AN		 12087static int nl80211_tdls_channel_switch(struct sk_buff *skb,
12088 struct genl_info *info)
12089{
12090 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12091 struct net_device *dev = info->user_ptr[1];
12092 struct wireless_dev *wdev = dev->ieee80211_ptr;
12093 struct cfg80211_chan_def chandef = {};
12094 const u8 *addr;
12095 u8 oper_class;
12096 int err;
12097
12098 if (!rdev->ops->tdls_channel_switch ||
12099 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12100 return -EOPNOTSUPP;
12101
12102 switch (dev->ieee80211_ptr->iftype) {
12103 case NL80211_IFTYPE_STATION:
12104 case NL80211_IFTYPE_P2P_CLIENT:
12105 break;
12106 default:
12107 return -EOPNOTSUPP;
12108 }
12109
12110 if (!info->attrs[NL80211_ATTR_MAC] ||
12111 !info->attrs[NL80211_ATTR_OPER_CLASS])
12112 return -EINVAL;
12113
12114 err = nl80211_parse_chandef(rdev, info, &chandef);
12115 if (err)
12116 return err;
12117
12118 /*
12119 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
12120 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
12121 * specification is not defined for them.
12122 */
57fbcce3 12123 if (chandef.chan->band == NL80211_BAND_2GHZ &&
1057d35e
AN		 12124 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
12125 chandef.width != NL80211_CHAN_WIDTH_20)
12126 return -EINVAL;
12127
12128 /* we will be active on the TDLS link */
923b352f
AN		 12129 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
12130 wdev->iftype))
1057d35e
AN		 12131 return -EINVAL;
12132
12133 /* don't allow switching to DFS channels */
12134 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
12135 return -EINVAL;
12136
12137 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12138 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
12139
12140 wdev_lock(wdev);
12141 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
12142 wdev_unlock(wdev);
12143
12144 return err;
12145}
12146
12147static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
12148 struct genl_info *info)
12149{
12150 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12151 struct net_device *dev = info->user_ptr[1];
12152 struct wireless_dev *wdev = dev->ieee80211_ptr;
12153 const u8 *addr;
12154
12155 if (!rdev->ops->tdls_channel_switch ||
12156 !rdev->ops->tdls_cancel_channel_switch ||
12157 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12158 return -EOPNOTSUPP;
12159
12160 switch (dev->ieee80211_ptr->iftype) {
12161 case NL80211_IFTYPE_STATION:
12162 case NL80211_IFTYPE_P2P_CLIENT:
12163 break;
12164 default:
12165 return -EOPNOTSUPP;
12166 }
12167
12168 if (!info->attrs[NL80211_ATTR_MAC])
12169 return -EINVAL;
12170
12171 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12172
12173 wdev_lock(wdev);
12174 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
12175 wdev_unlock(wdev);
12176
12177 return 0;
12178}
12179
ce0ce13a
MB		 12180static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
12181 struct genl_info *info)
12182{
12183 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12184 struct net_device *dev = info->user_ptr[1];
12185 struct wireless_dev *wdev = dev->ieee80211_ptr;
12186 const struct nlattr *nla;
12187 bool enabled;
12188
ce0ce13a
MB		 12189 if (!rdev->ops->set_multicast_to_unicast)
12190 return -EOPNOTSUPP;
12191
12192 if (wdev->iftype != NL80211_IFTYPE_AP &&
12193 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12194 return -EOPNOTSUPP;
12195
12196 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
12197 enabled = nla_get_flag(nla);
12198
12199 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
12200}
12201
4c476991
JB		 12202#define NL80211_FLAG_NEED_WIPHY 0x01
12203#define NL80211_FLAG_NEED_NETDEV 0x02
12204#define NL80211_FLAG_NEED_RTNL 0x04
41265714
JB		 12205#define NL80211_FLAG_CHECK_NETDEV_UP 0x08
12206#define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
12207 NL80211_FLAG_CHECK_NETDEV_UP)
1bf614ef 12208#define NL80211_FLAG_NEED_WDEV 0x10
98104fde 12209/* If a netdev is associated, it must be UP, P2P must be started */
1bf614ef
JB		 12210#define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
12211 NL80211_FLAG_CHECK_NETDEV_UP)
5393b917 12212#define NL80211_FLAG_CLEAR_SKB 0x20
4c476991 12213
f84f771d 12214static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12215 struct genl_info *info)
12216{
12217 struct cfg80211_registered_device *rdev;
89a54e48 12218 struct wireless_dev *wdev;
4c476991 12219 struct net_device *dev;
4c476991
JB		 12220 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
12221
12222 if (rtnl)
12223 rtnl_lock();
12224
12225 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
4f7eff10 12226 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
4c476991
JB		 12227 if (IS_ERR(rdev)) {
12228 if (rtnl)
12229 rtnl_unlock();
12230 return PTR_ERR(rdev);
12231 }
12232 info->user_ptr[0] = rdev;
1bf614ef
JB		 12233 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
12234 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
5fe231e8
JB		 12235 ASSERT_RTNL();
12236
89a54e48
JB		 12237 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
12238 info->attrs);
12239 if (IS_ERR(wdev)) {
4c476991
JB		 12240 if (rtnl)
12241 rtnl_unlock();
89a54e48 12242 return PTR_ERR(wdev);
4c476991 12243 }
89a54e48 12244
89a54e48 12245 dev = wdev->netdev;
f26cbf40 12246 rdev = wiphy_to_rdev(wdev->wiphy);
89a54e48 12247
1bf614ef
JB		 12248 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
12249 if (!dev) {
1bf614ef
JB		 12250 if (rtnl)
12251 rtnl_unlock();
12252 return -EINVAL;
12253 }
12254
12255 info->user_ptr[1] = dev;
12256 } else {
12257 info->user_ptr[1] = wdev;
41265714 12258 }
1bf614ef 12259
73c7da3d
AVS		 12260 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
12261 !wdev_running(wdev)) {
12262 if (rtnl)
12263 rtnl_unlock();
12264 return -ENETDOWN;
12265 }
1bf614ef 12266
73c7da3d 12267 if (dev)
1bf614ef 12268 dev_hold(dev);
89a54e48 12269
4c476991 12270 info->user_ptr[0] = rdev;
4c476991
JB		 12271 }
12272
12273 return 0;
12274}
12275
f84f771d 12276static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 12277 struct genl_info *info)
12278{
1bf614ef
JB		 12279 if (info->user_ptr[1]) {
12280 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
12281 struct wireless_dev *wdev = info->user_ptr[1];
12282
12283 if (wdev->netdev)
12284 dev_put(wdev->netdev);
12285 } else {
12286 dev_put(info->user_ptr[1]);
12287 }
12288 }
5393b917 12289
4c476991
JB		 12290 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
12291 rtnl_unlock();
5393b917
JB		 12292
12293 /* If needed, clear the netlink message payload from the SKB
12294 * as it might contain key data that shouldn't stick around on
12295 * the heap after the SKB is freed. The netlink message header
12296 * is still needed for further processing, so leave it intact.
12297 */
12298 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
12299 struct nlmsghdr *nlh = nlmsg_hdr(skb);
12300
12301 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
12302 }
4c476991
JB		 12303}
12304
4534de83 12305static const struct genl_ops nl80211_ops[] = {
55682965
JB		 12306 {
12307 .cmd = NL80211_CMD_GET_WIPHY,
12308 .doit = nl80211_get_wiphy,
12309 .dumpit = nl80211_dump_wiphy,
86e8cf98 12310 .done = nl80211_dump_wiphy_done,
55682965
JB		 12311 .policy = nl80211_policy,
12312 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12313 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12314 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12315 },
12316 {
12317 .cmd = NL80211_CMD_SET_WIPHY,
12318 .doit = nl80211_set_wiphy,
12319 .policy = nl80211_policy,
5617c6cd 12320 .flags = GENL_UNS_ADMIN_PERM,
4c476991 12321 .internal_flags = NL80211_FLAG_NEED_RTNL,
55682965
JB		 12322 },
12323 {
12324 .cmd = NL80211_CMD_GET_INTERFACE,
12325 .doit = nl80211_get_interface,
12326 .dumpit = nl80211_dump_interface,
12327 .policy = nl80211_policy,
12328 /* can be retrieved by unprivileged users */
5fe231e8
JB		 12329 .internal_flags = NL80211_FLAG_NEED_WDEV |
12330 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12331 },
12332 {
12333 .cmd = NL80211_CMD_SET_INTERFACE,
12334 .doit = nl80211_set_interface,
12335 .policy = nl80211_policy,
5617c6cd 12336 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12337 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12338 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12339 },
12340 {
12341 .cmd = NL80211_CMD_NEW_INTERFACE,
12342 .doit = nl80211_new_interface,
12343 .policy = nl80211_policy,
5617c6cd 12344 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12345 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12346 NL80211_FLAG_NEED_RTNL,
55682965
JB		 12347 },
12348 {
12349 .cmd = NL80211_CMD_DEL_INTERFACE,
12350 .doit = nl80211_del_interface,
12351 .policy = nl80211_policy,
5617c6cd 12352 .flags = GENL_UNS_ADMIN_PERM,
84efbb84 12353 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12354 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12355 },
12356 {
12357 .cmd = NL80211_CMD_GET_KEY,
12358 .doit = nl80211_get_key,
12359 .policy = nl80211_policy,
5617c6cd 12360 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12361 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12362 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 12363 },
12364 {
12365 .cmd = NL80211_CMD_SET_KEY,
12366 .doit = nl80211_set_key,
12367 .policy = nl80211_policy,
5617c6cd 12368 .flags = GENL_UNS_ADMIN_PERM,
41265714 12369 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12370 NL80211_FLAG_NEED_RTNL |
12371 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12372 },
12373 {
12374 .cmd = NL80211_CMD_NEW_KEY,
12375 .doit = nl80211_new_key,
12376 .policy = nl80211_policy,
5617c6cd 12377 .flags = GENL_UNS_ADMIN_PERM,
41265714 12378 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12379 NL80211_FLAG_NEED_RTNL |
12380 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 12381 },
12382 {
12383 .cmd = NL80211_CMD_DEL_KEY,
12384 .doit = nl80211_del_key,
12385 .policy = nl80211_policy,
5617c6cd 12386 .flags = GENL_UNS_ADMIN_PERM,
41265714 12387 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12388 NL80211_FLAG_NEED_RTNL,
55682965 12389 },
ed1b6cc7
JB		 12390 {
12391 .cmd = NL80211_CMD_SET_BEACON,
12392 .policy = nl80211_policy,
5617c6cd 12393 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12394 .doit = nl80211_set_beacon,
2b5f8b0b 12395 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12396 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12397 },
12398 {
8860020e 12399 .cmd = NL80211_CMD_START_AP,
ed1b6cc7 12400 .policy = nl80211_policy,
5617c6cd 12401 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12402 .doit = nl80211_start_ap,
2b5f8b0b 12403 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12404 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 12405 },
12406 {
8860020e 12407 .cmd = NL80211_CMD_STOP_AP,
ed1b6cc7 12408 .policy = nl80211_policy,
5617c6cd 12409 .flags = GENL_UNS_ADMIN_PERM,
8860020e 12410 .doit = nl80211_stop_ap,
2b5f8b0b 12411 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12412 NL80211_FLAG_NEED_RTNL,
ed1b6cc7 12413 },
5727ef1b
JB		 12414 {
12415 .cmd = NL80211_CMD_GET_STATION,
12416 .doit = nl80211_get_station,
2ec600d6 12417 .dumpit = nl80211_dump_station,
5727ef1b 12418 .policy = nl80211_policy,
4c476991
JB		 12419 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12420 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12421 },
12422 {
12423 .cmd = NL80211_CMD_SET_STATION,
12424 .doit = nl80211_set_station,
12425 .policy = nl80211_policy,
5617c6cd 12426 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12427 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12428 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12429 },
12430 {
12431 .cmd = NL80211_CMD_NEW_STATION,
12432 .doit = nl80211_new_station,
12433 .policy = nl80211_policy,
5617c6cd 12434 .flags = GENL_UNS_ADMIN_PERM,
41265714 12435 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12436 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 12437 },
12438 {
12439 .cmd = NL80211_CMD_DEL_STATION,
12440 .doit = nl80211_del_station,
12441 .policy = nl80211_policy,
5617c6cd 12442 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12443 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12444 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12445 },
12446 {
12447 .cmd = NL80211_CMD_GET_MPATH,
12448 .doit = nl80211_get_mpath,
12449 .dumpit = nl80211_dump_mpath,
12450 .policy = nl80211_policy,
5617c6cd 12451 .flags = GENL_UNS_ADMIN_PERM,
41265714 12452 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12453 NL80211_FLAG_NEED_RTNL,
2ec600d6 12454 },
66be7d2b
HR		 12455 {
12456 .cmd = NL80211_CMD_GET_MPP,
12457 .doit = nl80211_get_mpp,
12458 .dumpit = nl80211_dump_mpp,
12459 .policy = nl80211_policy,
5617c6cd 12460 .flags = GENL_UNS_ADMIN_PERM,
66be7d2b
HR		 12461 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12462 NL80211_FLAG_NEED_RTNL,
12463 },
2ec600d6
LCC		 12464 {
12465 .cmd = NL80211_CMD_SET_MPATH,
12466 .doit = nl80211_set_mpath,
12467 .policy = nl80211_policy,
5617c6cd 12468 .flags = GENL_UNS_ADMIN_PERM,
41265714 12469 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12470 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12471 },
12472 {
12473 .cmd = NL80211_CMD_NEW_MPATH,
12474 .doit = nl80211_new_mpath,
12475 .policy = nl80211_policy,
5617c6cd 12476 .flags = GENL_UNS_ADMIN_PERM,
41265714 12477 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12478 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 12479 },
12480 {
12481 .cmd = NL80211_CMD_DEL_MPATH,
12482 .doit = nl80211_del_mpath,
12483 .policy = nl80211_policy,
5617c6cd 12484 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12485 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12486 NL80211_FLAG_NEED_RTNL,
9f1ba906
JM		 12487 },
12488 {
12489 .cmd = NL80211_CMD_SET_BSS,
12490 .doit = nl80211_set_bss,
12491 .policy = nl80211_policy,
5617c6cd 12492 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12493 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12494 NL80211_FLAG_NEED_RTNL,
b2e1b302 12495 },
f130347c
LR		 12496 {
12497 .cmd = NL80211_CMD_GET_REG,
ad30ca2c
AN		 12498 .doit = nl80211_get_reg_do,
12499 .dumpit = nl80211_get_reg_dump,
f130347c 12500 .policy = nl80211_policy,
5fe231e8 12501 .internal_flags = NL80211_FLAG_NEED_RTNL,
f130347c
LR		 12502 /* can be retrieved by unprivileged users */
12503 },
b6863036 12504#ifdef CONFIG_CFG80211_CRDA_SUPPORT
b2e1b302
LR		 12505 {
12506 .cmd = NL80211_CMD_SET_REG,
12507 .doit = nl80211_set_reg,
12508 .policy = nl80211_policy,
12509 .flags = GENL_ADMIN_PERM,
5fe231e8 12510 .internal_flags = NL80211_FLAG_NEED_RTNL,
b2e1b302 12511 },
b6863036 12512#endif
b2e1b302
LR		 12513 {
12514 .cmd = NL80211_CMD_REQ_SET_REG,
12515 .doit = nl80211_req_set_reg,
12516 .policy = nl80211_policy,
93da9cc1 12517 .flags = GENL_ADMIN_PERM,
12518 },
12519 {
24bdd9f4
JC		 12520 .cmd = NL80211_CMD_GET_MESH_CONFIG,
12521 .doit = nl80211_get_mesh_config,
93da9cc1 12522 .policy = nl80211_policy,
12523 /* can be retrieved by unprivileged users */
2b5f8b0b 12524 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12525 NL80211_FLAG_NEED_RTNL,
93da9cc1 12526 },
12527 {
24bdd9f4
JC		 12528 .cmd = NL80211_CMD_SET_MESH_CONFIG,
12529 .doit = nl80211_update_mesh_config,
93da9cc1 12530 .policy = nl80211_policy,
5617c6cd 12531 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c 12532 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12533 NL80211_FLAG_NEED_RTNL,
9aed3cc1 12534 },
2a519311
JB		 12535 {
12536 .cmd = NL80211_CMD_TRIGGER_SCAN,
12537 .doit = nl80211_trigger_scan,
12538 .policy = nl80211_policy,
5617c6cd 12539 .flags = GENL_UNS_ADMIN_PERM,
fd014284 12540 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12541 NL80211_FLAG_NEED_RTNL,
2a519311 12542 },
91d3ab46
VK		 12543 {
12544 .cmd = NL80211_CMD_ABORT_SCAN,
12545 .doit = nl80211_abort_scan,
12546 .policy = nl80211_policy,
5617c6cd 12547 .flags = GENL_UNS_ADMIN_PERM,
91d3ab46
VK		 12548 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12549 NL80211_FLAG_NEED_RTNL,
12550 },
2a519311
JB		 12551 {
12552 .cmd = NL80211_CMD_GET_SCAN,
12553 .policy = nl80211_policy,
12554 .dumpit = nl80211_dump_scan,
12555 },
807f8a8c
LC		 12556 {
12557 .cmd = NL80211_CMD_START_SCHED_SCAN,
12558 .doit = nl80211_start_sched_scan,
12559 .policy = nl80211_policy,
5617c6cd 12560 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12561 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12562 NL80211_FLAG_NEED_RTNL,
12563 },
12564 {
12565 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
12566 .doit = nl80211_stop_sched_scan,
12567 .policy = nl80211_policy,
5617c6cd 12568 .flags = GENL_UNS_ADMIN_PERM,
807f8a8c
LC		 12569 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12570 NL80211_FLAG_NEED_RTNL,
12571 },
636a5d36
JM		 12572 {
12573 .cmd = NL80211_CMD_AUTHENTICATE,
12574 .doit = nl80211_authenticate,
12575 .policy = nl80211_policy,
5617c6cd 12576 .flags = GENL_UNS_ADMIN_PERM,
41265714 12577 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12578 NL80211_FLAG_NEED_RTNL |
12579 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 12580 },
12581 {
12582 .cmd = NL80211_CMD_ASSOCIATE,
12583 .doit = nl80211_associate,
12584 .policy = nl80211_policy,
5617c6cd 12585 .flags = GENL_UNS_ADMIN_PERM,
41265714 12586 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12587 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12588 },
12589 {
12590 .cmd = NL80211_CMD_DEAUTHENTICATE,
12591 .doit = nl80211_deauthenticate,
12592 .policy = nl80211_policy,
5617c6cd 12593 .flags = GENL_UNS_ADMIN_PERM,
41265714 12594 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12595 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 12596 },
12597 {
12598 .cmd = NL80211_CMD_DISASSOCIATE,
12599 .doit = nl80211_disassociate,
12600 .policy = nl80211_policy,
5617c6cd 12601 .flags = GENL_UNS_ADMIN_PERM,
41265714 12602 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12603 NL80211_FLAG_NEED_RTNL,
636a5d36 12604 },
04a773ad
JB		 12605 {
12606 .cmd = NL80211_CMD_JOIN_IBSS,
12607 .doit = nl80211_join_ibss,
12608 .policy = nl80211_policy,
5617c6cd 12609 .flags = GENL_UNS_ADMIN_PERM,
41265714 12610 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12611 NL80211_FLAG_NEED_RTNL,
04a773ad
JB		 12612 },
12613 {
12614 .cmd = NL80211_CMD_LEAVE_IBSS,
12615 .doit = nl80211_leave_ibss,
12616 .policy = nl80211_policy,
5617c6cd 12617 .flags = GENL_UNS_ADMIN_PERM,
41265714 12618 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12619 NL80211_FLAG_NEED_RTNL,
04a773ad 12620 },
aff89a9b
JB		 12621#ifdef CONFIG_NL80211_TESTMODE
12622 {
12623 .cmd = NL80211_CMD_TESTMODE,
12624 .doit = nl80211_testmode_do,
71063f0e 12625 .dumpit = nl80211_testmode_dump,
aff89a9b 12626 .policy = nl80211_policy,
5617c6cd 12627 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12628 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12629 NL80211_FLAG_NEED_RTNL,
aff89a9b
JB		 12630 },
12631#endif
b23aa676
SO		 12632 {
12633 .cmd = NL80211_CMD_CONNECT,
12634 .doit = nl80211_connect,
12635 .policy = nl80211_policy,
5617c6cd 12636 .flags = GENL_UNS_ADMIN_PERM,
41265714 12637 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12638 NL80211_FLAG_NEED_RTNL,
b23aa676 12639 },
088e8df8 12640 {
12641 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
12642 .doit = nl80211_update_connect_params,
12643 .policy = nl80211_policy,
12644 .flags = GENL_ADMIN_PERM,
12645 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12646 NL80211_FLAG_NEED_RTNL,
12647 },
b23aa676
SO		 12648 {
12649 .cmd = NL80211_CMD_DISCONNECT,
12650 .doit = nl80211_disconnect,
12651 .policy = nl80211_policy,
5617c6cd 12652 .flags = GENL_UNS_ADMIN_PERM,
41265714 12653 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12654 NL80211_FLAG_NEED_RTNL,
b23aa676 12655 },
463d0183
JB		 12656 {
12657 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
12658 .doit = nl80211_wiphy_netns,
12659 .policy = nl80211_policy,
5617c6cd 12660 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12661 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12662 NL80211_FLAG_NEED_RTNL,
463d0183 12663 },
61fa713c
HS		 12664 {
12665 .cmd = NL80211_CMD_GET_SURVEY,
12666 .policy = nl80211_policy,
12667 .dumpit = nl80211_dump_survey,
12668 },
67fbb16b
SO		 12669 {
12670 .cmd = NL80211_CMD_SET_PMKSA,
12671 .doit = nl80211_setdel_pmksa,
12672 .policy = nl80211_policy,
5617c6cd 12673 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12674 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12675 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12676 },
12677 {
12678 .cmd = NL80211_CMD_DEL_PMKSA,
12679 .doit = nl80211_setdel_pmksa,
12680 .policy = nl80211_policy,
5617c6cd 12681 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12682 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12683 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 12684 },
12685 {
12686 .cmd = NL80211_CMD_FLUSH_PMKSA,
12687 .doit = nl80211_flush_pmksa,
12688 .policy = nl80211_policy,
5617c6cd 12689 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12690 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 12691 NL80211_FLAG_NEED_RTNL,
67fbb16b 12692 },
9588bbd5
JM		 12693 {
12694 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
12695 .doit = nl80211_remain_on_channel,
12696 .policy = nl80211_policy,
5617c6cd 12697 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12698 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12699 NL80211_FLAG_NEED_RTNL,
9588bbd5
JM		 12700 },
12701 {
12702 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
12703 .doit = nl80211_cancel_remain_on_channel,
12704 .policy = nl80211_policy,
5617c6cd 12705 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12706 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12707 NL80211_FLAG_NEED_RTNL,
9588bbd5 12708 },
13ae75b1
JM		 12709 {
12710 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
12711 .doit = nl80211_set_tx_bitrate_mask,
12712 .policy = nl80211_policy,
5617c6cd 12713 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12714 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12715 NL80211_FLAG_NEED_RTNL,
13ae75b1 12716 },
026331c4 12717 {
2e161f78
JB		 12718 .cmd = NL80211_CMD_REGISTER_FRAME,
12719 .doit = nl80211_register_mgmt,
026331c4 12720 .policy = nl80211_policy,
5617c6cd 12721 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12722 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 12723 NL80211_FLAG_NEED_RTNL,
026331c4
JM		 12724 },
12725 {
2e161f78
JB		 12726 .cmd = NL80211_CMD_FRAME,
12727 .doit = nl80211_tx_mgmt,
026331c4 12728 .policy = nl80211_policy,
5617c6cd 12729 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12730 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
f7ca38df
JB		 12731 NL80211_FLAG_NEED_RTNL,
12732 },
12733 {
12734 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
12735 .doit = nl80211_tx_mgmt_cancel_wait,
12736 .policy = nl80211_policy,
5617c6cd 12737 .flags = GENL_UNS_ADMIN_PERM,
71bbc994 12738 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 12739 NL80211_FLAG_NEED_RTNL,
026331c4 12740 },
ffb9eb3d
KV		 12741 {
12742 .cmd = NL80211_CMD_SET_POWER_SAVE,
12743 .doit = nl80211_set_power_save,
12744 .policy = nl80211_policy,
5617c6cd 12745 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12746 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12747 NL80211_FLAG_NEED_RTNL,
ffb9eb3d
KV		 12748 },
12749 {
12750 .cmd = NL80211_CMD_GET_POWER_SAVE,
12751 .doit = nl80211_get_power_save,
12752 .policy = nl80211_policy,
12753 /* can be retrieved by unprivileged users */
4c476991
JB		 12754 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12755 NL80211_FLAG_NEED_RTNL,
ffb9eb3d 12756 },
d6dc1a38
JO		 12757 {
12758 .cmd = NL80211_CMD_SET_CQM,
12759 .doit = nl80211_set_cqm,
12760 .policy = nl80211_policy,
5617c6cd 12761 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12762 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12763 NL80211_FLAG_NEED_RTNL,
d6dc1a38 12764 },
f444de05
JB		 12765 {
12766 .cmd = NL80211_CMD_SET_CHANNEL,
12767 .doit = nl80211_set_channel,
12768 .policy = nl80211_policy,
5617c6cd 12769 .flags = GENL_UNS_ADMIN_PERM,
4c476991
JB		 12770 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12771 NL80211_FLAG_NEED_RTNL,
f444de05 12772 },
e8347eba
BJ		 12773 {
12774 .cmd = NL80211_CMD_SET_WDS_PEER,
12775 .doit = nl80211_set_wds_peer,
12776 .policy = nl80211_policy,
5617c6cd 12777 .flags = GENL_UNS_ADMIN_PERM,
43b19952
JB		 12778 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12779 NL80211_FLAG_NEED_RTNL,
e8347eba 12780 },
29cbe68c
JB		 12781 {
12782 .cmd = NL80211_CMD_JOIN_MESH,
12783 .doit = nl80211_join_mesh,
12784 .policy = nl80211_policy,
5617c6cd 12785 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12786 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12787 NL80211_FLAG_NEED_RTNL,
12788 },
12789 {
12790 .cmd = NL80211_CMD_LEAVE_MESH,
12791 .doit = nl80211_leave_mesh,
12792 .policy = nl80211_policy,
5617c6cd 12793 .flags = GENL_UNS_ADMIN_PERM,
29cbe68c
JB		 12794 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12795 NL80211_FLAG_NEED_RTNL,
12796 },
6e0bd6c3
RL		 12797 {
12798 .cmd = NL80211_CMD_JOIN_OCB,
12799 .doit = nl80211_join_ocb,
12800 .policy = nl80211_policy,
5617c6cd 12801 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12802 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12803 NL80211_FLAG_NEED_RTNL,
12804 },
12805 {
12806 .cmd = NL80211_CMD_LEAVE_OCB,
12807 .doit = nl80211_leave_ocb,
12808 .policy = nl80211_policy,
5617c6cd 12809 .flags = GENL_UNS_ADMIN_PERM,
6e0bd6c3
RL		 12810 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12811 NL80211_FLAG_NEED_RTNL,
12812 },
dfb89c56 12813#ifdef CONFIG_PM
ff1b6e69
JB		 12814 {
12815 .cmd = NL80211_CMD_GET_WOWLAN,
12816 .doit = nl80211_get_wowlan,
12817 .policy = nl80211_policy,
12818 /* can be retrieved by unprivileged users */
12819 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12820 NL80211_FLAG_NEED_RTNL,
12821 },
12822 {
12823 .cmd = NL80211_CMD_SET_WOWLAN,
12824 .doit = nl80211_set_wowlan,
12825 .policy = nl80211_policy,
5617c6cd 12826 .flags = GENL_UNS_ADMIN_PERM,
ff1b6e69
JB		 12827 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12828 NL80211_FLAG_NEED_RTNL,
12829 },
dfb89c56 12830#endif
e5497d76
JB		 12831 {
12832 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
12833 .doit = nl80211_set_rekey_data,
12834 .policy = nl80211_policy,
5617c6cd 12835 .flags = GENL_UNS_ADMIN_PERM,
e5497d76 12836 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 12837 NL80211_FLAG_NEED_RTNL |
12838 NL80211_FLAG_CLEAR_SKB,
e5497d76 12839 },
109086ce
AN		 12840 {
12841 .cmd = NL80211_CMD_TDLS_MGMT,
12842 .doit = nl80211_tdls_mgmt,
12843 .policy = nl80211_policy,
5617c6cd 12844 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 12845 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12846 NL80211_FLAG_NEED_RTNL,
12847 },
12848 {
12849 .cmd = NL80211_CMD_TDLS_OPER,
12850 .doit = nl80211_tdls_oper,
12851 .policy = nl80211_policy,
5617c6cd 12852 .flags = GENL_UNS_ADMIN_PERM,
109086ce
AN		 12853 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12854 NL80211_FLAG_NEED_RTNL,
12855 },
28946da7
JB		 12856 {
12857 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
12858 .doit = nl80211_register_unexpected_frame,
12859 .policy = nl80211_policy,
5617c6cd 12860 .flags = GENL_UNS_ADMIN_PERM,
28946da7
JB		 12861 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12862 NL80211_FLAG_NEED_RTNL,
12863 },
7f6cf311
JB		 12864 {
12865 .cmd = NL80211_CMD_PROBE_CLIENT,
12866 .doit = nl80211_probe_client,
12867 .policy = nl80211_policy,
5617c6cd 12868 .flags = GENL_UNS_ADMIN_PERM,
2b5f8b0b 12869 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7f6cf311
JB		 12870 NL80211_FLAG_NEED_RTNL,
12871 },
5e760230
JB		 12872 {
12873 .cmd = NL80211_CMD_REGISTER_BEACONS,
12874 .doit = nl80211_register_beacons,
12875 .policy = nl80211_policy,
5617c6cd 12876 .flags = GENL_UNS_ADMIN_PERM,
5e760230
JB		 12877 .internal_flags = NL80211_FLAG_NEED_WIPHY |
12878 NL80211_FLAG_NEED_RTNL,
12879 },
1d9d9213
SW		 12880 {
12881 .cmd = NL80211_CMD_SET_NOACK_MAP,
12882 .doit = nl80211_set_noack_map,
12883 .policy = nl80211_policy,
5617c6cd 12884 .flags = GENL_UNS_ADMIN_PERM,
1d9d9213
SW		 12885 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12886 NL80211_FLAG_NEED_RTNL,
12887 },
98104fde
JB		 12888 {
12889 .cmd = NL80211_CMD_START_P2P_DEVICE,
12890 .doit = nl80211_start_p2p_device,
12891 .policy = nl80211_policy,
5617c6cd 12892 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 12893 .internal_flags = NL80211_FLAG_NEED_WDEV |
12894 NL80211_FLAG_NEED_RTNL,
12895 },
12896 {
12897 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
12898 .doit = nl80211_stop_p2p_device,
12899 .policy = nl80211_policy,
5617c6cd 12900 .flags = GENL_UNS_ADMIN_PERM,
98104fde
JB		 12901 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12902 NL80211_FLAG_NEED_RTNL,
cb3b7d87
AB		 12903 },
12904 {
12905 .cmd = NL80211_CMD_START_NAN,
12906 .doit = nl80211_start_nan,
12907 .policy = nl80211_policy,
12908 .flags = GENL_ADMIN_PERM,
12909 .internal_flags = NL80211_FLAG_NEED_WDEV |
12910 NL80211_FLAG_NEED_RTNL,
12911 },
12912 {
12913 .cmd = NL80211_CMD_STOP_NAN,
12914 .doit = nl80211_stop_nan,
12915 .policy = nl80211_policy,
12916 .flags = GENL_ADMIN_PERM,
12917 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12918 NL80211_FLAG_NEED_RTNL,
a442b761
AB		 12919 },
12920 {
12921 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
12922 .doit = nl80211_nan_add_func,
12923 .policy = nl80211_policy,
12924 .flags = GENL_ADMIN_PERM,
12925 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12926 NL80211_FLAG_NEED_RTNL,
12927 },
12928 {
12929 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
12930 .doit = nl80211_nan_del_func,
12931 .policy = nl80211_policy,
12932 .flags = GENL_ADMIN_PERM,
12933 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12934 NL80211_FLAG_NEED_RTNL,
a5a9dcf2
AB		 12935 },
12936 {
12937 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
12938 .doit = nl80211_nan_change_config,
12939 .policy = nl80211_policy,
12940 .flags = GENL_ADMIN_PERM,
12941 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12942 NL80211_FLAG_NEED_RTNL,
98104fde 12943 },
f4e583c8
AQ		 12944 {
12945 .cmd = NL80211_CMD_SET_MCAST_RATE,
12946 .doit = nl80211_set_mcast_rate,
77765eaf 12947 .policy = nl80211_policy,
5617c6cd 12948 .flags = GENL_UNS_ADMIN_PERM,
77765eaf
VT		 12949 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12950 NL80211_FLAG_NEED_RTNL,
12951 },
12952 {
12953 .cmd = NL80211_CMD_SET_MAC_ACL,
12954 .doit = nl80211_set_mac_acl,
f4e583c8 12955 .policy = nl80211_policy,
5617c6cd 12956 .flags = GENL_UNS_ADMIN_PERM,
f4e583c8
AQ		 12957 .internal_flags = NL80211_FLAG_NEED_NETDEV |
12958 NL80211_FLAG_NEED_RTNL,
12959 },
04f39047
SW		 12960 {
12961 .cmd = NL80211_CMD_RADAR_DETECT,
12962 .doit = nl80211_start_radar_detection,
12963 .policy = nl80211_policy,
5617c6cd 12964 .flags = GENL_UNS_ADMIN_PERM,
04f39047
SW		 12965 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12966 NL80211_FLAG_NEED_RTNL,
12967 },
3713b4e3
JB		 12968 {
12969 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
12970 .doit = nl80211_get_protocol_features,
12971 .policy = nl80211_policy,
12972 },
355199e0
JM		 12973 {
12974 .cmd = NL80211_CMD_UPDATE_FT_IES,
12975 .doit = nl80211_update_ft_ies,
12976 .policy = nl80211_policy,
5617c6cd 12977 .flags = GENL_UNS_ADMIN_PERM,
355199e0
JM		 12978 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
12979 NL80211_FLAG_NEED_RTNL,
12980 },
5de17984
AS		 12981 {
12982 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
12983 .doit = nl80211_crit_protocol_start,
12984 .policy = nl80211_policy,
5617c6cd 12985 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 12986 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12987 NL80211_FLAG_NEED_RTNL,
12988 },
12989 {
12990 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
12991 .doit = nl80211_crit_protocol_stop,
12992 .policy = nl80211_policy,
5617c6cd 12993 .flags = GENL_UNS_ADMIN_PERM,
5de17984
AS		 12994 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
12995 NL80211_FLAG_NEED_RTNL,
be29b99a
AK		 12996 },
12997 {
12998 .cmd = NL80211_CMD_GET_COALESCE,
12999 .doit = nl80211_get_coalesce,
13000 .policy = nl80211_policy,
13001 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13002 NL80211_FLAG_NEED_RTNL,
13003 },
13004 {
13005 .cmd = NL80211_CMD_SET_COALESCE,
13006 .doit = nl80211_set_coalesce,
13007 .policy = nl80211_policy,
5617c6cd 13008 .flags = GENL_UNS_ADMIN_PERM,
be29b99a
AK		 13009 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13010 NL80211_FLAG_NEED_RTNL,
16ef1fe2
SW		 13011 },
13012 {
13013 .cmd = NL80211_CMD_CHANNEL_SWITCH,
13014 .doit = nl80211_channel_switch,
13015 .policy = nl80211_policy,
5617c6cd 13016 .flags = GENL_UNS_ADMIN_PERM,
16ef1fe2
SW		 13017 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13018 NL80211_FLAG_NEED_RTNL,
13019 },
ad7e718c
JB		 13020 {
13021 .cmd = NL80211_CMD_VENDOR,
13022 .doit = nl80211_vendor_cmd,
7bdbe400 13023 .dumpit = nl80211_vendor_cmd_dump,
ad7e718c 13024 .policy = nl80211_policy,
5617c6cd 13025 .flags = GENL_UNS_ADMIN_PERM,
ad7e718c
JB		 13026 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13027 NL80211_FLAG_NEED_RTNL,
13028 },
fa9ffc74
KP		 13029 {
13030 .cmd = NL80211_CMD_SET_QOS_MAP,
13031 .doit = nl80211_set_qos_map,
13032 .policy = nl80211_policy,
5617c6cd 13033 .flags = GENL_UNS_ADMIN_PERM,
fa9ffc74
KP		 13034 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13035 NL80211_FLAG_NEED_RTNL,
13036 },
960d01ac
JB		 13037 {
13038 .cmd = NL80211_CMD_ADD_TX_TS,
13039 .doit = nl80211_add_tx_ts,
13040 .policy = nl80211_policy,
5617c6cd 13041 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13042 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13043 NL80211_FLAG_NEED_RTNL,
13044 },
13045 {
13046 .cmd = NL80211_CMD_DEL_TX_TS,
13047 .doit = nl80211_del_tx_ts,
13048 .policy = nl80211_policy,
5617c6cd 13049 .flags = GENL_UNS_ADMIN_PERM,
960d01ac
JB		 13050 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13051 NL80211_FLAG_NEED_RTNL,
13052 },
1057d35e
AN		 13053 {
13054 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
13055 .doit = nl80211_tdls_channel_switch,
13056 .policy = nl80211_policy,
5617c6cd 13057 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13058 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13059 NL80211_FLAG_NEED_RTNL,
13060 },
13061 {
13062 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
13063 .doit = nl80211_tdls_cancel_channel_switch,
13064 .policy = nl80211_policy,
5617c6cd 13065 .flags = GENL_UNS_ADMIN_PERM,
1057d35e
AN		 13066 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13067 NL80211_FLAG_NEED_RTNL,
13068 },
ce0ce13a
MB		 13069 {
13070 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
13071 .doit = nl80211_set_multicast_to_unicast,
13072 .policy = nl80211_policy,
13073 .flags = GENL_UNS_ADMIN_PERM,
13074 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13075 NL80211_FLAG_NEED_RTNL,
13076 },
55682965 13077};
9588bbd5 13078
56989f6d 13079static struct genl_family nl80211_fam __ro_after_init = {
489111e5
JB		 13080 .name = NL80211_GENL_NAME, /* have users key off the name instead */
13081 .hdrsize = 0, /* no private header */
13082 .version = 1, /* no particular meaning now */
13083 .maxattr = NL80211_ATTR_MAX,
13084 .netnsok = true,
13085 .pre_doit = nl80211_pre_doit,
13086 .post_doit = nl80211_post_doit,
13087 .module = THIS_MODULE,
13088 .ops = nl80211_ops,
13089 .n_ops = ARRAY_SIZE(nl80211_ops),
13090 .mcgrps = nl80211_mcgrps,
13091 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
13092};
13093
55682965
JB		 13094/* notification functions */
13095
3bb20556
JB		 13096void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
13097 enum nl80211_commands cmd)
55682965
JB		 13098{
13099 struct sk_buff *msg;
86e8cf98 13100 struct nl80211_dump_wiphy_state state = {};
55682965 13101
3bb20556
JB		 13102 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
13103 cmd != NL80211_CMD_DEL_WIPHY);
13104
fd2120ca 13105 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 13106 if (!msg)
13107 return;
13108
3bb20556 13109 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
55682965
JB		 13110 nlmsg_free(msg);
13111 return;
13112 }
13113
68eb5503 13114 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13115 NL80211_MCGRP_CONFIG, GFP_KERNEL);
55682965
JB		 13116}
13117
896ff063
DK		 13118void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
13119 struct wireless_dev *wdev,
13120 enum nl80211_commands cmd)
13121{
13122 struct sk_buff *msg;
13123
13124 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
13125 cmd != NL80211_CMD_DEL_INTERFACE);
13126
13127 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13128 if (!msg)
13129 return;
13130
13131 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev,
13132 cmd == NL80211_CMD_DEL_INTERFACE) < 0) {
13133 nlmsg_free(msg);
13134 return;
13135 }
13136
13137 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
13138 NL80211_MCGRP_CONFIG, GFP_KERNEL);
13139}
13140
362a415d
JB		 13141static int nl80211_add_scan_req(struct sk_buff *msg,
13142 struct cfg80211_registered_device *rdev)
13143{
13144 struct cfg80211_scan_request *req = rdev->scan_req;
13145 struct nlattr *nest;
13146 int i;
13147
13148 if (WARN_ON(!req))
13149 return 0;
13150
13151 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
13152 if (!nest)
13153 goto nla_put_failure;
9360ffd1
DM		 13154 for (i = 0; i < req->n_ssids; i++) {
13155 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
13156 goto nla_put_failure;
13157 }
362a415d
JB		 13158 nla_nest_end(msg, nest);
13159
13160 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
13161 if (!nest)
13162 goto nla_put_failure;
9360ffd1
DM		 13163 for (i = 0; i < req->n_channels; i++) {
13164 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
13165 goto nla_put_failure;
13166 }
362a415d
JB		 13167 nla_nest_end(msg, nest);
13168
9360ffd1
DM		 13169 if (req->ie &&
13170 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
13171 goto nla_put_failure;
362a415d 13172
ae917c9f
JB		 13173 if (req->flags &&
13174 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
13175 goto nla_put_failure;
ed473771 13176
1d76250b
AS		 13177 if (req->info.scan_start_tsf &&
13178 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
13179 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
13180 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
13181 req->info.tsf_bssid)))
13182 goto nla_put_failure;
13183
362a415d
JB		 13184 return 0;
13185 nla_put_failure:
13186 return -ENOBUFS;
13187}
13188
505a2e88 13189static int nl80211_prep_scan_msg(struct sk_buff *msg,
a538e2d5 13190 struct cfg80211_registered_device *rdev,
fd014284 13191 struct wireless_dev *wdev,
15e47304 13192 u32 portid, u32 seq, int flags,
a538e2d5 13193 u32 cmd)
2a519311
JB		 13194{
13195 void *hdr;
13196
15e47304 13197 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2a519311
JB		 13198 if (!hdr)
13199 return -1;
13200
9360ffd1 13201 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
fd014284
JB		 13202 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13203 wdev->netdev->ifindex)) ||
2dad624e
ND		 13204 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13205 NL80211_ATTR_PAD))
9360ffd1 13206 goto nla_put_failure;
2a519311 13207
362a415d
JB		 13208 /* ignore errors and send incomplete event anyway */
13209 nl80211_add_scan_req(msg, rdev);
2a519311 13210
053c095a
JB		 13211 genlmsg_end(msg, hdr);
13212 return 0;
2a519311
JB		 13213
13214 nla_put_failure:
13215 genlmsg_cancel(msg, hdr);
13216 return -EMSGSIZE;
13217}
13218
807f8a8c 13219static int
505a2e88 13220nl80211_prep_sched_scan_msg(struct sk_buff *msg,
96b08fd6 13221 struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13222{
13223 void *hdr;
13224
96b08fd6 13225 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
807f8a8c
LC		 13226 if (!hdr)
13227 return -1;
13228
96b08fd6
AVS		 13229 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
13230 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
13231 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
13232 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
13233 NL80211_ATTR_PAD))
9360ffd1 13234 goto nla_put_failure;
807f8a8c 13235
053c095a
JB		 13236 genlmsg_end(msg, hdr);
13237 return 0;
807f8a8c
LC		 13238
13239 nla_put_failure:
13240 genlmsg_cancel(msg, hdr);
13241 return -EMSGSIZE;
13242}
13243
a538e2d5 13244void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
fd014284 13245 struct wireless_dev *wdev)
a538e2d5
JB		 13246{
13247 struct sk_buff *msg;
13248
58050fce 13249 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
a538e2d5
JB		 13250 if (!msg)
13251 return;
13252
505a2e88 13253 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
a538e2d5
JB		 13254 NL80211_CMD_TRIGGER_SCAN) < 0) {
13255 nlmsg_free(msg);
13256 return;
13257 }
13258
68eb5503 13259 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13260 NL80211_MCGRP_SCAN, GFP_KERNEL);
a538e2d5
JB		 13261}
13262
f9d15d16
JB		 13263struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
13264 struct wireless_dev *wdev, bool aborted)
2a519311
JB		 13265{
13266 struct sk_buff *msg;
13267
fd2120ca 13268 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311 13269 if (!msg)
f9d15d16 13270 return NULL;
2a519311 13271
505a2e88 13272 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
f9d15d16
JB		 13273 aborted ? NL80211_CMD_SCAN_ABORTED :
13274 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311 13275 nlmsg_free(msg);
f9d15d16 13276 return NULL;
2a519311
JB		 13277 }
13278
f9d15d16 13279 return msg;
2a519311
JB		 13280}
13281
505a2e88
AVS		 13282/* send message created by nl80211_build_scan_msg() */
13283void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
13284 struct sk_buff *msg)
807f8a8c 13285{
807f8a8c
LC		 13286 if (!msg)
13287 return;
13288
68eb5503 13289 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13290 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13291}
13292
96b08fd6 13293void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
807f8a8c
LC		 13294{
13295 struct sk_buff *msg;
13296
58050fce 13297 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
807f8a8c
LC		 13298 if (!msg)
13299 return;
13300
96b08fd6 13301 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
807f8a8c
LC		 13302 nlmsg_free(msg);
13303 return;
13304 }
13305
96b08fd6 13306 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
2a94fe48 13307 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 13308}
13309
b0d7aa59
JD		 13310static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
13311 struct regulatory_request *request)
73d54c9e 13312{
73d54c9e 13313 /* Userspace can always count this one always being set */
9360ffd1
DM		 13314 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
13315 goto nla_put_failure;
13316
13317 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
13318 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13319 NL80211_REGDOM_TYPE_WORLD))
13320 goto nla_put_failure;
13321 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
13322 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13323 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
13324 goto nla_put_failure;
13325 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
13326 request->intersect) {
13327 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13328 NL80211_REGDOM_TYPE_INTERSECTION))
13329 goto nla_put_failure;
13330 } else {
13331 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
13332 NL80211_REGDOM_TYPE_COUNTRY) ||
13333 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
13334 request->alpha2))
13335 goto nla_put_failure;
13336 }
13337
ad30ca2c
AN		 13338 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
13339 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
13340
13341 if (wiphy &&
13342 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
13343 goto nla_put_failure;
1bdd716c
AN		 13344
13345 if (wiphy &&
13346 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
13347 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
13348 goto nla_put_failure;
ad30ca2c 13349 }
73d54c9e 13350
b0d7aa59
JD		 13351 return true;
13352
13353nla_put_failure:
13354 return false;
13355}
13356
13357/*
13358 * This can happen on global regulatory changes or device specific settings
13359 * based on custom regulatory domains.
13360 */
13361void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
13362 struct regulatory_request *request)
13363{
13364 struct sk_buff *msg;
13365 void *hdr;
13366
13367 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13368 if (!msg)
13369 return;
13370
13371 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
13372 if (!hdr) {
13373 nlmsg_free(msg);
13374 return;
13375 }
13376
13377 if (nl80211_reg_change_event_fill(msg, request) == false)
13378 goto nla_put_failure;
13379
3b7b72ee 13380 genlmsg_end(msg, hdr);
73d54c9e 13381
bc43b28c 13382 rcu_read_lock();
68eb5503 13383 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13384 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
bc43b28c 13385 rcu_read_unlock();
73d54c9e
LR		 13386
13387 return;
13388
13389nla_put_failure:
13390 genlmsg_cancel(msg, hdr);
13391 nlmsg_free(msg);
13392}
13393
6039f6d2
JM		 13394static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
13395 struct net_device *netdev,
13396 const u8 *buf, size_t len,
b0b6aa2c
EP		 13397 enum nl80211_commands cmd, gfp_t gfp,
13398 int uapsd_queues)
6039f6d2
JM		 13399{
13400 struct sk_buff *msg;
13401 void *hdr;
13402
4ef8c1c9 13403 msg = nlmsg_new(100 + len, gfp);
6039f6d2
JM		 13404 if (!msg)
13405 return;
13406
13407 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13408 if (!hdr) {
13409 nlmsg_free(msg);
13410 return;
13411 }
13412
9360ffd1
DM		 13413 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13414 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13415 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
13416 goto nla_put_failure;
6039f6d2 13417
b0b6aa2c
EP		 13418 if (uapsd_queues >= 0) {
13419 struct nlattr *nla_wmm =
13420 nla_nest_start(msg, NL80211_ATTR_STA_WME);
13421 if (!nla_wmm)
13422 goto nla_put_failure;
13423
13424 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
13425 uapsd_queues))
13426 goto nla_put_failure;
13427
13428 nla_nest_end(msg, nla_wmm);
13429 }
13430
3b7b72ee 13431 genlmsg_end(msg, hdr);
6039f6d2 13432
68eb5503 13433 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13434 NL80211_MCGRP_MLME, gfp);
6039f6d2
JM		 13435 return;
13436
13437 nla_put_failure:
13438 genlmsg_cancel(msg, hdr);
13439 nlmsg_free(msg);
13440}
13441
13442void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13443 struct net_device *netdev, const u8 *buf,
13444 size_t len, gfp_t gfp)
6039f6d2
JM		 13445{
13446 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13447 NL80211_CMD_AUTHENTICATE, gfp, -1);
6039f6d2
JM		 13448}
13449
13450void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
13451 struct net_device *netdev, const u8 *buf,
b0b6aa2c 13452 size_t len, gfp_t gfp, int uapsd_queues)
6039f6d2 13453{
e6d6e342 13454 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13455 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
6039f6d2
JM		 13456}
13457
53b46b84 13458void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13459 struct net_device *netdev, const u8 *buf,
13460 size_t len, gfp_t gfp)
6039f6d2
JM		 13461{
13462 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13463 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
6039f6d2
JM		 13464}
13465
53b46b84
JM		 13466void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
13467 struct net_device *netdev, const u8 *buf,
e6d6e342 13468 size_t len, gfp_t gfp)
6039f6d2
JM		 13469{
13470 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 13471 NL80211_CMD_DISASSOCIATE, gfp, -1);
6039f6d2
JM		 13472}
13473
6ff57cf8
JB		 13474void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
13475 size_t len)
cf4e594e 13476{
947add36
JB		 13477 struct wireless_dev *wdev = dev->ieee80211_ptr;
13478 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13479 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
6ff57cf8
JB		 13480 const struct ieee80211_mgmt *mgmt = (void *)buf;
13481 u32 cmd;
947add36 13482
6ff57cf8
JB		 13483 if (WARN_ON(len < 2))
13484 return;
cf4e594e 13485
6ff57cf8
JB		 13486 if (ieee80211_is_deauth(mgmt->frame_control))
13487 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
13488 else
13489 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
947add36 13490
6ff57cf8 13491 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
b0b6aa2c 13492 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
cf4e594e 13493}
6ff57cf8 13494EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
cf4e594e 13495
1b06bb40
LR		 13496static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
13497 struct net_device *netdev, int cmd,
e6d6e342 13498 const u8 *addr, gfp_t gfp)
1965c853
JM		 13499{
13500 struct sk_buff *msg;
13501 void *hdr;
13502
e6d6e342 13503 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 13504 if (!msg)
13505 return;
13506
13507 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13508 if (!hdr) {
13509 nlmsg_free(msg);
13510 return;
13511 }
13512
9360ffd1
DM		 13513 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13514 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13515 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
13516 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
13517 goto nla_put_failure;
1965c853 13518
3b7b72ee 13519 genlmsg_end(msg, hdr);
1965c853 13520
68eb5503 13521 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13522 NL80211_MCGRP_MLME, gfp);
1965c853
JM		 13523 return;
13524
13525 nla_put_failure:
13526 genlmsg_cancel(msg, hdr);
13527 nlmsg_free(msg);
13528}
13529
13530void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13531 struct net_device *netdev, const u8 *addr,
13532 gfp_t gfp)
1965c853
JM		 13533{
13534 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 13535 addr, gfp);
1965c853
JM		 13536}
13537
13538void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 13539 struct net_device *netdev, const u8 *addr,
13540 gfp_t gfp)
1965c853 13541{
e6d6e342
JB		 13542 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
13543 addr, gfp);
1965c853
JM		 13544}
13545
b23aa676 13546void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
5349a0f7
VK		 13547 struct net_device *netdev,
13548 struct cfg80211_connect_resp_params *cr,
3093ebbe 13549 gfp_t gfp)
b23aa676
SO		 13550{
13551 struct sk_buff *msg;
13552 void *hdr;
13553
a3caf744
VK		 13554 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
13555 cr->fils_kek_len + cr->pmk_len +
13556 (cr->pmkid ? WLAN_PMKID_LEN : 0), gfp);
b23aa676
SO		 13557 if (!msg)
13558 return;
13559
13560 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
13561 if (!hdr) {
13562 nlmsg_free(msg);
13563 return;
13564 }
13565
9360ffd1
DM		 13566 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13567 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
5349a0f7
VK		 13568 (cr->bssid &&
13569 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
bf1ecd21 13570 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
5349a0f7
VK		 13571 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
13572 cr->status) ||
13573 (cr->status < 0 &&
3093ebbe 13574 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
5349a0f7
VK		 13575 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
13576 cr->timeout_reason))) ||
13577 (cr->req_ie &&
13578 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
13579 (cr->resp_ie &&
13580 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
a3caf744
VK		 13581 cr->resp_ie)) ||
13582 (cr->update_erp_next_seq_num &&
13583 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
13584 cr->fils_erp_next_seq_num)) ||
13585 (cr->status == WLAN_STATUS_SUCCESS &&
13586 ((cr->fils_kek &&
13587 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils_kek_len,
13588 cr->fils_kek)) ||
13589 (cr->pmk &&
13590 nla_put(msg, NL80211_ATTR_PMK, cr->pmk_len, cr->pmk)) ||
13591 (cr->pmkid &&
13592 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->pmkid)))))
9360ffd1 13593 goto nla_put_failure;
b23aa676 13594
3b7b72ee 13595 genlmsg_end(msg, hdr);
b23aa676 13596
68eb5503 13597 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13598 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13599 return;
13600
13601 nla_put_failure:
13602 genlmsg_cancel(msg, hdr);
13603 nlmsg_free(msg);
b23aa676
SO		 13604}
13605
13606void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
13607 struct net_device *netdev, const u8 *bssid,
13608 const u8 *req_ie, size_t req_ie_len,
13609 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
13610{
13611 struct sk_buff *msg;
13612 void *hdr;
13613
4ef8c1c9 13614 msg = nlmsg_new(100 + req_ie_len + resp_ie_len, gfp);
b23aa676
SO		 13615 if (!msg)
13616 return;
13617
13618 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
13619 if (!hdr) {
13620 nlmsg_free(msg);
13621 return;
13622 }
13623
9360ffd1
DM		 13624 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13625 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13626 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
13627 (req_ie &&
13628 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
13629 (resp_ie &&
13630 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
13631 goto nla_put_failure;
b23aa676 13632
3b7b72ee 13633 genlmsg_end(msg, hdr);
b23aa676 13634
68eb5503 13635 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13636 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 13637 return;
13638
13639 nla_put_failure:
13640 genlmsg_cancel(msg, hdr);
13641 nlmsg_free(msg);
b23aa676
SO		 13642}
13643
13644void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
13645 struct net_device *netdev, u16 reason,
667503dd 13646 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 13647{
13648 struct sk_buff *msg;
13649 void *hdr;
13650
4ef8c1c9 13651 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
b23aa676
SO		 13652 if (!msg)
13653 return;
13654
13655 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
13656 if (!hdr) {
13657 nlmsg_free(msg);
13658 return;
13659 }
13660
9360ffd1
DM		 13661 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13662 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13663 (from_ap && reason &&
13664 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
13665 (from_ap &&
13666 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
13667 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
13668 goto nla_put_failure;
b23aa676 13669
3b7b72ee 13670 genlmsg_end(msg, hdr);
b23aa676 13671
68eb5503 13672 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13673 NL80211_MCGRP_MLME, GFP_KERNEL);
b23aa676
SO		 13674 return;
13675
13676 nla_put_failure:
13677 genlmsg_cancel(msg, hdr);
13678 nlmsg_free(msg);
b23aa676
SO		 13679}
13680
04a773ad
JB		 13681void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
13682 struct net_device *netdev, const u8 *bssid,
13683 gfp_t gfp)
13684{
13685 struct sk_buff *msg;
13686 void *hdr;
13687
fd2120ca 13688 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 13689 if (!msg)
13690 return;
13691
13692 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
13693 if (!hdr) {
13694 nlmsg_free(msg);
13695 return;
13696 }
13697
9360ffd1
DM		 13698 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13699 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13700 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
13701 goto nla_put_failure;
04a773ad 13702
3b7b72ee 13703 genlmsg_end(msg, hdr);
04a773ad 13704
68eb5503 13705 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13706 NL80211_MCGRP_MLME, gfp);
04a773ad
JB		 13707 return;
13708
13709 nla_put_failure:
13710 genlmsg_cancel(msg, hdr);
13711 nlmsg_free(msg);
13712}
13713
947add36
JB		 13714void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
13715 const u8* ie, u8 ie_len, gfp_t gfp)
c93b5e71 13716{
947add36 13717 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 13718 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
c93b5e71
JC		 13719 struct sk_buff *msg;
13720 void *hdr;
13721
947add36
JB		 13722 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
13723 return;
13724
13725 trace_cfg80211_notify_new_peer_candidate(dev, addr);
13726
4ef8c1c9 13727 msg = nlmsg_new(100 + ie_len, gfp);
c93b5e71
JC		 13728 if (!msg)
13729 return;
13730
13731 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
13732 if (!hdr) {
13733 nlmsg_free(msg);
13734 return;
13735 }
13736
9360ffd1 13737 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36
JB		 13738 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
13739 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9360ffd1
DM		 13740 (ie_len && ie &&
13741 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
13742 goto nla_put_failure;
c93b5e71 13743
3b7b72ee 13744 genlmsg_end(msg, hdr);
c93b5e71 13745
68eb5503 13746 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13747 NL80211_MCGRP_MLME, gfp);
c93b5e71
JC		 13748 return;
13749
13750 nla_put_failure:
13751 genlmsg_cancel(msg, hdr);
13752 nlmsg_free(msg);
13753}
947add36 13754EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
c93b5e71 13755
a3b8b056
JM		 13756void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
13757 struct net_device *netdev, const u8 *addr,
13758 enum nl80211_key_type key_type, int key_id,
e6d6e342 13759 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 13760{
13761 struct sk_buff *msg;
13762 void *hdr;
13763
e6d6e342 13764 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 13765 if (!msg)
13766 return;
13767
13768 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
13769 if (!hdr) {
13770 nlmsg_free(msg);
13771 return;
13772 }
13773
9360ffd1
DM		 13774 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13775 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
13776 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
13777 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
13778 (key_id != -1 &&
13779 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
13780 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
13781 goto nla_put_failure;
a3b8b056 13782
3b7b72ee 13783 genlmsg_end(msg, hdr);
a3b8b056 13784
68eb5503 13785 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13786 NL80211_MCGRP_MLME, gfp);
a3b8b056
JM		 13787 return;
13788
13789 nla_put_failure:
13790 genlmsg_cancel(msg, hdr);
13791 nlmsg_free(msg);
13792}
13793
6bad8766
LR		 13794void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
13795 struct ieee80211_channel *channel_before,
13796 struct ieee80211_channel *channel_after)
13797{
13798 struct sk_buff *msg;
13799 void *hdr;
13800 struct nlattr *nl_freq;
13801
fd2120ca 13802 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 13803 if (!msg)
13804 return;
13805
13806 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
13807 if (!hdr) {
13808 nlmsg_free(msg);
13809 return;
13810 }
13811
13812 /*
13813 * Since we are applying the beacon hint to a wiphy we know its
13814 * wiphy_idx is valid
13815 */
9360ffd1
DM		 13816 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
13817 goto nla_put_failure;
6bad8766
LR		 13818
13819 /* Before */
13820 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
13821 if (!nl_freq)
13822 goto nla_put_failure;
cdc89b97 13823 if (nl80211_msg_put_channel(msg, channel_before, false))
6bad8766
LR		 13824 goto nla_put_failure;
13825 nla_nest_end(msg, nl_freq);
13826
13827 /* After */
13828 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
13829 if (!nl_freq)
13830 goto nla_put_failure;
cdc89b97 13831 if (nl80211_msg_put_channel(msg, channel_after, false))
6bad8766
LR		 13832 goto nla_put_failure;
13833 nla_nest_end(msg, nl_freq);
13834
3b7b72ee 13835 genlmsg_end(msg, hdr);
6bad8766 13836
463d0183 13837 rcu_read_lock();
68eb5503 13838 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 13839 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
463d0183 13840 rcu_read_unlock();
6bad8766
LR		 13841
13842 return;
13843
13844nla_put_failure:
13845 genlmsg_cancel(msg, hdr);
13846 nlmsg_free(msg);
13847}
13848
9588bbd5
JM		 13849static void nl80211_send_remain_on_chan_event(
13850 int cmd, struct cfg80211_registered_device *rdev,
71bbc994 13851 struct wireless_dev *wdev, u64 cookie,
9588bbd5 13852 struct ieee80211_channel *chan,
9588bbd5
JM		 13853 unsigned int duration, gfp_t gfp)
13854{
13855 struct sk_buff *msg;
13856 void *hdr;
13857
13858 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
13859 if (!msg)
13860 return;
13861
13862 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
13863 if (!hdr) {
13864 nlmsg_free(msg);
13865 return;
13866 }
13867
9360ffd1 13868 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 13869 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13870 wdev->netdev->ifindex)) ||
2dad624e
ND		 13871 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13872 NL80211_ATTR_PAD) ||
9360ffd1 13873 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
42d97a59
JB		 13874 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
13875 NL80211_CHAN_NO_HT) ||
2dad624e
ND		 13876 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
13877 NL80211_ATTR_PAD))
9360ffd1 13878 goto nla_put_failure;
9588bbd5 13879
9360ffd1
DM		 13880 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
13881 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
13882 goto nla_put_failure;
9588bbd5 13883
3b7b72ee 13884 genlmsg_end(msg, hdr);
9588bbd5 13885
68eb5503 13886 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13887 NL80211_MCGRP_MLME, gfp);
9588bbd5
JM		 13888 return;
13889
13890 nla_put_failure:
13891 genlmsg_cancel(msg, hdr);
13892 nlmsg_free(msg);
13893}
13894
947add36
JB		 13895void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
13896 struct ieee80211_channel *chan,
13897 unsigned int duration, gfp_t gfp)
9588bbd5 13898{
947add36 13899 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13900 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 13901
13902 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9588bbd5 13903 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
71bbc994 13904 rdev, wdev, cookie, chan,
42d97a59 13905 duration, gfp);
9588bbd5 13906}
947add36 13907EXPORT_SYMBOL(cfg80211_ready_on_channel);
9588bbd5 13908
947add36
JB		 13909void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
13910 struct ieee80211_channel *chan,
13911 gfp_t gfp)
9588bbd5 13912{
947add36 13913 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 13914 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 13915
13916 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9588bbd5 13917 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
42d97a59 13918 rdev, wdev, cookie, chan, 0, gfp);
9588bbd5 13919}
947add36 13920EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9588bbd5 13921
947add36
JB		 13922void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
13923 struct station_info *sinfo, gfp_t gfp)
98b62183 13924{
947add36 13925 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 13926 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
98b62183
JB		 13927 struct sk_buff *msg;
13928
947add36
JB		 13929 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
13930
58050fce 13931 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
98b62183
JB		 13932 if (!msg)
13933 return;
13934
cf5ead82 13935 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
66266b3a 13936 rdev, dev, mac_addr, sinfo) < 0) {
98b62183
JB		 13937 nlmsg_free(msg);
13938 return;
13939 }
13940
68eb5503 13941 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13942 NL80211_MCGRP_MLME, gfp);
98b62183 13943}
947add36 13944EXPORT_SYMBOL(cfg80211_new_sta);
98b62183 13945
cf5ead82
JB		 13946void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
13947 struct station_info *sinfo, gfp_t gfp)
ec15e68b 13948{
947add36 13949 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 13950 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ec15e68b 13951 struct sk_buff *msg;
cf5ead82
JB		 13952 struct station_info empty_sinfo = {};
13953
13954 if (!sinfo)
13955 sinfo = &empty_sinfo;
ec15e68b 13956
947add36
JB		 13957 trace_cfg80211_del_sta(dev, mac_addr);
13958
58050fce 13959 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
ec15e68b
JM		 13960 if (!msg)
13961 return;
13962
cf5ead82 13963 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
57007121 13964 rdev, dev, mac_addr, sinfo) < 0) {
ec15e68b
JM		 13965 nlmsg_free(msg);
13966 return;
13967 }
13968
68eb5503 13969 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 13970 NL80211_MCGRP_MLME, gfp);
ec15e68b 13971}
cf5ead82 13972EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
ec15e68b 13973
947add36
JB		 13974void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
13975 enum nl80211_connect_failed_reason reason,
13976 gfp_t gfp)
ed44a951 13977{
947add36 13978 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 13979 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ed44a951
PP		 13980 struct sk_buff *msg;
13981 void *hdr;
13982
13983 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
13984 if (!msg)
13985 return;
13986
13987 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
13988 if (!hdr) {
13989 nlmsg_free(msg);
13990 return;
13991 }
13992
13993 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
13994 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
13995 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
13996 goto nla_put_failure;
13997
13998 genlmsg_end(msg, hdr);
13999
68eb5503 14000 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14001 NL80211_MCGRP_MLME, gfp);
ed44a951
PP		 14002 return;
14003
14004 nla_put_failure:
14005 genlmsg_cancel(msg, hdr);
14006 nlmsg_free(msg);
14007}
947add36 14008EXPORT_SYMBOL(cfg80211_conn_failed);
ed44a951 14009
b92ab5d8
JB		 14010static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
14011 const u8 *addr, gfp_t gfp)
28946da7
JB		 14012{
14013 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14014 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
28946da7
JB		 14015 struct sk_buff *msg;
14016 void *hdr;
15e47304 14017 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
28946da7 14018
15e47304 14019 if (!nlportid)
28946da7
JB		 14020 return false;
14021
14022 msg = nlmsg_new(100, gfp);
14023 if (!msg)
14024 return true;
14025
b92ab5d8 14026 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
28946da7
JB		 14027 if (!hdr) {
14028 nlmsg_free(msg);
14029 return true;
14030 }
14031
9360ffd1
DM		 14032 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14033 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14034 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
14035 goto nla_put_failure;
28946da7 14036
9c90a9f6 14037 genlmsg_end(msg, hdr);
15e47304 14038 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
28946da7
JB		 14039 return true;
14040
14041 nla_put_failure:
14042 genlmsg_cancel(msg, hdr);
14043 nlmsg_free(msg);
14044 return true;
14045}
14046
947add36
JB		 14047bool cfg80211_rx_spurious_frame(struct net_device *dev,
14048 const u8 *addr, gfp_t gfp)
b92ab5d8 14049{
947add36
JB		 14050 struct wireless_dev *wdev = dev->ieee80211_ptr;
14051 bool ret;
14052
14053 trace_cfg80211_rx_spurious_frame(dev, addr);
14054
14055 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14056 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
14057 trace_cfg80211_return_bool(false);
14058 return false;
14059 }
14060 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
14061 addr, gfp);
14062 trace_cfg80211_return_bool(ret);
14063 return ret;
b92ab5d8 14064}
947add36 14065EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
b92ab5d8 14066
947add36
JB		 14067bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
14068 const u8 *addr, gfp_t gfp)
b92ab5d8 14069{
947add36
JB		 14070 struct wireless_dev *wdev = dev->ieee80211_ptr;
14071 bool ret;
14072
14073 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
14074
14075 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
14076 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
14077 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
14078 trace_cfg80211_return_bool(false);
14079 return false;
14080 }
14081 ret = __nl80211_unexpected_frame(dev,
14082 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
14083 addr, gfp);
14084 trace_cfg80211_return_bool(ret);
14085 return ret;
b92ab5d8 14086}
947add36 14087EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
b92ab5d8 14088
2e161f78 14089int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15e47304 14090 struct wireless_dev *wdev, u32 nlportid,
804483e9 14091 int freq, int sig_dbm,
19504cf5 14092 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
026331c4 14093{
71bbc994 14094 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14095 struct sk_buff *msg;
14096 void *hdr;
026331c4 14097
4ef8c1c9 14098 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14099 if (!msg)
14100 return -ENOMEM;
14101
2e161f78 14102 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
026331c4
JM		 14103 if (!hdr) {
14104 nlmsg_free(msg);
14105 return -ENOMEM;
14106 }
14107
9360ffd1 14108 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14109 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14110 netdev->ifindex)) ||
2dad624e
ND		 14111 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14112 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14113 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
14114 (sig_dbm &&
14115 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19504cf5
VK		 14116 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
14117 (flags &&
14118 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
9360ffd1 14119 goto nla_put_failure;
026331c4 14120
3b7b72ee 14121 genlmsg_end(msg, hdr);
026331c4 14122
15e47304 14123 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
026331c4
JM		 14124
14125 nla_put_failure:
14126 genlmsg_cancel(msg, hdr);
14127 nlmsg_free(msg);
14128 return -ENOBUFS;
14129}
14130
947add36
JB		 14131void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
14132 const u8 *buf, size_t len, bool ack, gfp_t gfp)
026331c4 14133{
947add36 14134 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14135 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
71bbc994 14136 struct net_device *netdev = wdev->netdev;
026331c4
JM		 14137 struct sk_buff *msg;
14138 void *hdr;
14139
947add36
JB		 14140 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
14141
4ef8c1c9 14142 msg = nlmsg_new(100 + len, gfp);
026331c4
JM		 14143 if (!msg)
14144 return;
14145
2e161f78 14146 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
026331c4
JM		 14147 if (!hdr) {
14148 nlmsg_free(msg);
14149 return;
14150 }
14151
9360ffd1 14152 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 14153 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14154 netdev->ifindex)) ||
2dad624e
ND		 14155 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14156 NL80211_ATTR_PAD) ||
9360ffd1 14157 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
2dad624e
ND		 14158 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14159 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14160 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
14161 goto nla_put_failure;
026331c4 14162
3b7b72ee 14163 genlmsg_end(msg, hdr);
026331c4 14164
68eb5503 14165 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14166 NL80211_MCGRP_MLME, gfp);
026331c4
JM		 14167 return;
14168
14169 nla_put_failure:
14170 genlmsg_cancel(msg, hdr);
14171 nlmsg_free(msg);
14172}
947add36 14173EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
026331c4 14174
5b97f49d
JB		 14175static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
14176 const char *mac, gfp_t gfp)
d6dc1a38 14177{
947add36 14178 struct wireless_dev *wdev = dev->ieee80211_ptr;
5b97f49d
JB		 14179 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
14180 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14181 void **cb;
947add36 14182
d6dc1a38 14183 if (!msg)
5b97f49d 14184 return NULL;
d6dc1a38 14185
5b97f49d
JB		 14186 cb = (void **)msg->cb;
14187
14188 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
14189 if (!cb[0]) {
d6dc1a38 14190 nlmsg_free(msg);
5b97f49d 14191 return NULL;
d6dc1a38
JO		 14192 }
14193
9360ffd1 14194 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36 14195 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9360ffd1 14196 goto nla_put_failure;
d6dc1a38 14197
5b97f49d 14198 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
d6dc1a38
JO		 14199 goto nla_put_failure;
14200
5b97f49d
JB		 14201 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
14202 if (!cb[1])
9360ffd1 14203 goto nla_put_failure;
d6dc1a38 14204
5b97f49d 14205 cb[2] = rdev;
d6dc1a38 14206
5b97f49d
JB		 14207 return msg;
14208 nla_put_failure:
14209 nlmsg_free(msg);
14210 return NULL;
14211}
14212
14213static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
14214{
14215 void **cb = (void **)msg->cb;
14216 struct cfg80211_registered_device *rdev = cb[2];
14217
14218 nla_nest_end(msg, cb[1]);
14219 genlmsg_end(msg, cb[0]);
14220
14221 memset(msg->cb, 0, sizeof(msg->cb));
d6dc1a38 14222
68eb5503 14223 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14224 NL80211_MCGRP_MLME, gfp);
5b97f49d
JB		 14225}
14226
14227void cfg80211_cqm_rssi_notify(struct net_device *dev,
14228 enum nl80211_cqm_rssi_threshold_event rssi_event,
bee427b8 14229 s32 rssi_level, gfp_t gfp)
5b97f49d
JB		 14230{
14231 struct sk_buff *msg;
4a4b8169
AZ		 14232 struct wireless_dev *wdev = dev->ieee80211_ptr;
14233 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
5b97f49d 14234
bee427b8 14235 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
5b97f49d 14236
98f03342
JB		 14237 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
14238 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
14239 return;
14240
4a4b8169
AZ		 14241 if (wdev->cqm_config) {
14242 wdev->cqm_config->last_rssi_event_value = rssi_level;
14243
14244 cfg80211_cqm_rssi_update(rdev, dev);
14245
14246 if (rssi_level == 0)
14247 rssi_level = wdev->cqm_config->last_rssi_event_value;
14248 }
14249
5b97f49d
JB		 14250 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14251 if (!msg)
14252 return;
14253
14254 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
14255 rssi_event))
14256 goto nla_put_failure;
14257
bee427b8
AZ		 14258 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
14259 rssi_level))
14260 goto nla_put_failure;
14261
5b97f49d
JB		 14262 cfg80211_send_cqm(msg, gfp);
14263
d6dc1a38
JO		 14264 return;
14265
14266 nla_put_failure:
d6dc1a38
JO		 14267 nlmsg_free(msg);
14268}
947add36 14269EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
d6dc1a38 14270
5b97f49d
JB		 14271void cfg80211_cqm_txe_notify(struct net_device *dev,
14272 const u8 *peer, u32 num_packets,
14273 u32 rate, u32 intvl, gfp_t gfp)
14274{
14275 struct sk_buff *msg;
14276
14277 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14278 if (!msg)
14279 return;
14280
14281 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
14282 goto nla_put_failure;
14283
14284 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
14285 goto nla_put_failure;
14286
14287 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
14288 goto nla_put_failure;
14289
14290 cfg80211_send_cqm(msg, gfp);
14291 return;
14292
14293 nla_put_failure:
14294 nlmsg_free(msg);
14295}
14296EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
14297
14298void cfg80211_cqm_pktloss_notify(struct net_device *dev,
14299 const u8 *peer, u32 num_packets, gfp_t gfp)
14300{
14301 struct sk_buff *msg;
14302
14303 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
14304
14305 msg = cfg80211_prepare_cqm(dev, peer, gfp);
14306 if (!msg)
14307 return;
14308
14309 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
14310 goto nla_put_failure;
14311
14312 cfg80211_send_cqm(msg, gfp);
14313 return;
14314
14315 nla_put_failure:
14316 nlmsg_free(msg);
14317}
14318EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
14319
98f03342
JB		 14320void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
14321{
14322 struct sk_buff *msg;
14323
14324 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
14325 if (!msg)
14326 return;
14327
14328 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
14329 goto nla_put_failure;
14330
14331 cfg80211_send_cqm(msg, gfp);
14332 return;
14333
14334 nla_put_failure:
14335 nlmsg_free(msg);
14336}
14337EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
14338
947add36
JB		 14339static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
14340 struct net_device *netdev, const u8 *bssid,
14341 const u8 *replay_ctr, gfp_t gfp)
e5497d76
JB		 14342{
14343 struct sk_buff *msg;
14344 struct nlattr *rekey_attr;
14345 void *hdr;
14346
58050fce 14347 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
e5497d76
JB		 14348 if (!msg)
14349 return;
14350
14351 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
14352 if (!hdr) {
14353 nlmsg_free(msg);
14354 return;
14355 }
14356
9360ffd1
DM		 14357 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14358 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14359 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14360 goto nla_put_failure;
e5497d76
JB		 14361
14362 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
14363 if (!rekey_attr)
14364 goto nla_put_failure;
14365
9360ffd1
DM		 14366 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
14367 NL80211_REPLAY_CTR_LEN, replay_ctr))
14368 goto nla_put_failure;
e5497d76
JB		 14369
14370 nla_nest_end(msg, rekey_attr);
14371
3b7b72ee 14372 genlmsg_end(msg, hdr);
e5497d76 14373
68eb5503 14374 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14375 NL80211_MCGRP_MLME, gfp);
e5497d76
JB		 14376 return;
14377
14378 nla_put_failure:
14379 genlmsg_cancel(msg, hdr);
14380 nlmsg_free(msg);
14381}
14382
947add36
JB		 14383void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
14384 const u8 *replay_ctr, gfp_t gfp)
14385{
14386 struct wireless_dev *wdev = dev->ieee80211_ptr;
14387 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14388 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14389
14390 trace_cfg80211_gtk_rekey_notify(dev, bssid);
14391 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
14392}
14393EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
14394
14395static void
14396nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
14397 struct net_device *netdev, int index,
14398 const u8 *bssid, bool preauth, gfp_t gfp)
c9df56b4
JM		 14399{
14400 struct sk_buff *msg;
14401 struct nlattr *attr;
14402 void *hdr;
14403
58050fce 14404 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
c9df56b4
JM		 14405 if (!msg)
14406 return;
14407
14408 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
14409 if (!hdr) {
14410 nlmsg_free(msg);
14411 return;
14412 }
14413
9360ffd1
DM		 14414 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14415 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14416 goto nla_put_failure;
c9df56b4
JM		 14417
14418 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
14419 if (!attr)
14420 goto nla_put_failure;
14421
9360ffd1
DM		 14422 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
14423 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
14424 (preauth &&
14425 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
14426 goto nla_put_failure;
c9df56b4
JM		 14427
14428 nla_nest_end(msg, attr);
14429
3b7b72ee 14430 genlmsg_end(msg, hdr);
c9df56b4 14431
68eb5503 14432 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14433 NL80211_MCGRP_MLME, gfp);
c9df56b4
JM		 14434 return;
14435
14436 nla_put_failure:
14437 genlmsg_cancel(msg, hdr);
14438 nlmsg_free(msg);
14439}
14440
947add36
JB		 14441void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
14442 const u8 *bssid, bool preauth, gfp_t gfp)
14443{
14444 struct wireless_dev *wdev = dev->ieee80211_ptr;
14445 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14446 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 14447
14448 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
14449 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
14450}
14451EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
14452
14453static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
14454 struct net_device *netdev,
14455 struct cfg80211_chan_def *chandef,
f8d7552e
LC		 14456 gfp_t gfp,
14457 enum nl80211_commands notif,
14458 u8 count)
5314526b
TP		 14459{
14460 struct sk_buff *msg;
14461 void *hdr;
14462
58050fce 14463 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5314526b
TP		 14464 if (!msg)
14465 return;
14466
f8d7552e 14467 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
5314526b
TP		 14468 if (!hdr) {
14469 nlmsg_free(msg);
14470 return;
14471 }
14472
683b6d3b
JB		 14473 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
14474 goto nla_put_failure;
14475
14476 if (nl80211_send_chandef(msg, chandef))
7eab0f64 14477 goto nla_put_failure;
5314526b 14478
f8d7552e
LC		 14479 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
14480 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
14481 goto nla_put_failure;
14482
5314526b
TP		 14483 genlmsg_end(msg, hdr);
14484
68eb5503 14485 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14486 NL80211_MCGRP_MLME, gfp);
5314526b
TP		 14487 return;
14488
14489 nla_put_failure:
14490 genlmsg_cancel(msg, hdr);
14491 nlmsg_free(msg);
14492}
14493
947add36
JB		 14494void cfg80211_ch_switch_notify(struct net_device *dev,
14495 struct cfg80211_chan_def *chandef)
84f10708 14496{
947add36
JB		 14497 struct wireless_dev *wdev = dev->ieee80211_ptr;
14498 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 14499 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36 14500
e487eaeb 14501 ASSERT_WDEV_LOCK(wdev);
947add36 14502
e487eaeb 14503 trace_cfg80211_ch_switch_notify(dev, chandef);
947add36 14504
9e0e2961 14505 wdev->chandef = *chandef;
96f55f12 14506 wdev->preset_chandef = *chandef;
f8d7552e
LC		 14507 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14508 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
947add36
JB		 14509}
14510EXPORT_SYMBOL(cfg80211_ch_switch_notify);
14511
f8d7552e
LC		 14512void cfg80211_ch_switch_started_notify(struct net_device *dev,
14513 struct cfg80211_chan_def *chandef,
14514 u8 count)
14515{
14516 struct wireless_dev *wdev = dev->ieee80211_ptr;
14517 struct wiphy *wiphy = wdev->wiphy;
14518 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14519
14520 trace_cfg80211_ch_switch_started_notify(dev, chandef);
14521
14522 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
14523 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
14524}
14525EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
14526
04f39047
SW		 14527void
14528nl80211_radar_notify(struct cfg80211_registered_device *rdev,
d2859df5 14529 const struct cfg80211_chan_def *chandef,
04f39047
SW		 14530 enum nl80211_radar_event event,
14531 struct net_device *netdev, gfp_t gfp)
14532{
14533 struct sk_buff *msg;
14534 void *hdr;
14535
14536 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14537 if (!msg)
14538 return;
14539
14540 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
14541 if (!hdr) {
14542 nlmsg_free(msg);
14543 return;
14544 }
14545
14546 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
14547 goto nla_put_failure;
14548
14549 /* NOP and radar events don't need a netdev parameter */
14550 if (netdev) {
14551 struct wireless_dev *wdev = netdev->ieee80211_ptr;
14552
14553 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
2dad624e
ND		 14554 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14555 NL80211_ATTR_PAD))
04f39047
SW		 14556 goto nla_put_failure;
14557 }
14558
14559 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
14560 goto nla_put_failure;
14561
14562 if (nl80211_send_chandef(msg, chandef))
14563 goto nla_put_failure;
14564
9c90a9f6 14565 genlmsg_end(msg, hdr);
04f39047 14566
68eb5503 14567 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14568 NL80211_MCGRP_MLME, gfp);
04f39047
SW		 14569 return;
14570
14571 nla_put_failure:
14572 genlmsg_cancel(msg, hdr);
14573 nlmsg_free(msg);
14574}
14575
7f6cf311
JB		 14576void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
14577 u64 cookie, bool acked, gfp_t gfp)
14578{
14579 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14580 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
7f6cf311
JB		 14581 struct sk_buff *msg;
14582 void *hdr;
7f6cf311 14583
4ee3e063
BL		 14584 trace_cfg80211_probe_status(dev, addr, cookie, acked);
14585
58050fce 14586 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4ee3e063 14587
7f6cf311
JB		 14588 if (!msg)
14589 return;
14590
14591 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
14592 if (!hdr) {
14593 nlmsg_free(msg);
14594 return;
14595 }
14596
9360ffd1
DM		 14597 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14598 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14599 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
2dad624e
ND		 14600 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14601 NL80211_ATTR_PAD) ||
9360ffd1
DM		 14602 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
14603 goto nla_put_failure;
7f6cf311 14604
9c90a9f6 14605 genlmsg_end(msg, hdr);
7f6cf311 14606
68eb5503 14607 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14608 NL80211_MCGRP_MLME, gfp);
7f6cf311
JB		 14609 return;
14610
14611 nla_put_failure:
14612 genlmsg_cancel(msg, hdr);
14613 nlmsg_free(msg);
14614}
14615EXPORT_SYMBOL(cfg80211_probe_status);
14616
5e760230
JB		 14617void cfg80211_report_obss_beacon(struct wiphy *wiphy,
14618 const u8 *frame, size_t len,
37c73b5f 14619 int freq, int sig_dbm)
5e760230 14620{
f26cbf40 14621 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5e760230
JB		 14622 struct sk_buff *msg;
14623 void *hdr;
37c73b5f 14624 struct cfg80211_beacon_registration *reg;
5e760230 14625
4ee3e063
BL		 14626 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
14627
37c73b5f
BG		 14628 spin_lock_bh(&rdev->beacon_registrations_lock);
14629 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
14630 msg = nlmsg_new(len + 100, GFP_ATOMIC);
14631 if (!msg) {
14632 spin_unlock_bh(&rdev->beacon_registrations_lock);
14633 return;
14634 }
5e760230 14635
37c73b5f
BG		 14636 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
14637 if (!hdr)
14638 goto nla_put_failure;
5e760230 14639
37c73b5f
BG		 14640 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14641 (freq &&
14642 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
14643 (sig_dbm &&
14644 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
14645 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
14646 goto nla_put_failure;
5e760230 14647
37c73b5f 14648 genlmsg_end(msg, hdr);
5e760230 14649
37c73b5f
BG		 14650 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
14651 }
14652 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 14653 return;
14654
14655 nla_put_failure:
37c73b5f
BG		 14656 spin_unlock_bh(&rdev->beacon_registrations_lock);
14657 if (hdr)
14658 genlmsg_cancel(msg, hdr);
5e760230
JB		 14659 nlmsg_free(msg);
14660}
14661EXPORT_SYMBOL(cfg80211_report_obss_beacon);
14662
cd8f7cb4 14663#ifdef CONFIG_PM
8cd4d456
LC		 14664static int cfg80211_net_detect_results(struct sk_buff *msg,
14665 struct cfg80211_wowlan_wakeup *wakeup)
14666{
14667 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
14668 struct nlattr *nl_results, *nl_match, *nl_freqs;
14669 int i, j;
14670
14671 nl_results = nla_nest_start(
14672 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
14673 if (!nl_results)
14674 return -EMSGSIZE;
14675
14676 for (i = 0; i < nd->n_matches; i++) {
14677 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
14678
14679 nl_match = nla_nest_start(msg, i);
14680 if (!nl_match)
14681 break;
14682
14683 /* The SSID attribute is optional in nl80211, but for
14684 * simplicity reasons it's always present in the
14685 * cfg80211 structure. If a driver can't pass the
14686 * SSID, that needs to be changed. A zero length SSID
14687 * is still a valid SSID (wildcard), so it cannot be
14688 * used for this purpose.
14689 */
14690 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
14691 match->ssid.ssid)) {
14692 nla_nest_cancel(msg, nl_match);
14693 goto out;
14694 }
14695
14696 if (match->n_channels) {
14697 nl_freqs = nla_nest_start(
14698 msg, NL80211_ATTR_SCAN_FREQUENCIES);
14699 if (!nl_freqs) {
14700 nla_nest_cancel(msg, nl_match);
14701 goto out;
14702 }
14703
14704 for (j = 0; j < match->n_channels; j++) {
5528fae8 14705 if (nla_put_u32(msg, j, match->channels[j])) {
8cd4d456
LC		 14706 nla_nest_cancel(msg, nl_freqs);
14707 nla_nest_cancel(msg, nl_match);
14708 goto out;
14709 }
14710 }
14711
14712 nla_nest_end(msg, nl_freqs);
14713 }
14714
14715 nla_nest_end(msg, nl_match);
14716 }
14717
14718out:
14719 nla_nest_end(msg, nl_results);
14720 return 0;
14721}
14722
cd8f7cb4
JB		 14723void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
14724 struct cfg80211_wowlan_wakeup *wakeup,
14725 gfp_t gfp)
14726{
f26cbf40 14727 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
cd8f7cb4
JB		 14728 struct sk_buff *msg;
14729 void *hdr;
9c90a9f6 14730 int size = 200;
cd8f7cb4
JB		 14731
14732 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
14733
14734 if (wakeup)
14735 size += wakeup->packet_present_len;
14736
14737 msg = nlmsg_new(size, gfp);
14738 if (!msg)
14739 return;
14740
14741 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
14742 if (!hdr)
14743 goto free_msg;
14744
14745 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 14746 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14747 NL80211_ATTR_PAD))
cd8f7cb4
JB		 14748 goto free_msg;
14749
14750 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14751 wdev->netdev->ifindex))
14752 goto free_msg;
14753
14754 if (wakeup) {
14755 struct nlattr *reasons;
14756
14757 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7fa322c8
JB		 14758 if (!reasons)
14759 goto free_msg;
cd8f7cb4
JB		 14760
14761 if (wakeup->disconnect &&
14762 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
14763 goto free_msg;
14764 if (wakeup->magic_pkt &&
14765 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
14766 goto free_msg;
14767 if (wakeup->gtk_rekey_failure &&
14768 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
14769 goto free_msg;
14770 if (wakeup->eap_identity_req &&
14771 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
14772 goto free_msg;
14773 if (wakeup->four_way_handshake &&
14774 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
14775 goto free_msg;
14776 if (wakeup->rfkill_release &&
14777 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
14778 goto free_msg;
14779
14780 if (wakeup->pattern_idx >= 0 &&
14781 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
14782 wakeup->pattern_idx))
14783 goto free_msg;
14784
ae917c9f
JB		 14785 if (wakeup->tcp_match &&
14786 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
14787 goto free_msg;
2a0e047e 14788
ae917c9f
JB		 14789 if (wakeup->tcp_connlost &&
14790 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
14791 goto free_msg;
2a0e047e 14792
ae917c9f
JB		 14793 if (wakeup->tcp_nomoretokens &&
14794 nla_put_flag(msg,
14795 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
14796 goto free_msg;
2a0e047e 14797
cd8f7cb4
JB		 14798 if (wakeup->packet) {
14799 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
14800 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
14801
14802 if (!wakeup->packet_80211) {
14803 pkt_attr =
14804 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
14805 len_attr =
14806 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
14807 }
14808
14809 if (wakeup->packet_len &&
14810 nla_put_u32(msg, len_attr, wakeup->packet_len))
14811 goto free_msg;
14812
14813 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
14814 wakeup->packet))
14815 goto free_msg;
14816 }
14817
8cd4d456
LC		 14818 if (wakeup->net_detect &&
14819 cfg80211_net_detect_results(msg, wakeup))
14820 goto free_msg;
14821
cd8f7cb4
JB		 14822 nla_nest_end(msg, reasons);
14823 }
14824
9c90a9f6 14825 genlmsg_end(msg, hdr);
cd8f7cb4 14826
68eb5503 14827 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14828 NL80211_MCGRP_MLME, gfp);
cd8f7cb4
JB		 14829 return;
14830
14831 free_msg:
14832 nlmsg_free(msg);
14833}
14834EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
14835#endif
14836
3475b094
JM		 14837void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
14838 enum nl80211_tdls_operation oper,
14839 u16 reason_code, gfp_t gfp)
14840{
14841 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 14842 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
3475b094
JM		 14843 struct sk_buff *msg;
14844 void *hdr;
3475b094
JM		 14845
14846 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
14847 reason_code);
14848
14849 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14850 if (!msg)
14851 return;
14852
14853 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
14854 if (!hdr) {
14855 nlmsg_free(msg);
14856 return;
14857 }
14858
14859 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14860 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14861 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
14862 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
14863 (reason_code > 0 &&
14864 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
14865 goto nla_put_failure;
14866
9c90a9f6 14867 genlmsg_end(msg, hdr);
3475b094 14868
68eb5503 14869 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14870 NL80211_MCGRP_MLME, gfp);
3475b094
JM		 14871 return;
14872
14873 nla_put_failure:
14874 genlmsg_cancel(msg, hdr);
14875 nlmsg_free(msg);
14876}
14877EXPORT_SYMBOL(cfg80211_tdls_oper_request);
14878
026331c4
JM		 14879static int nl80211_netlink_notify(struct notifier_block * nb,
14880 unsigned long state,
14881 void *_notify)
14882{
14883 struct netlink_notify *notify = _notify;
14884 struct cfg80211_registered_device *rdev;
14885 struct wireless_dev *wdev;
37c73b5f 14886 struct cfg80211_beacon_registration *reg, *tmp;
026331c4 14887
8f815cdd 14888 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
026331c4
JM		 14889 return NOTIFY_DONE;
14890
14891 rcu_read_lock();
14892
5e760230 14893 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
78f22b6a 14894 bool schedule_destroy_work = false;
93a1e86c
JR		 14895 struct cfg80211_sched_scan_request *sched_scan_req =
14896 rcu_dereference(rdev->sched_scan_req);
14897
14898 if (sched_scan_req && notify->portid &&
753aacfd
JB		 14899 sched_scan_req->owner_nlportid == notify->portid) {
14900 sched_scan_req->owner_nlportid = 0;
14901
14902 if (rdev->ops->sched_scan_stop &&
14903 rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
14904 schedule_work(&rdev->sched_scan_stop_wk);
14905 }
78f22b6a 14906
53873f13 14907 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
15e47304 14908 cfg80211_mlme_unregister_socket(wdev, notify->portid);
37c73b5f 14909
78f22b6a
JB		 14910 if (wdev->owner_nlportid == notify->portid)
14911 schedule_destroy_work = true;
bd2522b1
AZ		 14912 else if (wdev->conn_owner_nlportid == notify->portid)
14913 schedule_work(&wdev->disconnect_wk);
78f22b6a
JB		 14914 }
14915
37c73b5f
BG		 14916 spin_lock_bh(&rdev->beacon_registrations_lock);
14917 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
14918 list) {
14919 if (reg->nlportid == notify->portid) {
14920 list_del(&reg->list);
14921 kfree(reg);
14922 break;
14923 }
14924 }
14925 spin_unlock_bh(&rdev->beacon_registrations_lock);
78f22b6a
JB		 14926
14927 if (schedule_destroy_work) {
14928 struct cfg80211_iface_destroy *destroy;
14929
14930 destroy = kzalloc(sizeof(*destroy), GFP_ATOMIC);
14931 if (destroy) {
14932 destroy->nlportid = notify->portid;
14933 spin_lock(&rdev->destroy_list_lock);
14934 list_add(&destroy->list, &rdev->destroy_list);
14935 spin_unlock(&rdev->destroy_list_lock);
14936 schedule_work(&rdev->destroy_work);
14937 }
14938 }
5e760230 14939 }
026331c4
JM		 14940
14941 rcu_read_unlock();
14942
05050753
I		 14943 /*
14944 * It is possible that the user space process that is controlling the
14945 * indoor setting disappeared, so notify the regulatory core.
14946 */
14947 regulatory_netlink_notify(notify->portid);
6784c7db 14948 return NOTIFY_OK;
026331c4
JM		 14949}
14950
14951static struct notifier_block nl80211_netlink_notifier = {
14952 .notifier_call = nl80211_netlink_notify,
14953};
14954
355199e0
JM		 14955void cfg80211_ft_event(struct net_device *netdev,
14956 struct cfg80211_ft_event_params *ft_event)
14957{
14958 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
f26cbf40 14959 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
355199e0
JM		 14960 struct sk_buff *msg;
14961 void *hdr;
355199e0
JM		 14962
14963 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
14964
14965 if (!ft_event->target_ap)
14966 return;
14967
4ef8c1c9 14968 msg = nlmsg_new(100 + ft_event->ric_ies_len, GFP_KERNEL);
355199e0
JM		 14969 if (!msg)
14970 return;
14971
14972 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
ae917c9f
JB		 14973 if (!hdr)
14974 goto out;
355199e0 14975
ae917c9f
JB		 14976 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14977 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14978 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
14979 goto out;
355199e0 14980
ae917c9f
JB		 14981 if (ft_event->ies &&
14982 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
14983 goto out;
14984 if (ft_event->ric_ies &&
14985 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
14986 ft_event->ric_ies))
14987 goto out;
355199e0 14988
9c90a9f6 14989 genlmsg_end(msg, hdr);
355199e0 14990
68eb5503 14991 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 14992 NL80211_MCGRP_MLME, GFP_KERNEL);
ae917c9f
JB		 14993 return;
14994 out:
14995 nlmsg_free(msg);
355199e0
JM		 14996}
14997EXPORT_SYMBOL(cfg80211_ft_event);
14998
5de17984
AS		 14999void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
15000{
15001 struct cfg80211_registered_device *rdev;
15002 struct sk_buff *msg;
15003 void *hdr;
15004 u32 nlportid;
15005
f26cbf40 15006 rdev = wiphy_to_rdev(wdev->wiphy);
5de17984
AS		 15007 if (!rdev->crit_proto_nlportid)
15008 return;
15009
15010 nlportid = rdev->crit_proto_nlportid;
15011 rdev->crit_proto_nlportid = 0;
15012
15013 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15014 if (!msg)
15015 return;
15016
15017 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
15018 if (!hdr)
15019 goto nla_put_failure;
15020
15021 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2dad624e
ND		 15022 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15023 NL80211_ATTR_PAD))
5de17984
AS		 15024 goto nla_put_failure;
15025
15026 genlmsg_end(msg, hdr);
15027
15028 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15029 return;
15030
15031 nla_put_failure:
15032 if (hdr)
15033 genlmsg_cancel(msg, hdr);
15034 nlmsg_free(msg);
5de17984
AS		 15035}
15036EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
15037
348baf0e
JB		 15038void nl80211_send_ap_stopped(struct wireless_dev *wdev)
15039{
15040 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 15041 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
348baf0e
JB		 15042 struct sk_buff *msg;
15043 void *hdr;
15044
15045 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15046 if (!msg)
15047 return;
15048
15049 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
15050 if (!hdr)
15051 goto out;
15052
15053 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15054 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
2dad624e
ND		 15055 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15056 NL80211_ATTR_PAD))
348baf0e
JB		 15057 goto out;
15058
15059 genlmsg_end(msg, hdr);
15060
15061 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
15062 NL80211_MCGRP_MLME, GFP_KERNEL);
15063 return;
15064 out:
15065 nlmsg_free(msg);
15066}
15067
55682965
JB		 15068/* initialisation/exit functions */
15069
56989f6d 15070int __init nl80211_init(void)
55682965 15071{
0d63cbb5 15072 int err;
55682965 15073
489111e5 15074 err = genl_register_family(&nl80211_fam);
55682965
JB		 15075 if (err)
15076 return err;
15077
026331c4
JM		 15078 err = netlink_register_notifier(&nl80211_netlink_notifier);
15079 if (err)
15080 goto err_out;
15081
55682965
JB		 15082 return 0;
15083 err_out:
15084 genl_unregister_family(&nl80211_fam);
15085 return err;
15086}
15087
15088void nl80211_exit(void)
15089{
026331c4 15090 netlink_unregister_notifier(&nl80211_netlink_notifier);
55682965
JB		 15091 genl_unregister_family(&nl80211_fam);
15092}
Ubuntu Focal Linux kernel mirror