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