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