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