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