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