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