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