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