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