]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/wireless/nl80211.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nl80211: clarify packet statistics descriptions
[mirror_ubuntu-bionic-kernel.git] / net / wireless / nl80211.c
CommitLineData
55682965
JB		 1/*
2 * This is the new netlink-based wireless configuration interface.
3 *
026331c4 4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
2740f0cf 5 * Copyright 2013-2014 Intel Mobile Communications GmbH
55682965
JB		 6 */
7
8#include <linux/if.h>
9#include <linux/module.h>
10#include <linux/err.h>
5a0e3ad6 11#include <linux/slab.h>
55682965
JB		 12#include <linux/list.h>
13#include <linux/if_ether.h>
14#include <linux/ieee80211.h>
15#include <linux/nl80211.h>
16#include <linux/rtnetlink.h>
17#include <linux/netlink.h>
2a519311 18#include <linux/etherdevice.h>
463d0183 19#include <net/net_namespace.h>
55682965
JB		 20#include <net/genetlink.h>
21#include <net/cfg80211.h>
463d0183 22#include <net/sock.h>
2a0e047e 23#include <net/inet_connection_sock.h>
55682965
JB		 24#include "core.h"
25#include "nl80211.h"
b2e1b302 26#include "reg.h"
e35e4d28 27#include "rdev-ops.h"
55682965 28
5fb628e9
JM		 29static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
30 struct genl_info *info,
31 struct cfg80211_crypto_settings *settings,
32 int cipher_limit);
33
f84f771d 34static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991 35 struct genl_info *info);
f84f771d 36static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 37 struct genl_info *info);
38
55682965
JB		 39/* the netlink family */
40static struct genl_family nl80211_fam = {
fb4e1568
MH		 41 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
42 .name = NL80211_GENL_NAME, /* have users key off the name instead */
43 .hdrsize = 0, /* no private header */
44 .version = 1, /* no particular meaning now */
55682965 45 .maxattr = NL80211_ATTR_MAX,
463d0183 46 .netnsok = true,
4c476991
JB		 47 .pre_doit = nl80211_pre_doit,
48 .post_doit = nl80211_post_doit,
55682965
JB		 49};
50
2a94fe48
JB		 51/* multicast groups */
52enum nl80211_multicast_groups {
53 NL80211_MCGRP_CONFIG,
54 NL80211_MCGRP_SCAN,
55 NL80211_MCGRP_REGULATORY,
56 NL80211_MCGRP_MLME,
567ffc35 57 NL80211_MCGRP_VENDOR,
2a94fe48
JB		 58 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
59};
60
61static const struct genl_multicast_group nl80211_mcgrps[] = {
71b836ec
JB		 62 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
63 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
64 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
65 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
66 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
2a94fe48 67#ifdef CONFIG_NL80211_TESTMODE
71b836ec 68 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
2a94fe48
JB		 69#endif
70};
71
89a54e48
JB		 72/* returns ERR_PTR values */
73static struct wireless_dev *
74__cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
55682965 75{
89a54e48
JB		 76 struct cfg80211_registered_device *rdev;
77 struct wireless_dev *result = NULL;
78 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
79 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
80 u64 wdev_id;
81 int wiphy_idx = -1;
82 int ifidx = -1;
55682965 83
5fe231e8 84 ASSERT_RTNL();
55682965 85
89a54e48
JB		 86 if (!have_ifidx && !have_wdev_id)
87 return ERR_PTR(-EINVAL);
55682965 88
89a54e48
JB		 89 if (have_ifidx)
90 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
91 if (have_wdev_id) {
92 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
93 wiphy_idx = wdev_id >> 32;
55682965
JB		 94 }
95
89a54e48
JB		 96 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
97 struct wireless_dev *wdev;
98
99 if (wiphy_net(&rdev->wiphy) != netns)
100 continue;
101
102 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
103 continue;
104
89a54e48
JB		 105 list_for_each_entry(wdev, &rdev->wdev_list, list) {
106 if (have_ifidx && wdev->netdev &&
107 wdev->netdev->ifindex == ifidx) {
108 result = wdev;
109 break;
110 }
111 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
112 result = wdev;
113 break;
114 }
115 }
89a54e48
JB		 116
117 if (result)
118 break;
119 }
120
121 if (result)
122 return result;
123 return ERR_PTR(-ENODEV);
55682965
JB		 124}
125
a9455408 126static struct cfg80211_registered_device *
878d9ec7 127__cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
a9455408 128{
7fee4778
JB		 129 struct cfg80211_registered_device *rdev = NULL, *tmp;
130 struct net_device *netdev;
a9455408 131
5fe231e8 132 ASSERT_RTNL();
a9455408 133
878d9ec7 134 if (!attrs[NL80211_ATTR_WIPHY] &&
89a54e48
JB		 135 !attrs[NL80211_ATTR_IFINDEX] &&
136 !attrs[NL80211_ATTR_WDEV])
7fee4778
JB		 137 return ERR_PTR(-EINVAL);
138
878d9ec7 139 if (attrs[NL80211_ATTR_WIPHY])
7fee4778 140 rdev = cfg80211_rdev_by_wiphy_idx(
878d9ec7 141 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
a9455408 142
89a54e48
JB		 143 if (attrs[NL80211_ATTR_WDEV]) {
144 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
145 struct wireless_dev *wdev;
146 bool found = false;
147
148 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
149 if (tmp) {
150 /* make sure wdev exists */
89a54e48
JB		 151 list_for_each_entry(wdev, &tmp->wdev_list, list) {
152 if (wdev->identifier != (u32)wdev_id)
153 continue;
154 found = true;
155 break;
156 }
89a54e48
JB		 157
158 if (!found)
159 tmp = NULL;
160
161 if (rdev && tmp != rdev)
162 return ERR_PTR(-EINVAL);
163 rdev = tmp;
164 }
165 }
166
878d9ec7
JB		 167 if (attrs[NL80211_ATTR_IFINDEX]) {
168 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
7f2b8562 169 netdev = __dev_get_by_index(netns, ifindex);
7fee4778
JB		 170 if (netdev) {
171 if (netdev->ieee80211_ptr)
f26cbf40
ZG		 172 tmp = wiphy_to_rdev(
173 netdev->ieee80211_ptr->wiphy);
7fee4778
JB		 174 else
175 tmp = NULL;
176
7fee4778
JB		 177 /* not wireless device -- return error */
178 if (!tmp)
179 return ERR_PTR(-EINVAL);
180
181 /* mismatch -- return error */
182 if (rdev && tmp != rdev)
183 return ERR_PTR(-EINVAL);
184
185 rdev = tmp;
a9455408 186 }
a9455408 187 }
a9455408 188
4f7eff10
JB		 189 if (!rdev)
190 return ERR_PTR(-ENODEV);
a9455408 191
4f7eff10
JB		 192 if (netns != wiphy_net(&rdev->wiphy))
193 return ERR_PTR(-ENODEV);
194
195 return rdev;
a9455408
JB		 196}
197
198/*
199 * This function returns a pointer to the driver
200 * that the genl_info item that is passed refers to.
a9455408
JB		 201 *
202 * The result of this can be a PTR_ERR and hence must
203 * be checked with IS_ERR() for errors.
204 */
205static struct cfg80211_registered_device *
4f7eff10 206cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
a9455408 207{
5fe231e8 208 return __cfg80211_rdev_from_attrs(netns, info->attrs);
a9455408
JB		 209}
210
55682965 211/* policy for the attributes */
8cd4d456 212static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
55682965
JB		 213 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
214 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
079e24ed 215 .len = 20-1 },
31888487 216 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
3d9d1d66 217
72bdcf34 218 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
094d05dc 219 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
3d9d1d66
JB		 220 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
221 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
222 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
223
b9a5f8ca
JM		 224 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
225 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
226 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
227 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
81077e82 228 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
3057dbfd 229 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
55682965
JB		 230
231 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
232 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
233 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
41ade00f 234
e007b857
EP		 235 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
236 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
41ade00f 237
b9454e83 238 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
41ade00f
JB		 239 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
240 .len = WLAN_MAX_KEY_LEN },
241 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
242 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
243 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
81962267 244 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
e31b8213 245 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
ed1b6cc7
JB		 246
247 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
248 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
249 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
250 .len = IEEE80211_MAX_DATA_LEN },
251 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
252 .len = IEEE80211_MAX_DATA_LEN },
5727ef1b
JB		 253 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
254 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
255 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
256 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
257 .len = NL80211_MAX_SUPP_RATES },
2ec600d6 258 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
5727ef1b 259 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
0a9542ee 260 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
2ec600d6 261 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
a4f606ea 262 .len = IEEE80211_MAX_MESH_ID_LEN },
2ec600d6 263 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
9f1ba906 264
b2e1b302
LR		 265 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
266 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
267
9f1ba906
JM		 268 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
269 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
270 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
90c97a04
JM		 271 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
272 .len = NL80211_MAX_SUPP_RATES },
50b12f59 273 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
36aedc90 274
24bdd9f4 275 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
15d5dda6 276 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
93da9cc1 277
6c739419 278 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
9aed3cc1
JM		 279
280 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
281 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
282 .len = IEEE80211_MAX_DATA_LEN },
2a519311
JB		 283 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
284 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
636a5d36
JM		 285
286 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
287 .len = IEEE80211_MAX_SSID_LEN },
288 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
289 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
04a773ad 290 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
1965c853 291 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
dc6382ce 292 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
eccb8e8f
JB		 293 [NL80211_ATTR_STA_FLAGS2] = {
294 .len = sizeof(struct nl80211_sta_flag_update),
295 },
3f77316c 296 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
c0692b8f
JB		 297 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
298 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
b23aa676
SO		 299 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
300 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
301 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
463d0183 302 [NL80211_ATTR_PID] = { .type = NLA_U32 },
8b787643 303 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
67fbb16b
SO		 304 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
305 .len = WLAN_PMKID_LEN },
9588bbd5
JM		 306 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
307 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
13ae75b1 308 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
026331c4
JM		 309 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
310 .len = IEEE80211_MAX_DATA_LEN },
311 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
ffb9eb3d 312 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
d6dc1a38 313 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
d5cdfacb 314 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
fd8aaaf3 315 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
98d2ff8b
JO		 316 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
317 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
2e161f78 318 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
afe0cbf8
BR		 319 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
320 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
885a46d0 321 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
f7ca38df 322 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
dbd2fd65 323 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
ff1b6e69 324 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
9c3990aa 325 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
bbe6ad6d 326 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
e5497d76 327 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
34850ab2 328 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
32e9de84 329 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
9946ecfb
JM		 330 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
331 .len = IEEE80211_MAX_DATA_LEN },
332 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
333 .len = IEEE80211_MAX_DATA_LEN },
f4b34b55 334 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
a1f1c21c 335 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
e9f935e3 336 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
109086ce
AN		 337 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
338 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
339 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
340 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
341 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
31fa97c5 342 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
e247bd90 343 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
00f740e1
AN		 344 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
345 .len = IEEE80211_MAX_DATA_LEN },
8b60b078 346 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
7e7c8926
BG		 347 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
348 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
349 .len = NL80211_HT_CAPABILITY_LEN
350 },
1d9d9213 351 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
1b658f11 352 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
4486ea98 353 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
89a54e48 354 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
57b5ce07 355 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
e39e5b5e 356 [NL80211_ATTR_SAE_DATA] = { .type = NLA_BINARY, },
f461be3e 357 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
ed473771 358 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
53cabad7
JB		 359 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
360 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
77765eaf
VT		 361 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
362 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
9d62a986
JM		 363 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
364 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
3713b4e3 365 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
ee2aca34
JB		 366 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
367 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
368 .len = NL80211_VHT_CAPABILITY_LEN,
369 },
355199e0
JM		 370 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
371 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
372 .len = IEEE80211_MAX_DATA_LEN },
5e4b6f56 373 [NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
16ef1fe2
SW		 374 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
375 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
376 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
9a774c78
AO		 377 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
378 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
c01fc9ad
SD		 379 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
380 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
5336fa88 381 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
60f4a7b1 382 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
ad7e718c
JB		 383 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
384 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
385 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
fa9ffc74
KP		 386 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
387 .len = IEEE80211_QOS_MAP_LEN_MAX },
1df4a510
JM		 388 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
389 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
df942e7b 390 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
18e5ca65 391 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
34d22ce2 392 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
bab5ab7d 393 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
960d01ac
JB		 394 [NL80211_ATTR_TSID] = { .type = NLA_U8 },
395 [NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
396 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
18998c38 397 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
ad2b26ab 398 [NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
1bdd716c 399 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
55682965
JB		 400};
401
e31b8213 402/* policy for the key attributes */
b54452b0 403static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
fffd0934 404 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 405 [NL80211_KEY_IDX] = { .type = NLA_U8 },
406 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
81962267 407 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
b9454e83
JB		 408 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
409 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
e31b8213 410 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
dbd2fd65
JB		 411 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
412};
413
414/* policy for the key default flags */
415static const struct nla_policy
416nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
417 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
418 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
b9454e83
JB		 419};
420
ff1b6e69
JB		 421/* policy for WoWLAN attributes */
422static const struct nla_policy
423nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
424 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
425 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
426 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
427 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
77dbbb13
JB		 428 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
429 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
430 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
431 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
2a0e047e 432 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
8cd4d456 433 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
2a0e047e
JB		 434};
435
436static const struct nla_policy
437nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
438 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
439 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
440 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
441 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
442 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
443 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
444 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
445 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
446 },
447 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
448 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
449 },
450 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
451 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
452 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
ff1b6e69
JB		 453};
454
be29b99a
AK		 455/* policy for coalesce rule attributes */
456static const struct nla_policy
457nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
458 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
459 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
460 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
461};
462
e5497d76
JB		 463/* policy for GTK rekey offload attributes */
464static const struct nla_policy
465nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
466 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
467 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
468 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
469};
470
a1f1c21c
LC		 471static const struct nla_policy
472nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
4a4ab0d7 473 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
a1f1c21c 474 .len = IEEE80211_MAX_SSID_LEN },
88e920b4 475 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
a1f1c21c
LC		 476};
477
97990a06
JB		 478static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
479 struct netlink_callback *cb,
480 struct cfg80211_registered_device **rdev,
481 struct wireless_dev **wdev)
a043897a 482{
97990a06 483 int err;
a043897a 484
97990a06 485 rtnl_lock();
a043897a 486
97990a06
JB		 487 if (!cb->args[0]) {
488 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
489 nl80211_fam.attrbuf, nl80211_fam.maxattr,
490 nl80211_policy);
491 if (err)
492 goto out_unlock;
67748893 493
97990a06
JB		 494 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk),
495 nl80211_fam.attrbuf);
496 if (IS_ERR(*wdev)) {
497 err = PTR_ERR(*wdev);
498 goto out_unlock;
499 }
f26cbf40 500 *rdev = wiphy_to_rdev((*wdev)->wiphy);
c319d50b
JB		 501 /* 0 is the first index - add 1 to parse only once */
502 cb->args[0] = (*rdev)->wiphy_idx + 1;
97990a06
JB		 503 cb->args[1] = (*wdev)->identifier;
504 } else {
c319d50b
JB		 505 /* subtract the 1 again here */
506 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
97990a06 507 struct wireless_dev *tmp;
67748893 508
97990a06
JB		 509 if (!wiphy) {
510 err = -ENODEV;
511 goto out_unlock;
512 }
f26cbf40 513 *rdev = wiphy_to_rdev(wiphy);
97990a06 514 *wdev = NULL;
67748893 515
97990a06
JB		 516 list_for_each_entry(tmp, &(*rdev)->wdev_list, list) {
517 if (tmp->identifier == cb->args[1]) {
518 *wdev = tmp;
519 break;
520 }
521 }
67748893 522
97990a06
JB		 523 if (!*wdev) {
524 err = -ENODEV;
525 goto out_unlock;
526 }
67748893
JB		 527 }
528
67748893 529 return 0;
97990a06 530 out_unlock:
67748893
JB		 531 rtnl_unlock();
532 return err;
533}
534
97990a06 535static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev)
67748893 536{
67748893
JB		 537 rtnl_unlock();
538}
539
f4a11bb0
JB		 540/* IE validation */
541static bool is_valid_ie_attr(const struct nlattr *attr)
542{
543 const u8 *pos;
544 int len;
545
546 if (!attr)
547 return true;
548
549 pos = nla_data(attr);
550 len = nla_len(attr);
551
552 while (len) {
553 u8 elemlen;
554
555 if (len < 2)
556 return false;
557 len -= 2;
558
559 elemlen = pos[1];
560 if (elemlen > len)
561 return false;
562
563 len -= elemlen;
564 pos += 2 + elemlen;
565 }
566
567 return true;
568}
569
55682965 570/* message building helper */
15e47304 571static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
55682965
JB		 572 int flags, u8 cmd)
573{
574 /* since there is no private header just add the generic one */
15e47304 575 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
55682965
JB		 576}
577
5dab3b8a 578static int nl80211_msg_put_channel(struct sk_buff *msg,
cdc89b97
JB		 579 struct ieee80211_channel *chan,
580 bool large)
5dab3b8a 581{
ea077c1c
RL		 582 /* Some channels must be completely excluded from the
583 * list to protect old user-space tools from breaking
584 */
585 if (!large && chan->flags &
586 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
587 return 0;
588
9360ffd1
DM		 589 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
590 chan->center_freq))
591 goto nla_put_failure;
5dab3b8a 592
9360ffd1
DM		 593 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
594 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
595 goto nla_put_failure;
8fe02e16
LR		 596 if (chan->flags & IEEE80211_CHAN_NO_IR) {
597 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
598 goto nla_put_failure;
599 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
600 goto nla_put_failure;
601 }
cdc89b97
JB		 602 if (chan->flags & IEEE80211_CHAN_RADAR) {
603 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
604 goto nla_put_failure;
605 if (large) {
606 u32 time;
607
608 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
609
610 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
611 chan->dfs_state))
612 goto nla_put_failure;
613 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
614 time))
615 goto nla_put_failure;
089027e5
JD		 616 if (nla_put_u32(msg,
617 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
618 chan->dfs_cac_ms))
619 goto nla_put_failure;
cdc89b97
JB		 620 }
621 }
5dab3b8a 622
fe1abafd
JB		 623 if (large) {
624 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
625 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
626 goto nla_put_failure;
627 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
628 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
629 goto nla_put_failure;
630 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
631 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
632 goto nla_put_failure;
633 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
634 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
635 goto nla_put_failure;
570dbde1
DS		 636 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
637 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
638 goto nla_put_failure;
639 if ((chan->flags & IEEE80211_CHAN_GO_CONCURRENT) &&
640 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_GO_CONCURRENT))
641 goto nla_put_failure;
ea077c1c
RL		 642 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
643 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
644 goto nla_put_failure;
645 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
646 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
647 goto nla_put_failure;
fe1abafd
JB		 648 }
649
9360ffd1
DM		 650 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
651 DBM_TO_MBM(chan->max_power)))
652 goto nla_put_failure;
5dab3b8a
LR		 653
654 return 0;
655
656 nla_put_failure:
657 return -ENOBUFS;
658}
659
55682965
JB		 660/* netlink command implementations */
661
b9454e83
JB		 662struct key_parse {
663 struct key_params p;
664 int idx;
e31b8213 665 int type;
b9454e83 666 bool def, defmgmt;
dbd2fd65 667 bool def_uni, def_multi;
b9454e83
JB		 668};
669
670static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
671{
672 struct nlattr *tb[NL80211_KEY_MAX + 1];
673 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
674 nl80211_key_policy);
675 if (err)
676 return err;
677
678 k->def = !!tb[NL80211_KEY_DEFAULT];
679 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
680
dbd2fd65
JB		 681 if (k->def) {
682 k->def_uni = true;
683 k->def_multi = true;
684 }
685 if (k->defmgmt)
686 k->def_multi = true;
687
b9454e83
JB		 688 if (tb[NL80211_KEY_IDX])
689 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
690
691 if (tb[NL80211_KEY_DATA]) {
692 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
693 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
694 }
695
696 if (tb[NL80211_KEY_SEQ]) {
697 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
698 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
699 }
700
701 if (tb[NL80211_KEY_CIPHER])
702 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
703
e31b8213
JB		 704 if (tb[NL80211_KEY_TYPE]) {
705 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
706 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
707 return -EINVAL;
708 }
709
dbd2fd65
JB		 710 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
711 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
2da8f419
JB		 712 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
713 tb[NL80211_KEY_DEFAULT_TYPES],
714 nl80211_key_default_policy);
dbd2fd65
JB		 715 if (err)
716 return err;
717
718 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
719 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
720 }
721
b9454e83
JB		 722 return 0;
723}
724
725static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
726{
727 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
728 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
729 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
730 }
731
732 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
733 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
734 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
735 }
736
737 if (info->attrs[NL80211_ATTR_KEY_IDX])
738 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
739
740 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
741 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
742
743 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
744 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
745
dbd2fd65
JB		 746 if (k->def) {
747 k->def_uni = true;
748 k->def_multi = true;
749 }
750 if (k->defmgmt)
751 k->def_multi = true;
752
e31b8213
JB		 753 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
754 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
755 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
756 return -EINVAL;
757 }
758
dbd2fd65
JB		 759 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
760 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
761 int err = nla_parse_nested(
762 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
763 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
764 nl80211_key_default_policy);
765 if (err)
766 return err;
767
768 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
769 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
770 }
771
b9454e83
JB		 772 return 0;
773}
774
775static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
776{
777 int err;
778
779 memset(k, 0, sizeof(*k));
780 k->idx = -1;
e31b8213 781 k->type = -1;
b9454e83
JB		 782
783 if (info->attrs[NL80211_ATTR_KEY])
784 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
785 else
786 err = nl80211_parse_key_old(info, k);
787
788 if (err)
789 return err;
790
791 if (k->def && k->defmgmt)
792 return -EINVAL;
793
dbd2fd65
JB		 794 if (k->defmgmt) {
795 if (k->def_uni || !k->def_multi)
796 return -EINVAL;
797 }
798
b9454e83
JB		 799 if (k->idx != -1) {
800 if (k->defmgmt) {
801 if (k->idx < 4 || k->idx > 5)
802 return -EINVAL;
803 } else if (k->def) {
804 if (k->idx < 0 || k->idx > 3)
805 return -EINVAL;
806 } else {
807 if (k->idx < 0 || k->idx > 5)
808 return -EINVAL;
809 }
810 }
811
812 return 0;
813}
814
fffd0934
JB		 815static struct cfg80211_cached_keys *
816nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
de7044ee 817 struct nlattr *keys, bool *no_ht)
fffd0934
JB		 818{
819 struct key_parse parse;
820 struct nlattr *key;
821 struct cfg80211_cached_keys *result;
822 int rem, err, def = 0;
823
824 result = kzalloc(sizeof(*result), GFP_KERNEL);
825 if (!result)
826 return ERR_PTR(-ENOMEM);
827
828 result->def = -1;
829 result->defmgmt = -1;
830
831 nla_for_each_nested(key, keys, rem) {
832 memset(&parse, 0, sizeof(parse));
833 parse.idx = -1;
834
835 err = nl80211_parse_key_new(key, &parse);
836 if (err)
837 goto error;
838 err = -EINVAL;
839 if (!parse.p.key)
840 goto error;
841 if (parse.idx < 0 || parse.idx > 4)
842 goto error;
843 if (parse.def) {
844 if (def)
845 goto error;
846 def = 1;
847 result->def = parse.idx;
dbd2fd65
JB		 848 if (!parse.def_uni || !parse.def_multi)
849 goto error;
fffd0934
JB		 850 } else if (parse.defmgmt)
851 goto error;
852 err = cfg80211_validate_key_settings(rdev, &parse.p,
e31b8213 853 parse.idx, false, NULL);
fffd0934
JB		 854 if (err)
855 goto error;
856 result->params[parse.idx].cipher = parse.p.cipher;
857 result->params[parse.idx].key_len = parse.p.key_len;
858 result->params[parse.idx].key = result->data[parse.idx];
859 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
de7044ee
SM		 860
861 if (parse.p.cipher == WLAN_CIPHER_SUITE_WEP40 ||
862 parse.p.cipher == WLAN_CIPHER_SUITE_WEP104) {
863 if (no_ht)
864 *no_ht = true;
865 }
fffd0934
JB		 866 }
867
868 return result;
869 error:
870 kfree(result);
871 return ERR_PTR(err);
872}
873
874static int nl80211_key_allowed(struct wireless_dev *wdev)
875{
876 ASSERT_WDEV_LOCK(wdev);
877
fffd0934
JB		 878 switch (wdev->iftype) {
879 case NL80211_IFTYPE_AP:
880 case NL80211_IFTYPE_AP_VLAN:
074ac8df 881 case NL80211_IFTYPE_P2P_GO:
ff973af7 882 case NL80211_IFTYPE_MESH_POINT:
fffd0934
JB		 883 break;
884 case NL80211_IFTYPE_ADHOC:
fffd0934 885 case NL80211_IFTYPE_STATION:
074ac8df 886 case NL80211_IFTYPE_P2P_CLIENT:
ceca7b71 887 if (!wdev->current_bss)
fffd0934
JB		 888 return -ENOLINK;
889 break;
de4fcbad 890 case NL80211_IFTYPE_UNSPECIFIED:
6e0bd6c3 891 case NL80211_IFTYPE_OCB:
de4fcbad
JB		 892 case NL80211_IFTYPE_MONITOR:
893 case NL80211_IFTYPE_P2P_DEVICE:
894 case NL80211_IFTYPE_WDS:
895 case NUM_NL80211_IFTYPES:
fffd0934
JB		 896 return -EINVAL;
897 }
898
899 return 0;
900}
901
664834de
JM		 902static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
903 struct nlattr *tb)
904{
905 struct ieee80211_channel *chan;
906
907 if (tb == NULL)
908 return NULL;
909 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
910 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
911 return NULL;
912 return chan;
913}
914
7527a782
JB		 915static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
916{
917 struct nlattr *nl_modes = nla_nest_start(msg, attr);
918 int i;
919
920 if (!nl_modes)
921 goto nla_put_failure;
922
923 i = 0;
924 while (ifmodes) {
9360ffd1
DM		 925 if ((ifmodes & 1) && nla_put_flag(msg, i))
926 goto nla_put_failure;
7527a782
JB		 927 ifmodes >>= 1;
928 i++;
929 }
930
931 nla_nest_end(msg, nl_modes);
932 return 0;
933
934nla_put_failure:
935 return -ENOBUFS;
936}
937
938static int nl80211_put_iface_combinations(struct wiphy *wiphy,
cdc89b97
JB		 939 struct sk_buff *msg,
940 bool large)
7527a782
JB		 941{
942 struct nlattr *nl_combis;
943 int i, j;
944
945 nl_combis = nla_nest_start(msg,
946 NL80211_ATTR_INTERFACE_COMBINATIONS);
947 if (!nl_combis)
948 goto nla_put_failure;
949
950 for (i = 0; i < wiphy->n_iface_combinations; i++) {
951 const struct ieee80211_iface_combination *c;
952 struct nlattr *nl_combi, *nl_limits;
953
954 c = &wiphy->iface_combinations[i];
955
956 nl_combi = nla_nest_start(msg, i + 1);
957 if (!nl_combi)
958 goto nla_put_failure;
959
960 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
961 if (!nl_limits)
962 goto nla_put_failure;
963
964 for (j = 0; j < c->n_limits; j++) {
965 struct nlattr *nl_limit;
966
967 nl_limit = nla_nest_start(msg, j + 1);
968 if (!nl_limit)
969 goto nla_put_failure;
9360ffd1
DM		 970 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
971 c->limits[j].max))
972 goto nla_put_failure;
7527a782
JB		 973 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
974 c->limits[j].types))
975 goto nla_put_failure;
976 nla_nest_end(msg, nl_limit);
977 }
978
979 nla_nest_end(msg, nl_limits);
980
9360ffd1
DM		 981 if (c->beacon_int_infra_match &&
982 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
983 goto nla_put_failure;
984 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
985 c->num_different_channels) ||
986 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
987 c->max_interfaces))
988 goto nla_put_failure;
cdc89b97 989 if (large &&
8c48b50a
FF		 990 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
991 c->radar_detect_widths) ||
992 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
993 c->radar_detect_regions)))
cdc89b97 994 goto nla_put_failure;
7527a782
JB		 995
996 nla_nest_end(msg, nl_combi);
997 }
998
999 nla_nest_end(msg, nl_combis);
1000
1001 return 0;
1002nla_put_failure:
1003 return -ENOBUFS;
1004}
1005
3713b4e3 1006#ifdef CONFIG_PM
b56cf720
JB		 1007static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1008 struct sk_buff *msg)
1009{
964dc9e2 1010 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
b56cf720
JB		 1011 struct nlattr *nl_tcp;
1012
1013 if (!tcp)
1014 return 0;
1015
1016 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1017 if (!nl_tcp)
1018 return -ENOBUFS;
1019
1020 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1021 tcp->data_payload_max))
1022 return -ENOBUFS;
1023
1024 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1025 tcp->data_payload_max))
1026 return -ENOBUFS;
1027
1028 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1029 return -ENOBUFS;
1030
1031 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1032 sizeof(*tcp->tok), tcp->tok))
1033 return -ENOBUFS;
1034
1035 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1036 tcp->data_interval_max))
1037 return -ENOBUFS;
1038
1039 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1040 tcp->wake_payload_max))
1041 return -ENOBUFS;
1042
1043 nla_nest_end(msg, nl_tcp);
1044 return 0;
1045}
1046
3713b4e3 1047static int nl80211_send_wowlan(struct sk_buff *msg,
1b8ec87a 1048 struct cfg80211_registered_device *rdev,
b56cf720 1049 bool large)
55682965 1050{
3713b4e3 1051 struct nlattr *nl_wowlan;
55682965 1052
1b8ec87a 1053 if (!rdev->wiphy.wowlan)
3713b4e3 1054 return 0;
55682965 1055
3713b4e3
JB		 1056 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1057 if (!nl_wowlan)
1058 return -ENOBUFS;
9360ffd1 1059
1b8ec87a 1060 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
3713b4e3 1061 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1b8ec87a 1062 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
3713b4e3 1063 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1b8ec87a 1064 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
3713b4e3 1065 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1b8ec87a 1066 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
3713b4e3 1067 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1b8ec87a 1068 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
3713b4e3 1069 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1b8ec87a 1070 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
3713b4e3 1071 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1b8ec87a 1072 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
3713b4e3 1073 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1b8ec87a 1074 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
3713b4e3
JB		 1075 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1076 return -ENOBUFS;
9360ffd1 1077
1b8ec87a 1078 if (rdev->wiphy.wowlan->n_patterns) {
50ac6607 1079 struct nl80211_pattern_support pat = {
1b8ec87a
ZG		 1080 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1081 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1082 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1083 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
3713b4e3 1084 };
9360ffd1 1085
3713b4e3
JB		 1086 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1087 sizeof(pat), &pat))
1088 return -ENOBUFS;
1089 }
9360ffd1 1090
1b8ec87a 1091 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
b56cf720
JB		 1092 return -ENOBUFS;
1093
8cd4d456
LC		 1094 /* TODO: send wowlan net detect */
1095
3713b4e3 1096 nla_nest_end(msg, nl_wowlan);
9360ffd1 1097
3713b4e3
JB		 1098 return 0;
1099}
1100#endif
9360ffd1 1101
be29b99a 1102static int nl80211_send_coalesce(struct sk_buff *msg,
1b8ec87a 1103 struct cfg80211_registered_device *rdev)
be29b99a
AK		 1104{
1105 struct nl80211_coalesce_rule_support rule;
1106
1b8ec87a 1107 if (!rdev->wiphy.coalesce)
be29b99a
AK		 1108 return 0;
1109
1b8ec87a
ZG		 1110 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1111 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1112 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1113 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1114 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1115 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
be29b99a
AK		 1116
1117 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1118 return -ENOBUFS;
1119
1120 return 0;
1121}
1122
3713b4e3
JB		 1123static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1124 struct ieee80211_supported_band *sband)
1125{
1126 struct nlattr *nl_rates, *nl_rate;
1127 struct ieee80211_rate *rate;
1128 int i;
87bbbe22 1129
3713b4e3
JB		 1130 /* add HT info */
1131 if (sband->ht_cap.ht_supported &&
1132 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1133 sizeof(sband->ht_cap.mcs),
1134 &sband->ht_cap.mcs) ||
1135 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1136 sband->ht_cap.cap) ||
1137 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1138 sband->ht_cap.ampdu_factor) ||
1139 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1140 sband->ht_cap.ampdu_density)))
1141 return -ENOBUFS;
afe0cbf8 1142
3713b4e3
JB		 1143 /* add VHT info */
1144 if (sband->vht_cap.vht_supported &&
1145 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1146 sizeof(sband->vht_cap.vht_mcs),
1147 &sband->vht_cap.vht_mcs) ||
1148 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1149 sband->vht_cap.cap)))
1150 return -ENOBUFS;
f59ac048 1151
3713b4e3
JB		 1152 /* add bitrates */
1153 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1154 if (!nl_rates)
1155 return -ENOBUFS;
ee688b00 1156
3713b4e3
JB		 1157 for (i = 0; i < sband->n_bitrates; i++) {
1158 nl_rate = nla_nest_start(msg, i);
1159 if (!nl_rate)
1160 return -ENOBUFS;
ee688b00 1161
3713b4e3
JB		 1162 rate = &sband->bitrates[i];
1163 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1164 rate->bitrate))
1165 return -ENOBUFS;
1166 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1167 nla_put_flag(msg,
1168 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1169 return -ENOBUFS;
ee688b00 1170
3713b4e3
JB		 1171 nla_nest_end(msg, nl_rate);
1172 }
d51626df 1173
3713b4e3 1174 nla_nest_end(msg, nl_rates);
bf0c111e 1175
3713b4e3
JB		 1176 return 0;
1177}
ee688b00 1178
3713b4e3
JB		 1179static int
1180nl80211_send_mgmt_stypes(struct sk_buff *msg,
1181 const struct ieee80211_txrx_stypes *mgmt_stypes)
1182{
1183 u16 stypes;
1184 struct nlattr *nl_ftypes, *nl_ifs;
1185 enum nl80211_iftype ift;
1186 int i;
ee688b00 1187
3713b4e3
JB		 1188 if (!mgmt_stypes)
1189 return 0;
5dab3b8a 1190
3713b4e3
JB		 1191 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1192 if (!nl_ifs)
1193 return -ENOBUFS;
e2f367f2 1194
3713b4e3
JB		 1195 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1196 nl_ftypes = nla_nest_start(msg, ift);
1197 if (!nl_ftypes)
1198 return -ENOBUFS;
1199 i = 0;
1200 stypes = mgmt_stypes[ift].tx;
1201 while (stypes) {
1202 if ((stypes & 1) &&
1203 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1204 (i << 4) | IEEE80211_FTYPE_MGMT))
1205 return -ENOBUFS;
1206 stypes >>= 1;
1207 i++;
ee688b00 1208 }
3713b4e3
JB		 1209 nla_nest_end(msg, nl_ftypes);
1210 }
ee688b00 1211
3713b4e3 1212 nla_nest_end(msg, nl_ifs);
ee688b00 1213
3713b4e3
JB		 1214 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1215 if (!nl_ifs)
1216 return -ENOBUFS;
ee688b00 1217
3713b4e3
JB		 1218 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1219 nl_ftypes = nla_nest_start(msg, ift);
1220 if (!nl_ftypes)
1221 return -ENOBUFS;
1222 i = 0;
1223 stypes = mgmt_stypes[ift].rx;
1224 while (stypes) {
1225 if ((stypes & 1) &&
1226 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1227 (i << 4) | IEEE80211_FTYPE_MGMT))
1228 return -ENOBUFS;
1229 stypes >>= 1;
1230 i++;
1231 }
1232 nla_nest_end(msg, nl_ftypes);
1233 }
1234 nla_nest_end(msg, nl_ifs);
ee688b00 1235
3713b4e3
JB		 1236 return 0;
1237}
ee688b00 1238
86e8cf98
JB		 1239struct nl80211_dump_wiphy_state {
1240 s64 filter_wiphy;
1241 long start;
1242 long split_start, band_start, chan_start;
1243 bool split;
1244};
1245
1b8ec87a 1246static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
3bb20556 1247 enum nl80211_commands cmd,
3713b4e3 1248 struct sk_buff *msg, u32 portid, u32 seq,
86e8cf98 1249 int flags, struct nl80211_dump_wiphy_state *state)
3713b4e3
JB		 1250{
1251 void *hdr;
1252 struct nlattr *nl_bands, *nl_band;
1253 struct nlattr *nl_freqs, *nl_freq;
1254 struct nlattr *nl_cmds;
1255 enum ieee80211_band band;
1256 struct ieee80211_channel *chan;
1257 int i;
1258 const struct ieee80211_txrx_stypes *mgmt_stypes =
1b8ec87a 1259 rdev->wiphy.mgmt_stypes;
fe1abafd 1260 u32 features;
ee688b00 1261
3bb20556 1262 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3713b4e3
JB		 1263 if (!hdr)
1264 return -ENOBUFS;
ee688b00 1265
86e8cf98
JB		 1266 if (WARN_ON(!state))
1267 return -EINVAL;
ee688b00 1268
1b8ec87a 1269 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3713b4e3 1270 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1b8ec87a 1271 wiphy_name(&rdev->wiphy)) ||
3713b4e3
JB		 1272 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1273 cfg80211_rdev_list_generation))
8fdc621d
JB		 1274 goto nla_put_failure;
1275
3bb20556
JB		 1276 if (cmd != NL80211_CMD_NEW_WIPHY)
1277 goto finish;
1278
86e8cf98 1279 switch (state->split_start) {
3713b4e3
JB		 1280 case 0:
1281 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1b8ec87a 1282 rdev->wiphy.retry_short) ||
3713b4e3 1283 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1b8ec87a 1284 rdev->wiphy.retry_long) ||
3713b4e3 1285 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1b8ec87a 1286 rdev->wiphy.frag_threshold) ||
3713b4e3 1287 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1b8ec87a 1288 rdev->wiphy.rts_threshold) ||
3713b4e3 1289 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1b8ec87a 1290 rdev->wiphy.coverage_class) ||
3713b4e3 1291 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1b8ec87a 1292 rdev->wiphy.max_scan_ssids) ||
3713b4e3 1293 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1b8ec87a 1294 rdev->wiphy.max_sched_scan_ssids) ||
3713b4e3 1295 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1b8ec87a 1296 rdev->wiphy.max_scan_ie_len) ||
3713b4e3 1297 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1b8ec87a 1298 rdev->wiphy.max_sched_scan_ie_len) ||
3713b4e3 1299 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1b8ec87a 1300 rdev->wiphy.max_match_sets))
9360ffd1 1301 goto nla_put_failure;
3713b4e3 1302
1b8ec87a 1303 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
3713b4e3 1304 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
aa430da4 1305 goto nla_put_failure;
1b8ec87a 1306 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
3713b4e3
JB		 1307 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1308 goto nla_put_failure;
1b8ec87a 1309 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3713b4e3
JB		 1310 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1311 goto nla_put_failure;
1b8ec87a 1312 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
3713b4e3
JB		 1313 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1314 goto nla_put_failure;
1b8ec87a 1315 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
3713b4e3
JB		 1316 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1317 goto nla_put_failure;
1b8ec87a 1318 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
3713b4e3 1319 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
9360ffd1 1320 goto nla_put_failure;
86e8cf98
JB		 1321 state->split_start++;
1322 if (state->split)
3713b4e3
JB		 1323 break;
1324 case 1:
1325 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1b8ec87a
ZG		 1326 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1327 rdev->wiphy.cipher_suites))
3713b4e3 1328 goto nla_put_failure;
4745fc09 1329
3713b4e3 1330 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1b8ec87a 1331 rdev->wiphy.max_num_pmkids))
3713b4e3 1332 goto nla_put_failure;
b23aa676 1333
1b8ec87a 1334 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
3713b4e3 1335 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
9360ffd1 1336 goto nla_put_failure;
b23aa676 1337
3713b4e3 1338 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1b8ec87a 1339 rdev->wiphy.available_antennas_tx) ||
3713b4e3 1340 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1b8ec87a 1341 rdev->wiphy.available_antennas_rx))
9360ffd1 1342 goto nla_put_failure;
b23aa676 1343
1b8ec87a 1344 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
3713b4e3 1345 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1b8ec87a 1346 rdev->wiphy.probe_resp_offload))
3713b4e3 1347 goto nla_put_failure;
8fdc621d 1348
1b8ec87a
ZG		 1349 if ((rdev->wiphy.available_antennas_tx ||
1350 rdev->wiphy.available_antennas_rx) &&
1351 rdev->ops->get_antenna) {
3713b4e3
JB		 1352 u32 tx_ant = 0, rx_ant = 0;
1353 int res;
1b8ec87a 1354 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
3713b4e3
JB		 1355 if (!res) {
1356 if (nla_put_u32(msg,
1357 NL80211_ATTR_WIPHY_ANTENNA_TX,
1358 tx_ant) ||
1359 nla_put_u32(msg,
1360 NL80211_ATTR_WIPHY_ANTENNA_RX,
1361 rx_ant))
1362 goto nla_put_failure;
1363 }
1364 }
a293911d 1365
86e8cf98
JB		 1366 state->split_start++;
1367 if (state->split)
3713b4e3
JB		 1368 break;
1369 case 2:
1370 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1b8ec87a 1371 rdev->wiphy.interface_modes))
3713b4e3 1372 goto nla_put_failure;
86e8cf98
JB		 1373 state->split_start++;
1374 if (state->split)
3713b4e3
JB		 1375 break;
1376 case 3:
1377 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1378 if (!nl_bands)
1379 goto nla_put_failure;
f7ca38df 1380
86e8cf98
JB		 1381 for (band = state->band_start;
1382 band < IEEE80211_NUM_BANDS; band++) {
3713b4e3 1383 struct ieee80211_supported_band *sband;
2e161f78 1384
1b8ec87a 1385 sband = rdev->wiphy.bands[band];
2e161f78 1386
3713b4e3
JB		 1387 if (!sband)
1388 continue;
1389
1390 nl_band = nla_nest_start(msg, band);
1391 if (!nl_band)
2e161f78 1392 goto nla_put_failure;
3713b4e3 1393
86e8cf98 1394 switch (state->chan_start) {
3713b4e3
JB		 1395 case 0:
1396 if (nl80211_send_band_rateinfo(msg, sband))
9360ffd1 1397 goto nla_put_failure;
86e8cf98
JB		 1398 state->chan_start++;
1399 if (state->split)
3713b4e3
JB		 1400 break;
1401 default:
1402 /* add frequencies */
1403 nl_freqs = nla_nest_start(
1404 msg, NL80211_BAND_ATTR_FREQS);
1405 if (!nl_freqs)
1406 goto nla_put_failure;
1407
86e8cf98 1408 for (i = state->chan_start - 1;
3713b4e3
JB		 1409 i < sband->n_channels;
1410 i++) {
1411 nl_freq = nla_nest_start(msg, i);
1412 if (!nl_freq)
1413 goto nla_put_failure;
1414
1415 chan = &sband->channels[i];
1416
86e8cf98
JB		 1417 if (nl80211_msg_put_channel(
1418 msg, chan,
1419 state->split))
3713b4e3
JB		 1420 goto nla_put_failure;
1421
1422 nla_nest_end(msg, nl_freq);
86e8cf98 1423 if (state->split)
3713b4e3
JB		 1424 break;
1425 }
1426 if (i < sband->n_channels)
86e8cf98 1427 state->chan_start = i + 2;
3713b4e3 1428 else
86e8cf98 1429 state->chan_start = 0;
3713b4e3
JB		 1430 nla_nest_end(msg, nl_freqs);
1431 }
1432
1433 nla_nest_end(msg, nl_band);
1434
86e8cf98 1435 if (state->split) {
3713b4e3 1436 /* start again here */
86e8cf98 1437 if (state->chan_start)
3713b4e3
JB		 1438 band--;
1439 break;
2e161f78 1440 }
2e161f78 1441 }
3713b4e3 1442 nla_nest_end(msg, nl_bands);
2e161f78 1443
3713b4e3 1444 if (band < IEEE80211_NUM_BANDS)
86e8cf98 1445 state->band_start = band + 1;
3713b4e3 1446 else
86e8cf98 1447 state->band_start = 0;
74b70a4e 1448
3713b4e3 1449 /* if bands & channels are done, continue outside */
86e8cf98
JB		 1450 if (state->band_start == 0 && state->chan_start == 0)
1451 state->split_start++;
1452 if (state->split)
3713b4e3
JB		 1453 break;
1454 case 4:
1455 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1456 if (!nl_cmds)
2e161f78
JB		 1457 goto nla_put_failure;
1458
3713b4e3
JB		 1459 i = 0;
1460#define CMD(op, n) \
1461 do { \
1b8ec87a 1462 if (rdev->ops->op) { \
3713b4e3
JB		 1463 i++; \
1464 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1465 goto nla_put_failure; \
1466 } \
1467 } while (0)
1468
1469 CMD(add_virtual_intf, NEW_INTERFACE);
1470 CMD(change_virtual_intf, SET_INTERFACE);
1471 CMD(add_key, NEW_KEY);
1472 CMD(start_ap, START_AP);
1473 CMD(add_station, NEW_STATION);
1474 CMD(add_mpath, NEW_MPATH);
1475 CMD(update_mesh_config, SET_MESH_CONFIG);
1476 CMD(change_bss, SET_BSS);
1477 CMD(auth, AUTHENTICATE);
1478 CMD(assoc, ASSOCIATE);
1479 CMD(deauth, DEAUTHENTICATE);
1480 CMD(disassoc, DISASSOCIATE);
1481 CMD(join_ibss, JOIN_IBSS);
1482 CMD(join_mesh, JOIN_MESH);
1483 CMD(set_pmksa, SET_PMKSA);
1484 CMD(del_pmksa, DEL_PMKSA);
1485 CMD(flush_pmksa, FLUSH_PMKSA);
1b8ec87a 1486 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
3713b4e3
JB		 1487 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1488 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1489 CMD(mgmt_tx, FRAME);
1490 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1b8ec87a 1491 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
3713b4e3
JB		 1492 i++;
1493 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
2e161f78 1494 goto nla_put_failure;
2e161f78 1495 }
1b8ec87a
ZG		 1496 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1497 rdev->ops->join_mesh) {
3713b4e3
JB		 1498 i++;
1499 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1500 goto nla_put_failure;
1501 }
1502 CMD(set_wds_peer, SET_WDS_PEER);
1b8ec87a 1503 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
3713b4e3
JB		 1504 CMD(tdls_mgmt, TDLS_MGMT);
1505 CMD(tdls_oper, TDLS_OPER);
1506 }
1b8ec87a 1507 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
3713b4e3
JB		 1508 CMD(sched_scan_start, START_SCHED_SCAN);
1509 CMD(probe_client, PROBE_CLIENT);
1510 CMD(set_noack_map, SET_NOACK_MAP);
1b8ec87a 1511 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
3713b4e3
JB		 1512 i++;
1513 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1514 goto nla_put_failure;
1515 }
1516 CMD(start_p2p_device, START_P2P_DEVICE);
1517 CMD(set_mcast_rate, SET_MCAST_RATE);
02df00eb
JB		 1518#ifdef CONFIG_NL80211_TESTMODE
1519 CMD(testmode_cmd, TESTMODE);
1520#endif
86e8cf98 1521 if (state->split) {
5de17984
AS		 1522 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1523 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1b8ec87a 1524 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
16ef1fe2 1525 CMD(channel_switch, CHANNEL_SWITCH);
02df00eb 1526 CMD(set_qos_map, SET_QOS_MAP);
723e73ac
JB		 1527 if (rdev->wiphy.features &
1528 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
960d01ac 1529 CMD(add_tx_ts, ADD_TX_TS);
5de17984 1530 }
02df00eb 1531 /* add into the if now */
3713b4e3 1532#undef CMD
ff1b6e69 1533
1b8ec87a 1534 if (rdev->ops->connect || rdev->ops->auth) {
3713b4e3
JB		 1535 i++;
1536 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
9360ffd1 1537 goto nla_put_failure;
ff1b6e69
JB		 1538 }
1539
1b8ec87a 1540 if (rdev->ops->disconnect || rdev->ops->deauth) {
3713b4e3
JB		 1541 i++;
1542 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1543 goto nla_put_failure;
1544 }
1545
1546 nla_nest_end(msg, nl_cmds);
86e8cf98
JB		 1547 state->split_start++;
1548 if (state->split)
3713b4e3
JB		 1549 break;
1550 case 5:
1b8ec87a
ZG		 1551 if (rdev->ops->remain_on_channel &&
1552 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
3713b4e3
JB		 1553 nla_put_u32(msg,
1554 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1b8ec87a 1555 rdev->wiphy.max_remain_on_channel_duration))
3713b4e3
JB		 1556 goto nla_put_failure;
1557
1b8ec87a 1558 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
3713b4e3
JB		 1559 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1560 goto nla_put_failure;
1561
1562 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1563 goto nla_put_failure;
86e8cf98
JB		 1564 state->split_start++;
1565 if (state->split)
3713b4e3
JB		 1566 break;
1567 case 6:
1568#ifdef CONFIG_PM
1b8ec87a 1569 if (nl80211_send_wowlan(msg, rdev, state->split))
3713b4e3 1570 goto nla_put_failure;
86e8cf98
JB		 1571 state->split_start++;
1572 if (state->split)
3713b4e3
JB		 1573 break;
1574#else
86e8cf98 1575 state->split_start++;
dfb89c56 1576#endif
3713b4e3
JB		 1577 case 7:
1578 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1b8ec87a 1579 rdev->wiphy.software_iftypes))
3713b4e3 1580 goto nla_put_failure;
ff1b6e69 1581
1b8ec87a 1582 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
86e8cf98 1583 state->split))
3713b4e3 1584 goto nla_put_failure;
7527a782 1585
86e8cf98
JB		 1586 state->split_start++;
1587 if (state->split)
3713b4e3
JB		 1588 break;
1589 case 8:
1b8ec87a 1590 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
3713b4e3 1591 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1b8ec87a 1592 rdev->wiphy.ap_sme_capa))
3713b4e3 1593 goto nla_put_failure;
7527a782 1594
1b8ec87a 1595 features = rdev->wiphy.features;
fe1abafd
JB		 1596 /*
1597 * We can only add the per-channel limit information if the
1598 * dump is split, otherwise it makes it too big. Therefore
1599 * only advertise it in that case.
1600 */
86e8cf98 1601 if (state->split)
fe1abafd
JB		 1602 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1603 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
3713b4e3 1604 goto nla_put_failure;
562a7480 1605
1b8ec87a 1606 if (rdev->wiphy.ht_capa_mod_mask &&
3713b4e3 1607 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1b8ec87a
ZG		 1608 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1609 rdev->wiphy.ht_capa_mod_mask))
3713b4e3 1610 goto nla_put_failure;
1f074bd8 1611
1b8ec87a
ZG		 1612 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1613 rdev->wiphy.max_acl_mac_addrs &&
3713b4e3 1614 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1b8ec87a 1615 rdev->wiphy.max_acl_mac_addrs))
3713b4e3 1616 goto nla_put_failure;
7e7c8926 1617
3713b4e3
JB		 1618 /*
1619 * Any information below this point is only available to
1620 * applications that can deal with it being split. This
1621 * helps ensure that newly added capabilities don't break
1622 * older tools by overrunning their buffers.
1623 *
1624 * We still increment split_start so that in the split
1625 * case we'll continue with more data in the next round,
1626 * but break unconditionally so unsplit data stops here.
1627 */
86e8cf98 1628 state->split_start++;
3713b4e3
JB		 1629 break;
1630 case 9:
1b8ec87a 1631 if (rdev->wiphy.extended_capabilities &&
fe1abafd 1632 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1b8ec87a
ZG		 1633 rdev->wiphy.extended_capabilities_len,
1634 rdev->wiphy.extended_capabilities) ||
fe1abafd 1635 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1b8ec87a
ZG		 1636 rdev->wiphy.extended_capabilities_len,
1637 rdev->wiphy.extended_capabilities_mask)))
fe1abafd 1638 goto nla_put_failure;
a50df0c4 1639
1b8ec87a 1640 if (rdev->wiphy.vht_capa_mod_mask &&
ee2aca34 1641 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1b8ec87a
ZG		 1642 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1643 rdev->wiphy.vht_capa_mod_mask))
ee2aca34
JB		 1644 goto nla_put_failure;
1645
be29b99a
AK		 1646 state->split_start++;
1647 break;
1648 case 10:
1b8ec87a 1649 if (nl80211_send_coalesce(msg, rdev))
be29b99a
AK		 1650 goto nla_put_failure;
1651
1b8ec87a 1652 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
01e0daa4
FF		 1653 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1654 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1655 goto nla_put_failure;
b43504cf 1656
1b8ec87a 1657 if (rdev->wiphy.max_ap_assoc_sta &&
b43504cf 1658 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1b8ec87a 1659 rdev->wiphy.max_ap_assoc_sta))
b43504cf
JM		 1660 goto nla_put_failure;
1661
ad7e718c
JB		 1662 state->split_start++;
1663 break;
1664 case 11:
1b8ec87a 1665 if (rdev->wiphy.n_vendor_commands) {
567ffc35
JB		 1666 const struct nl80211_vendor_cmd_info *info;
1667 struct nlattr *nested;
1668
1669 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1670 if (!nested)
1671 goto nla_put_failure;
1672
1b8ec87a
ZG		 1673 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1674 info = &rdev->wiphy.vendor_commands[i].info;
567ffc35
JB		 1675 if (nla_put(msg, i + 1, sizeof(*info), info))
1676 goto nla_put_failure;
1677 }
1678 nla_nest_end(msg, nested);
1679 }
1680
1b8ec87a 1681 if (rdev->wiphy.n_vendor_events) {
567ffc35
JB		 1682 const struct nl80211_vendor_cmd_info *info;
1683 struct nlattr *nested;
ad7e718c 1684
567ffc35
JB		 1685 nested = nla_nest_start(msg,
1686 NL80211_ATTR_VENDOR_EVENTS);
1687 if (!nested)
ad7e718c 1688 goto nla_put_failure;
567ffc35 1689
1b8ec87a
ZG		 1690 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1691 info = &rdev->wiphy.vendor_events[i];
567ffc35
JB		 1692 if (nla_put(msg, i + 1, sizeof(*info), info))
1693 goto nla_put_failure;
1694 }
1695 nla_nest_end(msg, nested);
1696 }
9a774c78
AO		 1697 state->split_start++;
1698 break;
1699 case 12:
1700 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1701 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1702 rdev->wiphy.max_num_csa_counters))
1703 goto nla_put_failure;
01e0daa4 1704
1bdd716c
AN		 1705 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
1706 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
1707 goto nla_put_failure;
1708
d75bb06b
GKS		 1709 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
1710 sizeof(rdev->wiphy.ext_features),
1711 rdev->wiphy.ext_features))
1712 goto nla_put_failure;
1713
3713b4e3 1714 /* done */
86e8cf98 1715 state->split_start = 0;
3713b4e3
JB		 1716 break;
1717 }
3bb20556 1718 finish:
55682965
JB		 1719 return genlmsg_end(msg, hdr);
1720
1721 nla_put_failure:
bc3ed28c
TG		 1722 genlmsg_cancel(msg, hdr);
1723 return -EMSGSIZE;
55682965
JB		 1724}
1725
86e8cf98
JB		 1726static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
1727 struct netlink_callback *cb,
1728 struct nl80211_dump_wiphy_state *state)
1729{
1730 struct nlattr **tb = nl80211_fam.attrbuf;
1731 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1732 tb, nl80211_fam.maxattr, nl80211_policy);
1733 /* ignore parse errors for backward compatibility */
1734 if (ret)
1735 return 0;
1736
1737 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1738 if (tb[NL80211_ATTR_WIPHY])
1739 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1740 if (tb[NL80211_ATTR_WDEV])
1741 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1742 if (tb[NL80211_ATTR_IFINDEX]) {
1743 struct net_device *netdev;
1744 struct cfg80211_registered_device *rdev;
1745 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1746
7f2b8562 1747 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
86e8cf98
JB		 1748 if (!netdev)
1749 return -ENODEV;
1750 if (netdev->ieee80211_ptr) {
f26cbf40 1751 rdev = wiphy_to_rdev(
86e8cf98
JB		 1752 netdev->ieee80211_ptr->wiphy);
1753 state->filter_wiphy = rdev->wiphy_idx;
1754 }
86e8cf98
JB		 1755 }
1756
1757 return 0;
1758}
1759
55682965
JB		 1760static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1761{
645e77de 1762 int idx = 0, ret;
86e8cf98 1763 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
1b8ec87a 1764 struct cfg80211_registered_device *rdev;
3a5a423b 1765
5fe231e8 1766 rtnl_lock();
86e8cf98
JB		 1767 if (!state) {
1768 state = kzalloc(sizeof(*state), GFP_KERNEL);
57ed5cd6
JL		 1769 if (!state) {
1770 rtnl_unlock();
86e8cf98 1771 return -ENOMEM;
3713b4e3 1772 }
86e8cf98
JB		 1773 state->filter_wiphy = -1;
1774 ret = nl80211_dump_wiphy_parse(skb, cb, state);
1775 if (ret) {
1776 kfree(state);
1777 rtnl_unlock();
1778 return ret;
3713b4e3 1779 }
86e8cf98 1780 cb->args[0] = (long)state;
3713b4e3
JB		 1781 }
1782
1b8ec87a
ZG		 1783 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1784 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 1785 continue;
86e8cf98 1786 if (++idx <= state->start)
55682965 1787 continue;
86e8cf98 1788 if (state->filter_wiphy != -1 &&
1b8ec87a 1789 state->filter_wiphy != rdev->wiphy_idx)
3713b4e3
JB		 1790 continue;
1791 /* attempt to fit multiple wiphy data chunks into the skb */
1792 do {
3bb20556
JB		 1793 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
1794 skb,
3713b4e3
JB		 1795 NETLINK_CB(cb->skb).portid,
1796 cb->nlh->nlmsg_seq,
86e8cf98 1797 NLM_F_MULTI, state);
3713b4e3
JB		 1798 if (ret < 0) {
1799 /*
1800 * If sending the wiphy data didn't fit (ENOBUFS
1801 * or EMSGSIZE returned), this SKB is still
1802 * empty (so it's not too big because another
1803 * wiphy dataset is already in the skb) and
1804 * we've not tried to adjust the dump allocation
1805 * yet ... then adjust the alloc size to be
1806 * bigger, and return 1 but with the empty skb.
1807 * This results in an empty message being RX'ed
1808 * in userspace, but that is ignored.
1809 *
1810 * We can then retry with the larger buffer.
1811 */
1812 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
f12cb289 1813 !skb->len && !state->split &&
3713b4e3
JB		 1814 cb->min_dump_alloc < 4096) {
1815 cb->min_dump_alloc = 4096;
f12cb289 1816 state->split_start = 0;
d98cae64 1817 rtnl_unlock();
3713b4e3
JB		 1818 return 1;
1819 }
1820 idx--;
1821 break;
645e77de 1822 }
86e8cf98 1823 } while (state->split_start > 0);
3713b4e3 1824 break;
55682965 1825 }
5fe231e8 1826 rtnl_unlock();
55682965 1827
86e8cf98 1828 state->start = idx;
55682965
JB		 1829
1830 return skb->len;
1831}
1832
86e8cf98
JB		 1833static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
1834{
1835 kfree((void *)cb->args[0]);
1836 return 0;
1837}
1838
55682965
JB		 1839static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1840{
1841 struct sk_buff *msg;
1b8ec87a 1842 struct cfg80211_registered_device *rdev = info->user_ptr[0];
86e8cf98 1843 struct nl80211_dump_wiphy_state state = {};
55682965 1844
645e77de 1845 msg = nlmsg_new(4096, GFP_KERNEL);
55682965 1846 if (!msg)
4c476991 1847 return -ENOMEM;
55682965 1848
3bb20556
JB		 1849 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
1850 info->snd_portid, info->snd_seq, 0,
86e8cf98 1851 &state) < 0) {
4c476991
JB		 1852 nlmsg_free(msg);
1853 return -ENOBUFS;
1854 }
55682965 1855
134e6375 1856 return genlmsg_reply(msg, info);
55682965
JB		 1857}
1858
31888487
JM		 1859static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1860 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1861 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1862 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1863 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1864 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1865};
1866
1867static int parse_txq_params(struct nlattr *tb[],
1868 struct ieee80211_txq_params *txq_params)
1869{
a3304b0a 1870 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
31888487
JM		 1871 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1872 !tb[NL80211_TXQ_ATTR_AIFS])
1873 return -EINVAL;
1874
a3304b0a 1875 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
31888487
JM		 1876 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1877 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1878 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1879 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1880
a3304b0a
JB		 1881 if (txq_params->ac >= NL80211_NUM_ACS)
1882 return -EINVAL;
1883
31888487
JM		 1884 return 0;
1885}
1886
f444de05
JB		 1887static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1888{
1889 /*
cc1d2806
JB		 1890 * You can only set the channel explicitly for WDS interfaces,
1891 * all others have their channel managed via their respective
1892 * "establish a connection" command (connect, join, ...)
1893 *
1894 * For AP/GO and mesh mode, the channel can be set with the
1895 * channel userspace API, but is only stored and passed to the
1896 * low-level driver when the AP starts or the mesh is joined.
1897 * This is for backward compatibility, userspace can also give
1898 * the channel in the start-ap or join-mesh commands instead.
f444de05
JB		 1899 *
1900 * Monitors are special as they are normally slaved to
e8c9bd5b
JB		 1901 * whatever else is going on, so they have their own special
1902 * operation to set the monitor channel if possible.
f444de05
JB		 1903 */
1904 return !wdev ||
1905 wdev->iftype == NL80211_IFTYPE_AP ||
f444de05 1906 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
074ac8df
JB		 1907 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1908 wdev->iftype == NL80211_IFTYPE_P2P_GO;
f444de05
JB		 1909}
1910
683b6d3b
JB		 1911static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
1912 struct genl_info *info,
1913 struct cfg80211_chan_def *chandef)
1914{
dbeca2ea 1915 u32 control_freq;
683b6d3b
JB		 1916
1917 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1918 return -EINVAL;
1919
1920 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1921
1922 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
3d9d1d66
JB		 1923 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
1924 chandef->center_freq1 = control_freq;
1925 chandef->center_freq2 = 0;
683b6d3b
JB		 1926
1927 /* Primary channel not allowed */
1928 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
1929 return -EINVAL;
1930
3d9d1d66
JB		 1931 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1932 enum nl80211_channel_type chantype;
1933
1934 chantype = nla_get_u32(
1935 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1936
1937 switch (chantype) {
1938 case NL80211_CHAN_NO_HT:
1939 case NL80211_CHAN_HT20:
1940 case NL80211_CHAN_HT40PLUS:
1941 case NL80211_CHAN_HT40MINUS:
1942 cfg80211_chandef_create(chandef, chandef->chan,
1943 chantype);
1944 break;
1945 default:
1946 return -EINVAL;
1947 }
1948 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
1949 chandef->width =
1950 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
1951 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
1952 chandef->center_freq1 =
1953 nla_get_u32(
1954 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
1955 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
1956 chandef->center_freq2 =
1957 nla_get_u32(
1958 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
1959 }
1960
9f5e8f6e 1961 if (!cfg80211_chandef_valid(chandef))
3d9d1d66
JB		 1962 return -EINVAL;
1963
9f5e8f6e
JB		 1964 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
1965 IEEE80211_CHAN_DISABLED))
3d9d1d66
JB		 1966 return -EINVAL;
1967
2f301ab2
SW		 1968 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
1969 chandef->width == NL80211_CHAN_WIDTH_10) &&
1970 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ))
1971 return -EINVAL;
1972
683b6d3b
JB		 1973 return 0;
1974}
1975
f444de05 1976static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
e16821bc 1977 struct net_device *dev,
f444de05
JB		 1978 struct genl_info *info)
1979{
683b6d3b 1980 struct cfg80211_chan_def chandef;
f444de05 1981 int result;
e8c9bd5b 1982 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
e16821bc 1983 struct wireless_dev *wdev = NULL;
e8c9bd5b 1984
e16821bc
JM		 1985 if (dev)
1986 wdev = dev->ieee80211_ptr;
f444de05
JB		 1987 if (!nl80211_can_set_dev_channel(wdev))
1988 return -EOPNOTSUPP;
e16821bc
JM		 1989 if (wdev)
1990 iftype = wdev->iftype;
f444de05 1991
683b6d3b
JB		 1992 result = nl80211_parse_chandef(rdev, info, &chandef);
1993 if (result)
1994 return result;
f444de05 1995
e8c9bd5b 1996 switch (iftype) {
aa430da4
JB		 1997 case NL80211_IFTYPE_AP:
1998 case NL80211_IFTYPE_P2P_GO:
174e0cd2 1999 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef, iftype)) {
aa430da4
JB		 2000 result = -EINVAL;
2001 break;
2002 }
e16821bc
JM		 2003 if (wdev->beacon_interval) {
2004 if (!dev || !rdev->ops->set_ap_chanwidth ||
2005 !(rdev->wiphy.features &
2006 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2007 result = -EBUSY;
2008 break;
2009 }
2010
2011 /* Only allow dynamic channel width changes */
2012 if (chandef.chan != wdev->preset_chandef.chan) {
2013 result = -EBUSY;
2014 break;
2015 }
2016 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2017 if (result)
2018 break;
2019 }
683b6d3b 2020 wdev->preset_chandef = chandef;
aa430da4
JB		 2021 result = 0;
2022 break;
cc1d2806 2023 case NL80211_IFTYPE_MESH_POINT:
683b6d3b 2024 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
cc1d2806 2025 break;
e8c9bd5b 2026 case NL80211_IFTYPE_MONITOR:
683b6d3b 2027 result = cfg80211_set_monitor_channel(rdev, &chandef);
e8c9bd5b 2028 break;
aa430da4 2029 default:
e8c9bd5b 2030 result = -EINVAL;
f444de05 2031 }
f444de05
JB		 2032
2033 return result;
2034}
2035
2036static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2037{
4c476991
JB		 2038 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2039 struct net_device *netdev = info->user_ptr[1];
f444de05 2040
e16821bc 2041 return __nl80211_set_channel(rdev, netdev, info);
f444de05
JB		 2042}
2043
e8347eba
BJ		 2044static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2045{
43b19952
JB		 2046 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2047 struct net_device *dev = info->user_ptr[1];
2048 struct wireless_dev *wdev = dev->ieee80211_ptr;
388ac775 2049 const u8 *bssid;
e8347eba
BJ		 2050
2051 if (!info->attrs[NL80211_ATTR_MAC])
2052 return -EINVAL;
2053
43b19952
JB		 2054 if (netif_running(dev))
2055 return -EBUSY;
e8347eba 2056
43b19952
JB		 2057 if (!rdev->ops->set_wds_peer)
2058 return -EOPNOTSUPP;
e8347eba 2059
43b19952
JB		 2060 if (wdev->iftype != NL80211_IFTYPE_WDS)
2061 return -EOPNOTSUPP;
e8347eba
BJ		 2062
2063 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
e35e4d28 2064 return rdev_set_wds_peer(rdev, dev, bssid);
e8347eba
BJ		 2065}
2066
2067
55682965
JB		 2068static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2069{
2070 struct cfg80211_registered_device *rdev;
f444de05
JB		 2071 struct net_device *netdev = NULL;
2072 struct wireless_dev *wdev;
a1e567c8 2073 int result = 0, rem_txq_params = 0;
31888487 2074 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 2075 u32 changed;
2076 u8 retry_short = 0, retry_long = 0;
2077 u32 frag_threshold = 0, rts_threshold = 0;
81077e82 2078 u8 coverage_class = 0;
55682965 2079
5fe231e8
JB		 2080 ASSERT_RTNL();
2081
f444de05
JB		 2082 /*
2083 * Try to find the wiphy and netdev. Normally this
2084 * function shouldn't need the netdev, but this is
2085 * done for backward compatibility -- previously
2086 * setting the channel was done per wiphy, but now
2087 * it is per netdev. Previous userland like hostapd
2088 * also passed a netdev to set_wiphy, so that it is
2089 * possible to let that go to the right netdev!
2090 */
4bbf4d56 2091
f444de05
JB		 2092 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2093 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2094
7f2b8562 2095 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
5fe231e8 2096 if (netdev && netdev->ieee80211_ptr)
f26cbf40 2097 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
5fe231e8 2098 else
f444de05 2099 netdev = NULL;
4bbf4d56
JB		 2100 }
2101
f444de05 2102 if (!netdev) {
878d9ec7
JB		 2103 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2104 info->attrs);
5fe231e8 2105 if (IS_ERR(rdev))
4c476991 2106 return PTR_ERR(rdev);
f444de05
JB		 2107 wdev = NULL;
2108 netdev = NULL;
2109 result = 0;
71fe96bf 2110 } else
f444de05 2111 wdev = netdev->ieee80211_ptr;
f444de05
JB		 2112
2113 /*
2114 * end workaround code, by now the rdev is available
2115 * and locked, and wdev may or may not be NULL.
2116 */
4bbf4d56
JB		 2117
2118 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 2119 result = cfg80211_dev_rename(
2120 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56 2121
4bbf4d56 2122 if (result)
7f2b8562 2123 return result;
31888487
JM		 2124
2125 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2126 struct ieee80211_txq_params txq_params;
2127 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2128
7f2b8562
YX		 2129 if (!rdev->ops->set_txq_params)
2130 return -EOPNOTSUPP;
31888487 2131
7f2b8562
YX		 2132 if (!netdev)
2133 return -EINVAL;
f70f01c2 2134
133a3ff2 2135 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7f2b8562
YX		 2136 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2137 return -EINVAL;
133a3ff2 2138
7f2b8562
YX		 2139 if (!netif_running(netdev))
2140 return -ENETDOWN;
2b5f8b0b 2141
31888487
JM		 2142 nla_for_each_nested(nl_txq_params,
2143 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2144 rem_txq_params) {
ae811e21
JB		 2145 result = nla_parse(tb, NL80211_TXQ_ATTR_MAX,
2146 nla_data(nl_txq_params),
2147 nla_len(nl_txq_params),
2148 txq_params_policy);
2149 if (result)
2150 return result;
31888487
JM		 2151 result = parse_txq_params(tb, &txq_params);
2152 if (result)
7f2b8562 2153 return result;
31888487 2154
e35e4d28
HG		 2155 result = rdev_set_txq_params(rdev, netdev,
2156 &txq_params);
31888487 2157 if (result)
7f2b8562 2158 return result;
31888487
JM		 2159 }
2160 }
55682965 2161
72bdcf34 2162 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
e16821bc
JM		 2163 result = __nl80211_set_channel(
2164 rdev,
2165 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2166 info);
72bdcf34 2167 if (result)
7f2b8562 2168 return result;
72bdcf34
JM		 2169 }
2170
98d2ff8b 2171 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
c8442118 2172 struct wireless_dev *txp_wdev = wdev;
98d2ff8b
JO		 2173 enum nl80211_tx_power_setting type;
2174 int idx, mbm = 0;
2175
c8442118
JB		 2176 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2177 txp_wdev = NULL;
2178
7f2b8562
YX		 2179 if (!rdev->ops->set_tx_power)
2180 return -EOPNOTSUPP;
98d2ff8b
JO		 2181
2182 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2183 type = nla_get_u32(info->attrs[idx]);
2184
2185 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
7f2b8562
YX		 2186 (type != NL80211_TX_POWER_AUTOMATIC))
2187 return -EINVAL;
98d2ff8b
JO		 2188
2189 if (type != NL80211_TX_POWER_AUTOMATIC) {
2190 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2191 mbm = nla_get_u32(info->attrs[idx]);
2192 }
2193
c8442118 2194 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
98d2ff8b 2195 if (result)
7f2b8562 2196 return result;
98d2ff8b
JO		 2197 }
2198
afe0cbf8
BR		 2199 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2200 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2201 u32 tx_ant, rx_ant;
7f531e03
BR		 2202 if ((!rdev->wiphy.available_antennas_tx &&
2203 !rdev->wiphy.available_antennas_rx) ||
7f2b8562
YX		 2204 !rdev->ops->set_antenna)
2205 return -EOPNOTSUPP;
afe0cbf8
BR		 2206
2207 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2208 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2209
a7ffac95 2210 /* reject antenna configurations which don't match the
7f531e03
BR		 2211 * available antenna masks, except for the "all" mask */
2212 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
7f2b8562
YX		 2213 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2214 return -EINVAL;
a7ffac95 2215
7f531e03
BR		 2216 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2217 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
a7ffac95 2218
e35e4d28 2219 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
afe0cbf8 2220 if (result)
7f2b8562 2221 return result;
afe0cbf8
BR		 2222 }
2223
b9a5f8ca
JM		 2224 changed = 0;
2225
2226 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2227 retry_short = nla_get_u8(
2228 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
7f2b8562
YX		 2229 if (retry_short == 0)
2230 return -EINVAL;
2231
b9a5f8ca
JM		 2232 changed |= WIPHY_PARAM_RETRY_SHORT;
2233 }
2234
2235 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2236 retry_long = nla_get_u8(
2237 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
7f2b8562
YX		 2238 if (retry_long == 0)
2239 return -EINVAL;
2240
b9a5f8ca
JM		 2241 changed |= WIPHY_PARAM_RETRY_LONG;
2242 }
2243
2244 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2245 frag_threshold = nla_get_u32(
2246 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
7f2b8562
YX		 2247 if (frag_threshold < 256)
2248 return -EINVAL;
2249
b9a5f8ca
JM		 2250 if (frag_threshold != (u32) -1) {
2251 /*
2252 * Fragments (apart from the last one) are required to
2253 * have even length. Make the fragmentation code
2254 * simpler by stripping LSB should someone try to use
2255 * odd threshold value.
2256 */
2257 frag_threshold &= ~0x1;
2258 }
2259 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2260 }
2261
2262 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2263 rts_threshold = nla_get_u32(
2264 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2265 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2266 }
2267
81077e82 2268 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3057dbfd
LB		 2269 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2270 return -EINVAL;
2271
81077e82
LT		 2272 coverage_class = nla_get_u8(
2273 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2274 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2275 }
2276
3057dbfd
LB		 2277 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2278 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2279 return -EOPNOTSUPP;
2280
2281 changed |= WIPHY_PARAM_DYN_ACK;
81077e82
LT		 2282 }
2283
b9a5f8ca
JM		 2284 if (changed) {
2285 u8 old_retry_short, old_retry_long;
2286 u32 old_frag_threshold, old_rts_threshold;
81077e82 2287 u8 old_coverage_class;
b9a5f8ca 2288
7f2b8562
YX		 2289 if (!rdev->ops->set_wiphy_params)
2290 return -EOPNOTSUPP;
b9a5f8ca
JM		 2291
2292 old_retry_short = rdev->wiphy.retry_short;
2293 old_retry_long = rdev->wiphy.retry_long;
2294 old_frag_threshold = rdev->wiphy.frag_threshold;
2295 old_rts_threshold = rdev->wiphy.rts_threshold;
81077e82 2296 old_coverage_class = rdev->wiphy.coverage_class;
b9a5f8ca
JM		 2297
2298 if (changed & WIPHY_PARAM_RETRY_SHORT)
2299 rdev->wiphy.retry_short = retry_short;
2300 if (changed & WIPHY_PARAM_RETRY_LONG)
2301 rdev->wiphy.retry_long = retry_long;
2302 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2303 rdev->wiphy.frag_threshold = frag_threshold;
2304 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2305 rdev->wiphy.rts_threshold = rts_threshold;
81077e82
LT		 2306 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2307 rdev->wiphy.coverage_class = coverage_class;
b9a5f8ca 2308
e35e4d28 2309 result = rdev_set_wiphy_params(rdev, changed);
b9a5f8ca
JM		 2310 if (result) {
2311 rdev->wiphy.retry_short = old_retry_short;
2312 rdev->wiphy.retry_long = old_retry_long;
2313 rdev->wiphy.frag_threshold = old_frag_threshold;
2314 rdev->wiphy.rts_threshold = old_rts_threshold;
81077e82 2315 rdev->wiphy.coverage_class = old_coverage_class;
b9a5f8ca
JM		 2316 }
2317 }
7f2b8562 2318 return 0;
55682965
JB		 2319}
2320
71bbc994
JB		 2321static inline u64 wdev_id(struct wireless_dev *wdev)
2322{
2323 return (u64)wdev->identifier |
f26cbf40 2324 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
71bbc994 2325}
55682965 2326
683b6d3b 2327static int nl80211_send_chandef(struct sk_buff *msg,
d2859df5 2328 const struct cfg80211_chan_def *chandef)
683b6d3b 2329{
601555cd
JB		 2330 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2331 return -EINVAL;
3d9d1d66 2332
683b6d3b
JB		 2333 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2334 chandef->chan->center_freq))
2335 return -ENOBUFS;
3d9d1d66
JB		 2336 switch (chandef->width) {
2337 case NL80211_CHAN_WIDTH_20_NOHT:
2338 case NL80211_CHAN_WIDTH_20:
2339 case NL80211_CHAN_WIDTH_40:
2340 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2341 cfg80211_get_chandef_type(chandef)))
2342 return -ENOBUFS;
2343 break;
2344 default:
2345 break;
2346 }
2347 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2348 return -ENOBUFS;
2349 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2350 return -ENOBUFS;
2351 if (chandef->center_freq2 &&
2352 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
683b6d3b
JB		 2353 return -ENOBUFS;
2354 return 0;
2355}
2356
15e47304 2357static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
d726405a 2358 struct cfg80211_registered_device *rdev,
8f894be2 2359 struct wireless_dev *wdev, bool removal)
55682965 2360{
72fb2abc 2361 struct net_device *dev = wdev->netdev;
8f894be2 2362 u8 cmd = NL80211_CMD_NEW_INTERFACE;
55682965
JB		 2363 void *hdr;
2364
8f894be2
TB		 2365 if (removal)
2366 cmd = NL80211_CMD_DEL_INTERFACE;
2367
2368 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
55682965
JB		 2369 if (!hdr)
2370 return -1;
2371
72fb2abc
JB		 2372 if (dev &&
2373 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
98104fde 2374 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
72fb2abc
JB		 2375 goto nla_put_failure;
2376
2377 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2378 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
71bbc994 2379 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
98104fde 2380 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
9360ffd1
DM		 2381 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2382 rdev->devlist_generation ^
2383 (cfg80211_rdev_list_generation << 2)))
2384 goto nla_put_failure;
f5ea9120 2385
5b7ccaf3 2386 if (rdev->ops->get_channel) {
683b6d3b
JB		 2387 int ret;
2388 struct cfg80211_chan_def chandef;
2389
2390 ret = rdev_get_channel(rdev, wdev, &chandef);
2391 if (ret == 0) {
2392 if (nl80211_send_chandef(msg, &chandef))
2393 goto nla_put_failure;
2394 }
d91df0e3
PF		 2395 }
2396
b84e7a05
AQ		 2397 if (wdev->ssid_len) {
2398 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2399 goto nla_put_failure;
2400 }
2401
55682965
JB		 2402 return genlmsg_end(msg, hdr);
2403
2404 nla_put_failure:
bc3ed28c
TG		 2405 genlmsg_cancel(msg, hdr);
2406 return -EMSGSIZE;
55682965
JB		 2407}
2408
2409static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2410{
2411 int wp_idx = 0;
2412 int if_idx = 0;
2413 int wp_start = cb->args[0];
2414 int if_start = cb->args[1];
f5ea9120 2415 struct cfg80211_registered_device *rdev;
55682965
JB		 2416 struct wireless_dev *wdev;
2417
5fe231e8 2418 rtnl_lock();
f5ea9120
JB		 2419 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2420 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 2421 continue;
bba95fef
JB		 2422 if (wp_idx < wp_start) {
2423 wp_idx++;
55682965 2424 continue;
bba95fef 2425 }
55682965
JB		 2426 if_idx = 0;
2427
89a54e48 2428 list_for_each_entry(wdev, &rdev->wdev_list, list) {
bba95fef
JB		 2429 if (if_idx < if_start) {
2430 if_idx++;
55682965 2431 continue;
bba95fef 2432 }
15e47304 2433 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
55682965 2434 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8f894be2 2435 rdev, wdev, false) < 0) {
bba95fef
JB		 2436 goto out;
2437 }
2438 if_idx++;
55682965 2439 }
bba95fef
JB		 2440
2441 wp_idx++;
55682965 2442 }
bba95fef 2443 out:
5fe231e8 2444 rtnl_unlock();
55682965
JB		 2445
2446 cb->args[0] = wp_idx;
2447 cb->args[1] = if_idx;
2448
2449 return skb->len;
2450}
2451
2452static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2453{
2454 struct sk_buff *msg;
1b8ec87a 2455 struct cfg80211_registered_device *rdev = info->user_ptr[0];
72fb2abc 2456 struct wireless_dev *wdev = info->user_ptr[1];
55682965 2457
fd2120ca 2458 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965 2459 if (!msg)
4c476991 2460 return -ENOMEM;
55682965 2461
15e47304 2462 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2463 rdev, wdev, false) < 0) {
4c476991
JB		 2464 nlmsg_free(msg);
2465 return -ENOBUFS;
2466 }
55682965 2467
134e6375 2468 return genlmsg_reply(msg, info);
55682965
JB		 2469}
2470
66f7ac50
MW		 2471static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2472 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2473 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2474 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2475 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2476 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
e057d3c3 2477 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
66f7ac50
MW		 2478};
2479
2480static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2481{
2482 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2483 int flag;
2484
2485 *mntrflags = 0;
2486
2487 if (!nla)
2488 return -EINVAL;
2489
2490 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
2491 nla, mntr_flags_policy))
2492 return -EINVAL;
2493
2494 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2495 if (flags[flag])
2496 *mntrflags |= (1<<flag);
2497
2498 return 0;
2499}
2500
9bc383de 2501static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
ad4bb6f8
JB		 2502 struct net_device *netdev, u8 use_4addr,
2503 enum nl80211_iftype iftype)
9bc383de 2504{
ad4bb6f8 2505 if (!use_4addr) {
f350a0a8 2506 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
ad4bb6f8 2507 return -EBUSY;
9bc383de 2508 return 0;
ad4bb6f8 2509 }
9bc383de
JB		 2510
2511 switch (iftype) {
2512 case NL80211_IFTYPE_AP_VLAN:
2513 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2514 return 0;
2515 break;
2516 case NL80211_IFTYPE_STATION:
2517 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2518 return 0;
2519 break;
2520 default:
2521 break;
2522 }
2523
2524 return -EOPNOTSUPP;
2525}
2526
55682965
JB		 2527static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2528{
4c476991 2529 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2530 struct vif_params params;
e36d56b6 2531 int err;
04a773ad 2532 enum nl80211_iftype otype, ntype;
4c476991 2533 struct net_device *dev = info->user_ptr[1];
92ffe055 2534 u32 _flags, *flags = NULL;
ac7f9cfa 2535 bool change = false;
55682965 2536
2ec600d6
LCC		 2537 memset(&params, 0, sizeof(params));
2538
04a773ad 2539 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 2540
723b038d 2541 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 2542 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 2543 if (otype != ntype)
ac7f9cfa 2544 change = true;
4c476991
JB		 2545 if (ntype > NL80211_IFTYPE_MAX)
2546 return -EINVAL;
723b038d
JB		 2547 }
2548
92ffe055 2549 if (info->attrs[NL80211_ATTR_MESH_ID]) {
29cbe68c
JB		 2550 struct wireless_dev *wdev = dev->ieee80211_ptr;
2551
4c476991
JB		 2552 if (ntype != NL80211_IFTYPE_MESH_POINT)
2553 return -EINVAL;
29cbe68c
JB		 2554 if (netif_running(dev))
2555 return -EBUSY;
2556
2557 wdev_lock(wdev);
2558 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2559 IEEE80211_MAX_MESH_ID_LEN);
2560 wdev->mesh_id_up_len =
2561 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2562 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2563 wdev->mesh_id_up_len);
2564 wdev_unlock(wdev);
2ec600d6
LCC		 2565 }
2566
8b787643
FF		 2567 if (info->attrs[NL80211_ATTR_4ADDR]) {
2568 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2569 change = true;
ad4bb6f8 2570 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
9bc383de 2571 if (err)
4c476991 2572 return err;
8b787643
FF		 2573 } else {
2574 params.use_4addr = -1;
2575 }
2576
92ffe055 2577 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
4c476991
JB		 2578 if (ntype != NL80211_IFTYPE_MONITOR)
2579 return -EINVAL;
92ffe055
JB		 2580 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2581 &_flags);
ac7f9cfa 2582 if (err)
4c476991 2583 return err;
ac7f9cfa
JB		 2584
2585 flags = &_flags;
2586 change = true;
92ffe055 2587 }
3b85875a 2588
18003297 2589 if (flags && (*flags & MONITOR_FLAG_ACTIVE) &&
e057d3c3
FF		 2590 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2591 return -EOPNOTSUPP;
2592
ac7f9cfa 2593 if (change)
3d54d255 2594 err = cfg80211_change_iface(rdev, dev, ntype, flags, &params);
ac7f9cfa
JB		 2595 else
2596 err = 0;
60719ffd 2597
9bc383de
JB		 2598 if (!err && params.use_4addr != -1)
2599 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2600
55682965
JB		 2601 return err;
2602}
2603
2604static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2605{
4c476991 2606 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 2607 struct vif_params params;
84efbb84 2608 struct wireless_dev *wdev;
8f894be2 2609 struct sk_buff *msg, *event;
55682965
JB		 2610 int err;
2611 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
66f7ac50 2612 u32 flags;
55682965 2613
78f22b6a
JB		 2614 /* to avoid failing a new interface creation due to pending removal */
2615 cfg80211_destroy_ifaces(rdev);
2616
2ec600d6
LCC		 2617 memset(&params, 0, sizeof(params));
2618
55682965
JB		 2619 if (!info->attrs[NL80211_ATTR_IFNAME])
2620 return -EINVAL;
2621
2622 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2623 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2624 if (type > NL80211_IFTYPE_MAX)
2625 return -EINVAL;
2626 }
2627
79c97e97 2628 if (!rdev->ops->add_virtual_intf ||
4c476991
JB		 2629 !(rdev->wiphy.interface_modes & (1 << type)))
2630 return -EOPNOTSUPP;
55682965 2631
e8f479b1
BG		 2632 if ((type == NL80211_IFTYPE_P2P_DEVICE ||
2633 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2634 info->attrs[NL80211_ATTR_MAC]) {
1c18f145
AS		 2635 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2636 ETH_ALEN);
2637 if (!is_valid_ether_addr(params.macaddr))
2638 return -EADDRNOTAVAIL;
2639 }
2640
9bc383de 2641 if (info->attrs[NL80211_ATTR_4ADDR]) {
8b787643 2642 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
ad4bb6f8 2643 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
9bc383de 2644 if (err)
4c476991 2645 return err;
9bc383de 2646 }
8b787643 2647
1c90f9d4
JB		 2648 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2649 if (!msg)
2650 return -ENOMEM;
2651
66f7ac50
MW		 2652 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
2653 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
2654 &flags);
e057d3c3 2655
18003297 2656 if (!err && (flags & MONITOR_FLAG_ACTIVE) &&
e057d3c3
FF		 2657 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2658 return -EOPNOTSUPP;
2659
e35e4d28
HG		 2660 wdev = rdev_add_virtual_intf(rdev,
2661 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2662 type, err ? NULL : &flags, &params);
d687cbb7
RM		 2663 if (WARN_ON(!wdev)) {
2664 nlmsg_free(msg);
2665 return -EPROTO;
2666 } else if (IS_ERR(wdev)) {
1c90f9d4 2667 nlmsg_free(msg);
84efbb84 2668 return PTR_ERR(wdev);
1c90f9d4 2669 }
2ec600d6 2670
18e5ca65 2671 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
78f22b6a
JB		 2672 wdev->owner_nlportid = info->snd_portid;
2673
98104fde
JB		 2674 switch (type) {
2675 case NL80211_IFTYPE_MESH_POINT:
2676 if (!info->attrs[NL80211_ATTR_MESH_ID])
2677 break;
29cbe68c
JB		 2678 wdev_lock(wdev);
2679 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2680 IEEE80211_MAX_MESH_ID_LEN);
2681 wdev->mesh_id_up_len =
2682 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2683 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2684 wdev->mesh_id_up_len);
2685 wdev_unlock(wdev);
98104fde
JB		 2686 break;
2687 case NL80211_IFTYPE_P2P_DEVICE:
2688 /*
2689 * P2P Device doesn't have a netdev, so doesn't go
2690 * through the netdev notifier and must be added here
2691 */
2692 mutex_init(&wdev->mtx);
2693 INIT_LIST_HEAD(&wdev->event_list);
2694 spin_lock_init(&wdev->event_lock);
2695 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2696 spin_lock_init(&wdev->mgmt_registrations_lock);
2697
98104fde
JB		 2698 wdev->identifier = ++rdev->wdev_id;
2699 list_add_rcu(&wdev->list, &rdev->wdev_list);
2700 rdev->devlist_generation++;
98104fde
JB		 2701 break;
2702 default:
2703 break;
29cbe68c
JB		 2704 }
2705
15e47304 2706 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
8f894be2 2707 rdev, wdev, false) < 0) {
1c90f9d4
JB		 2708 nlmsg_free(msg);
2709 return -ENOBUFS;
2710 }
2711
8f894be2
TB		 2712 event = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2713 if (event) {
2714 if (nl80211_send_iface(event, 0, 0, 0,
2715 rdev, wdev, false) < 0) {
2716 nlmsg_free(event);
2717 goto out;
2718 }
2719
2720 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
2721 event, 0, NL80211_MCGRP_CONFIG,
2722 GFP_KERNEL);
2723 }
2724
2725out:
1c90f9d4 2726 return genlmsg_reply(msg, info);
55682965
JB		 2727}
2728
2729static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
2730{
4c476991 2731 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84efbb84 2732 struct wireless_dev *wdev = info->user_ptr[1];
8f894be2
TB		 2733 struct sk_buff *msg;
2734 int status;
55682965 2735
4c476991
JB		 2736 if (!rdev->ops->del_virtual_intf)
2737 return -EOPNOTSUPP;
55682965 2738
8f894be2
TB		 2739 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2740 if (msg && nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, true) < 0) {
2741 nlmsg_free(msg);
2742 msg = NULL;
2743 }
2744
84efbb84
JB		 2745 /*
2746 * If we remove a wireless device without a netdev then clear
2747 * user_ptr[1] so that nl80211_post_doit won't dereference it
2748 * to check if it needs to do dev_put(). Otherwise it crashes
2749 * since the wdev has been freed, unlike with a netdev where
2750 * we need the dev_put() for the netdev to really be freed.
2751 */
2752 if (!wdev->netdev)
2753 info->user_ptr[1] = NULL;
2754
8f894be2
TB		 2755 status = rdev_del_virtual_intf(rdev, wdev);
2756 if (status >= 0 && msg)
2757 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
2758 msg, 0, NL80211_MCGRP_CONFIG,
2759 GFP_KERNEL);
2760 else
2761 nlmsg_free(msg);
2762
2763 return status;
55682965
JB		 2764}
2765
1d9d9213
SW		 2766static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
2767{
2768 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2769 struct net_device *dev = info->user_ptr[1];
2770 u16 noack_map;
2771
2772 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
2773 return -EINVAL;
2774
2775 if (!rdev->ops->set_noack_map)
2776 return -EOPNOTSUPP;
2777
2778 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
2779
e35e4d28 2780 return rdev_set_noack_map(rdev, dev, noack_map);
1d9d9213
SW		 2781}
2782
41ade00f
JB		 2783struct get_key_cookie {
2784 struct sk_buff *msg;
2785 int error;
b9454e83 2786 int idx;
41ade00f
JB		 2787};
2788
2789static void get_key_callback(void *c, struct key_params *params)
2790{
b9454e83 2791 struct nlattr *key;
41ade00f
JB		 2792 struct get_key_cookie *cookie = c;
2793
9360ffd1
DM		 2794 if ((params->key &&
2795 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
2796 params->key_len, params->key)) ||
2797 (params->seq &&
2798 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
2799 params->seq_len, params->seq)) ||
2800 (params->cipher &&
2801 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
2802 params->cipher)))
2803 goto nla_put_failure;
41ade00f 2804
b9454e83
JB		 2805 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
2806 if (!key)
2807 goto nla_put_failure;
2808
9360ffd1
DM		 2809 if ((params->key &&
2810 nla_put(cookie->msg, NL80211_KEY_DATA,
2811 params->key_len, params->key)) ||
2812 (params->seq &&
2813 nla_put(cookie->msg, NL80211_KEY_SEQ,
2814 params->seq_len, params->seq)) ||
2815 (params->cipher &&
2816 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
2817 params->cipher)))
2818 goto nla_put_failure;
b9454e83 2819
9360ffd1
DM		 2820 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
2821 goto nla_put_failure;
b9454e83
JB		 2822
2823 nla_nest_end(cookie->msg, key);
2824
41ade00f
JB		 2825 return;
2826 nla_put_failure:
2827 cookie->error = 1;
2828}
2829
2830static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
2831{
4c476991 2832 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 2833 int err;
4c476991 2834 struct net_device *dev = info->user_ptr[1];
41ade00f 2835 u8 key_idx = 0;
e31b8213
JB		 2836 const u8 *mac_addr = NULL;
2837 bool pairwise;
41ade00f
JB		 2838 struct get_key_cookie cookie = {
2839 .error = 0,
2840 };
2841 void *hdr;
2842 struct sk_buff *msg;
2843
2844 if (info->attrs[NL80211_ATTR_KEY_IDX])
2845 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
2846
3cfcf6ac 2847 if (key_idx > 5)
41ade00f
JB		 2848 return -EINVAL;
2849
2850 if (info->attrs[NL80211_ATTR_MAC])
2851 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2852
e31b8213
JB		 2853 pairwise = !!mac_addr;
2854 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
2855 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
2856 if (kt >= NUM_NL80211_KEYTYPES)
2857 return -EINVAL;
2858 if (kt != NL80211_KEYTYPE_GROUP &&
2859 kt != NL80211_KEYTYPE_PAIRWISE)
2860 return -EINVAL;
2861 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
2862 }
2863
4c476991
JB		 2864 if (!rdev->ops->get_key)
2865 return -EOPNOTSUPP;
41ade00f 2866
fd2120ca 2867 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 2868 if (!msg)
2869 return -ENOMEM;
41ade00f 2870
15e47304 2871 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
41ade00f 2872 NL80211_CMD_NEW_KEY);
cb35fba3 2873 if (!hdr)
9fe271af 2874 goto nla_put_failure;
41ade00f
JB		 2875
2876 cookie.msg = msg;
b9454e83 2877 cookie.idx = key_idx;
41ade00f 2878
9360ffd1
DM		 2879 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2880 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2881 goto nla_put_failure;
2882 if (mac_addr &&
2883 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
2884 goto nla_put_failure;
41ade00f 2885
e31b8213
JB		 2886 if (pairwise && mac_addr &&
2887 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2888 return -ENOENT;
2889
e35e4d28
HG		 2890 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
2891 get_key_callback);
41ade00f
JB		 2892
2893 if (err)
6c95e2a2 2894 goto free_msg;
41ade00f
JB		 2895
2896 if (cookie.error)
2897 goto nla_put_failure;
2898
2899 genlmsg_end(msg, hdr);
4c476991 2900 return genlmsg_reply(msg, info);
41ade00f
JB		 2901
2902 nla_put_failure:
2903 err = -ENOBUFS;
6c95e2a2 2904 free_msg:
41ade00f 2905 nlmsg_free(msg);
41ade00f
JB		 2906 return err;
2907}
2908
2909static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2910{
4c476991 2911 struct cfg80211_registered_device *rdev = info->user_ptr[0];
b9454e83 2912 struct key_parse key;
41ade00f 2913 int err;
4c476991 2914 struct net_device *dev = info->user_ptr[1];
41ade00f 2915
b9454e83
JB		 2916 err = nl80211_parse_key(info, &key);
2917 if (err)
2918 return err;
41ade00f 2919
b9454e83 2920 if (key.idx < 0)
41ade00f
JB		 2921 return -EINVAL;
2922
b9454e83
JB		 2923 /* only support setting default key */
2924 if (!key.def && !key.defmgmt)
41ade00f
JB		 2925 return -EINVAL;
2926
dbd2fd65 2927 wdev_lock(dev->ieee80211_ptr);
3cfcf6ac 2928
dbd2fd65
JB		 2929 if (key.def) {
2930 if (!rdev->ops->set_default_key) {
2931 err = -EOPNOTSUPP;
2932 goto out;
2933 }
41ade00f 2934
dbd2fd65
JB		 2935 err = nl80211_key_allowed(dev->ieee80211_ptr);
2936 if (err)
2937 goto out;
2938
e35e4d28 2939 err = rdev_set_default_key(rdev, dev, key.idx,
dbd2fd65
JB		 2940 key.def_uni, key.def_multi);
2941
2942 if (err)
2943 goto out;
fffd0934 2944
3d23e349 2945#ifdef CONFIG_CFG80211_WEXT
dbd2fd65
JB		 2946 dev->ieee80211_ptr->wext.default_key = key.idx;
2947#endif
2948 } else {
2949 if (key.def_uni || !key.def_multi) {
2950 err = -EINVAL;
2951 goto out;
2952 }
2953
2954 if (!rdev->ops->set_default_mgmt_key) {
2955 err = -EOPNOTSUPP;
2956 goto out;
2957 }
2958
2959 err = nl80211_key_allowed(dev->ieee80211_ptr);
2960 if (err)
2961 goto out;
2962
e35e4d28 2963 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
dbd2fd65
JB		 2964 if (err)
2965 goto out;
2966
2967#ifdef CONFIG_CFG80211_WEXT
2968 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126 2969#endif
dbd2fd65
JB		 2970 }
2971
2972 out:
fffd0934 2973 wdev_unlock(dev->ieee80211_ptr);
41ade00f 2974
41ade00f
JB		 2975 return err;
2976}
2977
2978static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2979{
4c476991 2980 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fffd0934 2981 int err;
4c476991 2982 struct net_device *dev = info->user_ptr[1];
b9454e83 2983 struct key_parse key;
e31b8213 2984 const u8 *mac_addr = NULL;
41ade00f 2985
b9454e83
JB		 2986 err = nl80211_parse_key(info, &key);
2987 if (err)
2988 return err;
41ade00f 2989
b9454e83 2990 if (!key.p.key)
41ade00f
JB		 2991 return -EINVAL;
2992
41ade00f
JB		 2993 if (info->attrs[NL80211_ATTR_MAC])
2994 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2995
e31b8213
JB		 2996 if (key.type == -1) {
2997 if (mac_addr)
2998 key.type = NL80211_KEYTYPE_PAIRWISE;
2999 else
3000 key.type = NL80211_KEYTYPE_GROUP;
3001 }
3002
3003 /* for now */
3004 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3005 key.type != NL80211_KEYTYPE_GROUP)
3006 return -EINVAL;
3007
4c476991
JB		 3008 if (!rdev->ops->add_key)
3009 return -EOPNOTSUPP;
25e47c18 3010
e31b8213
JB		 3011 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3012 key.type == NL80211_KEYTYPE_PAIRWISE,
3013 mac_addr))
4c476991 3014 return -EINVAL;
41ade00f 3015
fffd0934
JB		 3016 wdev_lock(dev->ieee80211_ptr);
3017 err = nl80211_key_allowed(dev->ieee80211_ptr);
3018 if (!err)
e35e4d28
HG		 3019 err = rdev_add_key(rdev, dev, key.idx,
3020 key.type == NL80211_KEYTYPE_PAIRWISE,
3021 mac_addr, &key.p);
fffd0934 3022 wdev_unlock(dev->ieee80211_ptr);
41ade00f 3023
41ade00f
JB		 3024 return err;
3025}
3026
3027static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3028{
4c476991 3029 struct cfg80211_registered_device *rdev = info->user_ptr[0];
41ade00f 3030 int err;
4c476991 3031 struct net_device *dev = info->user_ptr[1];
41ade00f 3032 u8 *mac_addr = NULL;
b9454e83 3033 struct key_parse key;
41ade00f 3034
b9454e83
JB		 3035 err = nl80211_parse_key(info, &key);
3036 if (err)
3037 return err;
41ade00f
JB		 3038
3039 if (info->attrs[NL80211_ATTR_MAC])
3040 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3041
e31b8213
JB		 3042 if (key.type == -1) {
3043 if (mac_addr)
3044 key.type = NL80211_KEYTYPE_PAIRWISE;
3045 else
3046 key.type = NL80211_KEYTYPE_GROUP;
3047 }
3048
3049 /* for now */
3050 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3051 key.type != NL80211_KEYTYPE_GROUP)
3052 return -EINVAL;
3053
4c476991
JB		 3054 if (!rdev->ops->del_key)
3055 return -EOPNOTSUPP;
41ade00f 3056
fffd0934
JB		 3057 wdev_lock(dev->ieee80211_ptr);
3058 err = nl80211_key_allowed(dev->ieee80211_ptr);
e31b8213
JB		 3059
3060 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
3061 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3062 err = -ENOENT;
3063
fffd0934 3064 if (!err)
e35e4d28
HG		 3065 err = rdev_del_key(rdev, dev, key.idx,
3066 key.type == NL80211_KEYTYPE_PAIRWISE,
3067 mac_addr);
41ade00f 3068
3d23e349 3069#ifdef CONFIG_CFG80211_WEXT
08645126 3070 if (!err) {
b9454e83 3071 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 3072 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 3073 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 3074 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3075 }
3076#endif
fffd0934 3077 wdev_unlock(dev->ieee80211_ptr);
08645126 3078
41ade00f
JB		 3079 return err;
3080}
3081
77765eaf
VT		 3082/* This function returns an error or the number of nested attributes */
3083static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3084{
3085 struct nlattr *attr;
3086 int n_entries = 0, tmp;
3087
3088 nla_for_each_nested(attr, nl_attr, tmp) {
3089 if (nla_len(attr) != ETH_ALEN)
3090 return -EINVAL;
3091
3092 n_entries++;
3093 }
3094
3095 return n_entries;
3096}
3097
3098/*
3099 * This function parses ACL information and allocates memory for ACL data.
3100 * On successful return, the calling function is responsible to free the
3101 * ACL buffer returned by this function.
3102 */
3103static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3104 struct genl_info *info)
3105{
3106 enum nl80211_acl_policy acl_policy;
3107 struct nlattr *attr;
3108 struct cfg80211_acl_data *acl;
3109 int i = 0, n_entries, tmp;
3110
3111 if (!wiphy->max_acl_mac_addrs)
3112 return ERR_PTR(-EOPNOTSUPP);
3113
3114 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3115 return ERR_PTR(-EINVAL);
3116
3117 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3118 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3119 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3120 return ERR_PTR(-EINVAL);
3121
3122 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3123 return ERR_PTR(-EINVAL);
3124
3125 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3126 if (n_entries < 0)
3127 return ERR_PTR(n_entries);
3128
3129 if (n_entries > wiphy->max_acl_mac_addrs)
3130 return ERR_PTR(-ENOTSUPP);
3131
3132 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3133 GFP_KERNEL);
3134 if (!acl)
3135 return ERR_PTR(-ENOMEM);
3136
3137 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3138 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3139 i++;
3140 }
3141
3142 acl->n_acl_entries = n_entries;
3143 acl->acl_policy = acl_policy;
3144
3145 return acl;
3146}
3147
3148static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3149{
3150 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3151 struct net_device *dev = info->user_ptr[1];
3152 struct cfg80211_acl_data *acl;
3153 int err;
3154
3155 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3156 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3157 return -EOPNOTSUPP;
3158
3159 if (!dev->ieee80211_ptr->beacon_interval)
3160 return -EINVAL;
3161
3162 acl = parse_acl_data(&rdev->wiphy, info);
3163 if (IS_ERR(acl))
3164 return PTR_ERR(acl);
3165
3166 err = rdev_set_mac_acl(rdev, dev, acl);
3167
3168 kfree(acl);
3169
3170 return err;
3171}
3172
a1193be8 3173static int nl80211_parse_beacon(struct nlattr *attrs[],
8860020e 3174 struct cfg80211_beacon_data *bcn)
ed1b6cc7 3175{
8860020e 3176 bool haveinfo = false;
ed1b6cc7 3177
a1193be8
SW		 3178 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3179 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3180 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3181 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
f4a11bb0
JB		 3182 return -EINVAL;
3183
8860020e 3184 memset(bcn, 0, sizeof(*bcn));
ed1b6cc7 3185
a1193be8
SW		 3186 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
3187 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3188 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
8860020e
JB		 3189 if (!bcn->head_len)
3190 return -EINVAL;
3191 haveinfo = true;
ed1b6cc7
JB		 3192 }
3193
a1193be8
SW		 3194 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3195 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3196 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
8860020e 3197 haveinfo = true;
ed1b6cc7
JB		 3198 }
3199
4c476991
JB		 3200 if (!haveinfo)
3201 return -EINVAL;
3b85875a 3202
a1193be8
SW		 3203 if (attrs[NL80211_ATTR_IE]) {
3204 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3205 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
9946ecfb
JM		 3206 }
3207
a1193be8 3208 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
8860020e 3209 bcn->proberesp_ies =
a1193be8 3210 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
8860020e 3211 bcn->proberesp_ies_len =
a1193be8 3212 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
9946ecfb
JM		 3213 }
3214
a1193be8 3215 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
8860020e 3216 bcn->assocresp_ies =
a1193be8 3217 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
8860020e 3218 bcn->assocresp_ies_len =
a1193be8 3219 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
9946ecfb
JM		 3220 }
3221
a1193be8
SW		 3222 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3223 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3224 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
00f740e1
AN		 3225 }
3226
8860020e
JB		 3227 return 0;
3228}
3229
46c1dd0c
FF		 3230static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3231 struct cfg80211_ap_settings *params)
3232{
3233 struct wireless_dev *wdev;
3234 bool ret = false;
3235
89a54e48 3236 list_for_each_entry(wdev, &rdev->wdev_list, list) {
46c1dd0c
FF		 3237 if (wdev->iftype != NL80211_IFTYPE_AP &&
3238 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3239 continue;
3240
683b6d3b 3241 if (!wdev->preset_chandef.chan)
46c1dd0c
FF		 3242 continue;
3243
683b6d3b 3244 params->chandef = wdev->preset_chandef;
46c1dd0c
FF		 3245 ret = true;
3246 break;
3247 }
3248
46c1dd0c
FF		 3249 return ret;
3250}
3251
e39e5b5e
JM		 3252static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3253 enum nl80211_auth_type auth_type,
3254 enum nl80211_commands cmd)
3255{
3256 if (auth_type > NL80211_AUTHTYPE_MAX)
3257 return false;
3258
3259 switch (cmd) {
3260 case NL80211_CMD_AUTHENTICATE:
3261 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3262 auth_type == NL80211_AUTHTYPE_SAE)
3263 return false;
3264 return true;
3265 case NL80211_CMD_CONNECT:
3266 case NL80211_CMD_START_AP:
3267 /* SAE not supported yet */
3268 if (auth_type == NL80211_AUTHTYPE_SAE)
3269 return false;
3270 return true;
3271 default:
3272 return false;
3273 }
3274}
3275
8860020e
JB		 3276static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3277{
3278 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3279 struct net_device *dev = info->user_ptr[1];
3280 struct wireless_dev *wdev = dev->ieee80211_ptr;
3281 struct cfg80211_ap_settings params;
3282 int err;
3283
3284 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3285 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3286 return -EOPNOTSUPP;
3287
3288 if (!rdev->ops->start_ap)
3289 return -EOPNOTSUPP;
3290
3291 if (wdev->beacon_interval)
3292 return -EALREADY;
3293
3294 memset(&params, 0, sizeof(params));
3295
3296 /* these are required for START_AP */
3297 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3298 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3299 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3300 return -EINVAL;
3301
a1193be8 3302 err = nl80211_parse_beacon(info->attrs, &params.beacon);
8860020e
JB		 3303 if (err)
3304 return err;
3305
3306 params.beacon_interval =
3307 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3308 params.dtim_period =
3309 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3310
3311 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
3312 if (err)
3313 return err;
3314
3315 /*
3316 * In theory, some of these attributes should be required here
3317 * but since they were not used when the command was originally
3318 * added, keep them optional for old user space programs to let
3319 * them continue to work with drivers that do not need the
3320 * additional information -- drivers must check!
3321 */
3322 if (info->attrs[NL80211_ATTR_SSID]) {
3323 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3324 params.ssid_len =
3325 nla_len(info->attrs[NL80211_ATTR_SSID]);
3326 if (params.ssid_len == 0 ||
3327 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3328 return -EINVAL;
3329 }
3330
3331 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3332 params.hidden_ssid = nla_get_u32(
3333 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3334 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3335 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3336 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3337 return -EINVAL;
3338 }
3339
3340 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3341
3342 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3343 params.auth_type = nla_get_u32(
3344 info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 3345 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3346 NL80211_CMD_START_AP))
8860020e
JB		 3347 return -EINVAL;
3348 } else
3349 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3350
3351 err = nl80211_crypto_settings(rdev, info, &params.crypto,
3352 NL80211_MAX_NR_CIPHER_SUITES);
3353 if (err)
3354 return err;
3355
1b658f11
VT		 3356 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3357 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3358 return -EOPNOTSUPP;
3359 params.inactivity_timeout = nla_get_u16(
3360 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3361 }
3362
53cabad7
JB		 3363 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3364 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3365 return -EINVAL;
3366 params.p2p_ctwindow =
3367 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3368 if (params.p2p_ctwindow > 127)
3369 return -EINVAL;
3370 if (params.p2p_ctwindow != 0 &&
3371 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3372 return -EINVAL;
3373 }
3374
3375 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3376 u8 tmp;
3377
3378 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3379 return -EINVAL;
3380 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3381 if (tmp > 1)
3382 return -EINVAL;
3383 params.p2p_opp_ps = tmp;
3384 if (params.p2p_opp_ps != 0 &&
3385 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3386 return -EINVAL;
3387 }
3388
aa430da4 3389 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 3390 err = nl80211_parse_chandef(rdev, info, &params.chandef);
3391 if (err)
3392 return err;
3393 } else if (wdev->preset_chandef.chan) {
3394 params.chandef = wdev->preset_chandef;
46c1dd0c 3395 } else if (!nl80211_get_ap_channel(rdev, &params))
aa430da4
JB		 3396 return -EINVAL;
3397
174e0cd2
IP		 3398 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
3399 wdev->iftype))
aa430da4
JB		 3400 return -EINVAL;
3401
77765eaf
VT		 3402 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
3403 params.acl = parse_acl_data(&rdev->wiphy, info);
3404 if (IS_ERR(params.acl))
3405 return PTR_ERR(params.acl);
3406 }
3407
18998c38
EP		 3408 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
3409 params.smps_mode =
3410 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
3411 switch (params.smps_mode) {
3412 case NL80211_SMPS_OFF:
3413 break;
3414 case NL80211_SMPS_STATIC:
3415 if (!(rdev->wiphy.features &
3416 NL80211_FEATURE_STATIC_SMPS))
3417 return -EINVAL;
3418 break;
3419 case NL80211_SMPS_DYNAMIC:
3420 if (!(rdev->wiphy.features &
3421 NL80211_FEATURE_DYNAMIC_SMPS))
3422 return -EINVAL;
3423 break;
3424 default:
3425 return -EINVAL;
3426 }
3427 } else {
3428 params.smps_mode = NL80211_SMPS_OFF;
3429 }
3430
c56589ed 3431 wdev_lock(wdev);
e35e4d28 3432 err = rdev_start_ap(rdev, dev, &params);
46c1dd0c 3433 if (!err) {
683b6d3b 3434 wdev->preset_chandef = params.chandef;
8860020e 3435 wdev->beacon_interval = params.beacon_interval;
9e0e2961 3436 wdev->chandef = params.chandef;
06e191e2
AQ		 3437 wdev->ssid_len = params.ssid_len;
3438 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
46c1dd0c 3439 }
c56589ed 3440 wdev_unlock(wdev);
77765eaf
VT		 3441
3442 kfree(params.acl);
3443
56d1893d 3444 return err;
ed1b6cc7
JB		 3445}
3446
8860020e
JB		 3447static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
3448{
3449 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3450 struct net_device *dev = info->user_ptr[1];
3451 struct wireless_dev *wdev = dev->ieee80211_ptr;
3452 struct cfg80211_beacon_data params;
3453 int err;
3454
3455 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3456 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3457 return -EOPNOTSUPP;
3458
3459 if (!rdev->ops->change_beacon)
3460 return -EOPNOTSUPP;
3461
3462 if (!wdev->beacon_interval)
3463 return -EINVAL;
3464
a1193be8 3465 err = nl80211_parse_beacon(info->attrs, &params);
8860020e
JB		 3466 if (err)
3467 return err;
3468
c56589ed
SW		 3469 wdev_lock(wdev);
3470 err = rdev_change_beacon(rdev, dev, &params);
3471 wdev_unlock(wdev);
3472
3473 return err;
8860020e
JB		 3474}
3475
3476static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
ed1b6cc7 3477{
4c476991
JB		 3478 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3479 struct net_device *dev = info->user_ptr[1];
ed1b6cc7 3480
7c8d5e03 3481 return cfg80211_stop_ap(rdev, dev, false);
ed1b6cc7
JB		 3482}
3483
5727ef1b
JB		 3484static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
3485 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
3486 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
3487 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 3488 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
b39c48fa 3489 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
d83023da 3490 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5727ef1b
JB		 3491};
3492
eccb8e8f 3493static int parse_station_flags(struct genl_info *info,
bdd3ae3d 3494 enum nl80211_iftype iftype,
eccb8e8f 3495 struct station_parameters *params)
5727ef1b
JB		 3496{
3497 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 3498 struct nlattr *nla;
5727ef1b
JB		 3499 int flag;
3500
eccb8e8f
JB		 3501 /*
3502 * Try parsing the new attribute first so userspace
3503 * can specify both for older kernels.
3504 */
3505 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
3506 if (nla) {
3507 struct nl80211_sta_flag_update *sta_flags;
3508
3509 sta_flags = nla_data(nla);
3510 params->sta_flags_mask = sta_flags->mask;
3511 params->sta_flags_set = sta_flags->set;
77ee7c89 3512 params->sta_flags_set &= params->sta_flags_mask;
eccb8e8f
JB		 3513 if ((params->sta_flags_mask |
3514 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
3515 return -EINVAL;
3516 return 0;
3517 }
3518
3519 /* if present, parse the old attribute */
5727ef1b 3520
eccb8e8f 3521 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 3522 if (!nla)
3523 return 0;
3524
3525 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
3526 nla, sta_flags_policy))
3527 return -EINVAL;
3528
bdd3ae3d
JB		 3529 /*
3530 * Only allow certain flags for interface types so that
3531 * other attributes are silently ignored. Remember that
3532 * this is backward compatibility code with old userspace
3533 * and shouldn't be hit in other cases anyway.
3534 */
3535 switch (iftype) {
3536 case NL80211_IFTYPE_AP:
3537 case NL80211_IFTYPE_AP_VLAN:
3538 case NL80211_IFTYPE_P2P_GO:
3539 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3540 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3541 BIT(NL80211_STA_FLAG_WME) |
3542 BIT(NL80211_STA_FLAG_MFP);
3543 break;
3544 case NL80211_IFTYPE_P2P_CLIENT:
3545 case NL80211_IFTYPE_STATION:
3546 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3547 BIT(NL80211_STA_FLAG_TDLS_PEER);
3548 break;
3549 case NL80211_IFTYPE_MESH_POINT:
3550 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3551 BIT(NL80211_STA_FLAG_MFP) |
3552 BIT(NL80211_STA_FLAG_AUTHORIZED);
3553 default:
3554 return -EINVAL;
3555 }
5727ef1b 3556
3383b5a6
JB		 3557 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
3558 if (flags[flag]) {
eccb8e8f 3559 params->sta_flags_set |= (1<<flag);
5727ef1b 3560
3383b5a6
JB		 3561 /* no longer support new API additions in old API */
3562 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
3563 return -EINVAL;
3564 }
3565 }
3566
5727ef1b
JB		 3567 return 0;
3568}
3569
c8dcfd8a
FF		 3570static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
3571 int attr)
3572{
3573 struct nlattr *rate;
8eb41c8d
VK		 3574 u32 bitrate;
3575 u16 bitrate_compat;
c8dcfd8a
FF		 3576
3577 rate = nla_nest_start(msg, attr);
3578 if (!rate)
db9c64cf 3579 return false;
c8dcfd8a
FF		 3580
3581 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
3582 bitrate = cfg80211_calculate_bitrate(info);
8eb41c8d
VK		 3583 /* report 16-bit bitrate only if we can */
3584 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
db9c64cf
JB		 3585 if (bitrate > 0 &&
3586 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
3587 return false;
3588 if (bitrate_compat > 0 &&
3589 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
3590 return false;
3591
3592 if (info->flags & RATE_INFO_FLAGS_MCS) {
3593 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
3594 return false;
3595 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3596 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3597 return false;
3598 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3599 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3600 return false;
3601 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
3602 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
3603 return false;
3604 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
3605 return false;
3606 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3607 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3608 return false;
3609 if (info->flags & RATE_INFO_FLAGS_80_MHZ_WIDTH &&
3610 nla_put_flag(msg, NL80211_RATE_INFO_80_MHZ_WIDTH))
3611 return false;
3612 if (info->flags & RATE_INFO_FLAGS_80P80_MHZ_WIDTH &&
3613 nla_put_flag(msg, NL80211_RATE_INFO_80P80_MHZ_WIDTH))
3614 return false;
3615 if (info->flags & RATE_INFO_FLAGS_160_MHZ_WIDTH &&
3616 nla_put_flag(msg, NL80211_RATE_INFO_160_MHZ_WIDTH))
3617 return false;
3618 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3619 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3620 return false;
3621 }
c8dcfd8a
FF		 3622
3623 nla_nest_end(msg, rate);
3624 return true;
c8dcfd8a
FF		 3625}
3626
119363c7
FF		 3627static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
3628 int id)
3629{
3630 void *attr;
3631 int i = 0;
3632
3633 if (!mask)
3634 return true;
3635
3636 attr = nla_nest_start(msg, id);
3637 if (!attr)
3638 return false;
3639
3640 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
3641 if (!(mask & BIT(i)))
3642 continue;
3643
3644 if (nla_put_u8(msg, i, signal[i]))
3645 return false;
3646 }
3647
3648 nla_nest_end(msg, attr);
3649
3650 return true;
3651}
3652
cf5ead82
JB		 3653static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
3654 u32 seq, int flags,
66266b3a
JL		 3655 struct cfg80211_registered_device *rdev,
3656 struct net_device *dev,
98b62183 3657 const u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 3658{
3659 void *hdr;
f4263c98 3660 struct nlattr *sinfoattr, *bss_param;
fd5b74dc 3661
cf5ead82 3662 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
fd5b74dc
JB		 3663 if (!hdr)
3664 return -1;
3665
9360ffd1
DM		 3666 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3667 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
3668 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
3669 goto nla_put_failure;
f5ea9120 3670
2ec600d6
LCC		 3671 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
3672 if (!sinfoattr)
fd5b74dc 3673 goto nla_put_failure;
319090bf
JB		 3674
3675#define PUT_SINFO(attr, memb, type) do { \
3676 if (sinfo->filled & BIT(NL80211_STA_INFO_ ## attr) && \
3677 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
3678 sinfo->memb)) \
3679 goto nla_put_failure; \
3680 } while (0)
3681
3682 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
3683 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
3684
3685 if (sinfo->filled & (BIT(NL80211_STA_INFO_RX_BYTES) |
3686 BIT(NL80211_STA_INFO_RX_BYTES64)) &&
9360ffd1 3687 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
42745e03 3688 (u32)sinfo->rx_bytes))
9360ffd1 3689 goto nla_put_failure;
319090bf
JB		 3690
3691 if (sinfo->filled & (BIT(NL80211_STA_INFO_TX_BYTES) |
3692 BIT(NL80211_STA_INFO_TX_BYTES64)) &&
9360ffd1 3693 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
42745e03
VK		 3694 (u32)sinfo->tx_bytes))
3695 goto nla_put_failure;
319090bf
JB		 3696
3697 PUT_SINFO(RX_BYTES64, rx_bytes, u64);
3698 PUT_SINFO(TX_BYTES64, tx_bytes, u64);
3699 PUT_SINFO(LLID, llid, u16);
3700 PUT_SINFO(PLID, plid, u16);
3701 PUT_SINFO(PLINK_STATE, plink_state, u8);
3702
66266b3a
JL		 3703 switch (rdev->wiphy.signal_type) {
3704 case CFG80211_SIGNAL_TYPE_MBM:
319090bf
JB		 3705 PUT_SINFO(SIGNAL, signal, u8);
3706 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
66266b3a
JL		 3707 break;
3708 default:
3709 break;
3710 }
319090bf 3711 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL)) {
119363c7
FF		 3712 if (!nl80211_put_signal(msg, sinfo->chains,
3713 sinfo->chain_signal,
3714 NL80211_STA_INFO_CHAIN_SIGNAL))
3715 goto nla_put_failure;
3716 }
319090bf 3717 if (sinfo->filled & BIT(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
119363c7
FF		 3718 if (!nl80211_put_signal(msg, sinfo->chains,
3719 sinfo->chain_signal_avg,
3720 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
3721 goto nla_put_failure;
3722 }
319090bf 3723 if (sinfo->filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {
c8dcfd8a
FF		 3724 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
3725 NL80211_STA_INFO_TX_BITRATE))
3726 goto nla_put_failure;
3727 }
319090bf 3728 if (sinfo->filled & BIT(NL80211_STA_INFO_RX_BITRATE)) {
c8dcfd8a
FF		 3729 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
3730 NL80211_STA_INFO_RX_BITRATE))
420e7fab 3731 goto nla_put_failure;
420e7fab 3732 }
319090bf
JB		 3733
3734 PUT_SINFO(RX_PACKETS, rx_packets, u32);
3735 PUT_SINFO(TX_PACKETS, tx_packets, u32);
3736 PUT_SINFO(TX_RETRIES, tx_retries, u32);
3737 PUT_SINFO(TX_FAILED, tx_failed, u32);
3738 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
3739 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
3740 PUT_SINFO(LOCAL_PM, local_pm, u32);
3741 PUT_SINFO(PEER_PM, peer_pm, u32);
3742 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
3743
3744 if (sinfo->filled & BIT(NL80211_STA_INFO_BSS_PARAM)) {
f4263c98
PS		 3745 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
3746 if (!bss_param)
3747 goto nla_put_failure;
3748
9360ffd1
DM		 3749 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
3750 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
3751 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
3752 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
3753 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
3754 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
3755 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
3756 sinfo->bss_param.dtim_period) ||
3757 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
3758 sinfo->bss_param.beacon_interval))
3759 goto nla_put_failure;
f4263c98
PS		 3760
3761 nla_nest_end(msg, bss_param);
3762 }
319090bf 3763 if ((sinfo->filled & BIT(NL80211_STA_INFO_STA_FLAGS)) &&
9360ffd1
DM		 3764 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
3765 sizeof(struct nl80211_sta_flag_update),
3766 &sinfo->sta_flags))
3767 goto nla_put_failure;
319090bf
JB		 3768
3769 PUT_SINFO(T_OFFSET, t_offset, u64);
3770 PUT_SINFO(RX_DROP_MISC, rx_dropped_misc, u64);
a76b1942
JB		 3771 PUT_SINFO(BEACON_RX, rx_beacon, u64);
3772 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
319090bf
JB		 3773
3774#undef PUT_SINFO
2ec600d6 3775 nla_nest_end(msg, sinfoattr);
fd5b74dc 3776
319090bf 3777 if (sinfo->assoc_req_ies_len &&
9360ffd1
DM		 3778 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
3779 sinfo->assoc_req_ies))
3780 goto nla_put_failure;
50d3dfb7 3781
fd5b74dc
JB		 3782 return genlmsg_end(msg, hdr);
3783
3784 nla_put_failure:
bc3ed28c
TG		 3785 genlmsg_cancel(msg, hdr);
3786 return -EMSGSIZE;
fd5b74dc
JB		 3787}
3788
2ec600d6 3789static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 3790 struct netlink_callback *cb)
2ec600d6 3791{
2ec600d6 3792 struct station_info sinfo;
1b8ec87a 3793 struct cfg80211_registered_device *rdev;
97990a06 3794 struct wireless_dev *wdev;
2ec600d6 3795 u8 mac_addr[ETH_ALEN];
97990a06 3796 int sta_idx = cb->args[2];
2ec600d6 3797 int err;
2ec600d6 3798
1b8ec87a 3799 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 3800 if (err)
3801 return err;
bba95fef 3802
97990a06
JB		 3803 if (!wdev->netdev) {
3804 err = -EINVAL;
3805 goto out_err;
3806 }
3807
1b8ec87a 3808 if (!rdev->ops->dump_station) {
eec60b03 3809 err = -EOPNOTSUPP;
bba95fef
JB		 3810 goto out_err;
3811 }
3812
bba95fef 3813 while (1) {
f612cedf 3814 memset(&sinfo, 0, sizeof(sinfo));
1b8ec87a 3815 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
e35e4d28 3816 mac_addr, &sinfo);
bba95fef
JB		 3817 if (err == -ENOENT)
3818 break;
3819 if (err)
3b85875a 3820 goto out_err;
bba95fef 3821
cf5ead82 3822 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
15e47304 3823 NETLINK_CB(cb->skb).portid,
bba95fef 3824 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1b8ec87a 3825 rdev, wdev->netdev, mac_addr,
bba95fef
JB		 3826 &sinfo) < 0)
3827 goto out;
3828
3829 sta_idx++;
3830 }
3831
3832
3833 out:
97990a06 3834 cb->args[2] = sta_idx;
bba95fef 3835 err = skb->len;
bba95fef 3836 out_err:
1b8ec87a 3837 nl80211_finish_wdev_dump(rdev);
bba95fef
JB		 3838
3839 return err;
2ec600d6 3840}
fd5b74dc 3841
5727ef1b
JB		 3842static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
3843{
4c476991
JB		 3844 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3845 struct net_device *dev = info->user_ptr[1];
2ec600d6 3846 struct station_info sinfo;
fd5b74dc
JB		 3847 struct sk_buff *msg;
3848 u8 *mac_addr = NULL;
4c476991 3849 int err;
fd5b74dc 3850
2ec600d6 3851 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 3852
3853 if (!info->attrs[NL80211_ATTR_MAC])
3854 return -EINVAL;
3855
3856 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3857
4c476991
JB		 3858 if (!rdev->ops->get_station)
3859 return -EOPNOTSUPP;
3b85875a 3860
e35e4d28 3861 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
fd5b74dc 3862 if (err)
4c476991 3863 return err;
2ec600d6 3864
fd2120ca 3865 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc 3866 if (!msg)
4c476991 3867 return -ENOMEM;
fd5b74dc 3868
cf5ead82
JB		 3869 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
3870 info->snd_portid, info->snd_seq, 0,
66266b3a 3871 rdev, dev, mac_addr, &sinfo) < 0) {
4c476991
JB		 3872 nlmsg_free(msg);
3873 return -ENOBUFS;
3874 }
3b85875a 3875
4c476991 3876 return genlmsg_reply(msg, info);
5727ef1b
JB		 3877}
3878
77ee7c89
JB		 3879int cfg80211_check_station_change(struct wiphy *wiphy,
3880 struct station_parameters *params,
3881 enum cfg80211_station_type statype)
3882{
3883 if (params->listen_interval != -1)
3884 return -EINVAL;
c72e1140
AN		 3885 if (params->aid &&
3886 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
77ee7c89
JB		 3887 return -EINVAL;
3888
3889 /* When you run into this, adjust the code below for the new flag */
3890 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
3891
3892 switch (statype) {
eef941e6
TP		 3893 case CFG80211_STA_MESH_PEER_KERNEL:
3894 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 3895 /*
3896 * No ignoring the TDLS flag here -- the userspace mesh
3897 * code doesn't have the bug of including TDLS in the
3898 * mask everywhere.
3899 */
3900 if (params->sta_flags_mask &
3901 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3902 BIT(NL80211_STA_FLAG_MFP) |
3903 BIT(NL80211_STA_FLAG_AUTHORIZED)))
3904 return -EINVAL;
3905 break;
3906 case CFG80211_STA_TDLS_PEER_SETUP:
3907 case CFG80211_STA_TDLS_PEER_ACTIVE:
3908 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3909 return -EINVAL;
3910 /* ignore since it can't change */
3911 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3912 break;
3913 default:
3914 /* disallow mesh-specific things */
3915 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3916 return -EINVAL;
3917 if (params->local_pm)
3918 return -EINVAL;
3919 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3920 return -EINVAL;
3921 }
3922
3923 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
3924 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
3925 /* TDLS can't be set, ... */
3926 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3927 return -EINVAL;
3928 /*
3929 * ... but don't bother the driver with it. This works around
3930 * a hostapd/wpa_supplicant issue -- it always includes the
3931 * TLDS_PEER flag in the mask even for AP mode.
3932 */
3933 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3934 }
3935
3936 if (statype != CFG80211_STA_TDLS_PEER_SETUP) {
3937 /* reject other things that can't change */
3938 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
3939 return -EINVAL;
3940 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
3941 return -EINVAL;
3942 if (params->supported_rates)
3943 return -EINVAL;
3944 if (params->ext_capab || params->ht_capa || params->vht_capa)
3945 return -EINVAL;
3946 }
3947
3948 if (statype != CFG80211_STA_AP_CLIENT) {
3949 if (params->vlan)
3950 return -EINVAL;
3951 }
3952
3953 switch (statype) {
3954 case CFG80211_STA_AP_MLME_CLIENT:
3955 /* Use this only for authorizing/unauthorizing a station */
3956 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
3957 return -EOPNOTSUPP;
3958 break;
3959 case CFG80211_STA_AP_CLIENT:
3960 /* accept only the listed bits */
3961 if (params->sta_flags_mask &
3962 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3963 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3964 BIT(NL80211_STA_FLAG_ASSOCIATED) |
3965 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3966 BIT(NL80211_STA_FLAG_WME) |
3967 BIT(NL80211_STA_FLAG_MFP)))
3968 return -EINVAL;
3969
3970 /* but authenticated/associated only if driver handles it */
3971 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
3972 params->sta_flags_mask &
3973 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3974 BIT(NL80211_STA_FLAG_ASSOCIATED)))
3975 return -EINVAL;
3976 break;
3977 case CFG80211_STA_IBSS:
3978 case CFG80211_STA_AP_STA:
3979 /* reject any changes other than AUTHORIZED */
3980 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
3981 return -EINVAL;
3982 break;
3983 case CFG80211_STA_TDLS_PEER_SETUP:
3984 /* reject any changes other than AUTHORIZED or WME */
3985 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3986 BIT(NL80211_STA_FLAG_WME)))
3987 return -EINVAL;
3988 /* force (at least) rates when authorizing */
3989 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
3990 !params->supported_rates)
3991 return -EINVAL;
3992 break;
3993 case CFG80211_STA_TDLS_PEER_ACTIVE:
3994 /* reject any changes */
3995 return -EINVAL;
eef941e6 3996 case CFG80211_STA_MESH_PEER_KERNEL:
77ee7c89
JB		 3997 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3998 return -EINVAL;
3999 break;
eef941e6 4000 case CFG80211_STA_MESH_PEER_USER:
77ee7c89
JB		 4001 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
4002 return -EINVAL;
4003 break;
4004 }
4005
4006 return 0;
4007}
4008EXPORT_SYMBOL(cfg80211_check_station_change);
4009
5727ef1b 4010/*
c258d2de 4011 * Get vlan interface making sure it is running and on the right wiphy.
5727ef1b 4012 */
80b99899
JB		 4013static struct net_device *get_vlan(struct genl_info *info,
4014 struct cfg80211_registered_device *rdev)
5727ef1b 4015{
463d0183 4016 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
80b99899
JB		 4017 struct net_device *v;
4018 int ret;
4019
4020 if (!vlanattr)
4021 return NULL;
4022
4023 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4024 if (!v)
4025 return ERR_PTR(-ENODEV);
4026
4027 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4028 ret = -EINVAL;
4029 goto error;
5727ef1b 4030 }
80b99899 4031
77ee7c89
JB		 4032 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4033 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4034 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4035 ret = -EINVAL;
4036 goto error;
4037 }
4038
80b99899
JB		 4039 if (!netif_running(v)) {
4040 ret = -ENETDOWN;
4041 goto error;
4042 }
4043
4044 return v;
4045 error:
4046 dev_put(v);
4047 return ERR_PTR(ret);
5727ef1b
JB		 4048}
4049
94e860f1
JB		 4050static const struct nla_policy
4051nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
df881293
JM		 4052 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4053 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4054};
4055
ff276691
JB		 4056static int nl80211_parse_sta_wme(struct genl_info *info,
4057 struct station_parameters *params)
df881293 4058{
df881293
JM		 4059 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4060 struct nlattr *nla;
4061 int err;
4062
df881293
JM		 4063 /* parse WME attributes if present */
4064 if (!info->attrs[NL80211_ATTR_STA_WME])
4065 return 0;
4066
4067 nla = info->attrs[NL80211_ATTR_STA_WME];
4068 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
4069 nl80211_sta_wme_policy);
4070 if (err)
4071 return err;
4072
4073 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4074 params->uapsd_queues = nla_get_u8(
4075 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4076 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4077 return -EINVAL;
4078
4079 if (tb[NL80211_STA_WME_MAX_SP])
4080 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4081
4082 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4083 return -EINVAL;
4084
4085 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4086
4087 return 0;
4088}
4089
c01fc9ad
SD		 4090static int nl80211_parse_sta_channel_info(struct genl_info *info,
4091 struct station_parameters *params)
4092{
4093 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4094 params->supported_channels =
4095 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4096 params->supported_channels_len =
4097 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4098 /*
4099 * Need to include at least one (first channel, number of
4100 * channels) tuple for each subband, and must have proper
4101 * tuples for the rest of the data as well.
4102 */
4103 if (params->supported_channels_len < 2)
4104 return -EINVAL;
4105 if (params->supported_channels_len % 2)
4106 return -EINVAL;
4107 }
4108
4109 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4110 params->supported_oper_classes =
4111 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4112 params->supported_oper_classes_len =
4113 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4114 /*
4115 * The value of the Length field of the Supported Operating
4116 * Classes element is between 2 and 253.
4117 */
4118 if (params->supported_oper_classes_len < 2 ||
4119 params->supported_oper_classes_len > 253)
4120 return -EINVAL;
4121 }
4122 return 0;
4123}
4124
ff276691
JB		 4125static int nl80211_set_station_tdls(struct genl_info *info,
4126 struct station_parameters *params)
4127{
c01fc9ad 4128 int err;
ff276691 4129 /* Dummy STA entry gets updated once the peer capabilities are known */
5e4b6f56
JM		 4130 if (info->attrs[NL80211_ATTR_PEER_AID])
4131 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
ff276691
JB		 4132 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4133 params->ht_capa =
4134 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4135 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4136 params->vht_capa =
4137 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4138
c01fc9ad
SD		 4139 err = nl80211_parse_sta_channel_info(info, params);
4140 if (err)
4141 return err;
4142
ff276691
JB		 4143 return nl80211_parse_sta_wme(info, params);
4144}
4145
5727ef1b
JB		 4146static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4147{
4c476991 4148 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4149 struct net_device *dev = info->user_ptr[1];
5727ef1b 4150 struct station_parameters params;
77ee7c89
JB		 4151 u8 *mac_addr;
4152 int err;
5727ef1b
JB		 4153
4154 memset(&params, 0, sizeof(params));
4155
4156 params.listen_interval = -1;
4157
77ee7c89
JB		 4158 if (!rdev->ops->change_station)
4159 return -EOPNOTSUPP;
4160
5727ef1b
JB		 4161 if (info->attrs[NL80211_ATTR_STA_AID])
4162 return -EINVAL;
4163
4164 if (!info->attrs[NL80211_ATTR_MAC])
4165 return -EINVAL;
4166
4167 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4168
4169 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4170 params.supported_rates =
4171 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4172 params.supported_rates_len =
4173 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4174 }
4175
9d62a986
JM		 4176 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4177 params.capability =
4178 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4179 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4180 }
4181
4182 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4183 params.ext_capab =
4184 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4185 params.ext_capab_len =
4186 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4187 }
4188
df881293 4189 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
ba23d206 4190 return -EINVAL;
36aedc90 4191
bdd3ae3d 4192 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 4193 return -EINVAL;
4194
f8bacc21 4195 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
2ec600d6 4196 params.plink_action =
f8bacc21
JB		 4197 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4198 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4199 return -EINVAL;
4200 }
2ec600d6 4201
f8bacc21 4202 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
9c3990aa 4203 params.plink_state =
f8bacc21
JB		 4204 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
4205 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
4206 return -EINVAL;
4207 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
4208 }
9c3990aa 4209
3b1c5a53
MP		 4210 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
4211 enum nl80211_mesh_power_mode pm = nla_get_u32(
4212 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
4213
4214 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
4215 pm > NL80211_MESH_POWER_MAX)
4216 return -EINVAL;
4217
4218 params.local_pm = pm;
4219 }
4220
77ee7c89
JB		 4221 /* Include parameters for TDLS peer (will check later) */
4222 err = nl80211_set_station_tdls(info, &params);
4223 if (err)
4224 return err;
4225
4226 params.vlan = get_vlan(info, rdev);
4227 if (IS_ERR(params.vlan))
4228 return PTR_ERR(params.vlan);
4229
a97f4424
JB		 4230 switch (dev->ieee80211_ptr->iftype) {
4231 case NL80211_IFTYPE_AP:
4232 case NL80211_IFTYPE_AP_VLAN:
074ac8df 4233 case NL80211_IFTYPE_P2P_GO:
074ac8df 4234 case NL80211_IFTYPE_P2P_CLIENT:
a97f4424 4235 case NL80211_IFTYPE_STATION:
267335d6 4236 case NL80211_IFTYPE_ADHOC:
a97f4424 4237 case NL80211_IFTYPE_MESH_POINT:
a97f4424
JB		 4238 break;
4239 default:
77ee7c89
JB		 4240 err = -EOPNOTSUPP;
4241 goto out_put_vlan;
034d655e
JB		 4242 }
4243
77ee7c89 4244 /* driver will call cfg80211_check_station_change() */
e35e4d28 4245 err = rdev_change_station(rdev, dev, mac_addr, &params);
5727ef1b 4246
77ee7c89 4247 out_put_vlan:
5727ef1b
JB		 4248 if (params.vlan)
4249 dev_put(params.vlan);
3b85875a 4250
5727ef1b
JB		 4251 return err;
4252}
4253
4254static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
4255{
4c476991 4256 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5727ef1b 4257 int err;
4c476991 4258 struct net_device *dev = info->user_ptr[1];
5727ef1b
JB		 4259 struct station_parameters params;
4260 u8 *mac_addr = NULL;
4261
4262 memset(&params, 0, sizeof(params));
4263
984c311b
JB		 4264 if (!rdev->ops->add_station)
4265 return -EOPNOTSUPP;
4266
5727ef1b
JB		 4267 if (!info->attrs[NL80211_ATTR_MAC])
4268 return -EINVAL;
4269
5727ef1b
JB		 4270 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4271 return -EINVAL;
4272
4273 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
4274 return -EINVAL;
4275
5e4b6f56
JM		 4276 if (!info->attrs[NL80211_ATTR_STA_AID] &&
4277 !info->attrs[NL80211_ATTR_PEER_AID])
0e956c13
TLSC		 4278 return -EINVAL;
4279
5727ef1b
JB		 4280 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4281 params.supported_rates =
4282 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4283 params.supported_rates_len =
4284 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4285 params.listen_interval =
4286 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 4287
3d124ea2 4288 if (info->attrs[NL80211_ATTR_PEER_AID])
5e4b6f56 4289 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
3d124ea2
JM		 4290 else
4291 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
0e956c13
TLSC		 4292 if (!params.aid || params.aid > IEEE80211_MAX_AID)
4293 return -EINVAL;
51b50fbe 4294
9d62a986
JM		 4295 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4296 params.capability =
4297 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4298 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4299 }
4300
4301 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4302 params.ext_capab =
4303 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4304 params.ext_capab_len =
4305 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4306 }
4307
36aedc90
JM		 4308 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4309 params.ht_capa =
4310 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 4311
f461be3e
MP		 4312 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4313 params.vht_capa =
4314 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4315
60f4a7b1
MK		 4316 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
4317 params.opmode_notif_used = true;
4318 params.opmode_notif =
4319 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
4320 }
4321
f8bacc21 4322 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
96b78dff 4323 params.plink_action =
f8bacc21
JB		 4324 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4325 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4326 return -EINVAL;
4327 }
96b78dff 4328
c01fc9ad
SD		 4329 err = nl80211_parse_sta_channel_info(info, &params);
4330 if (err)
4331 return err;
4332
ff276691
JB		 4333 err = nl80211_parse_sta_wme(info, &params);
4334 if (err)
4335 return err;
bdd90d5e 4336
bdd3ae3d 4337 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
5727ef1b
JB		 4338 return -EINVAL;
4339
77ee7c89
JB		 4340 /* When you run into this, adjust the code below for the new flag */
4341 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4342
bdd90d5e
JB		 4343 switch (dev->ieee80211_ptr->iftype) {
4344 case NL80211_IFTYPE_AP:
4345 case NL80211_IFTYPE_AP_VLAN:
4346 case NL80211_IFTYPE_P2P_GO:
984c311b
JB		 4347 /* ignore WME attributes if iface/sta is not capable */
4348 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
4349 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
4350 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
c75786c9 4351
bdd90d5e 4352 /* TDLS peers cannot be added */
3d124ea2
JM		 4353 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
4354 info->attrs[NL80211_ATTR_PEER_AID])
4319e193 4355 return -EINVAL;
bdd90d5e
JB		 4356 /* but don't bother the driver with it */
4357 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3b9ce80c 4358
d582cffb
JB		 4359 /* allow authenticated/associated only if driver handles it */
4360 if (!(rdev->wiphy.features &
4361 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4362 params.sta_flags_mask &
4363 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4364 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4365 return -EINVAL;
4366
bdd90d5e
JB		 4367 /* must be last in here for error handling */
4368 params.vlan = get_vlan(info, rdev);
4369 if (IS_ERR(params.vlan))
4370 return PTR_ERR(params.vlan);
4371 break;
4372 case NL80211_IFTYPE_MESH_POINT:
984c311b
JB		 4373 /* ignore uAPSD data */
4374 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4375
d582cffb
JB		 4376 /* associated is disallowed */
4377 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
4378 return -EINVAL;
bdd90d5e 4379 /* TDLS peers cannot be added */
3d124ea2
JM		 4380 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
4381 info->attrs[NL80211_ATTR_PEER_AID])
bdd90d5e
JB		 4382 return -EINVAL;
4383 break;
4384 case NL80211_IFTYPE_STATION:
93d08f0b 4385 case NL80211_IFTYPE_P2P_CLIENT:
984c311b
JB		 4386 /* ignore uAPSD data */
4387 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4388
77ee7c89
JB		 4389 /* these are disallowed */
4390 if (params.sta_flags_mask &
4391 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
4392 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
d582cffb 4393 return -EINVAL;
bdd90d5e
JB		 4394 /* Only TDLS peers can be added */
4395 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4396 return -EINVAL;
4397 /* Can only add if TDLS ... */
4398 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
4399 return -EOPNOTSUPP;
4400 /* ... with external setup is supported */
4401 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
4402 return -EOPNOTSUPP;
77ee7c89
JB		 4403 /*
4404 * Older wpa_supplicant versions always mark the TDLS peer
4405 * as authorized, but it shouldn't yet be.
4406 */
4407 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
bdd90d5e
JB		 4408 break;
4409 default:
4410 return -EOPNOTSUPP;
c75786c9
EP		 4411 }
4412
bdd90d5e 4413 /* be aware of params.vlan when changing code here */
5727ef1b 4414
e35e4d28 4415 err = rdev_add_station(rdev, dev, mac_addr, &params);
5727ef1b 4416
5727ef1b
JB		 4417 if (params.vlan)
4418 dev_put(params.vlan);
5727ef1b
JB		 4419 return err;
4420}
4421
4422static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
4423{
4c476991
JB		 4424 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4425 struct net_device *dev = info->user_ptr[1];
89c771e5
JM		 4426 struct station_del_parameters params;
4427
4428 memset(&params, 0, sizeof(params));
5727ef1b
JB		 4429
4430 if (info->attrs[NL80211_ATTR_MAC])
89c771e5 4431 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5727ef1b 4432
e80cf853 4433 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
d5d9de02 4434 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
074ac8df 4435 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4c476991
JB		 4436 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4437 return -EINVAL;
5727ef1b 4438
4c476991
JB		 4439 if (!rdev->ops->del_station)
4440 return -EOPNOTSUPP;
3b85875a 4441
98856866
JM		 4442 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
4443 params.subtype =
4444 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
4445 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
4446 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
4447 return -EINVAL;
4448 } else {
4449 /* Default to Deauthentication frame */
4450 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
4451 }
4452
4453 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
4454 params.reason_code =
4455 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4456 if (params.reason_code == 0)
4457 return -EINVAL; /* 0 is reserved */
4458 } else {
4459 /* Default to reason code 2 */
4460 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
4461 }
4462
89c771e5 4463 return rdev_del_station(rdev, dev, &params);
5727ef1b
JB		 4464}
4465
15e47304 4466static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
2ec600d6
LCC		 4467 int flags, struct net_device *dev,
4468 u8 *dst, u8 *next_hop,
4469 struct mpath_info *pinfo)
4470{
4471 void *hdr;
4472 struct nlattr *pinfoattr;
4473
1ef4c850 4474 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
2ec600d6
LCC		 4475 if (!hdr)
4476 return -1;
4477
9360ffd1
DM		 4478 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4479 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
4480 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
4481 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
4482 goto nla_put_failure;
f5ea9120 4483
2ec600d6
LCC		 4484 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
4485 if (!pinfoattr)
4486 goto nla_put_failure;
9360ffd1
DM		 4487 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
4488 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
4489 pinfo->frame_qlen))
4490 goto nla_put_failure;
4491 if (((pinfo->filled & MPATH_INFO_SN) &&
4492 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
4493 ((pinfo->filled & MPATH_INFO_METRIC) &&
4494 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
4495 pinfo->metric)) ||
4496 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
4497 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
4498 pinfo->exptime)) ||
4499 ((pinfo->filled & MPATH_INFO_FLAGS) &&
4500 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
4501 pinfo->flags)) ||
4502 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
4503 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
4504 pinfo->discovery_timeout)) ||
4505 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
4506 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
4507 pinfo->discovery_retries)))
4508 goto nla_put_failure;
2ec600d6
LCC		 4509
4510 nla_nest_end(msg, pinfoattr);
4511
4512 return genlmsg_end(msg, hdr);
4513
4514 nla_put_failure:
bc3ed28c
TG		 4515 genlmsg_cancel(msg, hdr);
4516 return -EMSGSIZE;
2ec600d6
LCC		 4517}
4518
4519static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 4520 struct netlink_callback *cb)
2ec600d6 4521{
2ec600d6 4522 struct mpath_info pinfo;
1b8ec87a 4523 struct cfg80211_registered_device *rdev;
97990a06 4524 struct wireless_dev *wdev;
2ec600d6
LCC		 4525 u8 dst[ETH_ALEN];
4526 u8 next_hop[ETH_ALEN];
97990a06 4527 int path_idx = cb->args[2];
2ec600d6 4528 int err;
2ec600d6 4529
1b8ec87a 4530 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 4531 if (err)
4532 return err;
bba95fef 4533
1b8ec87a 4534 if (!rdev->ops->dump_mpath) {
eec60b03 4535 err = -EOPNOTSUPP;
bba95fef
JB		 4536 goto out_err;
4537 }
4538
97990a06 4539 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
eec60b03 4540 err = -EOPNOTSUPP;
0448b5fc 4541 goto out_err;
eec60b03
JM		 4542 }
4543
bba95fef 4544 while (1) {
1b8ec87a 4545 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
97990a06 4546 next_hop, &pinfo);
bba95fef 4547 if (err == -ENOENT)
2ec600d6 4548 break;
bba95fef 4549 if (err)
3b85875a 4550 goto out_err;
2ec600d6 4551
15e47304 4552 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
bba95fef 4553 cb->nlh->nlmsg_seq, NLM_F_MULTI,
97990a06 4554 wdev->netdev, dst, next_hop,
bba95fef
JB		 4555 &pinfo) < 0)
4556 goto out;
2ec600d6 4557
bba95fef 4558 path_idx++;
2ec600d6 4559 }
2ec600d6 4560
2ec600d6 4561
bba95fef 4562 out:
97990a06 4563 cb->args[2] = path_idx;
bba95fef 4564 err = skb->len;
bba95fef 4565 out_err:
1b8ec87a 4566 nl80211_finish_wdev_dump(rdev);
bba95fef 4567 return err;
2ec600d6
LCC		 4568}
4569
4570static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
4571{
4c476991 4572 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2ec600d6 4573 int err;
4c476991 4574 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 4575 struct mpath_info pinfo;
4576 struct sk_buff *msg;
4577 u8 *dst = NULL;
4578 u8 next_hop[ETH_ALEN];
4579
4580 memset(&pinfo, 0, sizeof(pinfo));
4581
4582 if (!info->attrs[NL80211_ATTR_MAC])
4583 return -EINVAL;
4584
4585 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4586
4c476991
JB		 4587 if (!rdev->ops->get_mpath)
4588 return -EOPNOTSUPP;
2ec600d6 4589
4c476991
JB		 4590 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4591 return -EOPNOTSUPP;
eec60b03 4592
e35e4d28 4593 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
2ec600d6 4594 if (err)
4c476991 4595 return err;
2ec600d6 4596
fd2120ca 4597 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6 4598 if (!msg)
4c476991 4599 return -ENOMEM;
2ec600d6 4600
15e47304 4601 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4c476991
JB		 4602 dev, dst, next_hop, &pinfo) < 0) {
4603 nlmsg_free(msg);
4604 return -ENOBUFS;
4605 }
3b85875a 4606
4c476991 4607 return genlmsg_reply(msg, info);
2ec600d6
LCC		 4608}
4609
4610static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
4611{
4c476991
JB		 4612 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4613 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 4614 u8 *dst = NULL;
4615 u8 *next_hop = NULL;
4616
4617 if (!info->attrs[NL80211_ATTR_MAC])
4618 return -EINVAL;
4619
4620 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4621 return -EINVAL;
4622
4623 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4624 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4625
4c476991
JB		 4626 if (!rdev->ops->change_mpath)
4627 return -EOPNOTSUPP;
35a8efe1 4628
4c476991
JB		 4629 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4630 return -EOPNOTSUPP;
2ec600d6 4631
e35e4d28 4632 return rdev_change_mpath(rdev, dev, dst, next_hop);
2ec600d6 4633}
4c476991 4634
2ec600d6
LCC		 4635static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
4636{
4c476991
JB		 4637 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4638 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 4639 u8 *dst = NULL;
4640 u8 *next_hop = NULL;
4641
4642 if (!info->attrs[NL80211_ATTR_MAC])
4643 return -EINVAL;
4644
4645 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4646 return -EINVAL;
4647
4648 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4649 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4650
4c476991
JB		 4651 if (!rdev->ops->add_mpath)
4652 return -EOPNOTSUPP;
35a8efe1 4653
4c476991
JB		 4654 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4655 return -EOPNOTSUPP;
2ec600d6 4656
e35e4d28 4657 return rdev_add_mpath(rdev, dev, dst, next_hop);
2ec600d6
LCC		 4658}
4659
4660static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
4661{
4c476991
JB		 4662 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4663 struct net_device *dev = info->user_ptr[1];
2ec600d6
LCC		 4664 u8 *dst = NULL;
4665
4666 if (info->attrs[NL80211_ATTR_MAC])
4667 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4668
4c476991
JB		 4669 if (!rdev->ops->del_mpath)
4670 return -EOPNOTSUPP;
3b85875a 4671
e35e4d28 4672 return rdev_del_mpath(rdev, dev, dst);
2ec600d6
LCC		 4673}
4674
66be7d2b
HR		 4675static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
4676{
4677 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4678 int err;
4679 struct net_device *dev = info->user_ptr[1];
4680 struct mpath_info pinfo;
4681 struct sk_buff *msg;
4682 u8 *dst = NULL;
4683 u8 mpp[ETH_ALEN];
4684
4685 memset(&pinfo, 0, sizeof(pinfo));
4686
4687 if (!info->attrs[NL80211_ATTR_MAC])
4688 return -EINVAL;
4689
4690 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4691
4692 if (!rdev->ops->get_mpp)
4693 return -EOPNOTSUPP;
4694
4695 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4696 return -EOPNOTSUPP;
4697
4698 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
4699 if (err)
4700 return err;
4701
4702 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4703 if (!msg)
4704 return -ENOMEM;
4705
4706 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4707 dev, dst, mpp, &pinfo) < 0) {
4708 nlmsg_free(msg);
4709 return -ENOBUFS;
4710 }
4711
4712 return genlmsg_reply(msg, info);
4713}
4714
4715static int nl80211_dump_mpp(struct sk_buff *skb,
4716 struct netlink_callback *cb)
4717{
4718 struct mpath_info pinfo;
4719 struct cfg80211_registered_device *rdev;
4720 struct wireless_dev *wdev;
4721 u8 dst[ETH_ALEN];
4722 u8 mpp[ETH_ALEN];
4723 int path_idx = cb->args[2];
4724 int err;
4725
4726 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
4727 if (err)
4728 return err;
4729
4730 if (!rdev->ops->dump_mpp) {
4731 err = -EOPNOTSUPP;
4732 goto out_err;
4733 }
4734
4735 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
4736 err = -EOPNOTSUPP;
4737 goto out_err;
4738 }
4739
4740 while (1) {
4741 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
4742 mpp, &pinfo);
4743 if (err == -ENOENT)
4744 break;
4745 if (err)
4746 goto out_err;
4747
4748 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4749 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4750 wdev->netdev, dst, mpp,
4751 &pinfo) < 0)
4752 goto out;
4753
4754 path_idx++;
4755 }
4756
4757 out:
4758 cb->args[2] = path_idx;
4759 err = skb->len;
4760 out_err:
4761 nl80211_finish_wdev_dump(rdev);
4762 return err;
4763}
4764
9f1ba906
JM		 4765static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
4766{
4c476991
JB		 4767 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4768 struct net_device *dev = info->user_ptr[1];
c56589ed 4769 struct wireless_dev *wdev = dev->ieee80211_ptr;
9f1ba906 4770 struct bss_parameters params;
c56589ed 4771 int err;
9f1ba906
JM		 4772
4773 memset(&params, 0, sizeof(params));
4774 /* default to not changing parameters */
4775 params.use_cts_prot = -1;
4776 params.use_short_preamble = -1;
4777 params.use_short_slot_time = -1;
fd8aaaf3 4778 params.ap_isolate = -1;
50b12f59 4779 params.ht_opmode = -1;
53cabad7
JB		 4780 params.p2p_ctwindow = -1;
4781 params.p2p_opp_ps = -1;
9f1ba906
JM		 4782
4783 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
4784 params.use_cts_prot =
4785 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
4786 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
4787 params.use_short_preamble =
4788 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
4789 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
4790 params.use_short_slot_time =
4791 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 4792 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
4793 params.basic_rates =
4794 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4795 params.basic_rates_len =
4796 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4797 }
fd8aaaf3
FF		 4798 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
4799 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
50b12f59
HS		 4800 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
4801 params.ht_opmode =
4802 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9f1ba906 4803
53cabad7
JB		 4804 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4805 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4806 return -EINVAL;
4807 params.p2p_ctwindow =
4808 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4809 if (params.p2p_ctwindow < 0)
4810 return -EINVAL;
4811 if (params.p2p_ctwindow != 0 &&
4812 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4813 return -EINVAL;
4814 }
4815
4816 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4817 u8 tmp;
4818
4819 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4820 return -EINVAL;
4821 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4822 if (tmp > 1)
4823 return -EINVAL;
4824 params.p2p_opp_ps = tmp;
4825 if (params.p2p_opp_ps &&
4826 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4827 return -EINVAL;
4828 }
4829
4c476991
JB		 4830 if (!rdev->ops->change_bss)
4831 return -EOPNOTSUPP;
9f1ba906 4832
074ac8df 4833 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4c476991
JB		 4834 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4835 return -EOPNOTSUPP;
3b85875a 4836
c56589ed
SW		 4837 wdev_lock(wdev);
4838 err = rdev_change_bss(rdev, dev, &params);
4839 wdev_unlock(wdev);
4840
4841 return err;
9f1ba906
JM		 4842}
4843
b54452b0 4844static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
b2e1b302
LR		 4845 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
4846 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
4847 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
4848 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
4849 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
4850 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
089027e5 4851 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
b2e1b302
LR		 4852};
4853
4854static int parse_reg_rule(struct nlattr *tb[],
4855 struct ieee80211_reg_rule *reg_rule)
4856{
4857 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
4858 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
4859
4860 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
4861 return -EINVAL;
4862 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
4863 return -EINVAL;
4864 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
4865 return -EINVAL;
b0dfd2ea
JD		 4866 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
4867 return -EINVAL;
b2e1b302
LR		 4868 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
4869 return -EINVAL;
4870
4871 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
4872
4873 freq_range->start_freq_khz =
4874 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
4875 freq_range->end_freq_khz =
4876 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
b0dfd2ea
JD		 4877 freq_range->max_bandwidth_khz =
4878 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
b2e1b302
LR		 4879
4880 power_rule->max_eirp =
4881 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
4882
4883 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
4884 power_rule->max_antenna_gain =
4885 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
4886
089027e5
JD		 4887 if (tb[NL80211_ATTR_DFS_CAC_TIME])
4888 reg_rule->dfs_cac_ms =
4889 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
4890
b2e1b302
LR		 4891 return 0;
4892}
4893
4894static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
4895{
b2e1b302 4896 char *data = NULL;
57b5ce07 4897 enum nl80211_user_reg_hint_type user_reg_hint_type;
b2e1b302 4898
80778f18
LR		 4899 /*
4900 * You should only get this when cfg80211 hasn't yet initialized
4901 * completely when built-in to the kernel right between the time
4902 * window between nl80211_init() and regulatory_init(), if that is
4903 * even possible.
4904 */
458f4f9e 4905 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
fe33eb39 4906 return -EINPROGRESS;
80778f18 4907
57b5ce07
LR		 4908 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
4909 user_reg_hint_type =
4910 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
4911 else
4912 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
4913
4914 switch (user_reg_hint_type) {
4915 case NL80211_USER_REG_HINT_USER:
4916 case NL80211_USER_REG_HINT_CELL_BASE:
52616f2b
IP		 4917 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4918 return -EINVAL;
4919
4920 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4921 return regulatory_hint_user(data, user_reg_hint_type);
4922 case NL80211_USER_REG_HINT_INDOOR:
4923 return regulatory_hint_indoor_user();
57b5ce07
LR		 4924 default:
4925 return -EINVAL;
4926 }
b2e1b302
LR		 4927}
4928
24bdd9f4 4929static int nl80211_get_mesh_config(struct sk_buff *skb,
29cbe68c 4930 struct genl_info *info)
93da9cc1 4931{
4c476991 4932 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 4933 struct net_device *dev = info->user_ptr[1];
29cbe68c
JB		 4934 struct wireless_dev *wdev = dev->ieee80211_ptr;
4935 struct mesh_config cur_params;
4936 int err = 0;
93da9cc1 4937 void *hdr;
4938 struct nlattr *pinfoattr;
4939 struct sk_buff *msg;
4940
29cbe68c
JB		 4941 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4942 return -EOPNOTSUPP;
4943
24bdd9f4 4944 if (!rdev->ops->get_mesh_config)
4c476991 4945 return -EOPNOTSUPP;
f3f92586 4946
29cbe68c
JB		 4947 wdev_lock(wdev);
4948 /* If not connected, get default parameters */
4949 if (!wdev->mesh_id_len)
4950 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
4951 else
e35e4d28 4952 err = rdev_get_mesh_config(rdev, dev, &cur_params);
29cbe68c
JB		 4953 wdev_unlock(wdev);
4954
93da9cc1 4955 if (err)
4c476991 4956 return err;
93da9cc1 4957
4958 /* Draw up a netlink message to send back */
fd2120ca 4959 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 4960 if (!msg)
4961 return -ENOMEM;
15e47304 4962 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
24bdd9f4 4963 NL80211_CMD_GET_MESH_CONFIG);
93da9cc1 4964 if (!hdr)
efe1cf0c 4965 goto out;
24bdd9f4 4966 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
93da9cc1 4967 if (!pinfoattr)
4968 goto nla_put_failure;
9360ffd1
DM		 4969 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4970 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
4971 cur_params.dot11MeshRetryTimeout) ||
4972 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4973 cur_params.dot11MeshConfirmTimeout) ||
4974 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
4975 cur_params.dot11MeshHoldingTimeout) ||
4976 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
4977 cur_params.dot11MeshMaxPeerLinks) ||
4978 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
4979 cur_params.dot11MeshMaxRetries) ||
4980 nla_put_u8(msg, NL80211_MESHCONF_TTL,
4981 cur_params.dot11MeshTTL) ||
4982 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
4983 cur_params.element_ttl) ||
4984 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4985 cur_params.auto_open_plinks) ||
7eab0f64
JL		 4986 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4987 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
9360ffd1
DM		 4988 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4989 cur_params.dot11MeshHWMPmaxPREQretries) ||
4990 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
4991 cur_params.path_refresh_time) ||
4992 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4993 cur_params.min_discovery_timeout) ||
4994 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4995 cur_params.dot11MeshHWMPactivePathTimeout) ||
4996 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4997 cur_params.dot11MeshHWMPpreqMinInterval) ||
4998 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4999 cur_params.dot11MeshHWMPperrMinInterval) ||
5000 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5001 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
5002 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
5003 cur_params.dot11MeshHWMPRootMode) ||
5004 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5005 cur_params.dot11MeshHWMPRannInterval) ||
5006 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5007 cur_params.dot11MeshGateAnnouncementProtocol) ||
5008 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
5009 cur_params.dot11MeshForwarding) ||
5010 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
70c33eaa
AN		 5011 cur_params.rssi_threshold) ||
5012 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5013 cur_params.ht_opmode) ||
5014 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5015 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
5016 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5017 cur_params.dot11MeshHWMProotInterval) ||
5018 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3b1c5a53
MP		 5019 cur_params.dot11MeshHWMPconfirmationInterval) ||
5020 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5021 cur_params.power_mode) ||
5022 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8e7c0538
CT		 5023 cur_params.dot11MeshAwakeWindowDuration) ||
5024 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5025 cur_params.plink_timeout))
9360ffd1 5026 goto nla_put_failure;
93da9cc1 5027 nla_nest_end(msg, pinfoattr);
5028 genlmsg_end(msg, hdr);
4c476991 5029 return genlmsg_reply(msg, info);
93da9cc1 5030
3b85875a 5031 nla_put_failure:
93da9cc1 5032 genlmsg_cancel(msg, hdr);
efe1cf0c 5033 out:
d080e275 5034 nlmsg_free(msg);
4c476991 5035 return -ENOBUFS;
93da9cc1 5036}
5037
b54452b0 5038static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
93da9cc1 5039 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5040 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5041 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5042 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5043 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5044 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
45904f21 5045 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
93da9cc1 5046 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
d299a1f2 5047 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
93da9cc1 5048 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5049 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5050 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5051 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5052 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
dca7e943 5053 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
93da9cc1 5054 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
699403db 5055 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
0507e159 5056 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
16dd7267 5057 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
94f90656 5058 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
a4f606ea
CYY		 5059 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5060 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
ac1073a6
CYY		 5061 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5062 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
728b19e5 5063 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3b1c5a53
MP		 5064 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5065 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8e7c0538 5066 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
93da9cc1 5067};
5068
c80d545d
JC		 5069static const struct nla_policy
5070 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
d299a1f2 5071 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
c80d545d
JC		 5072 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5073 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
15d5dda6 5074 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6e16d90b 5075 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
bb2798d4 5076 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
581a8b0f 5077 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
a4f606ea 5078 .len = IEEE80211_MAX_DATA_LEN },
b130e5ce 5079 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
c80d545d
JC		 5080};
5081
24bdd9f4 5082static int nl80211_parse_mesh_config(struct genl_info *info,
bd90fdcc
JB		 5083 struct mesh_config *cfg,
5084 u32 *mask_out)
93da9cc1 5085{
93da9cc1 5086 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
bd90fdcc 5087 u32 mask = 0;
93da9cc1 5088
ea54fba2
MP		 5089#define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5090do { \
5091 if (tb[attr]) { \
5092 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
5093 return -EINVAL; \
5094 cfg->param = fn(tb[attr]); \
5095 mask |= (1 << (attr - 1)); \
5096 } \
5097} while (0)
bd90fdcc
JB		 5098
5099
24bdd9f4 5100 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
93da9cc1 5101 return -EINVAL;
5102 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
24bdd9f4 5103 info->attrs[NL80211_ATTR_MESH_CONFIG],
bd90fdcc 5104 nl80211_meshconf_params_policy))
93da9cc1 5105 return -EINVAL;
5106
93da9cc1 5107 /* This makes sure that there aren't more than 32 mesh config
5108 * parameters (otherwise our bitfield scheme would not work.) */
5109 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
5110
5111 /* Fill in the params struct */
ea54fba2 5112 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
a4f606ea
CYY		 5113 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
5114 nla_get_u16);
ea54fba2 5115 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
a4f606ea
CYY		 5116 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5117 nla_get_u16);
ea54fba2 5118 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
a4f606ea
CYY		 5119 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
5120 nla_get_u16);
ea54fba2 5121 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
a4f606ea
CYY		 5122 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
5123 nla_get_u16);
ea54fba2 5124 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
a4f606ea
CYY		 5125 mask, NL80211_MESHCONF_MAX_RETRIES,
5126 nla_get_u8);
ea54fba2 5127 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
a4f606ea 5128 mask, NL80211_MESHCONF_TTL, nla_get_u8);
ea54fba2 5129 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
a4f606ea
CYY		 5130 mask, NL80211_MESHCONF_ELEMENT_TTL,
5131 nla_get_u8);
ea54fba2 5132 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
a4f606ea
CYY		 5133 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5134 nla_get_u8);
ea54fba2
MP		 5135 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
5136 1, 255, mask,
a4f606ea
CYY		 5137 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5138 nla_get_u32);
ea54fba2 5139 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
a4f606ea
CYY		 5140 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5141 nla_get_u8);
ea54fba2 5142 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
a4f606ea
CYY		 5143 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
5144 nla_get_u32);
ea54fba2 5145 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
a4f606ea
CYY		 5146 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5147 nla_get_u16);
ea54fba2
MP		 5148 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
5149 1, 65535, mask,
a4f606ea
CYY		 5150 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5151 nla_get_u32);
93da9cc1 5152 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
ea54fba2
MP		 5153 1, 65535, mask,
5154 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
a4f606ea 5155 nla_get_u16);
dca7e943 5156 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
ea54fba2
MP		 5157 1, 65535, mask,
5158 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
a4f606ea 5159 nla_get_u16);
93da9cc1 5160 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5161 dot11MeshHWMPnetDiameterTraversalTime,
5162 1, 65535, mask,
a4f606ea
CYY		 5163 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5164 nla_get_u16);
ea54fba2
MP		 5165 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
5166 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
5167 nla_get_u8);
5168 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
5169 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
a4f606ea 5170 nla_get_u16);
63c5723b 5171 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5172 dot11MeshGateAnnouncementProtocol, 0, 1,
5173 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
a4f606ea 5174 nla_get_u8);
ea54fba2 5175 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
a4f606ea
CYY		 5176 mask, NL80211_MESHCONF_FORWARDING,
5177 nla_get_u8);
83374fe9 5178 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
a4f606ea 5179 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
83374fe9 5180 nla_get_s32);
ea54fba2 5181 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode, 0, 16,
a4f606ea 5182 mask, NL80211_MESHCONF_HT_OPMODE,
ac1073a6
CYY		 5183 nla_get_u16);
5184 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
ea54fba2 5185 1, 65535, mask,
ac1073a6
CYY		 5186 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5187 nla_get_u32);
ea54fba2 5188 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
ac1073a6 5189 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
728b19e5
CYY		 5190 nla_get_u16);
5191 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
ea54fba2
MP		 5192 dot11MeshHWMPconfirmationInterval,
5193 1, 65535, mask,
728b19e5 5194 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
a4f606ea 5195 nla_get_u16);
3b1c5a53
MP		 5196 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
5197 NL80211_MESH_POWER_ACTIVE,
5198 NL80211_MESH_POWER_MAX,
5199 mask, NL80211_MESHCONF_POWER_MODE,
5200 nla_get_u32);
5201 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
5202 0, 65535, mask,
5203 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
8e7c0538
CT		 5204 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 1, 0xffffffff,
5205 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
5206 nla_get_u32);
bd90fdcc
JB		 5207 if (mask_out)
5208 *mask_out = mask;
c80d545d 5209
bd90fdcc
JB		 5210 return 0;
5211
5212#undef FILL_IN_MESH_PARAM_IF_SET
5213}
5214
c80d545d
JC		 5215static int nl80211_parse_mesh_setup(struct genl_info *info,
5216 struct mesh_setup *setup)
5217{
bb2798d4 5218 struct cfg80211_registered_device *rdev = info->user_ptr[0];
c80d545d
JC		 5219 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
5220
5221 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
5222 return -EINVAL;
5223 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
5224 info->attrs[NL80211_ATTR_MESH_SETUP],
5225 nl80211_mesh_setup_params_policy))
5226 return -EINVAL;
5227
d299a1f2
JC		 5228 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
5229 setup->sync_method =
5230 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
5231 IEEE80211_SYNC_METHOD_VENDOR :
5232 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
5233
c80d545d
JC		 5234 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
5235 setup->path_sel_proto =
5236 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
5237 IEEE80211_PATH_PROTOCOL_VENDOR :
5238 IEEE80211_PATH_PROTOCOL_HWMP;
5239
5240 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
5241 setup->path_metric =
5242 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
5243 IEEE80211_PATH_METRIC_VENDOR :
5244 IEEE80211_PATH_METRIC_AIRTIME;
5245
581a8b0f
JC		 5246
5247 if (tb[NL80211_MESH_SETUP_IE]) {
c80d545d 5248 struct nlattr *ieattr =
581a8b0f 5249 tb[NL80211_MESH_SETUP_IE];
c80d545d
JC		 5250 if (!is_valid_ie_attr(ieattr))
5251 return -EINVAL;
581a8b0f
JC		 5252 setup->ie = nla_data(ieattr);
5253 setup->ie_len = nla_len(ieattr);
c80d545d 5254 }
bb2798d4
TP		 5255 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
5256 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
5257 return -EINVAL;
5258 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
b130e5ce
JC		 5259 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
5260 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
bb2798d4
TP		 5261 if (setup->is_secure)
5262 setup->user_mpm = true;
c80d545d 5263
6e16d90b
CT		 5264 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
5265 if (!setup->user_mpm)
5266 return -EINVAL;
5267 setup->auth_id =
5268 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
5269 }
5270
c80d545d
JC		 5271 return 0;
5272}
5273
24bdd9f4 5274static int nl80211_update_mesh_config(struct sk_buff *skb,
29cbe68c 5275 struct genl_info *info)
bd90fdcc
JB		 5276{
5277 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5278 struct net_device *dev = info->user_ptr[1];
29cbe68c 5279 struct wireless_dev *wdev = dev->ieee80211_ptr;
bd90fdcc
JB		 5280 struct mesh_config cfg;
5281 u32 mask;
5282 int err;
5283
29cbe68c
JB		 5284 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5285 return -EOPNOTSUPP;
5286
24bdd9f4 5287 if (!rdev->ops->update_mesh_config)
bd90fdcc
JB		 5288 return -EOPNOTSUPP;
5289
24bdd9f4 5290 err = nl80211_parse_mesh_config(info, &cfg, &mask);
bd90fdcc
JB		 5291 if (err)
5292 return err;
5293
29cbe68c
JB		 5294 wdev_lock(wdev);
5295 if (!wdev->mesh_id_len)
5296 err = -ENOLINK;
5297
5298 if (!err)
e35e4d28 5299 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
29cbe68c
JB		 5300
5301 wdev_unlock(wdev);
5302
5303 return err;
93da9cc1 5304}
5305
ad30ca2c
AN		 5306static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
5307 struct sk_buff *msg)
f130347c 5308{
f130347c
LR		 5309 struct nlattr *nl_reg_rules;
5310 unsigned int i;
f130347c 5311
458f4f9e
JB		 5312 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
5313 (regdom->dfs_region &&
5314 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
ad30ca2c 5315 goto nla_put_failure;
458f4f9e 5316
f130347c
LR		 5317 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
5318 if (!nl_reg_rules)
ad30ca2c 5319 goto nla_put_failure;
f130347c 5320
458f4f9e 5321 for (i = 0; i < regdom->n_reg_rules; i++) {
f130347c
LR		 5322 struct nlattr *nl_reg_rule;
5323 const struct ieee80211_reg_rule *reg_rule;
5324 const struct ieee80211_freq_range *freq_range;
5325 const struct ieee80211_power_rule *power_rule;
97524820 5326 unsigned int max_bandwidth_khz;
f130347c 5327
458f4f9e 5328 reg_rule = &regdom->reg_rules[i];
f130347c
LR		 5329 freq_range = &reg_rule->freq_range;
5330 power_rule = &reg_rule->power_rule;
5331
5332 nl_reg_rule = nla_nest_start(msg, i);
5333 if (!nl_reg_rule)
ad30ca2c 5334 goto nla_put_failure;
f130347c 5335
97524820
JD		 5336 max_bandwidth_khz = freq_range->max_bandwidth_khz;
5337 if (!max_bandwidth_khz)
5338 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
5339 reg_rule);
5340
9360ffd1
DM		 5341 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
5342 reg_rule->flags) ||
5343 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
5344 freq_range->start_freq_khz) ||
5345 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
5346 freq_range->end_freq_khz) ||
5347 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
97524820 5348 max_bandwidth_khz) ||
9360ffd1
DM		 5349 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
5350 power_rule->max_antenna_gain) ||
5351 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
089027e5
JD		 5352 power_rule->max_eirp) ||
5353 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
5354 reg_rule->dfs_cac_ms))
ad30ca2c 5355 goto nla_put_failure;
f130347c
LR		 5356
5357 nla_nest_end(msg, nl_reg_rule);
5358 }
5359
5360 nla_nest_end(msg, nl_reg_rules);
ad30ca2c
AN		 5361 return 0;
5362
5363nla_put_failure:
5364 return -EMSGSIZE;
5365}
5366
5367static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
5368{
5369 const struct ieee80211_regdomain *regdom = NULL;
5370 struct cfg80211_registered_device *rdev;
5371 struct wiphy *wiphy = NULL;
5372 struct sk_buff *msg;
5373 void *hdr;
5374
5375 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5376 if (!msg)
5377 return -ENOBUFS;
5378
5379 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
5380 NL80211_CMD_GET_REG);
5381 if (!hdr)
5382 goto put_failure;
5383
5384 if (info->attrs[NL80211_ATTR_WIPHY]) {
1bdd716c
AN		 5385 bool self_managed;
5386
ad30ca2c
AN		 5387 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
5388 if (IS_ERR(rdev)) {
5389 nlmsg_free(msg);
5390 return PTR_ERR(rdev);
5391 }
5392
5393 wiphy = &rdev->wiphy;
1bdd716c
AN		 5394 self_managed = wiphy->regulatory_flags &
5395 REGULATORY_WIPHY_SELF_MANAGED;
ad30ca2c
AN		 5396 regdom = get_wiphy_regdom(wiphy);
5397
1bdd716c
AN		 5398 /* a self-managed-reg device must have a private regdom */
5399 if (WARN_ON(!regdom && self_managed)) {
5400 nlmsg_free(msg);
5401 return -EINVAL;
5402 }
5403
ad30ca2c
AN		 5404 if (regdom &&
5405 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
5406 goto nla_put_failure;
5407 }
5408
5409 if (!wiphy && reg_last_request_cell_base() &&
5410 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
5411 NL80211_USER_REG_HINT_CELL_BASE))
5412 goto nla_put_failure;
5413
5414 rcu_read_lock();
5415
5416 if (!regdom)
5417 regdom = rcu_dereference(cfg80211_regdomain);
5418
5419 if (nl80211_put_regdom(regdom, msg))
5420 goto nla_put_failure_rcu;
5421
5422 rcu_read_unlock();
f130347c
LR		 5423
5424 genlmsg_end(msg, hdr);
5fe231e8 5425 return genlmsg_reply(msg, info);
f130347c 5426
458f4f9e
JB		 5427nla_put_failure_rcu:
5428 rcu_read_unlock();
f130347c
LR		 5429nla_put_failure:
5430 genlmsg_cancel(msg, hdr);
efe1cf0c 5431put_failure:
d080e275 5432 nlmsg_free(msg);
5fe231e8 5433 return -EMSGSIZE;
f130347c
LR		 5434}
5435
ad30ca2c
AN		 5436static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
5437 u32 seq, int flags, struct wiphy *wiphy,
5438 const struct ieee80211_regdomain *regdom)
5439{
5440 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
5441 NL80211_CMD_GET_REG);
5442
5443 if (!hdr)
5444 return -1;
5445
5446 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
5447
5448 if (nl80211_put_regdom(regdom, msg))
5449 goto nla_put_failure;
5450
5451 if (!wiphy && reg_last_request_cell_base() &&
5452 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
5453 NL80211_USER_REG_HINT_CELL_BASE))
5454 goto nla_put_failure;
5455
5456 if (wiphy &&
5457 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
5458 goto nla_put_failure;
5459
1bdd716c
AN		 5460 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
5461 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
5462 goto nla_put_failure;
5463
ad30ca2c
AN		 5464 return genlmsg_end(msg, hdr);
5465
5466nla_put_failure:
5467 genlmsg_cancel(msg, hdr);
5468 return -EMSGSIZE;
5469}
5470
5471static int nl80211_get_reg_dump(struct sk_buff *skb,
5472 struct netlink_callback *cb)
5473{
5474 const struct ieee80211_regdomain *regdom = NULL;
5475 struct cfg80211_registered_device *rdev;
5476 int err, reg_idx, start = cb->args[2];
5477
5478 rtnl_lock();
5479
5480 if (cfg80211_regdomain && start == 0) {
5481 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
5482 NLM_F_MULTI, NULL,
5483 rtnl_dereference(cfg80211_regdomain));
5484 if (err < 0)
5485 goto out_err;
5486 }
5487
5488 /* the global regdom is idx 0 */
5489 reg_idx = 1;
5490 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
5491 regdom = get_wiphy_regdom(&rdev->wiphy);
5492 if (!regdom)
5493 continue;
5494
5495 if (++reg_idx <= start)
5496 continue;
5497
5498 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
5499 NLM_F_MULTI, &rdev->wiphy, regdom);
5500 if (err < 0) {
5501 reg_idx--;
5502 break;
5503 }
5504 }
5505
5506 cb->args[2] = reg_idx;
5507 err = skb->len;
5508out_err:
5509 rtnl_unlock();
5510 return err;
5511}
5512
b2e1b302
LR		 5513static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
5514{
5515 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
5516 struct nlattr *nl_reg_rule;
ea372c54
JB		 5517 char *alpha2;
5518 int rem_reg_rules, r;
b2e1b302 5519 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4c7d3982 5520 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
ea372c54 5521 struct ieee80211_regdomain *rd;
b2e1b302
LR		 5522
5523 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5524 return -EINVAL;
5525
5526 if (!info->attrs[NL80211_ATTR_REG_RULES])
5527 return -EINVAL;
5528
5529 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5530
8b60b078
LR		 5531 if (info->attrs[NL80211_ATTR_DFS_REGION])
5532 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
5533
b2e1b302 5534 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 5535 rem_reg_rules) {
b2e1b302
LR		 5536 num_rules++;
5537 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 5538 return -EINVAL;
b2e1b302
LR		 5539 }
5540
e438768f
LR		 5541 if (!reg_is_valid_request(alpha2))
5542 return -EINVAL;
5543
b2e1b302 5544 size_of_regd = sizeof(struct ieee80211_regdomain) +
1a919318 5545 num_rules * sizeof(struct ieee80211_reg_rule);
b2e1b302
LR		 5546
5547 rd = kzalloc(size_of_regd, GFP_KERNEL);
6913b49a
JB		 5548 if (!rd)
5549 return -ENOMEM;
b2e1b302
LR		 5550
5551 rd->n_reg_rules = num_rules;
5552 rd->alpha2[0] = alpha2[0];
5553 rd->alpha2[1] = alpha2[1];
5554
8b60b078
LR		 5555 /*
5556 * Disable DFS master mode if the DFS region was
5557 * not supported or known on this kernel.
5558 */
5559 if (reg_supported_dfs_region(dfs_region))
5560 rd->dfs_region = dfs_region;
5561
b2e1b302 5562 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
1a919318 5563 rem_reg_rules) {
ae811e21
JB		 5564 r = nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
5565 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
5566 reg_rule_policy);
5567 if (r)
5568 goto bad_reg;
b2e1b302
LR		 5569 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
5570 if (r)
5571 goto bad_reg;
5572
5573 rule_idx++;
5574
d0e18f83
LR		 5575 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
5576 r = -EINVAL;
b2e1b302 5577 goto bad_reg;
d0e18f83 5578 }
b2e1b302
LR		 5579 }
5580
b2e1b302 5581 r = set_regdom(rd);
6913b49a 5582 /* set_regdom took ownership */
1a919318 5583 rd = NULL;
b2e1b302 5584
d2372b31 5585 bad_reg:
b2e1b302 5586 kfree(rd);
d0e18f83 5587 return r;
b2e1b302
LR		 5588}
5589
83f5e2cf
JB		 5590static int validate_scan_freqs(struct nlattr *freqs)
5591{
5592 struct nlattr *attr1, *attr2;
5593 int n_channels = 0, tmp1, tmp2;
5594
5595 nla_for_each_nested(attr1, freqs, tmp1) {
5596 n_channels++;
5597 /*
5598 * Some hardware has a limited channel list for
5599 * scanning, and it is pretty much nonsensical
5600 * to scan for a channel twice, so disallow that
5601 * and don't require drivers to check that the
5602 * channel list they get isn't longer than what
5603 * they can scan, as long as they can scan all
5604 * the channels they registered at once.
5605 */
5606 nla_for_each_nested(attr2, freqs, tmp2)
5607 if (attr1 != attr2 &&
5608 nla_get_u32(attr1) == nla_get_u32(attr2))
5609 return 0;
5610 }
5611
5612 return n_channels;
5613}
5614
ad2b26ab
JB		 5615static int nl80211_parse_random_mac(struct nlattr **attrs,
5616 u8 *mac_addr, u8 *mac_addr_mask)
5617{
5618 int i;
5619
5620 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
5621 memset(mac_addr, 0, ETH_ALEN);
5622 memset(mac_addr_mask, 0, ETH_ALEN);
5623 mac_addr[0] = 0x2;
5624 mac_addr_mask[0] = 0x3;
5625
5626 return 0;
5627 }
5628
5629 /* need both or none */
5630 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
5631 return -EINVAL;
5632
5633 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
5634 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
5635
5636 /* don't allow or configure an mcast address */
5637 if (!is_multicast_ether_addr(mac_addr_mask) ||
5638 is_multicast_ether_addr(mac_addr))
5639 return -EINVAL;
5640
5641 /*
5642 * allow users to pass a MAC address that has bits set outside
5643 * of the mask, but don't bother drivers with having to deal
5644 * with such bits
5645 */
5646 for (i = 0; i < ETH_ALEN; i++)
5647 mac_addr[i] &= mac_addr_mask[i];
5648
5649 return 0;
5650}
5651
2a519311
JB		 5652static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
5653{
4c476991 5654 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd014284 5655 struct wireless_dev *wdev = info->user_ptr[1];
2a519311 5656 struct cfg80211_scan_request *request;
2a519311
JB		 5657 struct nlattr *attr;
5658 struct wiphy *wiphy;
83f5e2cf 5659 int err, tmp, n_ssids = 0, n_channels, i;
70692ad2 5660 size_t ie_len;
2a519311 5661
f4a11bb0
JB		 5662 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5663 return -EINVAL;
5664
79c97e97 5665 wiphy = &rdev->wiphy;
2a519311 5666
4c476991
JB		 5667 if (!rdev->ops->scan)
5668 return -EOPNOTSUPP;
2a519311 5669
f9d15d16 5670 if (rdev->scan_req || rdev->scan_msg) {
f9f47529
JB		 5671 err = -EBUSY;
5672 goto unlock;
5673 }
2a519311
JB		 5674
5675 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 5676 n_channels = validate_scan_freqs(
5677 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
f9f47529
JB		 5678 if (!n_channels) {
5679 err = -EINVAL;
5680 goto unlock;
5681 }
2a519311 5682 } else {
bdfbec2d 5683 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311
JB		 5684 }
5685
5686 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5687 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
5688 n_ssids++;
5689
f9f47529
JB		 5690 if (n_ssids > wiphy->max_scan_ssids) {
5691 err = -EINVAL;
5692 goto unlock;
5693 }
2a519311 5694
70692ad2
JM		 5695 if (info->attrs[NL80211_ATTR_IE])
5696 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5697 else
5698 ie_len = 0;
5699
f9f47529
JB		 5700 if (ie_len > wiphy->max_scan_ie_len) {
5701 err = -EINVAL;
5702 goto unlock;
5703 }
18a83659 5704
2a519311 5705 request = kzalloc(sizeof(*request)
a2cd43c5
LC		 5706 + sizeof(*request->ssids) * n_ssids
5707 + sizeof(*request->channels) * n_channels
70692ad2 5708 + ie_len, GFP_KERNEL);
f9f47529
JB		 5709 if (!request) {
5710 err = -ENOMEM;
5711 goto unlock;
5712 }
2a519311 5713
2a519311 5714 if (n_ssids)
5ba63533 5715 request->ssids = (void *)&request->channels[n_channels];
2a519311 5716 request->n_ssids = n_ssids;
70692ad2
JM		 5717 if (ie_len) {
5718 if (request->ssids)
5719 request->ie = (void *)(request->ssids + n_ssids);
5720 else
5721 request->ie = (void *)(request->channels + n_channels);
5722 }
2a519311 5723
584991dc 5724 i = 0;
2a519311
JB		 5725 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5726 /* user specified, bail out if channel not found */
2a519311 5727 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
584991dc
JB		 5728 struct ieee80211_channel *chan;
5729
5730 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5731
5732 if (!chan) {
2a519311
JB		 5733 err = -EINVAL;
5734 goto out_free;
5735 }
584991dc
JB		 5736
5737 /* ignore disabled channels */
5738 if (chan->flags & IEEE80211_CHAN_DISABLED)
5739 continue;
5740
5741 request->channels[i] = chan;
2a519311
JB		 5742 i++;
5743 }
5744 } else {
34850ab2
JB		 5745 enum ieee80211_band band;
5746
2a519311 5747 /* all channels */
2a519311
JB		 5748 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5749 int j;
5750 if (!wiphy->bands[band])
5751 continue;
5752 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dc
JB		 5753 struct ieee80211_channel *chan;
5754
5755 chan = &wiphy->bands[band]->channels[j];
5756
5757 if (chan->flags & IEEE80211_CHAN_DISABLED)
5758 continue;
5759
5760 request->channels[i] = chan;
2a519311
JB		 5761 i++;
5762 }
5763 }
5764 }
5765
584991dc
JB		 5766 if (!i) {
5767 err = -EINVAL;
5768 goto out_free;
5769 }
5770
5771 request->n_channels = i;
5772
2a519311
JB		 5773 i = 0;
5774 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5775 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d 5776 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311
JB		 5777 err = -EINVAL;
5778 goto out_free;
5779 }
57a27e1d 5780 request->ssids[i].ssid_len = nla_len(attr);
2a519311 5781 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2a519311
JB		 5782 i++;
5783 }
5784 }
5785
70692ad2
JM		 5786 if (info->attrs[NL80211_ATTR_IE]) {
5787 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 5788 memcpy((void *)request->ie,
5789 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 5790 request->ie_len);
5791 }
5792
34850ab2 5793 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
a401d2bb
JB		 5794 if (wiphy->bands[i])
5795 request->rates[i] =
5796 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab2
JB		 5797
5798 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
5799 nla_for_each_nested(attr,
5800 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
5801 tmp) {
5802 enum ieee80211_band band = nla_type(attr);
5803
84404623 5804 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
34850ab2
JB		 5805 err = -EINVAL;
5806 goto out_free;
5807 }
1b09cd82
FF		 5808
5809 if (!wiphy->bands[band])
5810 continue;
5811
34850ab2
JB		 5812 err = ieee80211_get_ratemask(wiphy->bands[band],
5813 nla_data(attr),
5814 nla_len(attr),
5815 &request->rates[band]);
5816 if (err)
5817 goto out_free;
5818 }
5819 }
5820
46856bbf 5821 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771
SL		 5822 request->flags = nla_get_u32(
5823 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 5824 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5825 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 5826 err = -EOPNOTSUPP;
5827 goto out_free;
5828 }
ad2b26ab
JB		 5829
5830 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
5831 if (!(wiphy->features &
5832 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)) {
5833 err = -EOPNOTSUPP;
5834 goto out_free;
5835 }
5836
5837 if (wdev->current_bss) {
5838 err = -EOPNOTSUPP;
5839 goto out_free;
5840 }
5841
5842 err = nl80211_parse_random_mac(info->attrs,
5843 request->mac_addr,
5844 request->mac_addr_mask);
5845 if (err)
5846 goto out_free;
5847 }
46856bbf 5848 }
ed473771 5849
e9f935e3
RM		 5850 request->no_cck =
5851 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5852
fd014284 5853 request->wdev = wdev;
79c97e97 5854 request->wiphy = &rdev->wiphy;
15d6030b 5855 request->scan_start = jiffies;
2a519311 5856
79c97e97 5857 rdev->scan_req = request;
e35e4d28 5858 err = rdev_scan(rdev, request);
2a519311 5859
463d0183 5860 if (!err) {
fd014284
JB		 5861 nl80211_send_scan_start(rdev, wdev);
5862 if (wdev->netdev)
5863 dev_hold(wdev->netdev);
4c476991 5864 } else {
2a519311 5865 out_free:
79c97e97 5866 rdev->scan_req = NULL;
2a519311
JB		 5867 kfree(request);
5868 }
3b85875a 5869
f9f47529 5870 unlock:
2a519311
JB		 5871 return err;
5872}
5873
256da02d 5874static struct cfg80211_sched_scan_request *
ad2b26ab 5875nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
256da02d 5876 struct nlattr **attrs)
807f8a8c
LC		 5877{
5878 struct cfg80211_sched_scan_request *request;
807f8a8c 5879 struct nlattr *attr;
a1f1c21c 5880 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
bbe6ad6d 5881 u32 interval;
807f8a8c
LC		 5882 enum ieee80211_band band;
5883 size_t ie_len;
a1f1c21c 5884 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
ea73cbce 5885 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
807f8a8c 5886
256da02d
LC		 5887 if (!is_valid_ie_attr(attrs[NL80211_ATTR_IE]))
5888 return ERR_PTR(-EINVAL);
807f8a8c 5889
256da02d
LC		 5890 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
5891 return ERR_PTR(-EINVAL);
bbe6ad6d 5892
256da02d 5893 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
bbe6ad6d 5894 if (interval == 0)
256da02d 5895 return ERR_PTR(-EINVAL);
807f8a8c 5896
256da02d 5897 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c 5898 n_channels = validate_scan_freqs(
256da02d 5899 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
807f8a8c 5900 if (!n_channels)
256da02d 5901 return ERR_PTR(-EINVAL);
807f8a8c 5902 } else {
bdfbec2d 5903 n_channels = ieee80211_get_num_supported_channels(wiphy);
807f8a8c
LC		 5904 }
5905
256da02d
LC		 5906 if (attrs[NL80211_ATTR_SCAN_SSIDS])
5907 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c
LC		 5908 tmp)
5909 n_ssids++;
5910
93b6aa69 5911 if (n_ssids > wiphy->max_sched_scan_ssids)
256da02d 5912 return ERR_PTR(-EINVAL);
807f8a8c 5913
ea73cbce
JB		 5914 /*
5915 * First, count the number of 'real' matchsets. Due to an issue with
5916 * the old implementation, matchsets containing only the RSSI attribute
5917 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
5918 * RSSI for all matchsets, rather than their own matchset for reporting
5919 * all APs with a strong RSSI. This is needed to be compatible with
5920 * older userspace that treated a matchset with only the RSSI as the
5921 * global RSSI for all other matchsets - if there are other matchsets.
5922 */
256da02d 5923 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 5924 nla_for_each_nested(attr,
256da02d 5925 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
ea73cbce
JB		 5926 tmp) {
5927 struct nlattr *rssi;
5928
5929 err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5930 nla_data(attr), nla_len(attr),
5931 nl80211_match_policy);
5932 if (err)
256da02d 5933 return ERR_PTR(err);
ea73cbce
JB		 5934 /* add other standalone attributes here */
5935 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID]) {
5936 n_match_sets++;
5937 continue;
5938 }
5939 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5940 if (rssi)
5941 default_match_rssi = nla_get_s32(rssi);
5942 }
5943 }
5944
5945 /* However, if there's no other matchset, add the RSSI one */
5946 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
5947 n_match_sets = 1;
a1f1c21c
LC		 5948
5949 if (n_match_sets > wiphy->max_match_sets)
256da02d 5950 return ERR_PTR(-EINVAL);
a1f1c21c 5951
256da02d
LC		 5952 if (attrs[NL80211_ATTR_IE])
5953 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
807f8a8c
LC		 5954 else
5955 ie_len = 0;
5956
5a865bad 5957 if (ie_len > wiphy->max_sched_scan_ie_len)
256da02d 5958 return ERR_PTR(-EINVAL);
c10841ca 5959
807f8a8c 5960 request = kzalloc(sizeof(*request)
a2cd43c5 5961 + sizeof(*request->ssids) * n_ssids
a1f1c21c 5962 + sizeof(*request->match_sets) * n_match_sets
a2cd43c5 5963 + sizeof(*request->channels) * n_channels
807f8a8c 5964 + ie_len, GFP_KERNEL);
256da02d
LC		 5965 if (!request)
5966 return ERR_PTR(-ENOMEM);
807f8a8c
LC		 5967
5968 if (n_ssids)
5969 request->ssids = (void *)&request->channels[n_channels];
5970 request->n_ssids = n_ssids;
5971 if (ie_len) {
5972 if (request->ssids)
5973 request->ie = (void *)(request->ssids + n_ssids);
5974 else
5975 request->ie = (void *)(request->channels + n_channels);
5976 }
5977
a1f1c21c
LC		 5978 if (n_match_sets) {
5979 if (request->ie)
5980 request->match_sets = (void *)(request->ie + ie_len);
5981 else if (request->ssids)
5982 request->match_sets =
5983 (void *)(request->ssids + n_ssids);
5984 else
5985 request->match_sets =
5986 (void *)(request->channels + n_channels);
5987 }
5988 request->n_match_sets = n_match_sets;
5989
807f8a8c 5990 i = 0;
256da02d 5991 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
807f8a8c
LC		 5992 /* user specified, bail out if channel not found */
5993 nla_for_each_nested(attr,
256da02d 5994 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
807f8a8c
LC		 5995 tmp) {
5996 struct ieee80211_channel *chan;
5997
5998 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5999
6000 if (!chan) {
6001 err = -EINVAL;
6002 goto out_free;
6003 }
6004
6005 /* ignore disabled channels */
6006 if (chan->flags & IEEE80211_CHAN_DISABLED)
6007 continue;
6008
6009 request->channels[i] = chan;
6010 i++;
6011 }
6012 } else {
6013 /* all channels */
6014 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
6015 int j;
6016 if (!wiphy->bands[band])
6017 continue;
6018 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
6019 struct ieee80211_channel *chan;
6020
6021 chan = &wiphy->bands[band]->channels[j];
6022
6023 if (chan->flags & IEEE80211_CHAN_DISABLED)
6024 continue;
6025
6026 request->channels[i] = chan;
6027 i++;
6028 }
6029 }
6030 }
6031
6032 if (!i) {
6033 err = -EINVAL;
6034 goto out_free;
6035 }
6036
6037 request->n_channels = i;
6038
6039 i = 0;
256da02d
LC		 6040 if (attrs[NL80211_ATTR_SCAN_SSIDS]) {
6041 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
807f8a8c 6042 tmp) {
57a27e1d 6043 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
807f8a8c
LC		 6044 err = -EINVAL;
6045 goto out_free;
6046 }
57a27e1d 6047 request->ssids[i].ssid_len = nla_len(attr);
807f8a8c
LC		 6048 memcpy(request->ssids[i].ssid, nla_data(attr),
6049 nla_len(attr));
807f8a8c
LC		 6050 i++;
6051 }
6052 }
6053
a1f1c21c 6054 i = 0;
256da02d 6055 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
a1f1c21c 6056 nla_for_each_nested(attr,
256da02d 6057 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
a1f1c21c 6058 tmp) {
88e920b4 6059 struct nlattr *ssid, *rssi;
a1f1c21c 6060
ae811e21
JB		 6061 err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
6062 nla_data(attr), nla_len(attr),
6063 nl80211_match_policy);
6064 if (err)
6065 goto out_free;
4a4ab0d7 6066 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
a1f1c21c 6067 if (ssid) {
ea73cbce
JB		 6068 if (WARN_ON(i >= n_match_sets)) {
6069 /* this indicates a programming error,
6070 * the loop above should have verified
6071 * things properly
6072 */
6073 err = -EINVAL;
6074 goto out_free;
6075 }
6076
a1f1c21c
LC		 6077 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
6078 err = -EINVAL;
6079 goto out_free;
6080 }
6081 memcpy(request->match_sets[i].ssid.ssid,
6082 nla_data(ssid), nla_len(ssid));
6083 request->match_sets[i].ssid.ssid_len =
6084 nla_len(ssid);
ea73cbce
JB		 6085 /* special attribute - old implemenation w/a */
6086 request->match_sets[i].rssi_thold =
6087 default_match_rssi;
6088 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
6089 if (rssi)
6090 request->match_sets[i].rssi_thold =
6091 nla_get_s32(rssi);
a1f1c21c
LC		 6092 }
6093 i++;
6094 }
ea73cbce
JB		 6095
6096 /* there was no other matchset, so the RSSI one is alone */
f89f46cf 6097 if (i == 0 && n_match_sets)
ea73cbce
JB		 6098 request->match_sets[0].rssi_thold = default_match_rssi;
6099
6100 request->min_rssi_thold = INT_MAX;
6101 for (i = 0; i < n_match_sets; i++)
6102 request->min_rssi_thold =
6103 min(request->match_sets[i].rssi_thold,
6104 request->min_rssi_thold);
6105 } else {
6106 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
a1f1c21c
LC		 6107 }
6108
9900e484
JB		 6109 if (ie_len) {
6110 request->ie_len = ie_len;
807f8a8c 6111 memcpy((void *)request->ie,
256da02d 6112 nla_data(attrs[NL80211_ATTR_IE]),
807f8a8c
LC		 6113 request->ie_len);
6114 }
6115
256da02d 6116 if (attrs[NL80211_ATTR_SCAN_FLAGS]) {
ed473771 6117 request->flags = nla_get_u32(
256da02d 6118 attrs[NL80211_ATTR_SCAN_FLAGS]);
00c3a6ed
JB		 6119 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
6120 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
46856bbf
SL		 6121 err = -EOPNOTSUPP;
6122 goto out_free;
6123 }
ad2b26ab
JB		 6124
6125 if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6126 u32 flg = NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
6127
6128 if (!wdev) /* must be net-detect */
6129 flg = NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
6130
6131 if (!(wiphy->features & flg)) {
6132 err = -EOPNOTSUPP;
6133 goto out_free;
6134 }
6135
6136 if (wdev && wdev->current_bss) {
6137 err = -EOPNOTSUPP;
6138 goto out_free;
6139 }
6140
6141 err = nl80211_parse_random_mac(attrs, request->mac_addr,
6142 request->mac_addr_mask);
6143 if (err)
6144 goto out_free;
6145 }
46856bbf 6146 }
ed473771 6147
bbe6ad6d 6148 request->interval = interval;
15d6030b 6149 request->scan_start = jiffies;
807f8a8c 6150
256da02d 6151 return request;
807f8a8c
LC		 6152
6153out_free:
6154 kfree(request);
256da02d
LC		 6155 return ERR_PTR(err);
6156}
6157
6158static int nl80211_start_sched_scan(struct sk_buff *skb,
6159 struct genl_info *info)
6160{
6161 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6162 struct net_device *dev = info->user_ptr[1];
ad2b26ab 6163 struct wireless_dev *wdev = dev->ieee80211_ptr;
31a60ed1 6164 struct cfg80211_sched_scan_request *sched_scan_req;
256da02d
LC		 6165 int err;
6166
6167 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
6168 !rdev->ops->sched_scan_start)
6169 return -EOPNOTSUPP;
6170
6171 if (rdev->sched_scan_req)
6172 return -EINPROGRESS;
6173
31a60ed1
JR		 6174 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
6175 info->attrs);
6176
6177 err = PTR_ERR_OR_ZERO(sched_scan_req);
256da02d
LC		 6178 if (err)
6179 goto out_err;
6180
31a60ed1 6181 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
256da02d
LC		 6182 if (err)
6183 goto out_free;
6184
31a60ed1
JR		 6185 sched_scan_req->dev = dev;
6186 sched_scan_req->wiphy = &rdev->wiphy;
6187
93a1e86c
JR		 6188 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
6189 sched_scan_req->owner_nlportid = info->snd_portid;
6190
31a60ed1 6191 rcu_assign_pointer(rdev->sched_scan_req, sched_scan_req);
256da02d
LC		 6192
6193 nl80211_send_sched_scan(rdev, dev,
6194 NL80211_CMD_START_SCHED_SCAN);
6195 return 0;
6196
6197out_free:
31a60ed1 6198 kfree(sched_scan_req);
256da02d 6199out_err:
807f8a8c
LC		 6200 return err;
6201}
6202
6203static int nl80211_stop_sched_scan(struct sk_buff *skb,
6204 struct genl_info *info)
6205{
6206 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6207
6208 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
6209 !rdev->ops->sched_scan_stop)
6210 return -EOPNOTSUPP;
6211
5fe231e8 6212 return __cfg80211_stop_sched_scan(rdev, false);
807f8a8c
LC		 6213}
6214
04f39047
SW		 6215static int nl80211_start_radar_detection(struct sk_buff *skb,
6216 struct genl_info *info)
6217{
6218 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6219 struct net_device *dev = info->user_ptr[1];
6220 struct wireless_dev *wdev = dev->ieee80211_ptr;
6221 struct cfg80211_chan_def chandef;
55f7435c 6222 enum nl80211_dfs_regions dfs_region;
31559f35 6223 unsigned int cac_time_ms;
04f39047
SW		 6224 int err;
6225
55f7435c
LR		 6226 dfs_region = reg_get_dfs_region(wdev->wiphy);
6227 if (dfs_region == NL80211_DFS_UNSET)
6228 return -EINVAL;
6229
04f39047
SW		 6230 err = nl80211_parse_chandef(rdev, info, &chandef);
6231 if (err)
6232 return err;
6233
ff311bc1
SW		 6234 if (netif_carrier_ok(dev))
6235 return -EBUSY;
6236
04f39047
SW		 6237 if (wdev->cac_started)
6238 return -EBUSY;
6239
2beb6dab 6240 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
00ec75fc 6241 wdev->iftype);
04f39047
SW		 6242 if (err < 0)
6243 return err;
6244
6245 if (err == 0)
6246 return -EINVAL;
6247
fe7c3a1f 6248 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
04f39047
SW		 6249 return -EINVAL;
6250
6251 if (!rdev->ops->start_radar_detection)
6252 return -EOPNOTSUPP;
6253
31559f35
JD		 6254 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
6255 if (WARN_ON(!cac_time_ms))
6256 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
6257
6258 err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef,
6259 cac_time_ms);
04f39047 6260 if (!err) {
9e0e2961 6261 wdev->chandef = chandef;
04f39047
SW		 6262 wdev->cac_started = true;
6263 wdev->cac_start_time = jiffies;
31559f35 6264 wdev->cac_time_ms = cac_time_ms;
04f39047 6265 }
04f39047
SW		 6266 return err;
6267}
6268
16ef1fe2
SW		 6269static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
6270{
6271 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6272 struct net_device *dev = info->user_ptr[1];
6273 struct wireless_dev *wdev = dev->ieee80211_ptr;
6274 struct cfg80211_csa_settings params;
6275 /* csa_attrs is defined static to avoid waste of stack size - this
6276 * function is called under RTNL lock, so this should not be a problem.
6277 */
6278 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
16ef1fe2 6279 int err;
ee4bc9e7 6280 bool need_new_beacon = false;
9a774c78 6281 int len, i;
252e07ca 6282 u32 cs_count;
16ef1fe2
SW		 6283
6284 if (!rdev->ops->channel_switch ||
6285 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
6286 return -EOPNOTSUPP;
6287
ee4bc9e7
SW		 6288 switch (dev->ieee80211_ptr->iftype) {
6289 case NL80211_IFTYPE_AP:
6290 case NL80211_IFTYPE_P2P_GO:
6291 need_new_beacon = true;
6292
6293 /* useless if AP is not running */
6294 if (!wdev->beacon_interval)
1ff79dfa 6295 return -ENOTCONN;
ee4bc9e7
SW		 6296 break;
6297 case NL80211_IFTYPE_ADHOC:
1ff79dfa
JB		 6298 if (!wdev->ssid_len)
6299 return -ENOTCONN;
6300 break;
c6da674a 6301 case NL80211_IFTYPE_MESH_POINT:
1ff79dfa
JB		 6302 if (!wdev->mesh_id_len)
6303 return -ENOTCONN;
ee4bc9e7
SW		 6304 break;
6305 default:
16ef1fe2 6306 return -EOPNOTSUPP;
ee4bc9e7 6307 }
16ef1fe2
SW		 6308
6309 memset(&params, 0, sizeof(params));
6310
6311 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
6312 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
6313 return -EINVAL;
6314
6315 /* only important for AP, IBSS and mesh create IEs internally */
d0a361a5 6316 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
16ef1fe2
SW		 6317 return -EINVAL;
6318
252e07ca
LC		 6319 /* Even though the attribute is u32, the specification says
6320 * u8, so let's make sure we don't overflow.
6321 */
6322 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
6323 if (cs_count > 255)
6324 return -EINVAL;
6325
6326 params.count = cs_count;
16ef1fe2 6327
ee4bc9e7
SW		 6328 if (!need_new_beacon)
6329 goto skip_beacons;
6330
16ef1fe2
SW		 6331 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
6332 if (err)
6333 return err;
6334
6335 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
6336 info->attrs[NL80211_ATTR_CSA_IES],
6337 nl80211_policy);
6338 if (err)
6339 return err;
6340
6341 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
6342 if (err)
6343 return err;
6344
6345 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
6346 return -EINVAL;
6347
9a774c78
AO		 6348 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
6349 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 6350 return -EINVAL;
6351
9a774c78
AO		 6352 params.n_counter_offsets_beacon = len / sizeof(u16);
6353 if (rdev->wiphy.max_num_csa_counters &&
6354 (params.n_counter_offsets_beacon >
6355 rdev->wiphy.max_num_csa_counters))
16ef1fe2
SW		 6356 return -EINVAL;
6357
9a774c78
AO		 6358 params.counter_offsets_beacon =
6359 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
6360
6361 /* sanity checks - counters should fit and be the same */
6362 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
6363 u16 offset = params.counter_offsets_beacon[i];
6364
6365 if (offset >= params.beacon_csa.tail_len)
6366 return -EINVAL;
6367
6368 if (params.beacon_csa.tail[offset] != params.count)
6369 return -EINVAL;
6370 }
6371
16ef1fe2 6372 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
9a774c78
AO		 6373 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
6374 if (!len || (len % sizeof(u16)))
16ef1fe2
SW		 6375 return -EINVAL;
6376
9a774c78
AO		 6377 params.n_counter_offsets_presp = len / sizeof(u16);
6378 if (rdev->wiphy.max_num_csa_counters &&
6379 (params.n_counter_offsets_beacon >
6380 rdev->wiphy.max_num_csa_counters))
16ef1fe2 6381 return -EINVAL;
9a774c78
AO		 6382
6383 params.counter_offsets_presp =
6384 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
6385
6386 /* sanity checks - counters should fit and be the same */
6387 for (i = 0; i < params.n_counter_offsets_presp; i++) {
6388 u16 offset = params.counter_offsets_presp[i];
6389
6390 if (offset >= params.beacon_csa.probe_resp_len)
6391 return -EINVAL;
6392
6393 if (params.beacon_csa.probe_resp[offset] !=
6394 params.count)
6395 return -EINVAL;
6396 }
16ef1fe2
SW		 6397 }
6398
ee4bc9e7 6399skip_beacons:
16ef1fe2
SW		 6400 err = nl80211_parse_chandef(rdev, info, &params.chandef);
6401 if (err)
6402 return err;
6403
174e0cd2
IP		 6404 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
6405 wdev->iftype))
16ef1fe2
SW		 6406 return -EINVAL;
6407
2beb6dab
LC		 6408 err = cfg80211_chandef_dfs_required(wdev->wiphy,
6409 &params.chandef,
6410 wdev->iftype);
6411 if (err < 0)
6412 return err;
6413
dcc6c2f5 6414 if (err > 0)
2beb6dab 6415 params.radar_required = true;
16ef1fe2 6416
16ef1fe2
SW		 6417 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
6418 params.block_tx = true;
6419
c56589ed
SW		 6420 wdev_lock(wdev);
6421 err = rdev_channel_switch(rdev, dev, &params);
6422 wdev_unlock(wdev);
6423
6424 return err;
16ef1fe2
SW		 6425}
6426
9720bb3a
JB		 6427static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
6428 u32 seq, int flags,
2a519311 6429 struct cfg80211_registered_device *rdev,
48ab905d
JB		 6430 struct wireless_dev *wdev,
6431 struct cfg80211_internal_bss *intbss)
2a519311 6432{
48ab905d 6433 struct cfg80211_bss *res = &intbss->pub;
9caf0364 6434 const struct cfg80211_bss_ies *ies;
2a519311
JB		 6435 void *hdr;
6436 struct nlattr *bss;
48ab905d
JB		 6437
6438 ASSERT_WDEV_LOCK(wdev);
2a519311 6439
15e47304 6440 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
2a519311
JB		 6441 NL80211_CMD_NEW_SCAN_RESULTS);
6442 if (!hdr)
6443 return -1;
6444
9720bb3a
JB		 6445 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
6446
97990a06
JB		 6447 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
6448 goto nla_put_failure;
6449 if (wdev->netdev &&
9360ffd1
DM		 6450 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
6451 goto nla_put_failure;
97990a06
JB		 6452 if (nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
6453 goto nla_put_failure;
2a519311
JB		 6454
6455 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
6456 if (!bss)
6457 goto nla_put_failure;
9360ffd1 6458 if ((!is_zero_ether_addr(res->bssid) &&
9caf0364 6459 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9360ffd1 6460 goto nla_put_failure;
9caf0364
JB		 6461
6462 rcu_read_lock();
0e227084
JB		 6463 /* indicate whether we have probe response data or not */
6464 if (rcu_access_pointer(res->proberesp_ies) &&
6465 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
6466 goto fail_unlock_rcu;
6467
6468 /* this pointer prefers to be pointed to probe response data
6469 * but is always valid
6470 */
9caf0364 6471 ies = rcu_dereference(res->ies);
8cef2c9d
JB		 6472 if (ies) {
6473 if (nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
6474 goto fail_unlock_rcu;
8cef2c9d
JB		 6475 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
6476 ies->len, ies->data))
6477 goto fail_unlock_rcu;
9caf0364 6478 }
0e227084
JB		 6479
6480 /* and this pointer is always (unless driver didn't know) beacon data */
9caf0364 6481 ies = rcu_dereference(res->beacon_ies);
0e227084
JB		 6482 if (ies && ies->from_beacon) {
6483 if (nla_put_u64(msg, NL80211_BSS_BEACON_TSF, ies->tsf))
8cef2c9d
JB		 6484 goto fail_unlock_rcu;
6485 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
6486 ies->len, ies->data))
6487 goto fail_unlock_rcu;
9caf0364
JB		 6488 }
6489 rcu_read_unlock();
6490
9360ffd1
DM		 6491 if (res->beacon_interval &&
6492 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
6493 goto nla_put_failure;
6494 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
6495 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
dcd6eac1 6496 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9360ffd1
DM		 6497 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
6498 jiffies_to_msecs(jiffies - intbss->ts)))
6499 goto nla_put_failure;
2a519311 6500
77965c97 6501 switch (rdev->wiphy.signal_type) {
2a519311 6502 case CFG80211_SIGNAL_TYPE_MBM:
9360ffd1
DM		 6503 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
6504 goto nla_put_failure;
2a519311
JB		 6505 break;
6506 case CFG80211_SIGNAL_TYPE_UNSPEC:
9360ffd1
DM		 6507 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
6508 goto nla_put_failure;
2a519311
JB		 6509 break;
6510 default:
6511 break;
6512 }
6513
48ab905d 6514 switch (wdev->iftype) {
074ac8df 6515 case NL80211_IFTYPE_P2P_CLIENT:
48ab905d 6516 case NL80211_IFTYPE_STATION:
9360ffd1
DM		 6517 if (intbss == wdev->current_bss &&
6518 nla_put_u32(msg, NL80211_BSS_STATUS,
6519 NL80211_BSS_STATUS_ASSOCIATED))
6520 goto nla_put_failure;
48ab905d
JB		 6521 break;
6522 case NL80211_IFTYPE_ADHOC:
9360ffd1
DM		 6523 if (intbss == wdev->current_bss &&
6524 nla_put_u32(msg, NL80211_BSS_STATUS,
6525 NL80211_BSS_STATUS_IBSS_JOINED))
6526 goto nla_put_failure;
48ab905d
JB		 6527 break;
6528 default:
6529 break;
6530 }
6531
2a519311
JB		 6532 nla_nest_end(msg, bss);
6533
6534 return genlmsg_end(msg, hdr);
6535
8cef2c9d
JB		 6536 fail_unlock_rcu:
6537 rcu_read_unlock();
2a519311
JB		 6538 nla_put_failure:
6539 genlmsg_cancel(msg, hdr);
6540 return -EMSGSIZE;
6541}
6542
97990a06 6543static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
2a519311 6544{
48ab905d 6545 struct cfg80211_registered_device *rdev;
2a519311 6546 struct cfg80211_internal_bss *scan;
48ab905d 6547 struct wireless_dev *wdev;
97990a06 6548 int start = cb->args[2], idx = 0;
2a519311
JB		 6549 int err;
6550
97990a06 6551 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 6552 if (err)
6553 return err;
2a519311 6554
48ab905d
JB		 6555 wdev_lock(wdev);
6556 spin_lock_bh(&rdev->bss_lock);
6557 cfg80211_bss_expire(rdev);
6558
9720bb3a
JB		 6559 cb->seq = rdev->bss_generation;
6560
48ab905d 6561 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 6562 if (++idx <= start)
6563 continue;
9720bb3a 6564 if (nl80211_send_bss(skb, cb,
2a519311 6565 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 6566 rdev, wdev, scan) < 0) {
2a519311 6567 idx--;
67748893 6568 break;
2a519311
JB		 6569 }
6570 }
6571
48ab905d
JB		 6572 spin_unlock_bh(&rdev->bss_lock);
6573 wdev_unlock(wdev);
2a519311 6574
97990a06
JB		 6575 cb->args[2] = idx;
6576 nl80211_finish_wdev_dump(rdev);
2a519311 6577
67748893 6578 return skb->len;
2a519311
JB		 6579}
6580
15e47304 6581static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
11f78ac3
JB		 6582 int flags, struct net_device *dev,
6583 bool allow_radio_stats,
6584 struct survey_info *survey)
61fa713c
HS		 6585{
6586 void *hdr;
6587 struct nlattr *infoattr;
6588
11f78ac3
JB		 6589 /* skip radio stats if userspace didn't request them */
6590 if (!survey->channel && !allow_radio_stats)
6591 return 0;
6592
15e47304 6593 hdr = nl80211hdr_put(msg, portid, seq, flags,
61fa713c
HS		 6594 NL80211_CMD_NEW_SURVEY_RESULTS);
6595 if (!hdr)
6596 return -ENOMEM;
6597
9360ffd1
DM		 6598 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
6599 goto nla_put_failure;
61fa713c
HS		 6600
6601 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
6602 if (!infoattr)
6603 goto nla_put_failure;
6604
11f78ac3
JB		 6605 if (survey->channel &&
6606 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9360ffd1
DM		 6607 survey->channel->center_freq))
6608 goto nla_put_failure;
6609
6610 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
6611 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
6612 goto nla_put_failure;
6613 if ((survey->filled & SURVEY_INFO_IN_USE) &&
6614 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
6615 goto nla_put_failure;
4ed20beb
JB		 6616 if ((survey->filled & SURVEY_INFO_TIME) &&
6617 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME,
6618 survey->time))
9360ffd1 6619 goto nla_put_failure;
4ed20beb
JB		 6620 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
6621 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME_BUSY,
6622 survey->time_busy))
9360ffd1 6623 goto nla_put_failure;
4ed20beb
JB		 6624 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
6625 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
6626 survey->time_ext_busy))
9360ffd1 6627 goto nla_put_failure;
4ed20beb
JB		 6628 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
6629 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME_RX,
6630 survey->time_rx))
9360ffd1 6631 goto nla_put_failure;
4ed20beb
JB		 6632 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
6633 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME_TX,
6634 survey->time_tx))
9360ffd1 6635 goto nla_put_failure;
052536ab
JB		 6636 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
6637 nla_put_u64(msg, NL80211_SURVEY_INFO_TIME_SCAN,
6638 survey->time_scan))
6639 goto nla_put_failure;
61fa713c
HS		 6640
6641 nla_nest_end(msg, infoattr);
6642
6643 return genlmsg_end(msg, hdr);
6644
6645 nla_put_failure:
6646 genlmsg_cancel(msg, hdr);
6647 return -EMSGSIZE;
6648}
6649
11f78ac3 6650static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
61fa713c
HS		 6651{
6652 struct survey_info survey;
1b8ec87a 6653 struct cfg80211_registered_device *rdev;
97990a06
JB		 6654 struct wireless_dev *wdev;
6655 int survey_idx = cb->args[2];
61fa713c 6656 int res;
11f78ac3 6657 bool radio_stats;
61fa713c 6658
1b8ec87a 6659 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
67748893
JB		 6660 if (res)
6661 return res;
61fa713c 6662
11f78ac3
JB		 6663 /* prepare_wdev_dump parsed the attributes */
6664 radio_stats = nl80211_fam.attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
6665
97990a06
JB		 6666 if (!wdev->netdev) {
6667 res = -EINVAL;
6668 goto out_err;
6669 }
6670
1b8ec87a 6671 if (!rdev->ops->dump_survey) {
61fa713c
HS		 6672 res = -EOPNOTSUPP;
6673 goto out_err;
6674 }
6675
6676 while (1) {
1b8ec87a 6677 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
61fa713c
HS		 6678 if (res == -ENOENT)
6679 break;
6680 if (res)
6681 goto out_err;
6682
11f78ac3
JB		 6683 /* don't send disabled channels, but do send non-channel data */
6684 if (survey.channel &&
6685 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
180cdc79
LR		 6686 survey_idx++;
6687 continue;
6688 }
6689
61fa713c 6690 if (nl80211_send_survey(skb,
15e47304 6691 NETLINK_CB(cb->skb).portid,
61fa713c 6692 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11f78ac3 6693 wdev->netdev, radio_stats, &survey) < 0)
61fa713c
HS		 6694 goto out;
6695 survey_idx++;
6696 }
6697
6698 out:
97990a06 6699 cb->args[2] = survey_idx;
61fa713c
HS		 6700 res = skb->len;
6701 out_err:
1b8ec87a 6702 nl80211_finish_wdev_dump(rdev);
61fa713c
HS		 6703 return res;
6704}
6705
b23aa676
SO		 6706static bool nl80211_valid_wpa_versions(u32 wpa_versions)
6707{
6708 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
6709 NL80211_WPA_VERSION_2));
6710}
6711
636a5d36
JM		 6712static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
6713{
4c476991
JB		 6714 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6715 struct net_device *dev = info->user_ptr[1];
19957bb3 6716 struct ieee80211_channel *chan;
e39e5b5e
JM		 6717 const u8 *bssid, *ssid, *ie = NULL, *sae_data = NULL;
6718 int err, ssid_len, ie_len = 0, sae_data_len = 0;
19957bb3 6719 enum nl80211_auth_type auth_type;
fffd0934 6720 struct key_parse key;
d5cdfacb 6721 bool local_state_change;
636a5d36 6722
f4a11bb0
JB		 6723 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6724 return -EINVAL;
6725
6726 if (!info->attrs[NL80211_ATTR_MAC])
6727 return -EINVAL;
6728
1778092e
JM		 6729 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
6730 return -EINVAL;
6731
19957bb3
JB		 6732 if (!info->attrs[NL80211_ATTR_SSID])
6733 return -EINVAL;
6734
6735 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
6736 return -EINVAL;
6737
fffd0934
JB		 6738 err = nl80211_parse_key(info, &key);
6739 if (err)
6740 return err;
6741
6742 if (key.idx >= 0) {
e31b8213
JB		 6743 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
6744 return -EINVAL;
fffd0934
JB		 6745 if (!key.p.key || !key.p.key_len)
6746 return -EINVAL;
6747 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
6748 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
6749 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
6750 key.p.key_len != WLAN_KEY_LEN_WEP104))
6751 return -EINVAL;
6752 if (key.idx > 4)
6753 return -EINVAL;
6754 } else {
6755 key.p.key_len = 0;
6756 key.p.key = NULL;
6757 }
6758
afea0b7a
JB		 6759 if (key.idx >= 0) {
6760 int i;
6761 bool ok = false;
6762 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
6763 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
6764 ok = true;
6765 break;
6766 }
6767 }
4c476991
JB		 6768 if (!ok)
6769 return -EINVAL;
afea0b7a
JB		 6770 }
6771
4c476991
JB		 6772 if (!rdev->ops->auth)
6773 return -EOPNOTSUPP;
636a5d36 6774
074ac8df 6775 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 6776 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6777 return -EOPNOTSUPP;
eec60b03 6778
19957bb3 6779 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
664834de
JM		 6780 chan = nl80211_get_valid_chan(&rdev->wiphy,
6781 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
6782 if (!chan)
4c476991 6783 return -EINVAL;
636a5d36 6784
19957bb3
JB		 6785 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6786 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 6787
6788 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 6789 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6790 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 6791 }
6792
19957bb3 6793 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e 6794 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
4c476991 6795 return -EINVAL;
636a5d36 6796
e39e5b5e
JM		 6797 if (auth_type == NL80211_AUTHTYPE_SAE &&
6798 !info->attrs[NL80211_ATTR_SAE_DATA])
6799 return -EINVAL;
6800
6801 if (info->attrs[NL80211_ATTR_SAE_DATA]) {
6802 if (auth_type != NL80211_AUTHTYPE_SAE)
6803 return -EINVAL;
6804 sae_data = nla_data(info->attrs[NL80211_ATTR_SAE_DATA]);
6805 sae_data_len = nla_len(info->attrs[NL80211_ATTR_SAE_DATA]);
6806 /* need to include at least Auth Transaction and Status Code */
6807 if (sae_data_len < 4)
6808 return -EINVAL;
6809 }
6810
d5cdfacb
JM		 6811 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6812
95de817b
JB		 6813 /*
6814 * Since we no longer track auth state, ignore
6815 * requests to only change local state.
6816 */
6817 if (local_state_change)
6818 return 0;
6819
91bf9b26
JB		 6820 wdev_lock(dev->ieee80211_ptr);
6821 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
6822 ssid, ssid_len, ie, ie_len,
6823 key.p.key, key.p.key_len, key.idx,
6824 sae_data, sae_data_len);
6825 wdev_unlock(dev->ieee80211_ptr);
6826 return err;
636a5d36
JM		 6827}
6828
c0692b8f
JB		 6829static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
6830 struct genl_info *info,
3dc27d25
JB		 6831 struct cfg80211_crypto_settings *settings,
6832 int cipher_limit)
b23aa676 6833{
c0b2bbd8
JB		 6834 memset(settings, 0, sizeof(*settings));
6835
b23aa676
SO		 6836 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
6837
c0692b8f
JB		 6838 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
6839 u16 proto;
6840 proto = nla_get_u16(
6841 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
6842 settings->control_port_ethertype = cpu_to_be16(proto);
6843 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
6844 proto != ETH_P_PAE)
6845 return -EINVAL;
6846 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
6847 settings->control_port_no_encrypt = true;
6848 } else
6849 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
6850
b23aa676
SO		 6851 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
6852 void *data;
6853 int len, i;
6854
6855 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6856 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6857 settings->n_ciphers_pairwise = len / sizeof(u32);
6858
6859 if (len % sizeof(u32))
6860 return -EINVAL;
6861
3dc27d25 6862 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 6863 return -EINVAL;
6864
6865 memcpy(settings->ciphers_pairwise, data, len);
6866
6867 for (i = 0; i < settings->n_ciphers_pairwise; i++)
38ba3c57
JM		 6868 if (!cfg80211_supported_cipher_suite(
6869 &rdev->wiphy,
b23aa676
SO		 6870 settings->ciphers_pairwise[i]))
6871 return -EINVAL;
6872 }
6873
6874 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
6875 settings->cipher_group =
6876 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
38ba3c57
JM		 6877 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
6878 settings->cipher_group))
b23aa676
SO		 6879 return -EINVAL;
6880 }
6881
6882 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
6883 settings->wpa_versions =
6884 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
6885 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
6886 return -EINVAL;
6887 }
6888
6889 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
6890 void *data;
6d30240e 6891 int len;
b23aa676
SO		 6892
6893 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
6894 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
6895 settings->n_akm_suites = len / sizeof(u32);
6896
6897 if (len % sizeof(u32))
6898 return -EINVAL;
6899
1b9ca027
JM		 6900 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
6901 return -EINVAL;
6902
b23aa676 6903 memcpy(settings->akm_suites, data, len);
b23aa676
SO		 6904 }
6905
6906 return 0;
6907}
6908
636a5d36
JM		 6909static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
6910{
4c476991
JB		 6911 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6912 struct net_device *dev = info->user_ptr[1];
f444de05 6913 struct ieee80211_channel *chan;
f62fab73
JB		 6914 struct cfg80211_assoc_request req = {};
6915 const u8 *bssid, *ssid;
6916 int err, ssid_len = 0;
636a5d36 6917
f4a11bb0
JB		 6918 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6919 return -EINVAL;
6920
6921 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 6922 !info->attrs[NL80211_ATTR_SSID] ||
6923 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 6924 return -EINVAL;
6925
4c476991
JB		 6926 if (!rdev->ops->assoc)
6927 return -EOPNOTSUPP;
636a5d36 6928
074ac8df 6929 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 6930 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6931 return -EOPNOTSUPP;
eec60b03 6932
19957bb3 6933 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 6934
664834de
JM		 6935 chan = nl80211_get_valid_chan(&rdev->wiphy,
6936 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
6937 if (!chan)
4c476991 6938 return -EINVAL;
636a5d36 6939
19957bb3
JB		 6940 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6941 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 6942
6943 if (info->attrs[NL80211_ATTR_IE]) {
f62fab73
JB		 6944 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6945 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 6946 }
6947
dc6382ce 6948 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 6949 enum nl80211_mfp mfp =
dc6382ce 6950 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 6951 if (mfp == NL80211_MFP_REQUIRED)
f62fab73 6952 req.use_mfp = true;
4c476991
JB		 6953 else if (mfp != NL80211_MFP_NO)
6954 return -EINVAL;
dc6382ce
JM		 6955 }
6956
3e5d7649 6957 if (info->attrs[NL80211_ATTR_PREV_BSSID])
f62fab73 6958 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3e5d7649 6959
7e7c8926 6960 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
f62fab73 6961 req.flags |= ASSOC_REQ_DISABLE_HT;
7e7c8926
BG		 6962
6963 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
f62fab73
JB		 6964 memcpy(&req.ht_capa_mask,
6965 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6966 sizeof(req.ht_capa_mask));
7e7c8926
BG		 6967
6968 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
f62fab73 6969 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7e7c8926 6970 return -EINVAL;
f62fab73
JB		 6971 memcpy(&req.ht_capa,
6972 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6973 sizeof(req.ht_capa));
7e7c8926
BG		 6974 }
6975
ee2aca34 6976 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
f62fab73 6977 req.flags |= ASSOC_REQ_DISABLE_VHT;
ee2aca34
JB		 6978
6979 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
f62fab73
JB		 6980 memcpy(&req.vht_capa_mask,
6981 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6982 sizeof(req.vht_capa_mask));
ee2aca34
JB		 6983
6984 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
f62fab73 6985 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
ee2aca34 6986 return -EINVAL;
f62fab73
JB		 6987 memcpy(&req.vht_capa,
6988 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6989 sizeof(req.vht_capa));
ee2aca34
JB		 6990 }
6991
bab5ab7d
AK		 6992 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
6993 if (!(rdev->wiphy.features &
6994 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) ||
6995 !(rdev->wiphy.features & NL80211_FEATURE_QUIET))
6996 return -EINVAL;
6997 req.flags |= ASSOC_REQ_USE_RRM;
6998 }
6999
f62fab73 7000 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
91bf9b26
JB		 7001 if (!err) {
7002 wdev_lock(dev->ieee80211_ptr);
f62fab73
JB		 7003 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
7004 ssid, ssid_len, &req);
91bf9b26
JB		 7005 wdev_unlock(dev->ieee80211_ptr);
7006 }
636a5d36 7007
636a5d36
JM		 7008 return err;
7009}
7010
7011static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
7012{
4c476991
JB		 7013 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7014 struct net_device *dev = info->user_ptr[1];
19957bb3 7015 const u8 *ie = NULL, *bssid;
91bf9b26 7016 int ie_len = 0, err;
19957bb3 7017 u16 reason_code;
d5cdfacb 7018 bool local_state_change;
636a5d36 7019
f4a11bb0
JB		 7020 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7021 return -EINVAL;
7022
7023 if (!info->attrs[NL80211_ATTR_MAC])
7024 return -EINVAL;
7025
7026 if (!info->attrs[NL80211_ATTR_REASON_CODE])
7027 return -EINVAL;
7028
4c476991
JB		 7029 if (!rdev->ops->deauth)
7030 return -EOPNOTSUPP;
636a5d36 7031
074ac8df 7032 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7033 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7034 return -EOPNOTSUPP;
eec60b03 7035
19957bb3 7036 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 7037
19957bb3
JB		 7038 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
7039 if (reason_code == 0) {
f4a11bb0 7040 /* Reason Code 0 is reserved */
4c476991 7041 return -EINVAL;
255e737e 7042 }
636a5d36
JM		 7043
7044 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 7045 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7046 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 7047 }
7048
d5cdfacb
JM		 7049 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
7050
91bf9b26
JB		 7051 wdev_lock(dev->ieee80211_ptr);
7052 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
7053 local_state_change);
7054 wdev_unlock(dev->ieee80211_ptr);
7055 return err;
636a5d36
JM		 7056}
7057
7058static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
7059{
4c476991
JB		 7060 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7061 struct net_device *dev = info->user_ptr[1];
19957bb3 7062 const u8 *ie = NULL, *bssid;
91bf9b26 7063 int ie_len = 0, err;
19957bb3 7064 u16 reason_code;
d5cdfacb 7065 bool local_state_change;
636a5d36 7066
f4a11bb0
JB		 7067 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7068 return -EINVAL;
7069
7070 if (!info->attrs[NL80211_ATTR_MAC])
7071 return -EINVAL;
7072
7073 if (!info->attrs[NL80211_ATTR_REASON_CODE])
7074 return -EINVAL;
7075
4c476991
JB		 7076 if (!rdev->ops->disassoc)
7077 return -EOPNOTSUPP;
636a5d36 7078
074ac8df 7079 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7080 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7081 return -EOPNOTSUPP;
eec60b03 7082
19957bb3 7083 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 7084
19957bb3
JB		 7085 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
7086 if (reason_code == 0) {
f4a11bb0 7087 /* Reason Code 0 is reserved */
4c476991 7088 return -EINVAL;
255e737e 7089 }
636a5d36
JM		 7090
7091 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 7092 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7093 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 7094 }
7095
d5cdfacb
JM		 7096 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
7097
91bf9b26
JB		 7098 wdev_lock(dev->ieee80211_ptr);
7099 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
7100 local_state_change);
7101 wdev_unlock(dev->ieee80211_ptr);
7102 return err;
636a5d36
JM		 7103}
7104
dd5b4cc7
FF		 7105static bool
7106nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
7107 int mcast_rate[IEEE80211_NUM_BANDS],
7108 int rateval)
7109{
7110 struct wiphy *wiphy = &rdev->wiphy;
7111 bool found = false;
7112 int band, i;
7113
7114 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
7115 struct ieee80211_supported_band *sband;
7116
7117 sband = wiphy->bands[band];
7118 if (!sband)
7119 continue;
7120
7121 for (i = 0; i < sband->n_bitrates; i++) {
7122 if (sband->bitrates[i].bitrate == rateval) {
7123 mcast_rate[band] = i + 1;
7124 found = true;
7125 break;
7126 }
7127 }
7128 }
7129
7130 return found;
7131}
7132
04a773ad
JB		 7133static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
7134{
4c476991
JB		 7135 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7136 struct net_device *dev = info->user_ptr[1];
04a773ad
JB		 7137 struct cfg80211_ibss_params ibss;
7138 struct wiphy *wiphy;
fffd0934 7139 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 7140 int err;
7141
8e30bc55
JB		 7142 memset(&ibss, 0, sizeof(ibss));
7143
04a773ad
JB		 7144 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7145 return -EINVAL;
7146
683b6d3b 7147 if (!info->attrs[NL80211_ATTR_SSID] ||
04a773ad
JB		 7148 !nla_len(info->attrs[NL80211_ATTR_SSID]))
7149 return -EINVAL;
7150
8e30bc55
JB		 7151 ibss.beacon_interval = 100;
7152
7153 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
7154 ibss.beacon_interval =
7155 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
7156 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
7157 return -EINVAL;
7158 }
7159
4c476991
JB		 7160 if (!rdev->ops->join_ibss)
7161 return -EOPNOTSUPP;
04a773ad 7162
4c476991
JB		 7163 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
7164 return -EOPNOTSUPP;
04a773ad 7165
79c97e97 7166 wiphy = &rdev->wiphy;
04a773ad 7167
39193498 7168 if (info->attrs[NL80211_ATTR_MAC]) {
04a773ad 7169 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
39193498
JB		 7170
7171 if (!is_valid_ether_addr(ibss.bssid))
7172 return -EINVAL;
7173 }
04a773ad
JB		 7174 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
7175 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
7176
7177 if (info->attrs[NL80211_ATTR_IE]) {
7178 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7179 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7180 }
7181
683b6d3b
JB		 7182 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
7183 if (err)
7184 return err;
04a773ad 7185
174e0cd2
IP		 7186 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
7187 NL80211_IFTYPE_ADHOC))
54858ee5
AS		 7188 return -EINVAL;
7189
2f301ab2 7190 switch (ibss.chandef.width) {
bf372645
SW		 7191 case NL80211_CHAN_WIDTH_5:
7192 case NL80211_CHAN_WIDTH_10:
2f301ab2
SW		 7193 case NL80211_CHAN_WIDTH_20_NOHT:
7194 break;
7195 case NL80211_CHAN_WIDTH_20:
7196 case NL80211_CHAN_WIDTH_40:
7197 if (rdev->wiphy.features & NL80211_FEATURE_HT_IBSS)
7198 break;
7199 default:
c04d6150 7200 return -EINVAL;
2f301ab2 7201 }
db9c64cf 7202
04a773ad 7203 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 7204 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
7205
fbd2c8dc
TP		 7206 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
7207 u8 *rates =
7208 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
7209 int n_rates =
7210 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
7211 struct ieee80211_supported_band *sband =
683b6d3b 7212 wiphy->bands[ibss.chandef.chan->band];
fbd2c8dc 7213
34850ab2
JB		 7214 err = ieee80211_get_ratemask(sband, rates, n_rates,
7215 &ibss.basic_rates);
7216 if (err)
7217 return err;
fbd2c8dc 7218 }
dd5b4cc7 7219
803768f5
SW		 7220 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7221 memcpy(&ibss.ht_capa_mask,
7222 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
7223 sizeof(ibss.ht_capa_mask));
7224
7225 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
7226 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7227 return -EINVAL;
7228 memcpy(&ibss.ht_capa,
7229 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
7230 sizeof(ibss.ht_capa));
7231 }
7232
dd5b4cc7
FF		 7233 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
7234 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
7235 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
7236 return -EINVAL;
fbd2c8dc 7237
4c476991 7238 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
de7044ee
SM		 7239 bool no_ht = false;
7240
4c476991 7241 connkeys = nl80211_parse_connkeys(rdev,
de7044ee
SM		 7242 info->attrs[NL80211_ATTR_KEYS],
7243 &no_ht);
4c476991
JB		 7244 if (IS_ERR(connkeys))
7245 return PTR_ERR(connkeys);
de7044ee 7246
3d9d1d66
JB		 7247 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
7248 no_ht) {
de7044ee
SM		 7249 kfree(connkeys);
7250 return -EINVAL;
7251 }
4c476991 7252 }
04a773ad 7253
267335d6
AQ		 7254 ibss.control_port =
7255 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
7256
5336fa88
SW		 7257 ibss.userspace_handles_dfs =
7258 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
7259
4c476991 7260 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
fffd0934 7261 if (err)
b47f610b 7262 kzfree(connkeys);
04a773ad
JB		 7263 return err;
7264}
7265
7266static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
7267{
4c476991
JB		 7268 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7269 struct net_device *dev = info->user_ptr[1];
04a773ad 7270
4c476991
JB		 7271 if (!rdev->ops->leave_ibss)
7272 return -EOPNOTSUPP;
04a773ad 7273
4c476991
JB		 7274 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
7275 return -EOPNOTSUPP;
04a773ad 7276
4c476991 7277 return cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 7278}
7279
f4e583c8
AQ		 7280static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
7281{
7282 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7283 struct net_device *dev = info->user_ptr[1];
7284 int mcast_rate[IEEE80211_NUM_BANDS];
7285 u32 nla_rate;
7286 int err;
7287
7288 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
7289 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7290 return -EOPNOTSUPP;
7291
7292 if (!rdev->ops->set_mcast_rate)
7293 return -EOPNOTSUPP;
7294
7295 memset(mcast_rate, 0, sizeof(mcast_rate));
7296
7297 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
7298 return -EINVAL;
7299
7300 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
7301 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
7302 return -EINVAL;
7303
7304 err = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
7305
7306 return err;
7307}
7308
ad7e718c
JB		 7309static struct sk_buff *
7310__cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
7311 int approxlen, u32 portid, u32 seq,
7312 enum nl80211_commands cmd,
567ffc35
JB		 7313 enum nl80211_attrs attr,
7314 const struct nl80211_vendor_cmd_info *info,
7315 gfp_t gfp)
ad7e718c
JB		 7316{
7317 struct sk_buff *skb;
7318 void *hdr;
7319 struct nlattr *data;
7320
7321 skb = nlmsg_new(approxlen + 100, gfp);
7322 if (!skb)
7323 return NULL;
7324
7325 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
7326 if (!hdr) {
7327 kfree_skb(skb);
7328 return NULL;
7329 }
7330
7331 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
7332 goto nla_put_failure;
567ffc35
JB		 7333
7334 if (info) {
7335 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
7336 info->vendor_id))
7337 goto nla_put_failure;
7338 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
7339 info->subcmd))
7340 goto nla_put_failure;
7341 }
7342
ad7e718c
JB		 7343 data = nla_nest_start(skb, attr);
7344
7345 ((void **)skb->cb)[0] = rdev;
7346 ((void **)skb->cb)[1] = hdr;
7347 ((void **)skb->cb)[2] = data;
7348
7349 return skb;
7350
7351 nla_put_failure:
7352 kfree_skb(skb);
7353 return NULL;
7354}
f4e583c8 7355
e03ad6ea
JB		 7356struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
7357 enum nl80211_commands cmd,
7358 enum nl80211_attrs attr,
7359 int vendor_event_idx,
7360 int approxlen, gfp_t gfp)
7361{
f26cbf40 7362 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
e03ad6ea
JB		 7363 const struct nl80211_vendor_cmd_info *info;
7364
7365 switch (cmd) {
7366 case NL80211_CMD_TESTMODE:
7367 if (WARN_ON(vendor_event_idx != -1))
7368 return NULL;
7369 info = NULL;
7370 break;
7371 case NL80211_CMD_VENDOR:
7372 if (WARN_ON(vendor_event_idx < 0 ||
7373 vendor_event_idx >= wiphy->n_vendor_events))
7374 return NULL;
7375 info = &wiphy->vendor_events[vendor_event_idx];
7376 break;
7377 default:
7378 WARN_ON(1);
7379 return NULL;
7380 }
7381
7382 return __cfg80211_alloc_vendor_skb(rdev, approxlen, 0, 0,
7383 cmd, attr, info, gfp);
7384}
7385EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
7386
7387void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
7388{
7389 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
7390 void *hdr = ((void **)skb->cb)[1];
7391 struct nlattr *data = ((void **)skb->cb)[2];
7392 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
7393
bd8c78e7
JB		 7394 /* clear CB data for netlink core to own from now on */
7395 memset(skb->cb, 0, sizeof(skb->cb));
7396
e03ad6ea
JB		 7397 nla_nest_end(skb, data);
7398 genlmsg_end(skb, hdr);
7399
7400 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
7401 mcgrp = NL80211_MCGRP_VENDOR;
7402
7403 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
7404 mcgrp, gfp);
7405}
7406EXPORT_SYMBOL(__cfg80211_send_event_skb);
7407
aff89a9b 7408#ifdef CONFIG_NL80211_TESTMODE
aff89a9b
JB		 7409static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
7410{
4c476991 7411 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fc73f11f
DS		 7412 struct wireless_dev *wdev =
7413 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
aff89a9b
JB		 7414 int err;
7415
fc73f11f
DS		 7416 if (!rdev->ops->testmode_cmd)
7417 return -EOPNOTSUPP;
7418
7419 if (IS_ERR(wdev)) {
7420 err = PTR_ERR(wdev);
7421 if (err != -EINVAL)
7422 return err;
7423 wdev = NULL;
7424 } else if (wdev->wiphy != &rdev->wiphy) {
7425 return -EINVAL;
7426 }
7427
aff89a9b
JB		 7428 if (!info->attrs[NL80211_ATTR_TESTDATA])
7429 return -EINVAL;
7430
ad7e718c 7431 rdev->cur_cmd_info = info;
fc73f11f 7432 err = rdev_testmode_cmd(rdev, wdev,
aff89a9b
JB		 7433 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
7434 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
ad7e718c 7435 rdev->cur_cmd_info = NULL;
aff89a9b 7436
aff89a9b
JB		 7437 return err;
7438}
7439
71063f0e
WYG		 7440static int nl80211_testmode_dump(struct sk_buff *skb,
7441 struct netlink_callback *cb)
7442{
00918d33 7443 struct cfg80211_registered_device *rdev;
71063f0e
WYG		 7444 int err;
7445 long phy_idx;
7446 void *data = NULL;
7447 int data_len = 0;
7448
5fe231e8
JB		 7449 rtnl_lock();
7450
71063f0e
WYG		 7451 if (cb->args[0]) {
7452 /*
7453 * 0 is a valid index, but not valid for args[0],
7454 * so we need to offset by 1.
7455 */
7456 phy_idx = cb->args[0] - 1;
7457 } else {
7458 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
7459 nl80211_fam.attrbuf, nl80211_fam.maxattr,
7460 nl80211_policy);
7461 if (err)
5fe231e8 7462 goto out_err;
00918d33 7463
2bd7e35d
JB		 7464 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk),
7465 nl80211_fam.attrbuf);
7466 if (IS_ERR(rdev)) {
5fe231e8
JB		 7467 err = PTR_ERR(rdev);
7468 goto out_err;
00918d33 7469 }
2bd7e35d
JB		 7470 phy_idx = rdev->wiphy_idx;
7471 rdev = NULL;
2bd7e35d 7472
71063f0e
WYG		 7473 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
7474 cb->args[1] =
7475 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
7476 }
7477
7478 if (cb->args[1]) {
7479 data = nla_data((void *)cb->args[1]);
7480 data_len = nla_len((void *)cb->args[1]);
7481 }
7482
00918d33
JB		 7483 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
7484 if (!rdev) {
5fe231e8
JB		 7485 err = -ENOENT;
7486 goto out_err;
71063f0e 7487 }
71063f0e 7488
00918d33 7489 if (!rdev->ops->testmode_dump) {
71063f0e
WYG		 7490 err = -EOPNOTSUPP;
7491 goto out_err;
7492 }
7493
7494 while (1) {
15e47304 7495 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
71063f0e
WYG		 7496 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7497 NL80211_CMD_TESTMODE);
7498 struct nlattr *tmdata;
7499
cb35fba3
DC		 7500 if (!hdr)
7501 break;
7502
9360ffd1 7503 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
71063f0e
WYG		 7504 genlmsg_cancel(skb, hdr);
7505 break;
7506 }
7507
7508 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
7509 if (!tmdata) {
7510 genlmsg_cancel(skb, hdr);
7511 break;
7512 }
e35e4d28 7513 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
71063f0e
WYG		 7514 nla_nest_end(skb, tmdata);
7515
7516 if (err == -ENOBUFS || err == -ENOENT) {
7517 genlmsg_cancel(skb, hdr);
7518 break;
7519 } else if (err) {
7520 genlmsg_cancel(skb, hdr);
7521 goto out_err;
7522 }
7523
7524 genlmsg_end(skb, hdr);
7525 }
7526
7527 err = skb->len;
7528 /* see above */
7529 cb->args[0] = phy_idx + 1;
7530 out_err:
5fe231e8 7531 rtnl_unlock();
71063f0e
WYG		 7532 return err;
7533}
aff89a9b
JB		 7534#endif
7535
b23aa676
SO		 7536static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
7537{
4c476991
JB		 7538 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7539 struct net_device *dev = info->user_ptr[1];
b23aa676
SO		 7540 struct cfg80211_connect_params connect;
7541 struct wiphy *wiphy;
fffd0934 7542 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 7543 int err;
7544
7545 memset(&connect, 0, sizeof(connect));
7546
7547 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7548 return -EINVAL;
7549
7550 if (!info->attrs[NL80211_ATTR_SSID] ||
7551 !nla_len(info->attrs[NL80211_ATTR_SSID]))
7552 return -EINVAL;
7553
7554 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
7555 connect.auth_type =
7556 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
e39e5b5e
JM		 7557 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
7558 NL80211_CMD_CONNECT))
b23aa676
SO		 7559 return -EINVAL;
7560 } else
7561 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
7562
7563 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
7564
c0692b8f 7565 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
3dc27d25 7566 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 7567 if (err)
7568 return err;
b23aa676 7569
074ac8df 7570 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7571 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7572 return -EOPNOTSUPP;
b23aa676 7573
79c97e97 7574 wiphy = &rdev->wiphy;
b23aa676 7575
4486ea98
BS		 7576 connect.bg_scan_period = -1;
7577 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
7578 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
7579 connect.bg_scan_period =
7580 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
7581 }
7582
b23aa676
SO		 7583 if (info->attrs[NL80211_ATTR_MAC])
7584 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1df4a510
JM		 7585 else if (info->attrs[NL80211_ATTR_MAC_HINT])
7586 connect.bssid_hint =
7587 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
b23aa676
SO		 7588 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
7589 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
7590
7591 if (info->attrs[NL80211_ATTR_IE]) {
7592 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7593 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7594 }
7595
cee00a95
JM		 7596 if (info->attrs[NL80211_ATTR_USE_MFP]) {
7597 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
7598 if (connect.mfp != NL80211_MFP_REQUIRED &&
7599 connect.mfp != NL80211_MFP_NO)
7600 return -EINVAL;
7601 } else {
7602 connect.mfp = NL80211_MFP_NO;
7603 }
7604
b23aa676 7605 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
664834de
JM		 7606 connect.channel = nl80211_get_valid_chan(
7607 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
7608 if (!connect.channel)
1df4a510
JM		 7609 return -EINVAL;
7610 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
664834de
JM		 7611 connect.channel_hint = nl80211_get_valid_chan(
7612 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
7613 if (!connect.channel_hint)
4c476991 7614 return -EINVAL;
b23aa676
SO		 7615 }
7616
fffd0934
JB		 7617 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
7618 connkeys = nl80211_parse_connkeys(rdev,
de7044ee 7619 info->attrs[NL80211_ATTR_KEYS], NULL);
4c476991
JB		 7620 if (IS_ERR(connkeys))
7621 return PTR_ERR(connkeys);
fffd0934
JB		 7622 }
7623
7e7c8926
BG		 7624 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
7625 connect.flags |= ASSOC_REQ_DISABLE_HT;
7626
7627 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7628 memcpy(&connect.ht_capa_mask,
7629 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
7630 sizeof(connect.ht_capa_mask));
7631
7632 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
b4e4f47e 7633 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
b47f610b 7634 kzfree(connkeys);
7e7c8926 7635 return -EINVAL;
b4e4f47e 7636 }
7e7c8926
BG		 7637 memcpy(&connect.ht_capa,
7638 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
7639 sizeof(connect.ht_capa));
7640 }
7641
ee2aca34
JB		 7642 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
7643 connect.flags |= ASSOC_REQ_DISABLE_VHT;
7644
7645 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
7646 memcpy(&connect.vht_capa_mask,
7647 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
7648 sizeof(connect.vht_capa_mask));
7649
7650 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
7651 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
b47f610b 7652 kzfree(connkeys);
ee2aca34
JB		 7653 return -EINVAL;
7654 }
7655 memcpy(&connect.vht_capa,
7656 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
7657 sizeof(connect.vht_capa));
7658 }
7659
bab5ab7d
AK		 7660 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
7661 if (!(rdev->wiphy.features &
7662 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) ||
7663 !(rdev->wiphy.features & NL80211_FEATURE_QUIET))
7664 return -EINVAL;
7665 connect.flags |= ASSOC_REQ_USE_RRM;
7666 }
7667
83739b03
JB		 7668 wdev_lock(dev->ieee80211_ptr);
7669 err = cfg80211_connect(rdev, dev, &connect, connkeys, NULL);
7670 wdev_unlock(dev->ieee80211_ptr);
fffd0934 7671 if (err)
b47f610b 7672 kzfree(connkeys);
b23aa676
SO		 7673 return err;
7674}
7675
7676static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
7677{
4c476991
JB		 7678 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7679 struct net_device *dev = info->user_ptr[1];
b23aa676 7680 u16 reason;
83739b03 7681 int ret;
b23aa676
SO		 7682
7683 if (!info->attrs[NL80211_ATTR_REASON_CODE])
7684 reason = WLAN_REASON_DEAUTH_LEAVING;
7685 else
7686 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
7687
7688 if (reason == 0)
7689 return -EINVAL;
7690
074ac8df 7691 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7692 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7693 return -EOPNOTSUPP;
b23aa676 7694
83739b03
JB		 7695 wdev_lock(dev->ieee80211_ptr);
7696 ret = cfg80211_disconnect(rdev, dev, reason, true);
7697 wdev_unlock(dev->ieee80211_ptr);
7698 return ret;
b23aa676
SO		 7699}
7700
463d0183
JB		 7701static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
7702{
4c476991 7703 struct cfg80211_registered_device *rdev = info->user_ptr[0];
463d0183
JB		 7704 struct net *net;
7705 int err;
7706 u32 pid;
7707
7708 if (!info->attrs[NL80211_ATTR_PID])
7709 return -EINVAL;
7710
7711 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
7712
463d0183 7713 net = get_net_ns_by_pid(pid);
4c476991
JB		 7714 if (IS_ERR(net))
7715 return PTR_ERR(net);
463d0183
JB		 7716
7717 err = 0;
7718
7719 /* check if anything to do */
4c476991
JB		 7720 if (!net_eq(wiphy_net(&rdev->wiphy), net))
7721 err = cfg80211_switch_netns(rdev, net);
463d0183 7722
463d0183 7723 put_net(net);
463d0183
JB		 7724 return err;
7725}
7726
67fbb16b
SO		 7727static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
7728{
4c476991 7729 struct cfg80211_registered_device *rdev = info->user_ptr[0];
67fbb16b
SO		 7730 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
7731 struct cfg80211_pmksa *pmksa) = NULL;
4c476991 7732 struct net_device *dev = info->user_ptr[1];
67fbb16b
SO		 7733 struct cfg80211_pmksa pmksa;
7734
7735 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
7736
7737 if (!info->attrs[NL80211_ATTR_MAC])
7738 return -EINVAL;
7739
7740 if (!info->attrs[NL80211_ATTR_PMKID])
7741 return -EINVAL;
7742
67fbb16b
SO		 7743 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
7744 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
7745
074ac8df 7746 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7747 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7748 return -EOPNOTSUPP;
67fbb16b
SO		 7749
7750 switch (info->genlhdr->cmd) {
7751 case NL80211_CMD_SET_PMKSA:
7752 rdev_ops = rdev->ops->set_pmksa;
7753 break;
7754 case NL80211_CMD_DEL_PMKSA:
7755 rdev_ops = rdev->ops->del_pmksa;
7756 break;
7757 default:
7758 WARN_ON(1);
7759 break;
7760 }
7761
4c476991
JB		 7762 if (!rdev_ops)
7763 return -EOPNOTSUPP;
67fbb16b 7764
4c476991 7765 return rdev_ops(&rdev->wiphy, dev, &pmksa);
67fbb16b
SO		 7766}
7767
7768static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
7769{
4c476991
JB		 7770 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7771 struct net_device *dev = info->user_ptr[1];
67fbb16b 7772
074ac8df 7773 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 7774 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7775 return -EOPNOTSUPP;
67fbb16b 7776
4c476991
JB		 7777 if (!rdev->ops->flush_pmksa)
7778 return -EOPNOTSUPP;
67fbb16b 7779
e35e4d28 7780 return rdev_flush_pmksa(rdev, dev);
67fbb16b
SO		 7781}
7782
109086ce
AN		 7783static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
7784{
7785 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7786 struct net_device *dev = info->user_ptr[1];
7787 u8 action_code, dialog_token;
df942e7b 7788 u32 peer_capability = 0;
109086ce
AN		 7789 u16 status_code;
7790 u8 *peer;
31fa97c5 7791 bool initiator;
109086ce
AN		 7792
7793 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
7794 !rdev->ops->tdls_mgmt)
7795 return -EOPNOTSUPP;
7796
7797 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
7798 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
7799 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
7800 !info->attrs[NL80211_ATTR_IE] ||
7801 !info->attrs[NL80211_ATTR_MAC])
7802 return -EINVAL;
7803
7804 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
7805 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
7806 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
7807 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
31fa97c5 7808 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
df942e7b
SDU		 7809 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
7810 peer_capability =
7811 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
109086ce 7812
e35e4d28 7813 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
df942e7b 7814 dialog_token, status_code, peer_capability,
31fa97c5 7815 initiator,
e35e4d28
HG		 7816 nla_data(info->attrs[NL80211_ATTR_IE]),
7817 nla_len(info->attrs[NL80211_ATTR_IE]));
109086ce
AN		 7818}
7819
7820static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
7821{
7822 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7823 struct net_device *dev = info->user_ptr[1];
7824 enum nl80211_tdls_operation operation;
7825 u8 *peer;
7826
7827 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
7828 !rdev->ops->tdls_oper)
7829 return -EOPNOTSUPP;
7830
7831 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
7832 !info->attrs[NL80211_ATTR_MAC])
7833 return -EINVAL;
7834
7835 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
7836 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
7837
e35e4d28 7838 return rdev_tdls_oper(rdev, dev, peer, operation);
109086ce
AN		 7839}
7840
9588bbd5
JM		 7841static int nl80211_remain_on_channel(struct sk_buff *skb,
7842 struct genl_info *info)
7843{
4c476991 7844 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 7845 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 7846 struct cfg80211_chan_def chandef;
9588bbd5
JM		 7847 struct sk_buff *msg;
7848 void *hdr;
7849 u64 cookie;
683b6d3b 7850 u32 duration;
9588bbd5
JM		 7851 int err;
7852
7853 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7854 !info->attrs[NL80211_ATTR_DURATION])
7855 return -EINVAL;
7856
7857 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
7858
ebf348fc
JB		 7859 if (!rdev->ops->remain_on_channel ||
7860 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
7861 return -EOPNOTSUPP;
7862
9588bbd5 7863 /*
ebf348fc
JB		 7864 * We should be on that channel for at least a minimum amount of
7865 * time (10ms) but no longer than the driver supports.
9588bbd5 7866 */
ebf348fc 7867 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
a293911d 7868 duration > rdev->wiphy.max_remain_on_channel_duration)
9588bbd5
JM		 7869 return -EINVAL;
7870
683b6d3b
JB		 7871 err = nl80211_parse_chandef(rdev, info, &chandef);
7872 if (err)
7873 return err;
9588bbd5
JM		 7874
7875 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 7876 if (!msg)
7877 return -ENOMEM;
9588bbd5 7878
15e47304 7879 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9588bbd5 7880 NL80211_CMD_REMAIN_ON_CHANNEL);
cb35fba3
DC		 7881 if (!hdr) {
7882 err = -ENOBUFS;
9588bbd5
JM		 7883 goto free_msg;
7884 }
7885
683b6d3b
JB		 7886 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
7887 duration, &cookie);
9588bbd5
JM		 7888
7889 if (err)
7890 goto free_msg;
7891
9360ffd1
DM		 7892 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7893 goto nla_put_failure;
9588bbd5
JM		 7894
7895 genlmsg_end(msg, hdr);
4c476991
JB		 7896
7897 return genlmsg_reply(msg, info);
9588bbd5
JM		 7898
7899 nla_put_failure:
7900 err = -ENOBUFS;
7901 free_msg:
7902 nlmsg_free(msg);
9588bbd5
JM		 7903 return err;
7904}
7905
7906static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
7907 struct genl_info *info)
7908{
4c476991 7909 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 7910 struct wireless_dev *wdev = info->user_ptr[1];
9588bbd5 7911 u64 cookie;
9588bbd5
JM		 7912
7913 if (!info->attrs[NL80211_ATTR_COOKIE])
7914 return -EINVAL;
7915
4c476991
JB		 7916 if (!rdev->ops->cancel_remain_on_channel)
7917 return -EOPNOTSUPP;
9588bbd5 7918
9588bbd5
JM		 7919 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7920
e35e4d28 7921 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
9588bbd5
JM		 7922}
7923
13ae75b1
JM		 7924static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
7925 u8 *rates, u8 rates_len)
7926{
7927 u8 i;
7928 u32 mask = 0;
7929
7930 for (i = 0; i < rates_len; i++) {
7931 int rate = (rates[i] & 0x7f) * 5;
7932 int ridx;
7933 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
7934 struct ieee80211_rate *srate =
7935 &sband->bitrates[ridx];
7936 if (rate == srate->bitrate) {
7937 mask |= 1 << ridx;
7938 break;
7939 }
7940 }
7941 if (ridx == sband->n_bitrates)
7942 return 0; /* rate not found */
7943 }
7944
7945 return mask;
7946}
7947
24db78c0
SW		 7948static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
7949 u8 *rates, u8 rates_len,
7950 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
7951{
7952 u8 i;
7953
7954 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
7955
7956 for (i = 0; i < rates_len; i++) {
7957 int ridx, rbit;
7958
7959 ridx = rates[i] / 8;
7960 rbit = BIT(rates[i] % 8);
7961
7962 /* check validity */
910570b5 7963 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
24db78c0
SW		 7964 return false;
7965
7966 /* check availability */
7967 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
7968 mcs[ridx] |= rbit;
7969 else
7970 return false;
7971 }
7972
7973 return true;
7974}
7975
204e35a9
JD		 7976static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
7977{
7978 u16 mcs_mask = 0;
7979
7980 switch (vht_mcs_map) {
7981 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
7982 break;
7983 case IEEE80211_VHT_MCS_SUPPORT_0_7:
7984 mcs_mask = 0x00FF;
7985 break;
7986 case IEEE80211_VHT_MCS_SUPPORT_0_8:
7987 mcs_mask = 0x01FF;
7988 break;
7989 case IEEE80211_VHT_MCS_SUPPORT_0_9:
7990 mcs_mask = 0x03FF;
7991 break;
7992 default:
7993 break;
7994 }
7995
7996 return mcs_mask;
7997}
7998
7999static void vht_build_mcs_mask(u16 vht_mcs_map,
8000 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
8001{
8002 u8 nss;
8003
8004 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
8005 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
8006 vht_mcs_map >>= 2;
8007 }
8008}
8009
8010static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
8011 struct nl80211_txrate_vht *txrate,
8012 u16 mcs[NL80211_VHT_NSS_MAX])
8013{
8014 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
8015 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
8016 u8 i;
8017
8018 if (!sband->vht_cap.vht_supported)
8019 return false;
8020
8021 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
8022
8023 /* Build vht_mcs_mask from VHT capabilities */
8024 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
8025
8026 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8027 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
8028 mcs[i] = txrate->mcs[i];
8029 else
8030 return false;
8031 }
8032
8033 return true;
8034}
8035
b54452b0 8036static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
13ae75b1
JM		 8037 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
8038 .len = NL80211_MAX_SUPP_RATES },
d1e33e65
JD		 8039 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
8040 .len = NL80211_MAX_SUPP_HT_RATES },
204e35a9 8041 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
0b9323f6 8042 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
13ae75b1
JM		 8043};
8044
8045static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
8046 struct genl_info *info)
8047{
8048 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4c476991 8049 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13ae75b1 8050 struct cfg80211_bitrate_mask mask;
4c476991
JB		 8051 int rem, i;
8052 struct net_device *dev = info->user_ptr[1];
13ae75b1
JM		 8053 struct nlattr *tx_rates;
8054 struct ieee80211_supported_band *sband;
204e35a9 8055 u16 vht_tx_mcs_map;
13ae75b1 8056
4c476991
JB		 8057 if (!rdev->ops->set_bitrate_mask)
8058 return -EOPNOTSUPP;
13ae75b1
JM		 8059
8060 memset(&mask, 0, sizeof(mask));
8061 /* Default to all rates enabled */
8062 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
8063 sband = rdev->wiphy.bands[i];
7869303b
JD		 8064
8065 if (!sband)
8066 continue;
8067
8068 mask.control[i].legacy = (1 << sband->n_bitrates) - 1;
d1e33e65 8069 memcpy(mask.control[i].ht_mcs,
7869303b 8070 sband->ht_cap.mcs.rx_mask,
d1e33e65 8071 sizeof(mask.control[i].ht_mcs));
204e35a9
JD		 8072
8073 if (!sband->vht_cap.vht_supported)
8074 continue;
8075
8076 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
8077 vht_build_mcs_mask(vht_tx_mcs_map, mask.control[i].vht_mcs);
13ae75b1
JM		 8078 }
8079
b9243ab0
JD		 8080 /* if no rates are given set it back to the defaults */
8081 if (!info->attrs[NL80211_ATTR_TX_RATES])
8082 goto out;
8083
13ae75b1
JM		 8084 /*
8085 * The nested attribute uses enum nl80211_band as the index. This maps
8086 * directly to the enum ieee80211_band values used in cfg80211.
8087 */
24db78c0 8088 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
ae811e21 8089 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
13ae75b1 8090 enum ieee80211_band band = nla_type(tx_rates);
ae811e21
JB		 8091 int err;
8092
4c476991
JB		 8093 if (band < 0 || band >= IEEE80211_NUM_BANDS)
8094 return -EINVAL;
13ae75b1 8095 sband = rdev->wiphy.bands[band];
4c476991
JB		 8096 if (sband == NULL)
8097 return -EINVAL;
ae811e21
JB		 8098 err = nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
8099 nla_len(tx_rates), nl80211_txattr_policy);
8100 if (err)
8101 return err;
13ae75b1
JM		 8102 if (tb[NL80211_TXRATE_LEGACY]) {
8103 mask.control[band].legacy = rateset_to_mask(
8104 sband,
8105 nla_data(tb[NL80211_TXRATE_LEGACY]),
8106 nla_len(tb[NL80211_TXRATE_LEGACY]));
218d2e26
BS		 8107 if ((mask.control[band].legacy == 0) &&
8108 nla_len(tb[NL80211_TXRATE_LEGACY]))
8109 return -EINVAL;
24db78c0 8110 }
d1e33e65 8111 if (tb[NL80211_TXRATE_HT]) {
24db78c0
SW		 8112 if (!ht_rateset_to_mask(
8113 sband,
d1e33e65
JD		 8114 nla_data(tb[NL80211_TXRATE_HT]),
8115 nla_len(tb[NL80211_TXRATE_HT]),
8116 mask.control[band].ht_mcs))
24db78c0
SW		 8117 return -EINVAL;
8118 }
204e35a9
JD		 8119 if (tb[NL80211_TXRATE_VHT]) {
8120 if (!vht_set_mcs_mask(
8121 sband,
8122 nla_data(tb[NL80211_TXRATE_VHT]),
8123 mask.control[band].vht_mcs))
8124 return -EINVAL;
8125 }
0b9323f6
JD		 8126 if (tb[NL80211_TXRATE_GI]) {
8127 mask.control[band].gi =
8128 nla_get_u8(tb[NL80211_TXRATE_GI]);
8129 if (mask.control[band].gi > NL80211_TXRATE_FORCE_LGI)
8130 return -EINVAL;
8131 }
24db78c0
SW		 8132
8133 if (mask.control[band].legacy == 0) {
204e35a9
JD		 8134 /* don't allow empty legacy rates if HT or VHT
8135 * are not even supported.
8136 */
8137 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
8138 rdev->wiphy.bands[band]->vht_cap.vht_supported))
24db78c0
SW		 8139 return -EINVAL;
8140
8141 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
d1e33e65 8142 if (mask.control[band].ht_mcs[i])
204e35a9
JD		 8143 goto out;
8144
8145 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
8146 if (mask.control[band].vht_mcs[i])
8147 goto out;
24db78c0
SW		 8148
8149 /* legacy and mcs rates may not be both empty */
204e35a9 8150 return -EINVAL;
13ae75b1
JM		 8151 }
8152 }
8153
b9243ab0 8154out:
e35e4d28 8155 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
13ae75b1
JM		 8156}
8157
2e161f78 8158static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 8159{
4c476991 8160 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 8161 struct wireless_dev *wdev = info->user_ptr[1];
2e161f78 8162 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
026331c4
JM		 8163
8164 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
8165 return -EINVAL;
8166
2e161f78
JB		 8167 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
8168 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
026331c4 8169
71bbc994
JB		 8170 switch (wdev->iftype) {
8171 case NL80211_IFTYPE_STATION:
8172 case NL80211_IFTYPE_ADHOC:
8173 case NL80211_IFTYPE_P2P_CLIENT:
8174 case NL80211_IFTYPE_AP:
8175 case NL80211_IFTYPE_AP_VLAN:
8176 case NL80211_IFTYPE_MESH_POINT:
8177 case NL80211_IFTYPE_P2P_GO:
98104fde 8178 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994
JB		 8179 break;
8180 default:
4c476991 8181 return -EOPNOTSUPP;
71bbc994 8182 }
026331c4
JM		 8183
8184 /* not much point in registering if we can't reply */
4c476991
JB		 8185 if (!rdev->ops->mgmt_tx)
8186 return -EOPNOTSUPP;
026331c4 8187
15e47304 8188 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
026331c4
JM		 8189 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
8190 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
026331c4
JM		 8191}
8192
2e161f78 8193static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
026331c4 8194{
4c476991 8195 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 8196 struct wireless_dev *wdev = info->user_ptr[1];
683b6d3b 8197 struct cfg80211_chan_def chandef;
026331c4 8198 int err;
d64d373f 8199 void *hdr = NULL;
026331c4 8200 u64 cookie;
e247bd90 8201 struct sk_buff *msg = NULL;
b176e629
AO		 8202 struct cfg80211_mgmt_tx_params params = {
8203 .dont_wait_for_ack =
8204 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
8205 };
026331c4 8206
683b6d3b 8207 if (!info->attrs[NL80211_ATTR_FRAME])
026331c4
JM		 8208 return -EINVAL;
8209
4c476991
JB		 8210 if (!rdev->ops->mgmt_tx)
8211 return -EOPNOTSUPP;
026331c4 8212
71bbc994 8213 switch (wdev->iftype) {
ea141b75
AQ		 8214 case NL80211_IFTYPE_P2P_DEVICE:
8215 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
8216 return -EINVAL;
71bbc994
JB		 8217 case NL80211_IFTYPE_STATION:
8218 case NL80211_IFTYPE_ADHOC:
8219 case NL80211_IFTYPE_P2P_CLIENT:
8220 case NL80211_IFTYPE_AP:
8221 case NL80211_IFTYPE_AP_VLAN:
8222 case NL80211_IFTYPE_MESH_POINT:
8223 case NL80211_IFTYPE_P2P_GO:
8224 break;
8225 default:
4c476991 8226 return -EOPNOTSUPP;
71bbc994 8227 }
026331c4 8228
f7ca38df 8229 if (info->attrs[NL80211_ATTR_DURATION]) {
7c4ef712 8230 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
f7ca38df 8231 return -EINVAL;
b176e629 8232 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
ebf348fc
JB		 8233
8234 /*
8235 * We should wait on the channel for at least a minimum amount
8236 * of time (10ms) but no longer than the driver supports.
8237 */
b176e629
AO		 8238 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
8239 params.wait > rdev->wiphy.max_remain_on_channel_duration)
ebf348fc
JB		 8240 return -EINVAL;
8241
f7ca38df
JB		 8242 }
8243
b176e629 8244 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
f7ca38df 8245
b176e629 8246 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7c4ef712
JB		 8247 return -EINVAL;
8248
b176e629 8249 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3 8250
ea141b75
AQ		 8251 /* get the channel if any has been specified, otherwise pass NULL to
8252 * the driver. The latter will use the current one
8253 */
8254 chandef.chan = NULL;
8255 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
8256 err = nl80211_parse_chandef(rdev, info, &chandef);
8257 if (err)
8258 return err;
8259 }
8260
b176e629 8261 if (!chandef.chan && params.offchan)
ea141b75 8262 return -EINVAL;
026331c4 8263
34d22ce2
AO		 8264 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
8265 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
8266
8267 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
8268 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
8269 int i;
8270
8271 if (len % sizeof(u16))
8272 return -EINVAL;
8273
8274 params.n_csa_offsets = len / sizeof(u16);
8275 params.csa_offsets =
8276 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
8277
8278 /* check that all the offsets fit the frame */
8279 for (i = 0; i < params.n_csa_offsets; i++) {
8280 if (params.csa_offsets[i] >= params.len)
8281 return -EINVAL;
8282 }
8283 }
8284
b176e629 8285 if (!params.dont_wait_for_ack) {
e247bd90
JB		 8286 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8287 if (!msg)
8288 return -ENOMEM;
026331c4 8289
15e47304 8290 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
e247bd90 8291 NL80211_CMD_FRAME);
cb35fba3
DC		 8292 if (!hdr) {
8293 err = -ENOBUFS;
e247bd90
JB		 8294 goto free_msg;
8295 }
026331c4 8296 }
e247bd90 8297
b176e629
AO		 8298 params.chan = chandef.chan;
8299 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
026331c4
JM		 8300 if (err)
8301 goto free_msg;
8302
e247bd90 8303 if (msg) {
9360ffd1
DM		 8304 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
8305 goto nla_put_failure;
026331c4 8306
e247bd90
JB		 8307 genlmsg_end(msg, hdr);
8308 return genlmsg_reply(msg, info);
8309 }
8310
8311 return 0;
026331c4
JM		 8312
8313 nla_put_failure:
8314 err = -ENOBUFS;
8315 free_msg:
8316 nlmsg_free(msg);
026331c4
JM		 8317 return err;
8318}
8319
f7ca38df
JB		 8320static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
8321{
8322 struct cfg80211_registered_device *rdev = info->user_ptr[0];
71bbc994 8323 struct wireless_dev *wdev = info->user_ptr[1];
f7ca38df
JB		 8324 u64 cookie;
8325
8326 if (!info->attrs[NL80211_ATTR_COOKIE])
8327 return -EINVAL;
8328
8329 if (!rdev->ops->mgmt_tx_cancel_wait)
8330 return -EOPNOTSUPP;
8331
71bbc994
JB		 8332 switch (wdev->iftype) {
8333 case NL80211_IFTYPE_STATION:
8334 case NL80211_IFTYPE_ADHOC:
8335 case NL80211_IFTYPE_P2P_CLIENT:
8336 case NL80211_IFTYPE_AP:
8337 case NL80211_IFTYPE_AP_VLAN:
8338 case NL80211_IFTYPE_P2P_GO:
98104fde 8339 case NL80211_IFTYPE_P2P_DEVICE:
71bbc994
JB		 8340 break;
8341 default:
f7ca38df 8342 return -EOPNOTSUPP;
71bbc994 8343 }
f7ca38df
JB		 8344
8345 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
8346
e35e4d28 8347 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
f7ca38df
JB		 8348}
8349
ffb9eb3d
KV		 8350static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
8351{
4c476991 8352 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d 8353 struct wireless_dev *wdev;
4c476991 8354 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 8355 u8 ps_state;
8356 bool state;
8357 int err;
8358
4c476991
JB		 8359 if (!info->attrs[NL80211_ATTR_PS_STATE])
8360 return -EINVAL;
ffb9eb3d
KV		 8361
8362 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
8363
4c476991
JB		 8364 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
8365 return -EINVAL;
ffb9eb3d
KV		 8366
8367 wdev = dev->ieee80211_ptr;
8368
4c476991
JB		 8369 if (!rdev->ops->set_power_mgmt)
8370 return -EOPNOTSUPP;
ffb9eb3d
KV		 8371
8372 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
8373
8374 if (state == wdev->ps)
4c476991 8375 return 0;
ffb9eb3d 8376
e35e4d28 8377 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
4c476991
JB		 8378 if (!err)
8379 wdev->ps = state;
ffb9eb3d
KV		 8380 return err;
8381}
8382
8383static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
8384{
4c476991 8385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
ffb9eb3d
KV		 8386 enum nl80211_ps_state ps_state;
8387 struct wireless_dev *wdev;
4c476991 8388 struct net_device *dev = info->user_ptr[1];
ffb9eb3d
KV		 8389 struct sk_buff *msg;
8390 void *hdr;
8391 int err;
8392
ffb9eb3d
KV		 8393 wdev = dev->ieee80211_ptr;
8394
4c476991
JB		 8395 if (!rdev->ops->set_power_mgmt)
8396 return -EOPNOTSUPP;
ffb9eb3d
KV		 8397
8398 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4c476991
JB		 8399 if (!msg)
8400 return -ENOMEM;
ffb9eb3d 8401
15e47304 8402 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ffb9eb3d
KV		 8403 NL80211_CMD_GET_POWER_SAVE);
8404 if (!hdr) {
4c476991 8405 err = -ENOBUFS;
ffb9eb3d
KV		 8406 goto free_msg;
8407 }
8408
8409 if (wdev->ps)
8410 ps_state = NL80211_PS_ENABLED;
8411 else
8412 ps_state = NL80211_PS_DISABLED;
8413
9360ffd1
DM		 8414 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
8415 goto nla_put_failure;
ffb9eb3d
KV		 8416
8417 genlmsg_end(msg, hdr);
4c476991 8418 return genlmsg_reply(msg, info);
ffb9eb3d 8419
4c476991 8420 nla_put_failure:
ffb9eb3d 8421 err = -ENOBUFS;
4c476991 8422 free_msg:
ffb9eb3d 8423 nlmsg_free(msg);
ffb9eb3d
KV		 8424 return err;
8425}
8426
94e860f1
JB		 8427static const struct nla_policy
8428nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
d6dc1a38
JO		 8429 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
8430 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
8431 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
84f10708
TP		 8432 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
8433 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
8434 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
d6dc1a38
JO		 8435};
8436
84f10708 8437static int nl80211_set_cqm_txe(struct genl_info *info,
d9d8b019 8438 u32 rate, u32 pkts, u32 intvl)
84f10708
TP		 8439{
8440 struct cfg80211_registered_device *rdev = info->user_ptr[0];
84f10708 8441 struct net_device *dev = info->user_ptr[1];
1da5fcc8 8442 struct wireless_dev *wdev = dev->ieee80211_ptr;
84f10708 8443
d9d8b019 8444 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
84f10708
TP		 8445 return -EINVAL;
8446
84f10708
TP		 8447 if (!rdev->ops->set_cqm_txe_config)
8448 return -EOPNOTSUPP;
8449
8450 if (wdev->iftype != NL80211_IFTYPE_STATION &&
8451 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
8452 return -EOPNOTSUPP;
8453
e35e4d28 8454 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
84f10708
TP		 8455}
8456
d6dc1a38
JO		 8457static int nl80211_set_cqm_rssi(struct genl_info *info,
8458 s32 threshold, u32 hysteresis)
8459{
4c476991 8460 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4c476991 8461 struct net_device *dev = info->user_ptr[1];
1da5fcc8 8462 struct wireless_dev *wdev = dev->ieee80211_ptr;
d6dc1a38
JO		 8463
8464 if (threshold > 0)
8465 return -EINVAL;
8466
1da5fcc8
JB		 8467 /* disabling - hysteresis should also be zero then */
8468 if (threshold == 0)
8469 hysteresis = 0;
d6dc1a38 8470
4c476991
JB		 8471 if (!rdev->ops->set_cqm_rssi_config)
8472 return -EOPNOTSUPP;
d6dc1a38 8473
074ac8df 8474 if (wdev->iftype != NL80211_IFTYPE_STATION &&
4c476991
JB		 8475 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
8476 return -EOPNOTSUPP;
d6dc1a38 8477
e35e4d28 8478 return rdev_set_cqm_rssi_config(rdev, dev, threshold, hysteresis);
d6dc1a38
JO		 8479}
8480
8481static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
8482{
8483 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
8484 struct nlattr *cqm;
8485 int err;
8486
8487 cqm = info->attrs[NL80211_ATTR_CQM];
1da5fcc8
JB		 8488 if (!cqm)
8489 return -EINVAL;
d6dc1a38
JO		 8490
8491 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
8492 nl80211_attr_cqm_policy);
8493 if (err)
1da5fcc8 8494 return err;
d6dc1a38
JO		 8495
8496 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
8497 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
1da5fcc8
JB		 8498 s32 threshold = nla_get_s32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
8499 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
d6dc1a38 8500
1da5fcc8
JB		 8501 return nl80211_set_cqm_rssi(info, threshold, hysteresis);
8502 }
8503
8504 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
8505 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
8506 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
8507 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
8508 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
8509 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
8510
8511 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
8512 }
8513
8514 return -EINVAL;
d6dc1a38
JO		 8515}
8516
6e0bd6c3
RL		 8517static int nl80211_join_ocb(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];
8521 struct ocb_setup setup = {};
8522 int err;
8523
8524 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
8525 if (err)
8526 return err;
8527
8528 return cfg80211_join_ocb(rdev, dev, &setup);
8529}
8530
8531static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
8532{
8533 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8534 struct net_device *dev = info->user_ptr[1];
8535
8536 return cfg80211_leave_ocb(rdev, dev);
8537}
8538
29cbe68c
JB		 8539static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
8540{
8541 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8542 struct net_device *dev = info->user_ptr[1];
8543 struct mesh_config cfg;
c80d545d 8544 struct mesh_setup setup;
29cbe68c
JB		 8545 int err;
8546
8547 /* start with default */
8548 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
c80d545d 8549 memcpy(&setup, &default_mesh_setup, sizeof(setup));
29cbe68c 8550
24bdd9f4 8551 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
29cbe68c 8552 /* and parse parameters if given */
24bdd9f4 8553 err = nl80211_parse_mesh_config(info, &cfg, NULL);
29cbe68c
JB		 8554 if (err)
8555 return err;
8556 }
8557
8558 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
8559 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
8560 return -EINVAL;
8561
c80d545d
JC		 8562 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
8563 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
8564
4bb62344
CYY		 8565 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8566 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
8567 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8568 return -EINVAL;
8569
9bdbf04d
MP		 8570 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
8571 setup.beacon_interval =
8572 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
8573 if (setup.beacon_interval < 10 ||
8574 setup.beacon_interval > 10000)
8575 return -EINVAL;
8576 }
8577
8578 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
8579 setup.dtim_period =
8580 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
8581 if (setup.dtim_period < 1 || setup.dtim_period > 100)
8582 return -EINVAL;
8583 }
8584
c80d545d
JC		 8585 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
8586 /* parse additional setup parameters if given */
8587 err = nl80211_parse_mesh_setup(info, &setup);
8588 if (err)
8589 return err;
8590 }
8591
d37bb18a
TP		 8592 if (setup.user_mpm)
8593 cfg.auto_open_plinks = false;
8594
cc1d2806 8595 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
683b6d3b
JB		 8596 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
8597 if (err)
8598 return err;
cc1d2806
JB		 8599 } else {
8600 /* cfg80211_join_mesh() will sort it out */
683b6d3b 8601 setup.chandef.chan = NULL;
cc1d2806
JB		 8602 }
8603
ffb3cf30
AN		 8604 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8605 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8606 int n_rates =
8607 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8608 struct ieee80211_supported_band *sband;
8609
8610 if (!setup.chandef.chan)
8611 return -EINVAL;
8612
8613 sband = rdev->wiphy.bands[setup.chandef.chan->band];
8614
8615 err = ieee80211_get_ratemask(sband, rates, n_rates,
8616 &setup.basic_rates);
8617 if (err)
8618 return err;
8619 }
8620
c80d545d 8621 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
29cbe68c
JB		 8622}
8623
8624static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
8625{
8626 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8627 struct net_device *dev = info->user_ptr[1];
8628
8629 return cfg80211_leave_mesh(rdev, dev);
8630}
8631
dfb89c56 8632#ifdef CONFIG_PM
bb92d199
AK		 8633static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
8634 struct cfg80211_registered_device *rdev)
8635{
6abb9cb9 8636 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
bb92d199
AK		 8637 struct nlattr *nl_pats, *nl_pat;
8638 int i, pat_len;
8639
6abb9cb9 8640 if (!wowlan->n_patterns)
bb92d199
AK		 8641 return 0;
8642
8643 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
8644 if (!nl_pats)
8645 return -ENOBUFS;
8646
6abb9cb9 8647 for (i = 0; i < wowlan->n_patterns; i++) {
bb92d199
AK		 8648 nl_pat = nla_nest_start(msg, i + 1);
8649 if (!nl_pat)
8650 return -ENOBUFS;
6abb9cb9 8651 pat_len = wowlan->patterns[i].pattern_len;
50ac6607 8652 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
6abb9cb9 8653 wowlan->patterns[i].mask) ||
50ac6607
AK		 8654 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
8655 wowlan->patterns[i].pattern) ||
8656 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
6abb9cb9 8657 wowlan->patterns[i].pkt_offset))
bb92d199
AK		 8658 return -ENOBUFS;
8659 nla_nest_end(msg, nl_pat);
8660 }
8661 nla_nest_end(msg, nl_pats);
8662
8663 return 0;
8664}
8665
2a0e047e
JB		 8666static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
8667 struct cfg80211_wowlan_tcp *tcp)
8668{
8669 struct nlattr *nl_tcp;
8670
8671 if (!tcp)
8672 return 0;
8673
8674 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
8675 if (!nl_tcp)
8676 return -ENOBUFS;
8677
8678 if (nla_put_be32(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
8679 nla_put_be32(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
8680 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
8681 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
8682 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
8683 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
8684 tcp->payload_len, tcp->payload) ||
8685 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
8686 tcp->data_interval) ||
8687 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
8688 tcp->wake_len, tcp->wake_data) ||
8689 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
8690 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
8691 return -ENOBUFS;
8692
8693 if (tcp->payload_seq.len &&
8694 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
8695 sizeof(tcp->payload_seq), &tcp->payload_seq))
8696 return -ENOBUFS;
8697
8698 if (tcp->payload_tok.len &&
8699 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
8700 sizeof(tcp->payload_tok) + tcp->tokens_size,
8701 &tcp->payload_tok))
8702 return -ENOBUFS;
8703
e248ad30
JB		 8704 nla_nest_end(msg, nl_tcp);
8705
2a0e047e
JB		 8706 return 0;
8707}
8708
ff1b6e69
JB		 8709static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
8710{
8711 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8712 struct sk_buff *msg;
8713 void *hdr;
2a0e047e 8714 u32 size = NLMSG_DEFAULT_SIZE;
ff1b6e69 8715
964dc9e2 8716 if (!rdev->wiphy.wowlan)
ff1b6e69
JB		 8717 return -EOPNOTSUPP;
8718
6abb9cb9 8719 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
2a0e047e 8720 /* adjust size to have room for all the data */
6abb9cb9
JB		 8721 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
8722 rdev->wiphy.wowlan_config->tcp->payload_len +
8723 rdev->wiphy.wowlan_config->tcp->wake_len +
8724 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
2a0e047e
JB		 8725 }
8726
8727 msg = nlmsg_new(size, GFP_KERNEL);
ff1b6e69
JB		 8728 if (!msg)
8729 return -ENOMEM;
8730
15e47304 8731 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
ff1b6e69
JB		 8732 NL80211_CMD_GET_WOWLAN);
8733 if (!hdr)
8734 goto nla_put_failure;
8735
6abb9cb9 8736 if (rdev->wiphy.wowlan_config) {
ff1b6e69
JB		 8737 struct nlattr *nl_wowlan;
8738
8739 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
8740 if (!nl_wowlan)
8741 goto nla_put_failure;
8742
6abb9cb9 8743 if ((rdev->wiphy.wowlan_config->any &&
9360ffd1 8744 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6abb9cb9 8745 (rdev->wiphy.wowlan_config->disconnect &&
9360ffd1 8746 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6abb9cb9 8747 (rdev->wiphy.wowlan_config->magic_pkt &&
9360ffd1 8748 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6abb9cb9 8749 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
9360ffd1 8750 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6abb9cb9 8751 (rdev->wiphy.wowlan_config->eap_identity_req &&
9360ffd1 8752 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6abb9cb9 8753 (rdev->wiphy.wowlan_config->four_way_handshake &&
9360ffd1 8754 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6abb9cb9 8755 (rdev->wiphy.wowlan_config->rfkill_release &&
9360ffd1
DM		 8756 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
8757 goto nla_put_failure;
2a0e047e 8758
bb92d199
AK		 8759 if (nl80211_send_wowlan_patterns(msg, rdev))
8760 goto nla_put_failure;
2a0e047e 8761
6abb9cb9
JB		 8762 if (nl80211_send_wowlan_tcp(msg,
8763 rdev->wiphy.wowlan_config->tcp))
2a0e047e
JB		 8764 goto nla_put_failure;
8765
ff1b6e69
JB		 8766 nla_nest_end(msg, nl_wowlan);
8767 }
8768
8769 genlmsg_end(msg, hdr);
8770 return genlmsg_reply(msg, info);
8771
8772nla_put_failure:
8773 nlmsg_free(msg);
8774 return -ENOBUFS;
8775}
8776
2a0e047e
JB		 8777static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
8778 struct nlattr *attr,
8779 struct cfg80211_wowlan *trig)
8780{
8781 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
8782 struct cfg80211_wowlan_tcp *cfg;
8783 struct nl80211_wowlan_tcp_data_token *tok = NULL;
8784 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
8785 u32 size;
8786 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
8787 int err, port;
8788
964dc9e2 8789 if (!rdev->wiphy.wowlan->tcp)
2a0e047e
JB		 8790 return -EINVAL;
8791
8792 err = nla_parse(tb, MAX_NL80211_WOWLAN_TCP,
8793 nla_data(attr), nla_len(attr),
8794 nl80211_wowlan_tcp_policy);
8795 if (err)
8796 return err;
8797
8798 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
8799 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
8800 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
8801 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
8802 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
8803 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
8804 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
8805 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
8806 return -EINVAL;
8807
8808 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
964dc9e2 8809 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
2a0e047e
JB		 8810 return -EINVAL;
8811
8812 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
964dc9e2 8813 rdev->wiphy.wowlan->tcp->data_interval_max ||
723d568a 8814 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
2a0e047e
JB		 8815 return -EINVAL;
8816
8817 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
964dc9e2 8818 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
2a0e047e
JB		 8819 return -EINVAL;
8820
8821 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
8822 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
8823 return -EINVAL;
8824
8825 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
8826 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
8827
8828 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
8829 tokens_size = tokln - sizeof(*tok);
8830
8831 if (!tok->len || tokens_size % tok->len)
8832 return -EINVAL;
964dc9e2 8833 if (!rdev->wiphy.wowlan->tcp->tok)
2a0e047e 8834 return -EINVAL;
964dc9e2 8835 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
2a0e047e 8836 return -EINVAL;
964dc9e2 8837 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
2a0e047e 8838 return -EINVAL;
964dc9e2 8839 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
2a0e047e
JB		 8840 return -EINVAL;
8841 if (tok->offset + tok->len > data_size)
8842 return -EINVAL;
8843 }
8844
8845 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
8846 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
964dc9e2 8847 if (!rdev->wiphy.wowlan->tcp->seq)
2a0e047e
JB		 8848 return -EINVAL;
8849 if (seq->len == 0 || seq->len > 4)
8850 return -EINVAL;
8851 if (seq->len + seq->offset > data_size)
8852 return -EINVAL;
8853 }
8854
8855 size = sizeof(*cfg);
8856 size += data_size;
8857 size += wake_size + wake_mask_size;
8858 size += tokens_size;
8859
8860 cfg = kzalloc(size, GFP_KERNEL);
8861 if (!cfg)
8862 return -ENOMEM;
8863 cfg->src = nla_get_be32(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
8864 cfg->dst = nla_get_be32(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
8865 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
8866 ETH_ALEN);
8867 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
8868 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
8869 else
8870 port = 0;
8871#ifdef CONFIG_INET
8872 /* allocate a socket and port for it and use it */
8873 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
8874 IPPROTO_TCP, &cfg->sock, 1);
8875 if (err) {
8876 kfree(cfg);
8877 return err;
8878 }
8879 if (inet_csk_get_port(cfg->sock->sk, port)) {
8880 sock_release(cfg->sock);
8881 kfree(cfg);
8882 return -EADDRINUSE;
8883 }
8884 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
8885#else
8886 if (!port) {
8887 kfree(cfg);
8888 return -EINVAL;
8889 }
8890 cfg->src_port = port;
8891#endif
8892
8893 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
8894 cfg->payload_len = data_size;
8895 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
8896 memcpy((void *)cfg->payload,
8897 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
8898 data_size);
8899 if (seq)
8900 cfg->payload_seq = *seq;
8901 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
8902 cfg->wake_len = wake_size;
8903 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
8904 memcpy((void *)cfg->wake_data,
8905 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
8906 wake_size);
8907 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
8908 data_size + wake_size;
8909 memcpy((void *)cfg->wake_mask,
8910 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
8911 wake_mask_size);
8912 if (tok) {
8913 cfg->tokens_size = tokens_size;
8914 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
8915 }
8916
8917 trig->tcp = cfg;
8918
8919 return 0;
8920}
8921
8cd4d456
LC		 8922static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
8923 const struct wiphy_wowlan_support *wowlan,
8924 struct nlattr *attr,
8925 struct cfg80211_wowlan *trig)
8926{
8927 struct nlattr **tb;
8928 int err;
8929
8930 tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL);
8931 if (!tb)
8932 return -ENOMEM;
8933
8934 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
8935 err = -EOPNOTSUPP;
8936 goto out;
8937 }
8938
8939 err = nla_parse(tb, NL80211_ATTR_MAX,
8940 nla_data(attr), nla_len(attr),
8941 nl80211_policy);
8942 if (err)
8943 goto out;
8944
ad2b26ab 8945 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb);
8cd4d456
LC		 8946 err = PTR_ERR_OR_ZERO(trig->nd_config);
8947 if (err)
8948 trig->nd_config = NULL;
8949
8950out:
8951 kfree(tb);
8952 return err;
8953}
8954
ff1b6e69
JB		 8955static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
8956{
8957 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8958 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
ff1b6e69 8959 struct cfg80211_wowlan new_triggers = {};
ae33bd81 8960 struct cfg80211_wowlan *ntrig;
964dc9e2 8961 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
ff1b6e69 8962 int err, i;
6abb9cb9 8963 bool prev_enabled = rdev->wiphy.wowlan_config;
ff1b6e69 8964
964dc9e2 8965 if (!wowlan)
ff1b6e69
JB		 8966 return -EOPNOTSUPP;
8967
ae33bd81
JB		 8968 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
8969 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 8970 rdev->wiphy.wowlan_config = NULL;
ae33bd81
JB		 8971 goto set_wakeup;
8972 }
ff1b6e69
JB		 8973
8974 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
8975 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
8976 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
8977 nl80211_wowlan_policy);
8978 if (err)
8979 return err;
8980
8981 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
8982 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
8983 return -EINVAL;
8984 new_triggers.any = true;
8985 }
8986
8987 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
8988 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
8989 return -EINVAL;
8990 new_triggers.disconnect = true;
8991 }
8992
8993 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
8994 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
8995 return -EINVAL;
8996 new_triggers.magic_pkt = true;
8997 }
8998
77dbbb13
JB		 8999 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
9000 return -EINVAL;
9001
9002 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
9003 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
9004 return -EINVAL;
9005 new_triggers.gtk_rekey_failure = true;
9006 }
9007
9008 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
9009 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
9010 return -EINVAL;
9011 new_triggers.eap_identity_req = true;
9012 }
9013
9014 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
9015 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
9016 return -EINVAL;
9017 new_triggers.four_way_handshake = true;
9018 }
9019
9020 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
9021 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
9022 return -EINVAL;
9023 new_triggers.rfkill_release = true;
9024 }
9025
ff1b6e69
JB		 9026 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
9027 struct nlattr *pat;
9028 int n_patterns = 0;
bb92d199 9029 int rem, pat_len, mask_len, pkt_offset;
50ac6607 9030 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
ff1b6e69
JB		 9031
9032 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
9033 rem)
9034 n_patterns++;
9035 if (n_patterns > wowlan->n_patterns)
9036 return -EINVAL;
9037
9038 new_triggers.patterns = kcalloc(n_patterns,
9039 sizeof(new_triggers.patterns[0]),
9040 GFP_KERNEL);
9041 if (!new_triggers.patterns)
9042 return -ENOMEM;
9043
9044 new_triggers.n_patterns = n_patterns;
9045 i = 0;
9046
9047 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
9048 rem) {
922bd80f
JB		 9049 u8 *mask_pat;
9050
50ac6607
AK		 9051 nla_parse(pat_tb, MAX_NL80211_PKTPAT, nla_data(pat),
9052 nla_len(pat), NULL);
ff1b6e69 9053 err = -EINVAL;
50ac6607
AK		 9054 if (!pat_tb[NL80211_PKTPAT_MASK] ||
9055 !pat_tb[NL80211_PKTPAT_PATTERN])
ff1b6e69 9056 goto error;
50ac6607 9057 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
ff1b6e69 9058 mask_len = DIV_ROUND_UP(pat_len, 8);
50ac6607 9059 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
ff1b6e69
JB		 9060 goto error;
9061 if (pat_len > wowlan->pattern_max_len ||
9062 pat_len < wowlan->pattern_min_len)
9063 goto error;
9064
50ac6607 9065 if (!pat_tb[NL80211_PKTPAT_OFFSET])
bb92d199
AK		 9066 pkt_offset = 0;
9067 else
9068 pkt_offset = nla_get_u32(
50ac6607 9069 pat_tb[NL80211_PKTPAT_OFFSET]);
bb92d199
AK		 9070 if (pkt_offset > wowlan->max_pkt_offset)
9071 goto error;
9072 new_triggers.patterns[i].pkt_offset = pkt_offset;
9073
922bd80f
JB		 9074 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
9075 if (!mask_pat) {
ff1b6e69
JB		 9076 err = -ENOMEM;
9077 goto error;
9078 }
922bd80f
JB		 9079 new_triggers.patterns[i].mask = mask_pat;
9080 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
ff1b6e69 9081 mask_len);
922bd80f
JB		 9082 mask_pat += mask_len;
9083 new_triggers.patterns[i].pattern = mask_pat;
ff1b6e69 9084 new_triggers.patterns[i].pattern_len = pat_len;
922bd80f 9085 memcpy(mask_pat,
50ac6607 9086 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
ff1b6e69
JB		 9087 pat_len);
9088 i++;
9089 }
9090 }
9091
2a0e047e
JB		 9092 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
9093 err = nl80211_parse_wowlan_tcp(
9094 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
9095 &new_triggers);
9096 if (err)
9097 goto error;
9098 }
9099
8cd4d456
LC		 9100 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
9101 err = nl80211_parse_wowlan_nd(
9102 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
9103 &new_triggers);
9104 if (err)
9105 goto error;
9106 }
9107
ae33bd81
JB		 9108 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
9109 if (!ntrig) {
9110 err = -ENOMEM;
9111 goto error;
ff1b6e69 9112 }
ae33bd81 9113 cfg80211_rdev_free_wowlan(rdev);
6abb9cb9 9114 rdev->wiphy.wowlan_config = ntrig;
ff1b6e69 9115
ae33bd81 9116 set_wakeup:
6abb9cb9
JB		 9117 if (rdev->ops->set_wakeup &&
9118 prev_enabled != !!rdev->wiphy.wowlan_config)
9119 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
6d52563f 9120
ff1b6e69
JB		 9121 return 0;
9122 error:
9123 for (i = 0; i < new_triggers.n_patterns; i++)
9124 kfree(new_triggers.patterns[i].mask);
9125 kfree(new_triggers.patterns);
2a0e047e
JB		 9126 if (new_triggers.tcp && new_triggers.tcp->sock)
9127 sock_release(new_triggers.tcp->sock);
9128 kfree(new_triggers.tcp);
ff1b6e69
JB		 9129 return err;
9130}
dfb89c56 9131#endif
ff1b6e69 9132
be29b99a
AK		 9133static int nl80211_send_coalesce_rules(struct sk_buff *msg,
9134 struct cfg80211_registered_device *rdev)
9135{
9136 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
9137 int i, j, pat_len;
9138 struct cfg80211_coalesce_rules *rule;
9139
9140 if (!rdev->coalesce->n_rules)
9141 return 0;
9142
9143 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
9144 if (!nl_rules)
9145 return -ENOBUFS;
9146
9147 for (i = 0; i < rdev->coalesce->n_rules; i++) {
9148 nl_rule = nla_nest_start(msg, i + 1);
9149 if (!nl_rule)
9150 return -ENOBUFS;
9151
9152 rule = &rdev->coalesce->rules[i];
9153 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
9154 rule->delay))
9155 return -ENOBUFS;
9156
9157 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
9158 rule->condition))
9159 return -ENOBUFS;
9160
9161 nl_pats = nla_nest_start(msg,
9162 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
9163 if (!nl_pats)
9164 return -ENOBUFS;
9165
9166 for (j = 0; j < rule->n_patterns; j++) {
9167 nl_pat = nla_nest_start(msg, j + 1);
9168 if (!nl_pat)
9169 return -ENOBUFS;
9170 pat_len = rule->patterns[j].pattern_len;
9171 if (nla_put(msg, NL80211_PKTPAT_MASK,
9172 DIV_ROUND_UP(pat_len, 8),
9173 rule->patterns[j].mask) ||
9174 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
9175 rule->patterns[j].pattern) ||
9176 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
9177 rule->patterns[j].pkt_offset))
9178 return -ENOBUFS;
9179 nla_nest_end(msg, nl_pat);
9180 }
9181 nla_nest_end(msg, nl_pats);
9182 nla_nest_end(msg, nl_rule);
9183 }
9184 nla_nest_end(msg, nl_rules);
9185
9186 return 0;
9187}
9188
9189static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
9190{
9191 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9192 struct sk_buff *msg;
9193 void *hdr;
9194
9195 if (!rdev->wiphy.coalesce)
9196 return -EOPNOTSUPP;
9197
9198 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9199 if (!msg)
9200 return -ENOMEM;
9201
9202 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9203 NL80211_CMD_GET_COALESCE);
9204 if (!hdr)
9205 goto nla_put_failure;
9206
9207 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
9208 goto nla_put_failure;
9209
9210 genlmsg_end(msg, hdr);
9211 return genlmsg_reply(msg, info);
9212
9213nla_put_failure:
9214 nlmsg_free(msg);
9215 return -ENOBUFS;
9216}
9217
9218void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
9219{
9220 struct cfg80211_coalesce *coalesce = rdev->coalesce;
9221 int i, j;
9222 struct cfg80211_coalesce_rules *rule;
9223
9224 if (!coalesce)
9225 return;
9226
9227 for (i = 0; i < coalesce->n_rules; i++) {
9228 rule = &coalesce->rules[i];
9229 for (j = 0; j < rule->n_patterns; j++)
9230 kfree(rule->patterns[j].mask);
9231 kfree(rule->patterns);
9232 }
9233 kfree(coalesce->rules);
9234 kfree(coalesce);
9235 rdev->coalesce = NULL;
9236}
9237
9238static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
9239 struct nlattr *rule,
9240 struct cfg80211_coalesce_rules *new_rule)
9241{
9242 int err, i;
9243 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
9244 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
9245 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
9246 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
9247
9248 err = nla_parse(tb, NL80211_ATTR_COALESCE_RULE_MAX, nla_data(rule),
9249 nla_len(rule), nl80211_coalesce_policy);
9250 if (err)
9251 return err;
9252
9253 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
9254 new_rule->delay =
9255 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
9256 if (new_rule->delay > coalesce->max_delay)
9257 return -EINVAL;
9258
9259 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
9260 new_rule->condition =
9261 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
9262 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
9263 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
9264 return -EINVAL;
9265
9266 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
9267 return -EINVAL;
9268
9269 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
9270 rem)
9271 n_patterns++;
9272 if (n_patterns > coalesce->n_patterns)
9273 return -EINVAL;
9274
9275 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
9276 GFP_KERNEL);
9277 if (!new_rule->patterns)
9278 return -ENOMEM;
9279
9280 new_rule->n_patterns = n_patterns;
9281 i = 0;
9282
9283 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
9284 rem) {
922bd80f
JB		 9285 u8 *mask_pat;
9286
be29b99a
AK		 9287 nla_parse(pat_tb, MAX_NL80211_PKTPAT, nla_data(pat),
9288 nla_len(pat), NULL);
9289 if (!pat_tb[NL80211_PKTPAT_MASK] ||
9290 !pat_tb[NL80211_PKTPAT_PATTERN])
9291 return -EINVAL;
9292 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
9293 mask_len = DIV_ROUND_UP(pat_len, 8);
9294 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
9295 return -EINVAL;
9296 if (pat_len > coalesce->pattern_max_len ||
9297 pat_len < coalesce->pattern_min_len)
9298 return -EINVAL;
9299
9300 if (!pat_tb[NL80211_PKTPAT_OFFSET])
9301 pkt_offset = 0;
9302 else
9303 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
9304 if (pkt_offset > coalesce->max_pkt_offset)
9305 return -EINVAL;
9306 new_rule->patterns[i].pkt_offset = pkt_offset;
9307
922bd80f
JB		 9308 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
9309 if (!mask_pat)
be29b99a 9310 return -ENOMEM;
922bd80f
JB		 9311
9312 new_rule->patterns[i].mask = mask_pat;
9313 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
9314 mask_len);
9315
9316 mask_pat += mask_len;
9317 new_rule->patterns[i].pattern = mask_pat;
be29b99a 9318 new_rule->patterns[i].pattern_len = pat_len;
922bd80f
JB		 9319 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
9320 pat_len);
be29b99a
AK		 9321 i++;
9322 }
9323
9324 return 0;
9325}
9326
9327static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
9328{
9329 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9330 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
9331 struct cfg80211_coalesce new_coalesce = {};
9332 struct cfg80211_coalesce *n_coalesce;
9333 int err, rem_rule, n_rules = 0, i, j;
9334 struct nlattr *rule;
9335 struct cfg80211_coalesce_rules *tmp_rule;
9336
9337 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
9338 return -EOPNOTSUPP;
9339
9340 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
9341 cfg80211_rdev_free_coalesce(rdev);
9342 rdev->ops->set_coalesce(&rdev->wiphy, NULL);
9343 return 0;
9344 }
9345
9346 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
9347 rem_rule)
9348 n_rules++;
9349 if (n_rules > coalesce->n_rules)
9350 return -EINVAL;
9351
9352 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
9353 GFP_KERNEL);
9354 if (!new_coalesce.rules)
9355 return -ENOMEM;
9356
9357 new_coalesce.n_rules = n_rules;
9358 i = 0;
9359
9360 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
9361 rem_rule) {
9362 err = nl80211_parse_coalesce_rule(rdev, rule,
9363 &new_coalesce.rules[i]);
9364 if (err)
9365 goto error;
9366
9367 i++;
9368 }
9369
9370 err = rdev->ops->set_coalesce(&rdev->wiphy, &new_coalesce);
9371 if (err)
9372 goto error;
9373
9374 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
9375 if (!n_coalesce) {
9376 err = -ENOMEM;
9377 goto error;
9378 }
9379 cfg80211_rdev_free_coalesce(rdev);
9380 rdev->coalesce = n_coalesce;
9381
9382 return 0;
9383error:
9384 for (i = 0; i < new_coalesce.n_rules; i++) {
9385 tmp_rule = &new_coalesce.rules[i];
9386 for (j = 0; j < tmp_rule->n_patterns; j++)
9387 kfree(tmp_rule->patterns[j].mask);
9388 kfree(tmp_rule->patterns);
9389 }
9390 kfree(new_coalesce.rules);
9391
9392 return err;
9393}
9394
e5497d76
JB		 9395static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
9396{
9397 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9398 struct net_device *dev = info->user_ptr[1];
9399 struct wireless_dev *wdev = dev->ieee80211_ptr;
9400 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
9401 struct cfg80211_gtk_rekey_data rekey_data;
9402 int err;
9403
9404 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
9405 return -EINVAL;
9406
9407 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
9408 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
9409 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
9410 nl80211_rekey_policy);
9411 if (err)
9412 return err;
9413
9414 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
9415 return -ERANGE;
9416 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
9417 return -ERANGE;
9418 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
9419 return -ERANGE;
9420
78f686ca
JB		 9421 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
9422 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
9423 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
e5497d76
JB		 9424
9425 wdev_lock(wdev);
9426 if (!wdev->current_bss) {
9427 err = -ENOTCONN;
9428 goto out;
9429 }
9430
9431 if (!rdev->ops->set_rekey_data) {
9432 err = -EOPNOTSUPP;
9433 goto out;
9434 }
9435
e35e4d28 9436 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
e5497d76
JB		 9437 out:
9438 wdev_unlock(wdev);
9439 return err;
9440}
9441
28946da7
JB		 9442static int nl80211_register_unexpected_frame(struct sk_buff *skb,
9443 struct genl_info *info)
9444{
9445 struct net_device *dev = info->user_ptr[1];
9446 struct wireless_dev *wdev = dev->ieee80211_ptr;
9447
9448 if (wdev->iftype != NL80211_IFTYPE_AP &&
9449 wdev->iftype != NL80211_IFTYPE_P2P_GO)
9450 return -EINVAL;
9451
15e47304 9452 if (wdev->ap_unexpected_nlportid)
28946da7
JB		 9453 return -EBUSY;
9454
15e47304 9455 wdev->ap_unexpected_nlportid = info->snd_portid;
28946da7
JB		 9456 return 0;
9457}
9458
7f6cf311
JB		 9459static int nl80211_probe_client(struct sk_buff *skb,
9460 struct genl_info *info)
9461{
9462 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9463 struct net_device *dev = info->user_ptr[1];
9464 struct wireless_dev *wdev = dev->ieee80211_ptr;
9465 struct sk_buff *msg;
9466 void *hdr;
9467 const u8 *addr;
9468 u64 cookie;
9469 int err;
9470
9471 if (wdev->iftype != NL80211_IFTYPE_AP &&
9472 wdev->iftype != NL80211_IFTYPE_P2P_GO)
9473 return -EOPNOTSUPP;
9474
9475 if (!info->attrs[NL80211_ATTR_MAC])
9476 return -EINVAL;
9477
9478 if (!rdev->ops->probe_client)
9479 return -EOPNOTSUPP;
9480
9481 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9482 if (!msg)
9483 return -ENOMEM;
9484
15e47304 9485 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7f6cf311 9486 NL80211_CMD_PROBE_CLIENT);
cb35fba3
DC		 9487 if (!hdr) {
9488 err = -ENOBUFS;
7f6cf311
JB		 9489 goto free_msg;
9490 }
9491
9492 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
9493
e35e4d28 9494 err = rdev_probe_client(rdev, dev, addr, &cookie);
7f6cf311
JB		 9495 if (err)
9496 goto free_msg;
9497
9360ffd1
DM		 9498 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
9499 goto nla_put_failure;
7f6cf311
JB		 9500
9501 genlmsg_end(msg, hdr);
9502
9503 return genlmsg_reply(msg, info);
9504
9505 nla_put_failure:
9506 err = -ENOBUFS;
9507 free_msg:
9508 nlmsg_free(msg);
9509 return err;
9510}
9511
5e760230
JB		 9512static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
9513{
9514 struct cfg80211_registered_device *rdev = info->user_ptr[0];
37c73b5f
BG		 9515 struct cfg80211_beacon_registration *reg, *nreg;
9516 int rv;
5e760230
JB		 9517
9518 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
9519 return -EOPNOTSUPP;
9520
37c73b5f
BG		 9521 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
9522 if (!nreg)
9523 return -ENOMEM;
9524
9525 /* First, check if already registered. */
9526 spin_lock_bh(&rdev->beacon_registrations_lock);
9527 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
9528 if (reg->nlportid == info->snd_portid) {
9529 rv = -EALREADY;
9530 goto out_err;
9531 }
9532 }
9533 /* Add it to the list */
9534 nreg->nlportid = info->snd_portid;
9535 list_add(&nreg->list, &rdev->beacon_registrations);
5e760230 9536
37c73b5f 9537 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 9538
9539 return 0;
37c73b5f
BG		 9540out_err:
9541 spin_unlock_bh(&rdev->beacon_registrations_lock);
9542 kfree(nreg);
9543 return rv;
5e760230
JB		 9544}
9545
98104fde
JB		 9546static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
9547{
9548 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9549 struct wireless_dev *wdev = info->user_ptr[1];
9550 int err;
9551
9552 if (!rdev->ops->start_p2p_device)
9553 return -EOPNOTSUPP;
9554
9555 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
9556 return -EOPNOTSUPP;
9557
9558 if (wdev->p2p_started)
9559 return 0;
9560
b6a55015
LC		 9561 if (rfkill_blocked(rdev->rfkill))
9562 return -ERFKILL;
98104fde 9563
eeb126e9 9564 err = rdev_start_p2p_device(rdev, wdev);
98104fde
JB		 9565 if (err)
9566 return err;
9567
9568 wdev->p2p_started = true;
98104fde 9569 rdev->opencount++;
98104fde
JB		 9570
9571 return 0;
9572}
9573
9574static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
9575{
9576 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9577 struct wireless_dev *wdev = info->user_ptr[1];
9578
9579 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
9580 return -EOPNOTSUPP;
9581
9582 if (!rdev->ops->stop_p2p_device)
9583 return -EOPNOTSUPP;
9584
f9f47529 9585 cfg80211_stop_p2p_device(rdev, wdev);
98104fde
JB		 9586
9587 return 0;
9588}
9589
3713b4e3
JB		 9590static int nl80211_get_protocol_features(struct sk_buff *skb,
9591 struct genl_info *info)
9592{
9593 void *hdr;
9594 struct sk_buff *msg;
9595
9596 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9597 if (!msg)
9598 return -ENOMEM;
9599
9600 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9601 NL80211_CMD_GET_PROTOCOL_FEATURES);
9602 if (!hdr)
9603 goto nla_put_failure;
9604
9605 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
9606 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
9607 goto nla_put_failure;
9608
9609 genlmsg_end(msg, hdr);
9610 return genlmsg_reply(msg, info);
9611
9612 nla_put_failure:
9613 kfree_skb(msg);
9614 return -ENOBUFS;
9615}
9616
355199e0
JM		 9617static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
9618{
9619 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9620 struct cfg80211_update_ft_ies_params ft_params;
9621 struct net_device *dev = info->user_ptr[1];
9622
9623 if (!rdev->ops->update_ft_ies)
9624 return -EOPNOTSUPP;
9625
9626 if (!info->attrs[NL80211_ATTR_MDID] ||
9627 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9628 return -EINVAL;
9629
9630 memset(&ft_params, 0, sizeof(ft_params));
9631 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
9632 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9633 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9634
9635 return rdev_update_ft_ies(rdev, dev, &ft_params);
9636}
9637
5de17984
AS		 9638static int nl80211_crit_protocol_start(struct sk_buff *skb,
9639 struct genl_info *info)
9640{
9641 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9642 struct wireless_dev *wdev = info->user_ptr[1];
9643 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
9644 u16 duration;
9645 int ret;
9646
9647 if (!rdev->ops->crit_proto_start)
9648 return -EOPNOTSUPP;
9649
9650 if (WARN_ON(!rdev->ops->crit_proto_stop))
9651 return -EINVAL;
9652
9653 if (rdev->crit_proto_nlportid)
9654 return -EBUSY;
9655
9656 /* determine protocol if provided */
9657 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
9658 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
9659
9660 if (proto >= NUM_NL80211_CRIT_PROTO)
9661 return -EINVAL;
9662
9663 /* timeout must be provided */
9664 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
9665 return -EINVAL;
9666
9667 duration =
9668 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
9669
9670 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
9671 return -ERANGE;
9672
9673 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
9674 if (!ret)
9675 rdev->crit_proto_nlportid = info->snd_portid;
9676
9677 return ret;
9678}
9679
9680static int nl80211_crit_protocol_stop(struct sk_buff *skb,
9681 struct genl_info *info)
9682{
9683 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9684 struct wireless_dev *wdev = info->user_ptr[1];
9685
9686 if (!rdev->ops->crit_proto_stop)
9687 return -EOPNOTSUPP;
9688
9689 if (rdev->crit_proto_nlportid) {
9690 rdev->crit_proto_nlportid = 0;
9691 rdev_crit_proto_stop(rdev, wdev);
9692 }
9693 return 0;
9694}
9695
ad7e718c
JB		 9696static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
9697{
9698 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9699 struct wireless_dev *wdev =
9700 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
9701 int i, err;
9702 u32 vid, subcmd;
9703
9704 if (!rdev->wiphy.vendor_commands)
9705 return -EOPNOTSUPP;
9706
9707 if (IS_ERR(wdev)) {
9708 err = PTR_ERR(wdev);
9709 if (err != -EINVAL)
9710 return err;
9711 wdev = NULL;
9712 } else if (wdev->wiphy != &rdev->wiphy) {
9713 return -EINVAL;
9714 }
9715
9716 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
9717 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
9718 return -EINVAL;
9719
9720 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
9721 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
9722 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
9723 const struct wiphy_vendor_command *vcmd;
9724 void *data = NULL;
9725 int len = 0;
9726
9727 vcmd = &rdev->wiphy.vendor_commands[i];
9728
9729 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
9730 continue;
9731
9732 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
9733 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
9734 if (!wdev)
9735 return -EINVAL;
9736 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
9737 !wdev->netdev)
9738 return -EINVAL;
9739
9740 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
9741 if (wdev->netdev &&
9742 !netif_running(wdev->netdev))
9743 return -ENETDOWN;
9744 if (!wdev->netdev && !wdev->p2p_started)
9745 return -ENETDOWN;
9746 }
9747 } else {
9748 wdev = NULL;
9749 }
9750
9751 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
9752 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
9753 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
9754 }
9755
9756 rdev->cur_cmd_info = info;
9757 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
9758 data, len);
9759 rdev->cur_cmd_info = NULL;
9760 return err;
9761 }
9762
9763 return -EOPNOTSUPP;
9764}
9765
9766struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
9767 enum nl80211_commands cmd,
9768 enum nl80211_attrs attr,
9769 int approxlen)
9770{
f26cbf40 9771 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ad7e718c
JB		 9772
9773 if (WARN_ON(!rdev->cur_cmd_info))
9774 return NULL;
9775
9776 return __cfg80211_alloc_vendor_skb(rdev, approxlen,
9777 rdev->cur_cmd_info->snd_portid,
9778 rdev->cur_cmd_info->snd_seq,
567ffc35 9779 cmd, attr, NULL, GFP_KERNEL);
ad7e718c
JB		 9780}
9781EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
9782
9783int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
9784{
9785 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
9786 void *hdr = ((void **)skb->cb)[1];
9787 struct nlattr *data = ((void **)skb->cb)[2];
9788
bd8c78e7
JB		 9789 /* clear CB data for netlink core to own from now on */
9790 memset(skb->cb, 0, sizeof(skb->cb));
9791
ad7e718c
JB		 9792 if (WARN_ON(!rdev->cur_cmd_info)) {
9793 kfree_skb(skb);
9794 return -EINVAL;
9795 }
9796
9797 nla_nest_end(skb, data);
9798 genlmsg_end(skb, hdr);
9799 return genlmsg_reply(skb, rdev->cur_cmd_info);
9800}
9801EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
9802
9803
fa9ffc74
KP		 9804static int nl80211_set_qos_map(struct sk_buff *skb,
9805 struct genl_info *info)
9806{
9807 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9808 struct cfg80211_qos_map *qos_map = NULL;
9809 struct net_device *dev = info->user_ptr[1];
9810 u8 *pos, len, num_des, des_len, des;
9811 int ret;
9812
9813 if (!rdev->ops->set_qos_map)
9814 return -EOPNOTSUPP;
9815
9816 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
9817 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
9818 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
9819
9820 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
9821 len > IEEE80211_QOS_MAP_LEN_MAX)
9822 return -EINVAL;
9823
9824 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
9825 if (!qos_map)
9826 return -ENOMEM;
9827
9828 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
9829 if (num_des) {
9830 des_len = num_des *
9831 sizeof(struct cfg80211_dscp_exception);
9832 memcpy(qos_map->dscp_exception, pos, des_len);
9833 qos_map->num_des = num_des;
9834 for (des = 0; des < num_des; des++) {
9835 if (qos_map->dscp_exception[des].up > 7) {
9836 kfree(qos_map);
9837 return -EINVAL;
9838 }
9839 }
9840 pos += des_len;
9841 }
9842 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
9843 }
9844
9845 wdev_lock(dev->ieee80211_ptr);
9846 ret = nl80211_key_allowed(dev->ieee80211_ptr);
9847 if (!ret)
9848 ret = rdev_set_qos_map(rdev, dev, qos_map);
9849 wdev_unlock(dev->ieee80211_ptr);
9850
9851 kfree(qos_map);
9852 return ret;
9853}
9854
960d01ac
JB		 9855static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
9856{
9857 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9858 struct net_device *dev = info->user_ptr[1];
9859 struct wireless_dev *wdev = dev->ieee80211_ptr;
9860 const u8 *peer;
9861 u8 tsid, up;
9862 u16 admitted_time = 0;
9863 int err;
9864
723e73ac 9865 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
960d01ac
JB		 9866 return -EOPNOTSUPP;
9867
9868 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
9869 !info->attrs[NL80211_ATTR_USER_PRIO])
9870 return -EINVAL;
9871
9872 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
9873 if (tsid >= IEEE80211_NUM_TIDS)
9874 return -EINVAL;
9875
9876 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
9877 if (up >= IEEE80211_NUM_UPS)
9878 return -EINVAL;
9879
9880 /* WMM uses TIDs 0-7 even for TSPEC */
723e73ac 9881 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
960d01ac 9882 /* TODO: handle 802.11 TSPEC/admission control
723e73ac
JB		 9883 * need more attributes for that (e.g. BA session requirement);
9884 * change the WMM adminssion test above to allow both then
960d01ac
JB		 9885 */
9886 return -EINVAL;
9887 }
9888
9889 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9890
9891 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
9892 admitted_time =
9893 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
9894 if (!admitted_time)
9895 return -EINVAL;
9896 }
9897
9898 wdev_lock(wdev);
9899 switch (wdev->iftype) {
9900 case NL80211_IFTYPE_STATION:
9901 case NL80211_IFTYPE_P2P_CLIENT:
9902 if (wdev->current_bss)
9903 break;
9904 err = -ENOTCONN;
9905 goto out;
9906 default:
9907 err = -EOPNOTSUPP;
9908 goto out;
9909 }
9910
9911 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
9912
9913 out:
9914 wdev_unlock(wdev);
9915 return err;
9916}
9917
9918static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
9919{
9920 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9921 struct net_device *dev = info->user_ptr[1];
9922 struct wireless_dev *wdev = dev->ieee80211_ptr;
9923 const u8 *peer;
9924 u8 tsid;
9925 int err;
9926
9927 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
9928 return -EINVAL;
9929
9930 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
9931 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9932
9933 wdev_lock(wdev);
9934 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
9935 wdev_unlock(wdev);
9936
9937 return err;
9938}
9939
1057d35e
AN		 9940static int nl80211_tdls_channel_switch(struct sk_buff *skb,
9941 struct genl_info *info)
9942{
9943 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9944 struct net_device *dev = info->user_ptr[1];
9945 struct wireless_dev *wdev = dev->ieee80211_ptr;
9946 struct cfg80211_chan_def chandef = {};
9947 const u8 *addr;
9948 u8 oper_class;
9949 int err;
9950
9951 if (!rdev->ops->tdls_channel_switch ||
9952 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
9953 return -EOPNOTSUPP;
9954
9955 switch (dev->ieee80211_ptr->iftype) {
9956 case NL80211_IFTYPE_STATION:
9957 case NL80211_IFTYPE_P2P_CLIENT:
9958 break;
9959 default:
9960 return -EOPNOTSUPP;
9961 }
9962
9963 if (!info->attrs[NL80211_ATTR_MAC] ||
9964 !info->attrs[NL80211_ATTR_OPER_CLASS])
9965 return -EINVAL;
9966
9967 err = nl80211_parse_chandef(rdev, info, &chandef);
9968 if (err)
9969 return err;
9970
9971 /*
9972 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
9973 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
9974 * specification is not defined for them.
9975 */
9976 if (chandef.chan->band == IEEE80211_BAND_2GHZ &&
9977 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
9978 chandef.width != NL80211_CHAN_WIDTH_20)
9979 return -EINVAL;
9980
9981 /* we will be active on the TDLS link */
9982 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef, wdev->iftype))
9983 return -EINVAL;
9984
9985 /* don't allow switching to DFS channels */
9986 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
9987 return -EINVAL;
9988
9989 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
9990 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
9991
9992 wdev_lock(wdev);
9993 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
9994 wdev_unlock(wdev);
9995
9996 return err;
9997}
9998
9999static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
10000 struct genl_info *info)
10001{
10002 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10003 struct net_device *dev = info->user_ptr[1];
10004 struct wireless_dev *wdev = dev->ieee80211_ptr;
10005 const u8 *addr;
10006
10007 if (!rdev->ops->tdls_channel_switch ||
10008 !rdev->ops->tdls_cancel_channel_switch ||
10009 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
10010 return -EOPNOTSUPP;
10011
10012 switch (dev->ieee80211_ptr->iftype) {
10013 case NL80211_IFTYPE_STATION:
10014 case NL80211_IFTYPE_P2P_CLIENT:
10015 break;
10016 default:
10017 return -EOPNOTSUPP;
10018 }
10019
10020 if (!info->attrs[NL80211_ATTR_MAC])
10021 return -EINVAL;
10022
10023 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
10024
10025 wdev_lock(wdev);
10026 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
10027 wdev_unlock(wdev);
10028
10029 return 0;
10030}
10031
4c476991
JB		 10032#define NL80211_FLAG_NEED_WIPHY 0x01
10033#define NL80211_FLAG_NEED_NETDEV 0x02
10034#define NL80211_FLAG_NEED_RTNL 0x04
41265714
JB		 10035#define NL80211_FLAG_CHECK_NETDEV_UP 0x08
10036#define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
10037 NL80211_FLAG_CHECK_NETDEV_UP)
1bf614ef 10038#define NL80211_FLAG_NEED_WDEV 0x10
98104fde 10039/* If a netdev is associated, it must be UP, P2P must be started */
1bf614ef
JB		 10040#define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
10041 NL80211_FLAG_CHECK_NETDEV_UP)
5393b917 10042#define NL80211_FLAG_CLEAR_SKB 0x20
4c476991 10043
f84f771d 10044static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 10045 struct genl_info *info)
10046{
10047 struct cfg80211_registered_device *rdev;
89a54e48 10048 struct wireless_dev *wdev;
4c476991 10049 struct net_device *dev;
4c476991
JB		 10050 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
10051
10052 if (rtnl)
10053 rtnl_lock();
10054
10055 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
4f7eff10 10056 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
4c476991
JB		 10057 if (IS_ERR(rdev)) {
10058 if (rtnl)
10059 rtnl_unlock();
10060 return PTR_ERR(rdev);
10061 }
10062 info->user_ptr[0] = rdev;
1bf614ef
JB		 10063 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
10064 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
5fe231e8
JB		 10065 ASSERT_RTNL();
10066
89a54e48
JB		 10067 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
10068 info->attrs);
10069 if (IS_ERR(wdev)) {
4c476991
JB		 10070 if (rtnl)
10071 rtnl_unlock();
89a54e48 10072 return PTR_ERR(wdev);
4c476991 10073 }
89a54e48 10074
89a54e48 10075 dev = wdev->netdev;
f26cbf40 10076 rdev = wiphy_to_rdev(wdev->wiphy);
89a54e48 10077
1bf614ef
JB		 10078 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
10079 if (!dev) {
1bf614ef
JB		 10080 if (rtnl)
10081 rtnl_unlock();
10082 return -EINVAL;
10083 }
10084
10085 info->user_ptr[1] = dev;
10086 } else {
10087 info->user_ptr[1] = wdev;
41265714 10088 }
1bf614ef
JB		 10089
10090 if (dev) {
10091 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
10092 !netif_running(dev)) {
1bf614ef
JB		 10093 if (rtnl)
10094 rtnl_unlock();
10095 return -ENETDOWN;
10096 }
10097
10098 dev_hold(dev);
98104fde
JB		 10099 } else if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP) {
10100 if (!wdev->p2p_started) {
98104fde
JB		 10101 if (rtnl)
10102 rtnl_unlock();
10103 return -ENETDOWN;
10104 }
41265714 10105 }
89a54e48 10106
4c476991 10107 info->user_ptr[0] = rdev;
4c476991
JB		 10108 }
10109
10110 return 0;
10111}
10112
f84f771d 10113static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
4c476991
JB		 10114 struct genl_info *info)
10115{
1bf614ef
JB		 10116 if (info->user_ptr[1]) {
10117 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
10118 struct wireless_dev *wdev = info->user_ptr[1];
10119
10120 if (wdev->netdev)
10121 dev_put(wdev->netdev);
10122 } else {
10123 dev_put(info->user_ptr[1]);
10124 }
10125 }
5393b917 10126
4c476991
JB		 10127 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
10128 rtnl_unlock();
5393b917
JB		 10129
10130 /* If needed, clear the netlink message payload from the SKB
10131 * as it might contain key data that shouldn't stick around on
10132 * the heap after the SKB is freed. The netlink message header
10133 * is still needed for further processing, so leave it intact.
10134 */
10135 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
10136 struct nlmsghdr *nlh = nlmsg_hdr(skb);
10137
10138 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
10139 }
4c476991
JB		 10140}
10141
4534de83 10142static const struct genl_ops nl80211_ops[] = {
55682965
JB		 10143 {
10144 .cmd = NL80211_CMD_GET_WIPHY,
10145 .doit = nl80211_get_wiphy,
10146 .dumpit = nl80211_dump_wiphy,
86e8cf98 10147 .done = nl80211_dump_wiphy_done,
55682965
JB		 10148 .policy = nl80211_policy,
10149 /* can be retrieved by unprivileged users */
5fe231e8
JB		 10150 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10151 NL80211_FLAG_NEED_RTNL,
55682965
JB		 10152 },
10153 {
10154 .cmd = NL80211_CMD_SET_WIPHY,
10155 .doit = nl80211_set_wiphy,
10156 .policy = nl80211_policy,
10157 .flags = GENL_ADMIN_PERM,
4c476991 10158 .internal_flags = NL80211_FLAG_NEED_RTNL,
55682965
JB		 10159 },
10160 {
10161 .cmd = NL80211_CMD_GET_INTERFACE,
10162 .doit = nl80211_get_interface,
10163 .dumpit = nl80211_dump_interface,
10164 .policy = nl80211_policy,
10165 /* can be retrieved by unprivileged users */
5fe231e8
JB		 10166 .internal_flags = NL80211_FLAG_NEED_WDEV |
10167 NL80211_FLAG_NEED_RTNL,
55682965
JB		 10168 },
10169 {
10170 .cmd = NL80211_CMD_SET_INTERFACE,
10171 .doit = nl80211_set_interface,
10172 .policy = nl80211_policy,
10173 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10174 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10175 NL80211_FLAG_NEED_RTNL,
55682965
JB		 10176 },
10177 {
10178 .cmd = NL80211_CMD_NEW_INTERFACE,
10179 .doit = nl80211_new_interface,
10180 .policy = nl80211_policy,
10181 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10182 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10183 NL80211_FLAG_NEED_RTNL,
55682965
JB		 10184 },
10185 {
10186 .cmd = NL80211_CMD_DEL_INTERFACE,
10187 .doit = nl80211_del_interface,
10188 .policy = nl80211_policy,
41ade00f 10189 .flags = GENL_ADMIN_PERM,
84efbb84 10190 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 10191 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 10192 },
10193 {
10194 .cmd = NL80211_CMD_GET_KEY,
10195 .doit = nl80211_get_key,
10196 .policy = nl80211_policy,
10197 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10198 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10199 NL80211_FLAG_NEED_RTNL,
41ade00f
JB		 10200 },
10201 {
10202 .cmd = NL80211_CMD_SET_KEY,
10203 .doit = nl80211_set_key,
10204 .policy = nl80211_policy,
10205 .flags = GENL_ADMIN_PERM,
41265714 10206 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 10207 NL80211_FLAG_NEED_RTNL |
10208 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 10209 },
10210 {
10211 .cmd = NL80211_CMD_NEW_KEY,
10212 .doit = nl80211_new_key,
10213 .policy = nl80211_policy,
10214 .flags = GENL_ADMIN_PERM,
41265714 10215 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 10216 NL80211_FLAG_NEED_RTNL |
10217 NL80211_FLAG_CLEAR_SKB,
41ade00f
JB		 10218 },
10219 {
10220 .cmd = NL80211_CMD_DEL_KEY,
10221 .doit = nl80211_del_key,
10222 .policy = nl80211_policy,
55682965 10223 .flags = GENL_ADMIN_PERM,
41265714 10224 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10225 NL80211_FLAG_NEED_RTNL,
55682965 10226 },
ed1b6cc7
JB		 10227 {
10228 .cmd = NL80211_CMD_SET_BEACON,
10229 .policy = nl80211_policy,
10230 .flags = GENL_ADMIN_PERM,
8860020e 10231 .doit = nl80211_set_beacon,
2b5f8b0b 10232 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10233 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 10234 },
10235 {
8860020e 10236 .cmd = NL80211_CMD_START_AP,
ed1b6cc7
JB		 10237 .policy = nl80211_policy,
10238 .flags = GENL_ADMIN_PERM,
8860020e 10239 .doit = nl80211_start_ap,
2b5f8b0b 10240 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10241 NL80211_FLAG_NEED_RTNL,
ed1b6cc7
JB		 10242 },
10243 {
8860020e 10244 .cmd = NL80211_CMD_STOP_AP,
ed1b6cc7
JB		 10245 .policy = nl80211_policy,
10246 .flags = GENL_ADMIN_PERM,
8860020e 10247 .doit = nl80211_stop_ap,
2b5f8b0b 10248 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10249 NL80211_FLAG_NEED_RTNL,
ed1b6cc7 10250 },
5727ef1b
JB		 10251 {
10252 .cmd = NL80211_CMD_GET_STATION,
10253 .doit = nl80211_get_station,
2ec600d6 10254 .dumpit = nl80211_dump_station,
5727ef1b 10255 .policy = nl80211_policy,
4c476991
JB		 10256 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10257 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 10258 },
10259 {
10260 .cmd = NL80211_CMD_SET_STATION,
10261 .doit = nl80211_set_station,
10262 .policy = nl80211_policy,
10263 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10264 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10265 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 10266 },
10267 {
10268 .cmd = NL80211_CMD_NEW_STATION,
10269 .doit = nl80211_new_station,
10270 .policy = nl80211_policy,
10271 .flags = GENL_ADMIN_PERM,
41265714 10272 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10273 NL80211_FLAG_NEED_RTNL,
5727ef1b
JB		 10274 },
10275 {
10276 .cmd = NL80211_CMD_DEL_STATION,
10277 .doit = nl80211_del_station,
10278 .policy = nl80211_policy,
2ec600d6 10279 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10280 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10281 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 10282 },
10283 {
10284 .cmd = NL80211_CMD_GET_MPATH,
10285 .doit = nl80211_get_mpath,
10286 .dumpit = nl80211_dump_mpath,
10287 .policy = nl80211_policy,
10288 .flags = GENL_ADMIN_PERM,
41265714 10289 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10290 NL80211_FLAG_NEED_RTNL,
2ec600d6 10291 },
66be7d2b
HR		 10292 {
10293 .cmd = NL80211_CMD_GET_MPP,
10294 .doit = nl80211_get_mpp,
10295 .dumpit = nl80211_dump_mpp,
10296 .policy = nl80211_policy,
10297 .flags = GENL_ADMIN_PERM,
10298 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10299 NL80211_FLAG_NEED_RTNL,
10300 },
2ec600d6
LCC		 10301 {
10302 .cmd = NL80211_CMD_SET_MPATH,
10303 .doit = nl80211_set_mpath,
10304 .policy = nl80211_policy,
10305 .flags = GENL_ADMIN_PERM,
41265714 10306 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10307 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 10308 },
10309 {
10310 .cmd = NL80211_CMD_NEW_MPATH,
10311 .doit = nl80211_new_mpath,
10312 .policy = nl80211_policy,
10313 .flags = GENL_ADMIN_PERM,
41265714 10314 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10315 NL80211_FLAG_NEED_RTNL,
2ec600d6
LCC		 10316 },
10317 {
10318 .cmd = NL80211_CMD_DEL_MPATH,
10319 .doit = nl80211_del_mpath,
10320 .policy = nl80211_policy,
9f1ba906 10321 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10322 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10323 NL80211_FLAG_NEED_RTNL,
9f1ba906
JM		 10324 },
10325 {
10326 .cmd = NL80211_CMD_SET_BSS,
10327 .doit = nl80211_set_bss,
10328 .policy = nl80211_policy,
b2e1b302 10329 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10330 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10331 NL80211_FLAG_NEED_RTNL,
b2e1b302 10332 },
f130347c
LR		 10333 {
10334 .cmd = NL80211_CMD_GET_REG,
ad30ca2c
AN		 10335 .doit = nl80211_get_reg_do,
10336 .dumpit = nl80211_get_reg_dump,
f130347c 10337 .policy = nl80211_policy,
5fe231e8 10338 .internal_flags = NL80211_FLAG_NEED_RTNL,
f130347c
LR		 10339 /* can be retrieved by unprivileged users */
10340 },
b2e1b302
LR		 10341 {
10342 .cmd = NL80211_CMD_SET_REG,
10343 .doit = nl80211_set_reg,
10344 .policy = nl80211_policy,
10345 .flags = GENL_ADMIN_PERM,
5fe231e8 10346 .internal_flags = NL80211_FLAG_NEED_RTNL,
b2e1b302
LR		 10347 },
10348 {
10349 .cmd = NL80211_CMD_REQ_SET_REG,
10350 .doit = nl80211_req_set_reg,
10351 .policy = nl80211_policy,
93da9cc1 10352 .flags = GENL_ADMIN_PERM,
10353 },
10354 {
24bdd9f4
JC		 10355 .cmd = NL80211_CMD_GET_MESH_CONFIG,
10356 .doit = nl80211_get_mesh_config,
93da9cc1 10357 .policy = nl80211_policy,
10358 /* can be retrieved by unprivileged users */
2b5f8b0b 10359 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10360 NL80211_FLAG_NEED_RTNL,
93da9cc1 10361 },
10362 {
24bdd9f4
JC		 10363 .cmd = NL80211_CMD_SET_MESH_CONFIG,
10364 .doit = nl80211_update_mesh_config,
93da9cc1 10365 .policy = nl80211_policy,
9aed3cc1 10366 .flags = GENL_ADMIN_PERM,
29cbe68c 10367 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10368 NL80211_FLAG_NEED_RTNL,
9aed3cc1 10369 },
2a519311
JB		 10370 {
10371 .cmd = NL80211_CMD_TRIGGER_SCAN,
10372 .doit = nl80211_trigger_scan,
10373 .policy = nl80211_policy,
10374 .flags = GENL_ADMIN_PERM,
fd014284 10375 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 10376 NL80211_FLAG_NEED_RTNL,
2a519311
JB		 10377 },
10378 {
10379 .cmd = NL80211_CMD_GET_SCAN,
10380 .policy = nl80211_policy,
10381 .dumpit = nl80211_dump_scan,
10382 },
807f8a8c
LC		 10383 {
10384 .cmd = NL80211_CMD_START_SCHED_SCAN,
10385 .doit = nl80211_start_sched_scan,
10386 .policy = nl80211_policy,
10387 .flags = GENL_ADMIN_PERM,
10388 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10389 NL80211_FLAG_NEED_RTNL,
10390 },
10391 {
10392 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
10393 .doit = nl80211_stop_sched_scan,
10394 .policy = nl80211_policy,
10395 .flags = GENL_ADMIN_PERM,
10396 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10397 NL80211_FLAG_NEED_RTNL,
10398 },
636a5d36
JM		 10399 {
10400 .cmd = NL80211_CMD_AUTHENTICATE,
10401 .doit = nl80211_authenticate,
10402 .policy = nl80211_policy,
10403 .flags = GENL_ADMIN_PERM,
41265714 10404 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 10405 NL80211_FLAG_NEED_RTNL |
10406 NL80211_FLAG_CLEAR_SKB,
636a5d36
JM		 10407 },
10408 {
10409 .cmd = NL80211_CMD_ASSOCIATE,
10410 .doit = nl80211_associate,
10411 .policy = nl80211_policy,
10412 .flags = GENL_ADMIN_PERM,
41265714 10413 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10414 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 10415 },
10416 {
10417 .cmd = NL80211_CMD_DEAUTHENTICATE,
10418 .doit = nl80211_deauthenticate,
10419 .policy = nl80211_policy,
10420 .flags = GENL_ADMIN_PERM,
41265714 10421 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10422 NL80211_FLAG_NEED_RTNL,
636a5d36
JM		 10423 },
10424 {
10425 .cmd = NL80211_CMD_DISASSOCIATE,
10426 .doit = nl80211_disassociate,
10427 .policy = nl80211_policy,
10428 .flags = GENL_ADMIN_PERM,
41265714 10429 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10430 NL80211_FLAG_NEED_RTNL,
636a5d36 10431 },
04a773ad
JB		 10432 {
10433 .cmd = NL80211_CMD_JOIN_IBSS,
10434 .doit = nl80211_join_ibss,
10435 .policy = nl80211_policy,
10436 .flags = GENL_ADMIN_PERM,
41265714 10437 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10438 NL80211_FLAG_NEED_RTNL,
04a773ad
JB		 10439 },
10440 {
10441 .cmd = NL80211_CMD_LEAVE_IBSS,
10442 .doit = nl80211_leave_ibss,
10443 .policy = nl80211_policy,
10444 .flags = GENL_ADMIN_PERM,
41265714 10445 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10446 NL80211_FLAG_NEED_RTNL,
04a773ad 10447 },
aff89a9b
JB		 10448#ifdef CONFIG_NL80211_TESTMODE
10449 {
10450 .cmd = NL80211_CMD_TESTMODE,
10451 .doit = nl80211_testmode_do,
71063f0e 10452 .dumpit = nl80211_testmode_dump,
aff89a9b
JB		 10453 .policy = nl80211_policy,
10454 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10455 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10456 NL80211_FLAG_NEED_RTNL,
aff89a9b
JB		 10457 },
10458#endif
b23aa676
SO		 10459 {
10460 .cmd = NL80211_CMD_CONNECT,
10461 .doit = nl80211_connect,
10462 .policy = nl80211_policy,
10463 .flags = GENL_ADMIN_PERM,
41265714 10464 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10465 NL80211_FLAG_NEED_RTNL,
b23aa676
SO		 10466 },
10467 {
10468 .cmd = NL80211_CMD_DISCONNECT,
10469 .doit = nl80211_disconnect,
10470 .policy = nl80211_policy,
10471 .flags = GENL_ADMIN_PERM,
41265714 10472 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10473 NL80211_FLAG_NEED_RTNL,
b23aa676 10474 },
463d0183
JB		 10475 {
10476 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
10477 .doit = nl80211_wiphy_netns,
10478 .policy = nl80211_policy,
10479 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10480 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10481 NL80211_FLAG_NEED_RTNL,
463d0183 10482 },
61fa713c
HS		 10483 {
10484 .cmd = NL80211_CMD_GET_SURVEY,
10485 .policy = nl80211_policy,
10486 .dumpit = nl80211_dump_survey,
10487 },
67fbb16b
SO		 10488 {
10489 .cmd = NL80211_CMD_SET_PMKSA,
10490 .doit = nl80211_setdel_pmksa,
10491 .policy = nl80211_policy,
10492 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10493 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10494 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 10495 },
10496 {
10497 .cmd = NL80211_CMD_DEL_PMKSA,
10498 .doit = nl80211_setdel_pmksa,
10499 .policy = nl80211_policy,
10500 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10501 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10502 NL80211_FLAG_NEED_RTNL,
67fbb16b
SO		 10503 },
10504 {
10505 .cmd = NL80211_CMD_FLUSH_PMKSA,
10506 .doit = nl80211_flush_pmksa,
10507 .policy = nl80211_policy,
10508 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10509 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
4c476991 10510 NL80211_FLAG_NEED_RTNL,
67fbb16b 10511 },
9588bbd5
JM		 10512 {
10513 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
10514 .doit = nl80211_remain_on_channel,
10515 .policy = nl80211_policy,
10516 .flags = GENL_ADMIN_PERM,
71bbc994 10517 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 10518 NL80211_FLAG_NEED_RTNL,
9588bbd5
JM		 10519 },
10520 {
10521 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
10522 .doit = nl80211_cancel_remain_on_channel,
10523 .policy = nl80211_policy,
10524 .flags = GENL_ADMIN_PERM,
71bbc994 10525 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 10526 NL80211_FLAG_NEED_RTNL,
9588bbd5 10527 },
13ae75b1
JM		 10528 {
10529 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
10530 .doit = nl80211_set_tx_bitrate_mask,
10531 .policy = nl80211_policy,
10532 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10533 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10534 NL80211_FLAG_NEED_RTNL,
13ae75b1 10535 },
026331c4 10536 {
2e161f78
JB		 10537 .cmd = NL80211_CMD_REGISTER_FRAME,
10538 .doit = nl80211_register_mgmt,
026331c4
JM		 10539 .policy = nl80211_policy,
10540 .flags = GENL_ADMIN_PERM,
71bbc994 10541 .internal_flags = NL80211_FLAG_NEED_WDEV |
4c476991 10542 NL80211_FLAG_NEED_RTNL,
026331c4
JM		 10543 },
10544 {
2e161f78
JB		 10545 .cmd = NL80211_CMD_FRAME,
10546 .doit = nl80211_tx_mgmt,
026331c4 10547 .policy = nl80211_policy,
f7ca38df 10548 .flags = GENL_ADMIN_PERM,
71bbc994 10549 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
f7ca38df
JB		 10550 NL80211_FLAG_NEED_RTNL,
10551 },
10552 {
10553 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
10554 .doit = nl80211_tx_mgmt_cancel_wait,
10555 .policy = nl80211_policy,
026331c4 10556 .flags = GENL_ADMIN_PERM,
71bbc994 10557 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
4c476991 10558 NL80211_FLAG_NEED_RTNL,
026331c4 10559 },
ffb9eb3d
KV		 10560 {
10561 .cmd = NL80211_CMD_SET_POWER_SAVE,
10562 .doit = nl80211_set_power_save,
10563 .policy = nl80211_policy,
10564 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10565 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10566 NL80211_FLAG_NEED_RTNL,
ffb9eb3d
KV		 10567 },
10568 {
10569 .cmd = NL80211_CMD_GET_POWER_SAVE,
10570 .doit = nl80211_get_power_save,
10571 .policy = nl80211_policy,
10572 /* can be retrieved by unprivileged users */
4c476991
JB		 10573 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10574 NL80211_FLAG_NEED_RTNL,
ffb9eb3d 10575 },
d6dc1a38
JO		 10576 {
10577 .cmd = NL80211_CMD_SET_CQM,
10578 .doit = nl80211_set_cqm,
10579 .policy = nl80211_policy,
10580 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10581 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10582 NL80211_FLAG_NEED_RTNL,
d6dc1a38 10583 },
f444de05
JB		 10584 {
10585 .cmd = NL80211_CMD_SET_CHANNEL,
10586 .doit = nl80211_set_channel,
10587 .policy = nl80211_policy,
10588 .flags = GENL_ADMIN_PERM,
4c476991
JB		 10589 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10590 NL80211_FLAG_NEED_RTNL,
f444de05 10591 },
e8347eba
BJ		 10592 {
10593 .cmd = NL80211_CMD_SET_WDS_PEER,
10594 .doit = nl80211_set_wds_peer,
10595 .policy = nl80211_policy,
10596 .flags = GENL_ADMIN_PERM,
43b19952
JB		 10597 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10598 NL80211_FLAG_NEED_RTNL,
e8347eba 10599 },
29cbe68c
JB		 10600 {
10601 .cmd = NL80211_CMD_JOIN_MESH,
10602 .doit = nl80211_join_mesh,
10603 .policy = nl80211_policy,
10604 .flags = GENL_ADMIN_PERM,
10605 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10606 NL80211_FLAG_NEED_RTNL,
10607 },
10608 {
10609 .cmd = NL80211_CMD_LEAVE_MESH,
10610 .doit = nl80211_leave_mesh,
10611 .policy = nl80211_policy,
10612 .flags = GENL_ADMIN_PERM,
10613 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10614 NL80211_FLAG_NEED_RTNL,
10615 },
6e0bd6c3
RL		 10616 {
10617 .cmd = NL80211_CMD_JOIN_OCB,
10618 .doit = nl80211_join_ocb,
10619 .policy = nl80211_policy,
10620 .flags = GENL_ADMIN_PERM,
10621 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10622 NL80211_FLAG_NEED_RTNL,
10623 },
10624 {
10625 .cmd = NL80211_CMD_LEAVE_OCB,
10626 .doit = nl80211_leave_ocb,
10627 .policy = nl80211_policy,
10628 .flags = GENL_ADMIN_PERM,
10629 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10630 NL80211_FLAG_NEED_RTNL,
10631 },
dfb89c56 10632#ifdef CONFIG_PM
ff1b6e69
JB		 10633 {
10634 .cmd = NL80211_CMD_GET_WOWLAN,
10635 .doit = nl80211_get_wowlan,
10636 .policy = nl80211_policy,
10637 /* can be retrieved by unprivileged users */
10638 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10639 NL80211_FLAG_NEED_RTNL,
10640 },
10641 {
10642 .cmd = NL80211_CMD_SET_WOWLAN,
10643 .doit = nl80211_set_wowlan,
10644 .policy = nl80211_policy,
10645 .flags = GENL_ADMIN_PERM,
10646 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10647 NL80211_FLAG_NEED_RTNL,
10648 },
dfb89c56 10649#endif
e5497d76
JB		 10650 {
10651 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
10652 .doit = nl80211_set_rekey_data,
10653 .policy = nl80211_policy,
10654 .flags = GENL_ADMIN_PERM,
10655 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5393b917
JB		 10656 NL80211_FLAG_NEED_RTNL |
10657 NL80211_FLAG_CLEAR_SKB,
e5497d76 10658 },
109086ce
AN		 10659 {
10660 .cmd = NL80211_CMD_TDLS_MGMT,
10661 .doit = nl80211_tdls_mgmt,
10662 .policy = nl80211_policy,
10663 .flags = GENL_ADMIN_PERM,
10664 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10665 NL80211_FLAG_NEED_RTNL,
10666 },
10667 {
10668 .cmd = NL80211_CMD_TDLS_OPER,
10669 .doit = nl80211_tdls_oper,
10670 .policy = nl80211_policy,
10671 .flags = GENL_ADMIN_PERM,
10672 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10673 NL80211_FLAG_NEED_RTNL,
10674 },
28946da7
JB		 10675 {
10676 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
10677 .doit = nl80211_register_unexpected_frame,
10678 .policy = nl80211_policy,
10679 .flags = GENL_ADMIN_PERM,
10680 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10681 NL80211_FLAG_NEED_RTNL,
10682 },
7f6cf311
JB		 10683 {
10684 .cmd = NL80211_CMD_PROBE_CLIENT,
10685 .doit = nl80211_probe_client,
10686 .policy = nl80211_policy,
10687 .flags = GENL_ADMIN_PERM,
2b5f8b0b 10688 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7f6cf311
JB		 10689 NL80211_FLAG_NEED_RTNL,
10690 },
5e760230
JB		 10691 {
10692 .cmd = NL80211_CMD_REGISTER_BEACONS,
10693 .doit = nl80211_register_beacons,
10694 .policy = nl80211_policy,
10695 .flags = GENL_ADMIN_PERM,
10696 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10697 NL80211_FLAG_NEED_RTNL,
10698 },
1d9d9213
SW		 10699 {
10700 .cmd = NL80211_CMD_SET_NOACK_MAP,
10701 .doit = nl80211_set_noack_map,
10702 .policy = nl80211_policy,
10703 .flags = GENL_ADMIN_PERM,
10704 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10705 NL80211_FLAG_NEED_RTNL,
10706 },
98104fde
JB		 10707 {
10708 .cmd = NL80211_CMD_START_P2P_DEVICE,
10709 .doit = nl80211_start_p2p_device,
10710 .policy = nl80211_policy,
10711 .flags = GENL_ADMIN_PERM,
10712 .internal_flags = NL80211_FLAG_NEED_WDEV |
10713 NL80211_FLAG_NEED_RTNL,
10714 },
10715 {
10716 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
10717 .doit = nl80211_stop_p2p_device,
10718 .policy = nl80211_policy,
10719 .flags = GENL_ADMIN_PERM,
10720 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10721 NL80211_FLAG_NEED_RTNL,
10722 },
f4e583c8
AQ		 10723 {
10724 .cmd = NL80211_CMD_SET_MCAST_RATE,
10725 .doit = nl80211_set_mcast_rate,
77765eaf
VT		 10726 .policy = nl80211_policy,
10727 .flags = GENL_ADMIN_PERM,
10728 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10729 NL80211_FLAG_NEED_RTNL,
10730 },
10731 {
10732 .cmd = NL80211_CMD_SET_MAC_ACL,
10733 .doit = nl80211_set_mac_acl,
f4e583c8
AQ		 10734 .policy = nl80211_policy,
10735 .flags = GENL_ADMIN_PERM,
10736 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10737 NL80211_FLAG_NEED_RTNL,
10738 },
04f39047
SW		 10739 {
10740 .cmd = NL80211_CMD_RADAR_DETECT,
10741 .doit = nl80211_start_radar_detection,
10742 .policy = nl80211_policy,
10743 .flags = GENL_ADMIN_PERM,
10744 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10745 NL80211_FLAG_NEED_RTNL,
10746 },
3713b4e3
JB		 10747 {
10748 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
10749 .doit = nl80211_get_protocol_features,
10750 .policy = nl80211_policy,
10751 },
355199e0
JM		 10752 {
10753 .cmd = NL80211_CMD_UPDATE_FT_IES,
10754 .doit = nl80211_update_ft_ies,
10755 .policy = nl80211_policy,
10756 .flags = GENL_ADMIN_PERM,
10757 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10758 NL80211_FLAG_NEED_RTNL,
10759 },
5de17984
AS		 10760 {
10761 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
10762 .doit = nl80211_crit_protocol_start,
10763 .policy = nl80211_policy,
10764 .flags = GENL_ADMIN_PERM,
10765 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10766 NL80211_FLAG_NEED_RTNL,
10767 },
10768 {
10769 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
10770 .doit = nl80211_crit_protocol_stop,
10771 .policy = nl80211_policy,
10772 .flags = GENL_ADMIN_PERM,
10773 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10774 NL80211_FLAG_NEED_RTNL,
be29b99a
AK		 10775 },
10776 {
10777 .cmd = NL80211_CMD_GET_COALESCE,
10778 .doit = nl80211_get_coalesce,
10779 .policy = nl80211_policy,
10780 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10781 NL80211_FLAG_NEED_RTNL,
10782 },
10783 {
10784 .cmd = NL80211_CMD_SET_COALESCE,
10785 .doit = nl80211_set_coalesce,
10786 .policy = nl80211_policy,
10787 .flags = GENL_ADMIN_PERM,
10788 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10789 NL80211_FLAG_NEED_RTNL,
16ef1fe2
SW		 10790 },
10791 {
10792 .cmd = NL80211_CMD_CHANNEL_SWITCH,
10793 .doit = nl80211_channel_switch,
10794 .policy = nl80211_policy,
10795 .flags = GENL_ADMIN_PERM,
10796 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10797 NL80211_FLAG_NEED_RTNL,
10798 },
ad7e718c
JB		 10799 {
10800 .cmd = NL80211_CMD_VENDOR,
10801 .doit = nl80211_vendor_cmd,
10802 .policy = nl80211_policy,
10803 .flags = GENL_ADMIN_PERM,
10804 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10805 NL80211_FLAG_NEED_RTNL,
10806 },
fa9ffc74
KP		 10807 {
10808 .cmd = NL80211_CMD_SET_QOS_MAP,
10809 .doit = nl80211_set_qos_map,
10810 .policy = nl80211_policy,
10811 .flags = GENL_ADMIN_PERM,
10812 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10813 NL80211_FLAG_NEED_RTNL,
10814 },
960d01ac
JB		 10815 {
10816 .cmd = NL80211_CMD_ADD_TX_TS,
10817 .doit = nl80211_add_tx_ts,
10818 .policy = nl80211_policy,
10819 .flags = GENL_ADMIN_PERM,
10820 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10821 NL80211_FLAG_NEED_RTNL,
10822 },
10823 {
10824 .cmd = NL80211_CMD_DEL_TX_TS,
10825 .doit = nl80211_del_tx_ts,
10826 .policy = nl80211_policy,
10827 .flags = GENL_ADMIN_PERM,
10828 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10829 NL80211_FLAG_NEED_RTNL,
10830 },
1057d35e
AN		 10831 {
10832 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
10833 .doit = nl80211_tdls_channel_switch,
10834 .policy = nl80211_policy,
10835 .flags = GENL_ADMIN_PERM,
10836 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10837 NL80211_FLAG_NEED_RTNL,
10838 },
10839 {
10840 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
10841 .doit = nl80211_tdls_cancel_channel_switch,
10842 .policy = nl80211_policy,
10843 .flags = GENL_ADMIN_PERM,
10844 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10845 NL80211_FLAG_NEED_RTNL,
10846 },
55682965 10847};
9588bbd5 10848
55682965
JB		 10849/* notification functions */
10850
3bb20556
JB		 10851void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
10852 enum nl80211_commands cmd)
55682965
JB		 10853{
10854 struct sk_buff *msg;
86e8cf98 10855 struct nl80211_dump_wiphy_state state = {};
55682965 10856
3bb20556
JB		 10857 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
10858 cmd != NL80211_CMD_DEL_WIPHY);
10859
fd2120ca 10860 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 10861 if (!msg)
10862 return;
10863
3bb20556 10864 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
55682965
JB		 10865 nlmsg_free(msg);
10866 return;
10867 }
10868
68eb5503 10869 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 10870 NL80211_MCGRP_CONFIG, GFP_KERNEL);
55682965
JB		 10871}
10872
362a415d
JB		 10873static int nl80211_add_scan_req(struct sk_buff *msg,
10874 struct cfg80211_registered_device *rdev)
10875{
10876 struct cfg80211_scan_request *req = rdev->scan_req;
10877 struct nlattr *nest;
10878 int i;
10879
10880 if (WARN_ON(!req))
10881 return 0;
10882
10883 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
10884 if (!nest)
10885 goto nla_put_failure;
9360ffd1
DM		 10886 for (i = 0; i < req->n_ssids; i++) {
10887 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
10888 goto nla_put_failure;
10889 }
362a415d
JB		 10890 nla_nest_end(msg, nest);
10891
10892 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10893 if (!nest)
10894 goto nla_put_failure;
9360ffd1
DM		 10895 for (i = 0; i < req->n_channels; i++) {
10896 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10897 goto nla_put_failure;
10898 }
362a415d
JB		 10899 nla_nest_end(msg, nest);
10900
9360ffd1
DM		 10901 if (req->ie &&
10902 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
10903 goto nla_put_failure;
362a415d 10904
ae917c9f
JB		 10905 if (req->flags &&
10906 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
10907 goto nla_put_failure;
ed473771 10908
362a415d
JB		 10909 return 0;
10910 nla_put_failure:
10911 return -ENOBUFS;
10912}
10913
a538e2d5
JB		 10914static int nl80211_send_scan_msg(struct sk_buff *msg,
10915 struct cfg80211_registered_device *rdev,
fd014284 10916 struct wireless_dev *wdev,
15e47304 10917 u32 portid, u32 seq, int flags,
a538e2d5 10918 u32 cmd)
2a519311
JB		 10919{
10920 void *hdr;
10921
15e47304 10922 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2a519311
JB		 10923 if (!hdr)
10924 return -1;
10925
9360ffd1 10926 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
fd014284
JB		 10927 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10928 wdev->netdev->ifindex)) ||
10929 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
9360ffd1 10930 goto nla_put_failure;
2a519311 10931
362a415d
JB		 10932 /* ignore errors and send incomplete event anyway */
10933 nl80211_add_scan_req(msg, rdev);
2a519311
JB		 10934
10935 return genlmsg_end(msg, hdr);
10936
10937 nla_put_failure:
10938 genlmsg_cancel(msg, hdr);
10939 return -EMSGSIZE;
10940}
10941
807f8a8c
LC		 10942static int
10943nl80211_send_sched_scan_msg(struct sk_buff *msg,
10944 struct cfg80211_registered_device *rdev,
10945 struct net_device *netdev,
15e47304 10946 u32 portid, u32 seq, int flags, u32 cmd)
807f8a8c
LC		 10947{
10948 void *hdr;
10949
15e47304 10950 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
807f8a8c
LC		 10951 if (!hdr)
10952 return -1;
10953
9360ffd1
DM		 10954 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10955 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10956 goto nla_put_failure;
807f8a8c
LC		 10957
10958 return genlmsg_end(msg, hdr);
10959
10960 nla_put_failure:
10961 genlmsg_cancel(msg, hdr);
10962 return -EMSGSIZE;
10963}
10964
a538e2d5 10965void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
fd014284 10966 struct wireless_dev *wdev)
a538e2d5
JB		 10967{
10968 struct sk_buff *msg;
10969
58050fce 10970 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
a538e2d5
JB		 10971 if (!msg)
10972 return;
10973
fd014284 10974 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
a538e2d5
JB		 10975 NL80211_CMD_TRIGGER_SCAN) < 0) {
10976 nlmsg_free(msg);
10977 return;
10978 }
10979
68eb5503 10980 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 10981 NL80211_MCGRP_SCAN, GFP_KERNEL);
a538e2d5
JB		 10982}
10983
f9d15d16
JB		 10984struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
10985 struct wireless_dev *wdev, bool aborted)
2a519311
JB		 10986{
10987 struct sk_buff *msg;
10988
fd2120ca 10989 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311 10990 if (!msg)
f9d15d16 10991 return NULL;
2a519311 10992
fd014284 10993 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
f9d15d16
JB		 10994 aborted ? NL80211_CMD_SCAN_ABORTED :
10995 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311 10996 nlmsg_free(msg);
f9d15d16 10997 return NULL;
2a519311
JB		 10998 }
10999
f9d15d16 11000 return msg;
2a519311
JB		 11001}
11002
f9d15d16
JB		 11003void nl80211_send_scan_result(struct cfg80211_registered_device *rdev,
11004 struct sk_buff *msg)
2a519311 11005{
2a519311
JB		 11006 if (!msg)
11007 return;
11008
68eb5503 11009 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11010 NL80211_MCGRP_SCAN, GFP_KERNEL);
2a519311
JB		 11011}
11012
807f8a8c
LC		 11013void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
11014 struct net_device *netdev)
11015{
11016 struct sk_buff *msg;
11017
11018 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11019 if (!msg)
11020 return;
11021
11022 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
11023 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
11024 nlmsg_free(msg);
11025 return;
11026 }
11027
68eb5503 11028 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11029 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 11030}
11031
11032void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
11033 struct net_device *netdev, u32 cmd)
11034{
11035 struct sk_buff *msg;
11036
58050fce 11037 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
807f8a8c
LC		 11038 if (!msg)
11039 return;
11040
11041 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
11042 nlmsg_free(msg);
11043 return;
11044 }
11045
68eb5503 11046 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11047 NL80211_MCGRP_SCAN, GFP_KERNEL);
807f8a8c
LC		 11048}
11049
b0d7aa59
JD		 11050static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
11051 struct regulatory_request *request)
73d54c9e 11052{
73d54c9e 11053 /* Userspace can always count this one always being set */
9360ffd1
DM		 11054 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
11055 goto nla_put_failure;
11056
11057 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
11058 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
11059 NL80211_REGDOM_TYPE_WORLD))
11060 goto nla_put_failure;
11061 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
11062 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
11063 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
11064 goto nla_put_failure;
11065 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
11066 request->intersect) {
11067 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
11068 NL80211_REGDOM_TYPE_INTERSECTION))
11069 goto nla_put_failure;
11070 } else {
11071 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
11072 NL80211_REGDOM_TYPE_COUNTRY) ||
11073 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
11074 request->alpha2))
11075 goto nla_put_failure;
11076 }
11077
ad30ca2c
AN		 11078 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
11079 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
11080
11081 if (wiphy &&
11082 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
11083 goto nla_put_failure;
1bdd716c
AN		 11084
11085 if (wiphy &&
11086 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
11087 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
11088 goto nla_put_failure;
ad30ca2c 11089 }
73d54c9e 11090
b0d7aa59
JD		 11091 return true;
11092
11093nla_put_failure:
11094 return false;
11095}
11096
11097/*
11098 * This can happen on global regulatory changes or device specific settings
11099 * based on custom regulatory domains.
11100 */
11101void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
11102 struct regulatory_request *request)
11103{
11104 struct sk_buff *msg;
11105 void *hdr;
11106
11107 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11108 if (!msg)
11109 return;
11110
11111 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
11112 if (!hdr) {
11113 nlmsg_free(msg);
11114 return;
11115 }
11116
11117 if (nl80211_reg_change_event_fill(msg, request) == false)
11118 goto nla_put_failure;
11119
3b7b72ee 11120 genlmsg_end(msg, hdr);
73d54c9e 11121
bc43b28c 11122 rcu_read_lock();
68eb5503 11123 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 11124 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
bc43b28c 11125 rcu_read_unlock();
73d54c9e
LR		 11126
11127 return;
11128
11129nla_put_failure:
11130 genlmsg_cancel(msg, hdr);
11131 nlmsg_free(msg);
11132}
11133
6039f6d2
JM		 11134static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
11135 struct net_device *netdev,
11136 const u8 *buf, size_t len,
b0b6aa2c
EP		 11137 enum nl80211_commands cmd, gfp_t gfp,
11138 int uapsd_queues)
6039f6d2
JM		 11139{
11140 struct sk_buff *msg;
11141 void *hdr;
11142
e6d6e342 11143 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
6039f6d2
JM		 11144 if (!msg)
11145 return;
11146
11147 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
11148 if (!hdr) {
11149 nlmsg_free(msg);
11150 return;
11151 }
11152
9360ffd1
DM		 11153 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11154 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11155 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
11156 goto nla_put_failure;
6039f6d2 11157
b0b6aa2c
EP		 11158 if (uapsd_queues >= 0) {
11159 struct nlattr *nla_wmm =
11160 nla_nest_start(msg, NL80211_ATTR_STA_WME);
11161 if (!nla_wmm)
11162 goto nla_put_failure;
11163
11164 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
11165 uapsd_queues))
11166 goto nla_put_failure;
11167
11168 nla_nest_end(msg, nla_wmm);
11169 }
11170
3b7b72ee 11171 genlmsg_end(msg, hdr);
6039f6d2 11172
68eb5503 11173 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11174 NL80211_MCGRP_MLME, gfp);
6039f6d2
JM		 11175 return;
11176
11177 nla_put_failure:
11178 genlmsg_cancel(msg, hdr);
11179 nlmsg_free(msg);
11180}
11181
11182void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 11183 struct net_device *netdev, const u8 *buf,
11184 size_t len, gfp_t gfp)
6039f6d2
JM		 11185{
11186 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 11187 NL80211_CMD_AUTHENTICATE, gfp, -1);
6039f6d2
JM		 11188}
11189
11190void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
11191 struct net_device *netdev, const u8 *buf,
b0b6aa2c 11192 size_t len, gfp_t gfp, int uapsd_queues)
6039f6d2 11193{
e6d6e342 11194 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 11195 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
6039f6d2
JM		 11196}
11197
53b46b84 11198void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 11199 struct net_device *netdev, const u8 *buf,
11200 size_t len, gfp_t gfp)
6039f6d2
JM		 11201{
11202 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 11203 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
6039f6d2
JM		 11204}
11205
53b46b84
JM		 11206void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
11207 struct net_device *netdev, const u8 *buf,
e6d6e342 11208 size_t len, gfp_t gfp)
6039f6d2
JM		 11209{
11210 nl80211_send_mlme_event(rdev, netdev, buf, len,
b0b6aa2c 11211 NL80211_CMD_DISASSOCIATE, gfp, -1);
6039f6d2
JM		 11212}
11213
6ff57cf8
JB		 11214void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
11215 size_t len)
cf4e594e 11216{
947add36
JB		 11217 struct wireless_dev *wdev = dev->ieee80211_ptr;
11218 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 11219 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
6ff57cf8
JB		 11220 const struct ieee80211_mgmt *mgmt = (void *)buf;
11221 u32 cmd;
947add36 11222
6ff57cf8
JB		 11223 if (WARN_ON(len < 2))
11224 return;
cf4e594e 11225
6ff57cf8
JB		 11226 if (ieee80211_is_deauth(mgmt->frame_control))
11227 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
11228 else
11229 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
947add36 11230
6ff57cf8 11231 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
b0b6aa2c 11232 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
cf4e594e 11233}
6ff57cf8 11234EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
cf4e594e 11235
1b06bb40
LR		 11236static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
11237 struct net_device *netdev, int cmd,
e6d6e342 11238 const u8 *addr, gfp_t gfp)
1965c853
JM		 11239{
11240 struct sk_buff *msg;
11241 void *hdr;
11242
e6d6e342 11243 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 11244 if (!msg)
11245 return;
11246
11247 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
11248 if (!hdr) {
11249 nlmsg_free(msg);
11250 return;
11251 }
11252
9360ffd1
DM		 11253 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11254 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11255 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
11256 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
11257 goto nla_put_failure;
1965c853 11258
3b7b72ee 11259 genlmsg_end(msg, hdr);
1965c853 11260
68eb5503 11261 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11262 NL80211_MCGRP_MLME, gfp);
1965c853
JM		 11263 return;
11264
11265 nla_put_failure:
11266 genlmsg_cancel(msg, hdr);
11267 nlmsg_free(msg);
11268}
11269
11270void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 11271 struct net_device *netdev, const u8 *addr,
11272 gfp_t gfp)
1965c853
JM		 11273{
11274 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 11275 addr, gfp);
1965c853
JM		 11276}
11277
11278void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 11279 struct net_device *netdev, const u8 *addr,
11280 gfp_t gfp)
1965c853 11281{
e6d6e342
JB		 11282 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
11283 addr, gfp);
1965c853
JM		 11284}
11285
b23aa676
SO		 11286void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
11287 struct net_device *netdev, const u8 *bssid,
11288 const u8 *req_ie, size_t req_ie_len,
11289 const u8 *resp_ie, size_t resp_ie_len,
11290 u16 status, gfp_t gfp)
11291{
11292 struct sk_buff *msg;
11293 void *hdr;
11294
58050fce 11295 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
b23aa676
SO		 11296 if (!msg)
11297 return;
11298
11299 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
11300 if (!hdr) {
11301 nlmsg_free(msg);
11302 return;
11303 }
11304
9360ffd1
DM		 11305 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11306 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11307 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
11308 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
11309 (req_ie &&
11310 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
11311 (resp_ie &&
11312 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
11313 goto nla_put_failure;
b23aa676 11314
3b7b72ee 11315 genlmsg_end(msg, hdr);
b23aa676 11316
68eb5503 11317 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11318 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 11319 return;
11320
11321 nla_put_failure:
11322 genlmsg_cancel(msg, hdr);
11323 nlmsg_free(msg);
11324
11325}
11326
11327void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
11328 struct net_device *netdev, const u8 *bssid,
11329 const u8 *req_ie, size_t req_ie_len,
11330 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
11331{
11332 struct sk_buff *msg;
11333 void *hdr;
11334
58050fce 11335 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
b23aa676
SO		 11336 if (!msg)
11337 return;
11338
11339 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
11340 if (!hdr) {
11341 nlmsg_free(msg);
11342 return;
11343 }
11344
9360ffd1
DM		 11345 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11346 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11347 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
11348 (req_ie &&
11349 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
11350 (resp_ie &&
11351 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
11352 goto nla_put_failure;
b23aa676 11353
3b7b72ee 11354 genlmsg_end(msg, hdr);
b23aa676 11355
68eb5503 11356 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11357 NL80211_MCGRP_MLME, gfp);
b23aa676
SO		 11358 return;
11359
11360 nla_put_failure:
11361 genlmsg_cancel(msg, hdr);
11362 nlmsg_free(msg);
11363
11364}
11365
11366void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
11367 struct net_device *netdev, u16 reason,
667503dd 11368 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 11369{
11370 struct sk_buff *msg;
11371 void *hdr;
11372
58050fce 11373 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
b23aa676
SO		 11374 if (!msg)
11375 return;
11376
11377 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
11378 if (!hdr) {
11379 nlmsg_free(msg);
11380 return;
11381 }
11382
9360ffd1
DM		 11383 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11384 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11385 (from_ap && reason &&
11386 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
11387 (from_ap &&
11388 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
11389 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
11390 goto nla_put_failure;
b23aa676 11391
3b7b72ee 11392 genlmsg_end(msg, hdr);
b23aa676 11393
68eb5503 11394 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11395 NL80211_MCGRP_MLME, GFP_KERNEL);
b23aa676
SO		 11396 return;
11397
11398 nla_put_failure:
11399 genlmsg_cancel(msg, hdr);
11400 nlmsg_free(msg);
11401
11402}
11403
04a773ad
JB		 11404void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
11405 struct net_device *netdev, const u8 *bssid,
11406 gfp_t gfp)
11407{
11408 struct sk_buff *msg;
11409 void *hdr;
11410
fd2120ca 11411 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 11412 if (!msg)
11413 return;
11414
11415 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
11416 if (!hdr) {
11417 nlmsg_free(msg);
11418 return;
11419 }
11420
9360ffd1
DM		 11421 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11422 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11423 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
11424 goto nla_put_failure;
04a773ad 11425
3b7b72ee 11426 genlmsg_end(msg, hdr);
04a773ad 11427
68eb5503 11428 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11429 NL80211_MCGRP_MLME, gfp);
04a773ad
JB		 11430 return;
11431
11432 nla_put_failure:
11433 genlmsg_cancel(msg, hdr);
11434 nlmsg_free(msg);
11435}
11436
947add36
JB		 11437void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
11438 const u8* ie, u8 ie_len, gfp_t gfp)
c93b5e71 11439{
947add36 11440 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 11441 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
c93b5e71
JC		 11442 struct sk_buff *msg;
11443 void *hdr;
11444
947add36
JB		 11445 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
11446 return;
11447
11448 trace_cfg80211_notify_new_peer_candidate(dev, addr);
11449
c93b5e71
JC		 11450 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11451 if (!msg)
11452 return;
11453
11454 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
11455 if (!hdr) {
11456 nlmsg_free(msg);
11457 return;
11458 }
11459
9360ffd1 11460 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36
JB		 11461 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11462 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9360ffd1
DM		 11463 (ie_len && ie &&
11464 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
11465 goto nla_put_failure;
c93b5e71 11466
3b7b72ee 11467 genlmsg_end(msg, hdr);
c93b5e71 11468
68eb5503 11469 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11470 NL80211_MCGRP_MLME, gfp);
c93b5e71
JC		 11471 return;
11472
11473 nla_put_failure:
11474 genlmsg_cancel(msg, hdr);
11475 nlmsg_free(msg);
11476}
947add36 11477EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
c93b5e71 11478
a3b8b056
JM		 11479void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
11480 struct net_device *netdev, const u8 *addr,
11481 enum nl80211_key_type key_type, int key_id,
e6d6e342 11482 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 11483{
11484 struct sk_buff *msg;
11485 void *hdr;
11486
e6d6e342 11487 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 11488 if (!msg)
11489 return;
11490
11491 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
11492 if (!hdr) {
11493 nlmsg_free(msg);
11494 return;
11495 }
11496
9360ffd1
DM		 11497 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11498 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11499 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
11500 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
11501 (key_id != -1 &&
11502 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
11503 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
11504 goto nla_put_failure;
a3b8b056 11505
3b7b72ee 11506 genlmsg_end(msg, hdr);
a3b8b056 11507
68eb5503 11508 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11509 NL80211_MCGRP_MLME, gfp);
a3b8b056
JM		 11510 return;
11511
11512 nla_put_failure:
11513 genlmsg_cancel(msg, hdr);
11514 nlmsg_free(msg);
11515}
11516
6bad8766
LR		 11517void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
11518 struct ieee80211_channel *channel_before,
11519 struct ieee80211_channel *channel_after)
11520{
11521 struct sk_buff *msg;
11522 void *hdr;
11523 struct nlattr *nl_freq;
11524
fd2120ca 11525 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 11526 if (!msg)
11527 return;
11528
11529 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
11530 if (!hdr) {
11531 nlmsg_free(msg);
11532 return;
11533 }
11534
11535 /*
11536 * Since we are applying the beacon hint to a wiphy we know its
11537 * wiphy_idx is valid
11538 */
9360ffd1
DM		 11539 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
11540 goto nla_put_failure;
6bad8766
LR		 11541
11542 /* Before */
11543 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
11544 if (!nl_freq)
11545 goto nla_put_failure;
cdc89b97 11546 if (nl80211_msg_put_channel(msg, channel_before, false))
6bad8766
LR		 11547 goto nla_put_failure;
11548 nla_nest_end(msg, nl_freq);
11549
11550 /* After */
11551 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
11552 if (!nl_freq)
11553 goto nla_put_failure;
cdc89b97 11554 if (nl80211_msg_put_channel(msg, channel_after, false))
6bad8766
LR		 11555 goto nla_put_failure;
11556 nla_nest_end(msg, nl_freq);
11557
3b7b72ee 11558 genlmsg_end(msg, hdr);
6bad8766 11559
463d0183 11560 rcu_read_lock();
68eb5503 11561 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
2a94fe48 11562 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
463d0183 11563 rcu_read_unlock();
6bad8766
LR		 11564
11565 return;
11566
11567nla_put_failure:
11568 genlmsg_cancel(msg, hdr);
11569 nlmsg_free(msg);
11570}
11571
9588bbd5
JM		 11572static void nl80211_send_remain_on_chan_event(
11573 int cmd, struct cfg80211_registered_device *rdev,
71bbc994 11574 struct wireless_dev *wdev, u64 cookie,
9588bbd5 11575 struct ieee80211_channel *chan,
9588bbd5
JM		 11576 unsigned int duration, gfp_t gfp)
11577{
11578 struct sk_buff *msg;
11579 void *hdr;
11580
11581 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11582 if (!msg)
11583 return;
11584
11585 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
11586 if (!hdr) {
11587 nlmsg_free(msg);
11588 return;
11589 }
11590
9360ffd1 11591 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 11592 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11593 wdev->netdev->ifindex)) ||
00f53350 11594 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9360ffd1 11595 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
42d97a59
JB		 11596 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
11597 NL80211_CHAN_NO_HT) ||
9360ffd1
DM		 11598 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
11599 goto nla_put_failure;
9588bbd5 11600
9360ffd1
DM		 11601 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
11602 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
11603 goto nla_put_failure;
9588bbd5 11604
3b7b72ee 11605 genlmsg_end(msg, hdr);
9588bbd5 11606
68eb5503 11607 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11608 NL80211_MCGRP_MLME, gfp);
9588bbd5
JM		 11609 return;
11610
11611 nla_put_failure:
11612 genlmsg_cancel(msg, hdr);
11613 nlmsg_free(msg);
11614}
11615
947add36
JB		 11616void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
11617 struct ieee80211_channel *chan,
11618 unsigned int duration, gfp_t gfp)
9588bbd5 11619{
947add36 11620 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 11621 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 11622
11623 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9588bbd5 11624 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
71bbc994 11625 rdev, wdev, cookie, chan,
42d97a59 11626 duration, gfp);
9588bbd5 11627}
947add36 11628EXPORT_SYMBOL(cfg80211_ready_on_channel);
9588bbd5 11629
947add36
JB		 11630void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
11631 struct ieee80211_channel *chan,
11632 gfp_t gfp)
9588bbd5 11633{
947add36 11634 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 11635 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 11636
11637 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9588bbd5 11638 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
42d97a59 11639 rdev, wdev, cookie, chan, 0, gfp);
9588bbd5 11640}
947add36 11641EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9588bbd5 11642
947add36
JB		 11643void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
11644 struct station_info *sinfo, gfp_t gfp)
98b62183 11645{
947add36 11646 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 11647 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
98b62183
JB		 11648 struct sk_buff *msg;
11649
947add36
JB		 11650 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
11651
58050fce 11652 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
98b62183
JB		 11653 if (!msg)
11654 return;
11655
cf5ead82 11656 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
66266b3a 11657 rdev, dev, mac_addr, sinfo) < 0) {
98b62183
JB		 11658 nlmsg_free(msg);
11659 return;
11660 }
11661
68eb5503 11662 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11663 NL80211_MCGRP_MLME, gfp);
98b62183 11664}
947add36 11665EXPORT_SYMBOL(cfg80211_new_sta);
98b62183 11666
cf5ead82
JB		 11667void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
11668 struct station_info *sinfo, gfp_t gfp)
ec15e68b 11669{
947add36 11670 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 11671 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ec15e68b 11672 struct sk_buff *msg;
cf5ead82
JB		 11673 struct station_info empty_sinfo = {};
11674
11675 if (!sinfo)
11676 sinfo = &empty_sinfo;
ec15e68b 11677
947add36
JB		 11678 trace_cfg80211_del_sta(dev, mac_addr);
11679
58050fce 11680 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
ec15e68b
JM		 11681 if (!msg)
11682 return;
11683
cf5ead82
JB		 11684 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
11685 rdev, dev, mac_addr, sinfo)) {
ec15e68b
JM		 11686 nlmsg_free(msg);
11687 return;
11688 }
11689
68eb5503 11690 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11691 NL80211_MCGRP_MLME, gfp);
ec15e68b 11692}
cf5ead82 11693EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
ec15e68b 11694
947add36
JB		 11695void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
11696 enum nl80211_connect_failed_reason reason,
11697 gfp_t gfp)
ed44a951 11698{
947add36 11699 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
f26cbf40 11700 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
ed44a951
PP		 11701 struct sk_buff *msg;
11702 void *hdr;
11703
11704 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
11705 if (!msg)
11706 return;
11707
11708 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
11709 if (!hdr) {
11710 nlmsg_free(msg);
11711 return;
11712 }
11713
11714 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11715 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
11716 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
11717 goto nla_put_failure;
11718
11719 genlmsg_end(msg, hdr);
11720
68eb5503 11721 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11722 NL80211_MCGRP_MLME, gfp);
ed44a951
PP		 11723 return;
11724
11725 nla_put_failure:
11726 genlmsg_cancel(msg, hdr);
11727 nlmsg_free(msg);
11728}
947add36 11729EXPORT_SYMBOL(cfg80211_conn_failed);
ed44a951 11730
b92ab5d8
JB		 11731static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
11732 const u8 *addr, gfp_t gfp)
28946da7
JB		 11733{
11734 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 11735 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
28946da7
JB		 11736 struct sk_buff *msg;
11737 void *hdr;
15e47304 11738 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
28946da7 11739
15e47304 11740 if (!nlportid)
28946da7
JB		 11741 return false;
11742
11743 msg = nlmsg_new(100, gfp);
11744 if (!msg)
11745 return true;
11746
b92ab5d8 11747 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
28946da7
JB		 11748 if (!hdr) {
11749 nlmsg_free(msg);
11750 return true;
11751 }
11752
9360ffd1
DM		 11753 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11754 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11755 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
11756 goto nla_put_failure;
28946da7 11757
9c90a9f6 11758 genlmsg_end(msg, hdr);
15e47304 11759 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
28946da7
JB		 11760 return true;
11761
11762 nla_put_failure:
11763 genlmsg_cancel(msg, hdr);
11764 nlmsg_free(msg);
11765 return true;
11766}
11767
947add36
JB		 11768bool cfg80211_rx_spurious_frame(struct net_device *dev,
11769 const u8 *addr, gfp_t gfp)
b92ab5d8 11770{
947add36
JB		 11771 struct wireless_dev *wdev = dev->ieee80211_ptr;
11772 bool ret;
11773
11774 trace_cfg80211_rx_spurious_frame(dev, addr);
11775
11776 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
11777 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
11778 trace_cfg80211_return_bool(false);
11779 return false;
11780 }
11781 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
11782 addr, gfp);
11783 trace_cfg80211_return_bool(ret);
11784 return ret;
b92ab5d8 11785}
947add36 11786EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
b92ab5d8 11787
947add36
JB		 11788bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
11789 const u8 *addr, gfp_t gfp)
b92ab5d8 11790{
947add36
JB		 11791 struct wireless_dev *wdev = dev->ieee80211_ptr;
11792 bool ret;
11793
11794 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
11795
11796 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
11797 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
11798 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
11799 trace_cfg80211_return_bool(false);
11800 return false;
11801 }
11802 ret = __nl80211_unexpected_frame(dev,
11803 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
11804 addr, gfp);
11805 trace_cfg80211_return_bool(ret);
11806 return ret;
b92ab5d8 11807}
947add36 11808EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
b92ab5d8 11809
2e161f78 11810int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15e47304 11811 struct wireless_dev *wdev, u32 nlportid,
804483e9 11812 int freq, int sig_dbm,
19504cf5 11813 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
026331c4 11814{
71bbc994 11815 struct net_device *netdev = wdev->netdev;
026331c4
JM		 11816 struct sk_buff *msg;
11817 void *hdr;
026331c4
JM		 11818
11819 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11820 if (!msg)
11821 return -ENOMEM;
11822
2e161f78 11823 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
026331c4
JM		 11824 if (!hdr) {
11825 nlmsg_free(msg);
11826 return -ENOMEM;
11827 }
11828
9360ffd1 11829 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 11830 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11831 netdev->ifindex)) ||
a838490b 11832 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9360ffd1
DM		 11833 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
11834 (sig_dbm &&
11835 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19504cf5
VK		 11836 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
11837 (flags &&
11838 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
9360ffd1 11839 goto nla_put_failure;
026331c4 11840
3b7b72ee 11841 genlmsg_end(msg, hdr);
026331c4 11842
15e47304 11843 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
026331c4
JM		 11844
11845 nla_put_failure:
11846 genlmsg_cancel(msg, hdr);
11847 nlmsg_free(msg);
11848 return -ENOBUFS;
11849}
11850
947add36
JB		 11851void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
11852 const u8 *buf, size_t len, bool ack, gfp_t gfp)
026331c4 11853{
947add36 11854 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 11855 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
71bbc994 11856 struct net_device *netdev = wdev->netdev;
026331c4
JM		 11857 struct sk_buff *msg;
11858 void *hdr;
11859
947add36
JB		 11860 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
11861
026331c4
JM		 11862 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11863 if (!msg)
11864 return;
11865
2e161f78 11866 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
026331c4
JM		 11867 if (!hdr) {
11868 nlmsg_free(msg);
11869 return;
11870 }
11871
9360ffd1 11872 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
71bbc994
JB		 11873 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11874 netdev->ifindex)) ||
a838490b 11875 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9360ffd1
DM		 11876 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
11877 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
11878 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
11879 goto nla_put_failure;
026331c4 11880
3b7b72ee 11881 genlmsg_end(msg, hdr);
026331c4 11882
68eb5503 11883 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11884 NL80211_MCGRP_MLME, gfp);
026331c4
JM		 11885 return;
11886
11887 nla_put_failure:
11888 genlmsg_cancel(msg, hdr);
11889 nlmsg_free(msg);
11890}
947add36 11891EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
026331c4 11892
5b97f49d
JB		 11893static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
11894 const char *mac, gfp_t gfp)
d6dc1a38 11895{
947add36 11896 struct wireless_dev *wdev = dev->ieee80211_ptr;
5b97f49d
JB		 11897 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
11898 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11899 void **cb;
947add36 11900
d6dc1a38 11901 if (!msg)
5b97f49d 11902 return NULL;
d6dc1a38 11903
5b97f49d
JB		 11904 cb = (void **)msg->cb;
11905
11906 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
11907 if (!cb[0]) {
d6dc1a38 11908 nlmsg_free(msg);
5b97f49d 11909 return NULL;
d6dc1a38
JO		 11910 }
11911
9360ffd1 11912 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
947add36 11913 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9360ffd1 11914 goto nla_put_failure;
d6dc1a38 11915
5b97f49d 11916 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
d6dc1a38
JO		 11917 goto nla_put_failure;
11918
5b97f49d
JB		 11919 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
11920 if (!cb[1])
9360ffd1 11921 goto nla_put_failure;
d6dc1a38 11922
5b97f49d 11923 cb[2] = rdev;
d6dc1a38 11924
5b97f49d
JB		 11925 return msg;
11926 nla_put_failure:
11927 nlmsg_free(msg);
11928 return NULL;
11929}
11930
11931static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
11932{
11933 void **cb = (void **)msg->cb;
11934 struct cfg80211_registered_device *rdev = cb[2];
11935
11936 nla_nest_end(msg, cb[1]);
11937 genlmsg_end(msg, cb[0]);
11938
11939 memset(msg->cb, 0, sizeof(msg->cb));
d6dc1a38 11940
68eb5503 11941 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 11942 NL80211_MCGRP_MLME, gfp);
5b97f49d
JB		 11943}
11944
11945void cfg80211_cqm_rssi_notify(struct net_device *dev,
11946 enum nl80211_cqm_rssi_threshold_event rssi_event,
11947 gfp_t gfp)
11948{
11949 struct sk_buff *msg;
11950
11951 trace_cfg80211_cqm_rssi_notify(dev, rssi_event);
11952
98f03342
JB		 11953 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
11954 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
11955 return;
11956
5b97f49d
JB		 11957 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
11958 if (!msg)
11959 return;
11960
11961 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
11962 rssi_event))
11963 goto nla_put_failure;
11964
11965 cfg80211_send_cqm(msg, gfp);
11966
d6dc1a38
JO		 11967 return;
11968
11969 nla_put_failure:
d6dc1a38
JO		 11970 nlmsg_free(msg);
11971}
947add36 11972EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
d6dc1a38 11973
5b97f49d
JB		 11974void cfg80211_cqm_txe_notify(struct net_device *dev,
11975 const u8 *peer, u32 num_packets,
11976 u32 rate, u32 intvl, gfp_t gfp)
11977{
11978 struct sk_buff *msg;
11979
11980 msg = cfg80211_prepare_cqm(dev, peer, gfp);
11981 if (!msg)
11982 return;
11983
11984 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
11985 goto nla_put_failure;
11986
11987 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
11988 goto nla_put_failure;
11989
11990 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
11991 goto nla_put_failure;
11992
11993 cfg80211_send_cqm(msg, gfp);
11994 return;
11995
11996 nla_put_failure:
11997 nlmsg_free(msg);
11998}
11999EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
12000
12001void cfg80211_cqm_pktloss_notify(struct net_device *dev,
12002 const u8 *peer, u32 num_packets, gfp_t gfp)
12003{
12004 struct sk_buff *msg;
12005
12006 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
12007
12008 msg = cfg80211_prepare_cqm(dev, peer, gfp);
12009 if (!msg)
12010 return;
12011
12012 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
12013 goto nla_put_failure;
12014
12015 cfg80211_send_cqm(msg, gfp);
12016 return;
12017
12018 nla_put_failure:
12019 nlmsg_free(msg);
12020}
12021EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
12022
98f03342
JB		 12023void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
12024{
12025 struct sk_buff *msg;
12026
12027 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
12028 if (!msg)
12029 return;
12030
12031 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
12032 goto nla_put_failure;
12033
12034 cfg80211_send_cqm(msg, gfp);
12035 return;
12036
12037 nla_put_failure:
12038 nlmsg_free(msg);
12039}
12040EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
12041
947add36
JB		 12042static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
12043 struct net_device *netdev, const u8 *bssid,
12044 const u8 *replay_ctr, gfp_t gfp)
e5497d76
JB		 12045{
12046 struct sk_buff *msg;
12047 struct nlattr *rekey_attr;
12048 void *hdr;
12049
58050fce 12050 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
e5497d76
JB		 12051 if (!msg)
12052 return;
12053
12054 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
12055 if (!hdr) {
12056 nlmsg_free(msg);
12057 return;
12058 }
12059
9360ffd1
DM		 12060 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12061 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
12062 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
12063 goto nla_put_failure;
e5497d76
JB		 12064
12065 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
12066 if (!rekey_attr)
12067 goto nla_put_failure;
12068
9360ffd1
DM		 12069 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
12070 NL80211_REPLAY_CTR_LEN, replay_ctr))
12071 goto nla_put_failure;
e5497d76
JB		 12072
12073 nla_nest_end(msg, rekey_attr);
12074
3b7b72ee 12075 genlmsg_end(msg, hdr);
e5497d76 12076
68eb5503 12077 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12078 NL80211_MCGRP_MLME, gfp);
e5497d76
JB		 12079 return;
12080
12081 nla_put_failure:
12082 genlmsg_cancel(msg, hdr);
12083 nlmsg_free(msg);
12084}
12085
947add36
JB		 12086void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
12087 const u8 *replay_ctr, gfp_t gfp)
12088{
12089 struct wireless_dev *wdev = dev->ieee80211_ptr;
12090 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 12091 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 12092
12093 trace_cfg80211_gtk_rekey_notify(dev, bssid);
12094 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
12095}
12096EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
12097
12098static void
12099nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
12100 struct net_device *netdev, int index,
12101 const u8 *bssid, bool preauth, gfp_t gfp)
c9df56b4
JM		 12102{
12103 struct sk_buff *msg;
12104 struct nlattr *attr;
12105 void *hdr;
12106
58050fce 12107 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
c9df56b4
JM		 12108 if (!msg)
12109 return;
12110
12111 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
12112 if (!hdr) {
12113 nlmsg_free(msg);
12114 return;
12115 }
12116
9360ffd1
DM		 12117 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12118 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
12119 goto nla_put_failure;
c9df56b4
JM		 12120
12121 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
12122 if (!attr)
12123 goto nla_put_failure;
12124
9360ffd1
DM		 12125 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
12126 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
12127 (preauth &&
12128 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
12129 goto nla_put_failure;
c9df56b4
JM		 12130
12131 nla_nest_end(msg, attr);
12132
3b7b72ee 12133 genlmsg_end(msg, hdr);
c9df56b4 12134
68eb5503 12135 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12136 NL80211_MCGRP_MLME, gfp);
c9df56b4
JM		 12137 return;
12138
12139 nla_put_failure:
12140 genlmsg_cancel(msg, hdr);
12141 nlmsg_free(msg);
12142}
12143
947add36
JB		 12144void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
12145 const u8 *bssid, bool preauth, gfp_t gfp)
12146{
12147 struct wireless_dev *wdev = dev->ieee80211_ptr;
12148 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 12149 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36
JB		 12150
12151 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
12152 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
12153}
12154EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
12155
12156static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
12157 struct net_device *netdev,
12158 struct cfg80211_chan_def *chandef,
f8d7552e
LC		 12159 gfp_t gfp,
12160 enum nl80211_commands notif,
12161 u8 count)
5314526b
TP		 12162{
12163 struct sk_buff *msg;
12164 void *hdr;
12165
58050fce 12166 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5314526b
TP		 12167 if (!msg)
12168 return;
12169
f8d7552e 12170 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
5314526b
TP		 12171 if (!hdr) {
12172 nlmsg_free(msg);
12173 return;
12174 }
12175
683b6d3b
JB		 12176 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
12177 goto nla_put_failure;
12178
12179 if (nl80211_send_chandef(msg, chandef))
7eab0f64 12180 goto nla_put_failure;
5314526b 12181
f8d7552e
LC		 12182 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
12183 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
12184 goto nla_put_failure;
12185
5314526b
TP		 12186 genlmsg_end(msg, hdr);
12187
68eb5503 12188 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12189 NL80211_MCGRP_MLME, gfp);
5314526b
TP		 12190 return;
12191
12192 nla_put_failure:
12193 genlmsg_cancel(msg, hdr);
12194 nlmsg_free(msg);
12195}
12196
947add36
JB		 12197void cfg80211_ch_switch_notify(struct net_device *dev,
12198 struct cfg80211_chan_def *chandef)
84f10708 12199{
947add36
JB		 12200 struct wireless_dev *wdev = dev->ieee80211_ptr;
12201 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 12202 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
947add36 12203
e487eaeb 12204 ASSERT_WDEV_LOCK(wdev);
947add36 12205
e487eaeb 12206 trace_cfg80211_ch_switch_notify(dev, chandef);
947add36 12207
9e0e2961 12208 wdev->chandef = *chandef;
96f55f12 12209 wdev->preset_chandef = *chandef;
f8d7552e
LC		 12210 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
12211 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
947add36
JB		 12212}
12213EXPORT_SYMBOL(cfg80211_ch_switch_notify);
12214
f8d7552e
LC		 12215void cfg80211_ch_switch_started_notify(struct net_device *dev,
12216 struct cfg80211_chan_def *chandef,
12217 u8 count)
12218{
12219 struct wireless_dev *wdev = dev->ieee80211_ptr;
12220 struct wiphy *wiphy = wdev->wiphy;
12221 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12222
12223 trace_cfg80211_ch_switch_started_notify(dev, chandef);
12224
12225 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
12226 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
12227}
12228EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
12229
04f39047
SW		 12230void
12231nl80211_radar_notify(struct cfg80211_registered_device *rdev,
d2859df5 12232 const struct cfg80211_chan_def *chandef,
04f39047
SW		 12233 enum nl80211_radar_event event,
12234 struct net_device *netdev, gfp_t gfp)
12235{
12236 struct sk_buff *msg;
12237 void *hdr;
12238
12239 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12240 if (!msg)
12241 return;
12242
12243 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
12244 if (!hdr) {
12245 nlmsg_free(msg);
12246 return;
12247 }
12248
12249 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
12250 goto nla_put_failure;
12251
12252 /* NOP and radar events don't need a netdev parameter */
12253 if (netdev) {
12254 struct wireless_dev *wdev = netdev->ieee80211_ptr;
12255
12256 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
12257 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12258 goto nla_put_failure;
12259 }
12260
12261 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
12262 goto nla_put_failure;
12263
12264 if (nl80211_send_chandef(msg, chandef))
12265 goto nla_put_failure;
12266
9c90a9f6 12267 genlmsg_end(msg, hdr);
04f39047 12268
68eb5503 12269 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12270 NL80211_MCGRP_MLME, gfp);
04f39047
SW		 12271 return;
12272
12273 nla_put_failure:
12274 genlmsg_cancel(msg, hdr);
12275 nlmsg_free(msg);
12276}
12277
7f6cf311
JB		 12278void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
12279 u64 cookie, bool acked, gfp_t gfp)
12280{
12281 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 12282 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
7f6cf311
JB		 12283 struct sk_buff *msg;
12284 void *hdr;
7f6cf311 12285
4ee3e063
BL		 12286 trace_cfg80211_probe_status(dev, addr, cookie, acked);
12287
58050fce 12288 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4ee3e063 12289
7f6cf311
JB		 12290 if (!msg)
12291 return;
12292
12293 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
12294 if (!hdr) {
12295 nlmsg_free(msg);
12296 return;
12297 }
12298
9360ffd1
DM		 12299 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12300 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
12301 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
12302 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
12303 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
12304 goto nla_put_failure;
7f6cf311 12305
9c90a9f6 12306 genlmsg_end(msg, hdr);
7f6cf311 12307
68eb5503 12308 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12309 NL80211_MCGRP_MLME, gfp);
7f6cf311
JB		 12310 return;
12311
12312 nla_put_failure:
12313 genlmsg_cancel(msg, hdr);
12314 nlmsg_free(msg);
12315}
12316EXPORT_SYMBOL(cfg80211_probe_status);
12317
5e760230
JB		 12318void cfg80211_report_obss_beacon(struct wiphy *wiphy,
12319 const u8 *frame, size_t len,
37c73b5f 12320 int freq, int sig_dbm)
5e760230 12321{
f26cbf40 12322 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5e760230
JB		 12323 struct sk_buff *msg;
12324 void *hdr;
37c73b5f 12325 struct cfg80211_beacon_registration *reg;
5e760230 12326
4ee3e063
BL		 12327 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
12328
37c73b5f
BG		 12329 spin_lock_bh(&rdev->beacon_registrations_lock);
12330 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
12331 msg = nlmsg_new(len + 100, GFP_ATOMIC);
12332 if (!msg) {
12333 spin_unlock_bh(&rdev->beacon_registrations_lock);
12334 return;
12335 }
5e760230 12336
37c73b5f
BG		 12337 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
12338 if (!hdr)
12339 goto nla_put_failure;
5e760230 12340
37c73b5f
BG		 12341 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12342 (freq &&
12343 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
12344 (sig_dbm &&
12345 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
12346 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
12347 goto nla_put_failure;
5e760230 12348
37c73b5f 12349 genlmsg_end(msg, hdr);
5e760230 12350
37c73b5f
BG		 12351 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
12352 }
12353 spin_unlock_bh(&rdev->beacon_registrations_lock);
5e760230
JB		 12354 return;
12355
12356 nla_put_failure:
37c73b5f
BG		 12357 spin_unlock_bh(&rdev->beacon_registrations_lock);
12358 if (hdr)
12359 genlmsg_cancel(msg, hdr);
5e760230
JB		 12360 nlmsg_free(msg);
12361}
12362EXPORT_SYMBOL(cfg80211_report_obss_beacon);
12363
cd8f7cb4 12364#ifdef CONFIG_PM
8cd4d456
LC		 12365static int cfg80211_net_detect_results(struct sk_buff *msg,
12366 struct cfg80211_wowlan_wakeup *wakeup)
12367{
12368 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
12369 struct nlattr *nl_results, *nl_match, *nl_freqs;
12370 int i, j;
12371
12372 nl_results = nla_nest_start(
12373 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
12374 if (!nl_results)
12375 return -EMSGSIZE;
12376
12377 for (i = 0; i < nd->n_matches; i++) {
12378 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
12379
12380 nl_match = nla_nest_start(msg, i);
12381 if (!nl_match)
12382 break;
12383
12384 /* The SSID attribute is optional in nl80211, but for
12385 * simplicity reasons it's always present in the
12386 * cfg80211 structure. If a driver can't pass the
12387 * SSID, that needs to be changed. A zero length SSID
12388 * is still a valid SSID (wildcard), so it cannot be
12389 * used for this purpose.
12390 */
12391 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
12392 match->ssid.ssid)) {
12393 nla_nest_cancel(msg, nl_match);
12394 goto out;
12395 }
12396
12397 if (match->n_channels) {
12398 nl_freqs = nla_nest_start(
12399 msg, NL80211_ATTR_SCAN_FREQUENCIES);
12400 if (!nl_freqs) {
12401 nla_nest_cancel(msg, nl_match);
12402 goto out;
12403 }
12404
12405 for (j = 0; j < match->n_channels; j++) {
12406 if (nla_put_u32(msg,
12407 NL80211_ATTR_WIPHY_FREQ,
12408 match->channels[j])) {
12409 nla_nest_cancel(msg, nl_freqs);
12410 nla_nest_cancel(msg, nl_match);
12411 goto out;
12412 }
12413 }
12414
12415 nla_nest_end(msg, nl_freqs);
12416 }
12417
12418 nla_nest_end(msg, nl_match);
12419 }
12420
12421out:
12422 nla_nest_end(msg, nl_results);
12423 return 0;
12424}
12425
cd8f7cb4
JB		 12426void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
12427 struct cfg80211_wowlan_wakeup *wakeup,
12428 gfp_t gfp)
12429{
f26cbf40 12430 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
cd8f7cb4
JB		 12431 struct sk_buff *msg;
12432 void *hdr;
9c90a9f6 12433 int size = 200;
cd8f7cb4
JB		 12434
12435 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
12436
12437 if (wakeup)
12438 size += wakeup->packet_present_len;
12439
12440 msg = nlmsg_new(size, gfp);
12441 if (!msg)
12442 return;
12443
12444 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
12445 if (!hdr)
12446 goto free_msg;
12447
12448 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12449 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12450 goto free_msg;
12451
12452 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12453 wdev->netdev->ifindex))
12454 goto free_msg;
12455
12456 if (wakeup) {
12457 struct nlattr *reasons;
12458
12459 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7fa322c8
JB		 12460 if (!reasons)
12461 goto free_msg;
cd8f7cb4
JB		 12462
12463 if (wakeup->disconnect &&
12464 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
12465 goto free_msg;
12466 if (wakeup->magic_pkt &&
12467 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
12468 goto free_msg;
12469 if (wakeup->gtk_rekey_failure &&
12470 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
12471 goto free_msg;
12472 if (wakeup->eap_identity_req &&
12473 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
12474 goto free_msg;
12475 if (wakeup->four_way_handshake &&
12476 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
12477 goto free_msg;
12478 if (wakeup->rfkill_release &&
12479 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
12480 goto free_msg;
12481
12482 if (wakeup->pattern_idx >= 0 &&
12483 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
12484 wakeup->pattern_idx))
12485 goto free_msg;
12486
ae917c9f
JB		 12487 if (wakeup->tcp_match &&
12488 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
12489 goto free_msg;
2a0e047e 12490
ae917c9f
JB		 12491 if (wakeup->tcp_connlost &&
12492 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
12493 goto free_msg;
2a0e047e 12494
ae917c9f
JB		 12495 if (wakeup->tcp_nomoretokens &&
12496 nla_put_flag(msg,
12497 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
12498 goto free_msg;
2a0e047e 12499
cd8f7cb4
JB		 12500 if (wakeup->packet) {
12501 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
12502 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
12503
12504 if (!wakeup->packet_80211) {
12505 pkt_attr =
12506 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
12507 len_attr =
12508 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
12509 }
12510
12511 if (wakeup->packet_len &&
12512 nla_put_u32(msg, len_attr, wakeup->packet_len))
12513 goto free_msg;
12514
12515 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
12516 wakeup->packet))
12517 goto free_msg;
12518 }
12519
8cd4d456
LC		 12520 if (wakeup->net_detect &&
12521 cfg80211_net_detect_results(msg, wakeup))
12522 goto free_msg;
12523
cd8f7cb4
JB		 12524 nla_nest_end(msg, reasons);
12525 }
12526
9c90a9f6 12527 genlmsg_end(msg, hdr);
cd8f7cb4 12528
68eb5503 12529 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12530 NL80211_MCGRP_MLME, gfp);
cd8f7cb4
JB		 12531 return;
12532
12533 free_msg:
12534 nlmsg_free(msg);
12535}
12536EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
12537#endif
12538
3475b094
JM		 12539void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
12540 enum nl80211_tdls_operation oper,
12541 u16 reason_code, gfp_t gfp)
12542{
12543 struct wireless_dev *wdev = dev->ieee80211_ptr;
f26cbf40 12544 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
3475b094
JM		 12545 struct sk_buff *msg;
12546 void *hdr;
3475b094
JM		 12547
12548 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
12549 reason_code);
12550
12551 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12552 if (!msg)
12553 return;
12554
12555 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
12556 if (!hdr) {
12557 nlmsg_free(msg);
12558 return;
12559 }
12560
12561 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12562 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
12563 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
12564 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
12565 (reason_code > 0 &&
12566 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
12567 goto nla_put_failure;
12568
9c90a9f6 12569 genlmsg_end(msg, hdr);
3475b094 12570
68eb5503 12571 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12572 NL80211_MCGRP_MLME, gfp);
3475b094
JM		 12573 return;
12574
12575 nla_put_failure:
12576 genlmsg_cancel(msg, hdr);
12577 nlmsg_free(msg);
12578}
12579EXPORT_SYMBOL(cfg80211_tdls_oper_request);
12580
026331c4
JM		 12581static int nl80211_netlink_notify(struct notifier_block * nb,
12582 unsigned long state,
12583 void *_notify)
12584{
12585 struct netlink_notify *notify = _notify;
12586 struct cfg80211_registered_device *rdev;
12587 struct wireless_dev *wdev;
37c73b5f 12588 struct cfg80211_beacon_registration *reg, *tmp;
026331c4
JM		 12589
12590 if (state != NETLINK_URELEASE)
12591 return NOTIFY_DONE;
12592
12593 rcu_read_lock();
12594
5e760230 12595 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
78f22b6a 12596 bool schedule_destroy_work = false;
93a1e86c
JR		 12597 bool schedule_scan_stop = false;
12598 struct cfg80211_sched_scan_request *sched_scan_req =
12599 rcu_dereference(rdev->sched_scan_req);
12600
12601 if (sched_scan_req && notify->portid &&
12602 sched_scan_req->owner_nlportid == notify->portid)
12603 schedule_scan_stop = true;
78f22b6a
JB		 12604
12605 list_for_each_entry_rcu(wdev, &rdev->wdev_list, list) {
15e47304 12606 cfg80211_mlme_unregister_socket(wdev, notify->portid);
37c73b5f 12607
78f22b6a
JB		 12608 if (wdev->owner_nlportid == notify->portid)
12609 schedule_destroy_work = true;
12610 }
12611
37c73b5f
BG		 12612 spin_lock_bh(&rdev->beacon_registrations_lock);
12613 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
12614 list) {
12615 if (reg->nlportid == notify->portid) {
12616 list_del(&reg->list);
12617 kfree(reg);
12618 break;
12619 }
12620 }
12621 spin_unlock_bh(&rdev->beacon_registrations_lock);
78f22b6a
JB		 12622
12623 if (schedule_destroy_work) {
12624 struct cfg80211_iface_destroy *destroy;
12625
12626 destroy = kzalloc(sizeof(*destroy), GFP_ATOMIC);
12627 if (destroy) {
12628 destroy->nlportid = notify->portid;
12629 spin_lock(&rdev->destroy_list_lock);
12630 list_add(&destroy->list, &rdev->destroy_list);
12631 spin_unlock(&rdev->destroy_list_lock);
12632 schedule_work(&rdev->destroy_work);
12633 }
93a1e86c
JR		 12634 } else if (schedule_scan_stop) {
12635 sched_scan_req->owner_nlportid = 0;
12636
12637 if (rdev->ops->sched_scan_stop &&
12638 rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
12639 schedule_work(&rdev->sched_scan_stop_wk);
78f22b6a 12640 }
5e760230 12641 }
026331c4
JM		 12642
12643 rcu_read_unlock();
12644
6784c7db 12645 return NOTIFY_OK;
026331c4
JM		 12646}
12647
12648static struct notifier_block nl80211_netlink_notifier = {
12649 .notifier_call = nl80211_netlink_notify,
12650};
12651
355199e0
JM		 12652void cfg80211_ft_event(struct net_device *netdev,
12653 struct cfg80211_ft_event_params *ft_event)
12654{
12655 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
f26cbf40 12656 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
355199e0
JM		 12657 struct sk_buff *msg;
12658 void *hdr;
355199e0
JM		 12659
12660 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
12661
12662 if (!ft_event->target_ap)
12663 return;
12664
12665 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12666 if (!msg)
12667 return;
12668
12669 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
ae917c9f
JB		 12670 if (!hdr)
12671 goto out;
355199e0 12672
ae917c9f
JB		 12673 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12674 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
12675 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
12676 goto out;
355199e0 12677
ae917c9f
JB		 12678 if (ft_event->ies &&
12679 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
12680 goto out;
12681 if (ft_event->ric_ies &&
12682 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
12683 ft_event->ric_ies))
12684 goto out;
355199e0 12685
9c90a9f6 12686 genlmsg_end(msg, hdr);
355199e0 12687
68eb5503 12688 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
2a94fe48 12689 NL80211_MCGRP_MLME, GFP_KERNEL);
ae917c9f
JB		 12690 return;
12691 out:
12692 nlmsg_free(msg);
355199e0
JM		 12693}
12694EXPORT_SYMBOL(cfg80211_ft_event);
12695
5de17984
AS		 12696void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
12697{
12698 struct cfg80211_registered_device *rdev;
12699 struct sk_buff *msg;
12700 void *hdr;
12701 u32 nlportid;
12702
f26cbf40 12703 rdev = wiphy_to_rdev(wdev->wiphy);
5de17984
AS		 12704 if (!rdev->crit_proto_nlportid)
12705 return;
12706
12707 nlportid = rdev->crit_proto_nlportid;
12708 rdev->crit_proto_nlportid = 0;
12709
12710 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12711 if (!msg)
12712 return;
12713
12714 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
12715 if (!hdr)
12716 goto nla_put_failure;
12717
12718 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12719 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12720 goto nla_put_failure;
12721
12722 genlmsg_end(msg, hdr);
12723
12724 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
12725 return;
12726
12727 nla_put_failure:
12728 if (hdr)
12729 genlmsg_cancel(msg, hdr);
12730 nlmsg_free(msg);
12731
12732}
12733EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
12734
348baf0e
JB		 12735void nl80211_send_ap_stopped(struct wireless_dev *wdev)
12736{
12737 struct wiphy *wiphy = wdev->wiphy;
f26cbf40 12738 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
348baf0e
JB		 12739 struct sk_buff *msg;
12740 void *hdr;
12741
12742 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12743 if (!msg)
12744 return;
12745
12746 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
12747 if (!hdr)
12748 goto out;
12749
12750 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12751 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
12752 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12753 goto out;
12754
12755 genlmsg_end(msg, hdr);
12756
12757 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
12758 NL80211_MCGRP_MLME, GFP_KERNEL);
12759 return;
12760 out:
12761 nlmsg_free(msg);
12762}
12763
55682965
JB		 12764/* initialisation/exit functions */
12765
12766int nl80211_init(void)
12767{
0d63cbb5 12768 int err;
55682965 12769
2a94fe48
JB		 12770 err = genl_register_family_with_ops_groups(&nl80211_fam, nl80211_ops,
12771 nl80211_mcgrps);
55682965
JB		 12772 if (err)
12773 return err;
12774
026331c4
JM		 12775 err = netlink_register_notifier(&nl80211_netlink_notifier);
12776 if (err)
12777 goto err_out;
12778
55682965
JB		 12779 return 0;
12780 err_out:
12781 genl_unregister_family(&nl80211_fam);
12782 return err;
12783}
12784
12785void nl80211_exit(void)
12786{
026331c4 12787 netlink_unregister_notifier(&nl80211_netlink_notifier);
55682965
JB		 12788 genl_unregister_family(&nl80211_fam);
12789}
ubuntu-bionic-kernel mirror