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