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