]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - net/wireless/nl80211.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nl80211: Validate MFP flag type when parsing STA flags
[mirror_ubuntu-focal-kernel.git] / net / wireless / nl80211.c
CommitLineData
55682965
JB		 1/*
2 * This is the new netlink-based wireless configuration interface.
3 *
08645126 4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
55682965
JB		 5 */
6
7#include <linux/if.h>
8#include <linux/module.h>
9#include <linux/err.h>
55682965
JB		 10#include <linux/list.h>
11#include <linux/if_ether.h>
12#include <linux/ieee80211.h>
13#include <linux/nl80211.h>
14#include <linux/rtnetlink.h>
15#include <linux/netlink.h>
2a519311 16#include <linux/etherdevice.h>
55682965
JB		 17#include <net/genetlink.h>
18#include <net/cfg80211.h>
19#include "core.h"
20#include "nl80211.h"
b2e1b302 21#include "reg.h"
55682965
JB		 22
23/* the netlink family */
24static struct genl_family nl80211_fam = {
25 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
26 .name = "nl80211", /* have users key off the name instead */
27 .hdrsize = 0, /* no private header */
28 .version = 1, /* no particular meaning now */
29 .maxattr = NL80211_ATTR_MAX,
30};
31
32/* internal helper: get drv and dev */
bba95fef 33static int get_drv_dev_by_info_ifindex(struct nlattr **attrs,
55682965
JB		 34 struct cfg80211_registered_device **drv,
35 struct net_device **dev)
36{
37 int ifindex;
38
bba95fef 39 if (!attrs[NL80211_ATTR_IFINDEX])
55682965
JB		 40 return -EINVAL;
41
bba95fef 42 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
55682965
JB		 43 *dev = dev_get_by_index(&init_net, ifindex);
44 if (!*dev)
45 return -ENODEV;
46
47 *drv = cfg80211_get_dev_from_ifindex(ifindex);
48 if (IS_ERR(*drv)) {
49 dev_put(*dev);
50 return PTR_ERR(*drv);
51 }
52
53 return 0;
54}
55
56/* policy for the attributes */
57static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
58 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
59 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
60 .len = BUS_ID_SIZE-1 },
31888487 61 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
72bdcf34 62 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
094d05dc 63 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
b9a5f8ca
JM		 64 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
65 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
66 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
67 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
55682965
JB		 68
69 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
70 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
71 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
41ade00f
JB		 72
73 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
74
75 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
76 .len = WLAN_MAX_KEY_LEN },
77 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
78 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
79 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
ed1b6cc7
JB		 80
81 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
82 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
83 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
84 .len = IEEE80211_MAX_DATA_LEN },
85 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
86 .len = IEEE80211_MAX_DATA_LEN },
5727ef1b
JB		 87 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
88 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
89 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
90 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
91 .len = NL80211_MAX_SUPP_RATES },
2ec600d6 92 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
5727ef1b 93 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
0a9542ee 94 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
2ec600d6
LCC		 95 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
96 .len = IEEE80211_MAX_MESH_ID_LEN },
97 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
9f1ba906 98
b2e1b302
LR		 99 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
100 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
101
9f1ba906
JM		 102 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
103 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
104 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
90c97a04
JM		 105 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
106 .len = NL80211_MAX_SUPP_RATES },
36aedc90 107
93da9cc1 108 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
109
36aedc90
JM		 110 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
111 .len = NL80211_HT_CAPABILITY_LEN },
9aed3cc1
JM		 112
113 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
114 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
115 .len = IEEE80211_MAX_DATA_LEN },
2a519311
JB		 116 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
117 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
636a5d36
JM		 118
119 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
120 .len = IEEE80211_MAX_SSID_LEN },
121 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
122 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
04a773ad 123 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
1965c853 124 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
dc6382ce 125 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
55682965
JB		 126};
127
f4a11bb0
JB		 128/* IE validation */
129static bool is_valid_ie_attr(const struct nlattr *attr)
130{
131 const u8 *pos;
132 int len;
133
134 if (!attr)
135 return true;
136
137 pos = nla_data(attr);
138 len = nla_len(attr);
139
140 while (len) {
141 u8 elemlen;
142
143 if (len < 2)
144 return false;
145 len -= 2;
146
147 elemlen = pos[1];
148 if (elemlen > len)
149 return false;
150
151 len -= elemlen;
152 pos += 2 + elemlen;
153 }
154
155 return true;
156}
157
55682965
JB		 158/* message building helper */
159static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
160 int flags, u8 cmd)
161{
162 /* since there is no private header just add the generic one */
163 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
164}
165
5dab3b8a
LR		 166static int nl80211_msg_put_channel(struct sk_buff *msg,
167 struct ieee80211_channel *chan)
168{
169 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
170 chan->center_freq);
171
172 if (chan->flags & IEEE80211_CHAN_DISABLED)
173 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
174 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
175 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
176 if (chan->flags & IEEE80211_CHAN_NO_IBSS)
177 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
178 if (chan->flags & IEEE80211_CHAN_RADAR)
179 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
180
181 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
182 DBM_TO_MBM(chan->max_power));
183
184 return 0;
185
186 nla_put_failure:
187 return -ENOBUFS;
188}
189
55682965
JB		 190/* netlink command implementations */
191
192static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
193 struct cfg80211_registered_device *dev)
194{
195 void *hdr;
ee688b00
JB		 196 struct nlattr *nl_bands, *nl_band;
197 struct nlattr *nl_freqs, *nl_freq;
198 struct nlattr *nl_rates, *nl_rate;
f59ac048 199 struct nlattr *nl_modes;
8fdc621d 200 struct nlattr *nl_cmds;
ee688b00
JB		 201 enum ieee80211_band band;
202 struct ieee80211_channel *chan;
203 struct ieee80211_rate *rate;
204 int i;
f59ac048 205 u16 ifmodes = dev->wiphy.interface_modes;
55682965
JB		 206
207 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
208 if (!hdr)
209 return -1;
210
b5850a7a 211 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
55682965 212 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
b9a5f8ca
JM		 213
214 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
215 dev->wiphy.retry_short);
216 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
217 dev->wiphy.retry_long);
218 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
219 dev->wiphy.frag_threshold);
220 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
221 dev->wiphy.rts_threshold);
222
2a519311
JB		 223 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
224 dev->wiphy.max_scan_ssids);
18a83659
JB		 225 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
226 dev->wiphy.max_scan_ie_len);
ee688b00 227
25e47c18
JB		 228 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
229 sizeof(u32) * dev->wiphy.n_cipher_suites,
230 dev->wiphy.cipher_suites);
231
f59ac048
LR		 232 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
233 if (!nl_modes)
234 goto nla_put_failure;
235
236 i = 0;
237 while (ifmodes) {
238 if (ifmodes & 1)
239 NLA_PUT_FLAG(msg, i);
240 ifmodes >>= 1;
241 i++;
242 }
243
244 nla_nest_end(msg, nl_modes);
245
ee688b00
JB		 246 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
247 if (!nl_bands)
248 goto nla_put_failure;
249
250 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
251 if (!dev->wiphy.bands[band])
252 continue;
253
254 nl_band = nla_nest_start(msg, band);
255 if (!nl_band)
256 goto nla_put_failure;
257
d51626df
JB		 258 /* add HT info */
259 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
260 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
261 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
262 &dev->wiphy.bands[band]->ht_cap.mcs);
263 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
264 dev->wiphy.bands[band]->ht_cap.cap);
265 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
266 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
267 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
268 dev->wiphy.bands[band]->ht_cap.ampdu_density);
269 }
270
ee688b00
JB		 271 /* add frequencies */
272 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
273 if (!nl_freqs)
274 goto nla_put_failure;
275
276 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
277 nl_freq = nla_nest_start(msg, i);
278 if (!nl_freq)
279 goto nla_put_failure;
280
281 chan = &dev->wiphy.bands[band]->channels[i];
5dab3b8a
LR		 282
283 if (nl80211_msg_put_channel(msg, chan))
284 goto nla_put_failure;
e2f367f2 285
ee688b00
JB		 286 nla_nest_end(msg, nl_freq);
287 }
288
289 nla_nest_end(msg, nl_freqs);
290
291 /* add bitrates */
292 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
293 if (!nl_rates)
294 goto nla_put_failure;
295
296 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
297 nl_rate = nla_nest_start(msg, i);
298 if (!nl_rate)
299 goto nla_put_failure;
300
301 rate = &dev->wiphy.bands[band]->bitrates[i];
302 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
303 rate->bitrate);
304 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
305 NLA_PUT_FLAG(msg,
306 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
307
308 nla_nest_end(msg, nl_rate);
309 }
310
311 nla_nest_end(msg, nl_rates);
312
313 nla_nest_end(msg, nl_band);
314 }
315 nla_nest_end(msg, nl_bands);
316
8fdc621d
JB		 317 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
318 if (!nl_cmds)
319 goto nla_put_failure;
320
321 i = 0;
322#define CMD(op, n) \
323 do { \
324 if (dev->ops->op) { \
325 i++; \
326 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \
327 } \
328 } while (0)
329
330 CMD(add_virtual_intf, NEW_INTERFACE);
331 CMD(change_virtual_intf, SET_INTERFACE);
332 CMD(add_key, NEW_KEY);
333 CMD(add_beacon, NEW_BEACON);
334 CMD(add_station, NEW_STATION);
335 CMD(add_mpath, NEW_MPATH);
336 CMD(set_mesh_params, SET_MESH_PARAMS);
337 CMD(change_bss, SET_BSS);
636a5d36
JM		 338 CMD(auth, AUTHENTICATE);
339 CMD(assoc, ASSOCIATE);
340 CMD(deauth, DEAUTHENTICATE);
341 CMD(disassoc, DISASSOCIATE);
04a773ad 342 CMD(join_ibss, JOIN_IBSS);
8fdc621d
JB		 343
344#undef CMD
345 nla_nest_end(msg, nl_cmds);
346
55682965
JB		 347 return genlmsg_end(msg, hdr);
348
349 nla_put_failure:
bc3ed28c
TG		 350 genlmsg_cancel(msg, hdr);
351 return -EMSGSIZE;
55682965
JB		 352}
353
354static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
355{
356 int idx = 0;
357 int start = cb->args[0];
358 struct cfg80211_registered_device *dev;
359
a1794390 360 mutex_lock(&cfg80211_mutex);
55682965 361 list_for_each_entry(dev, &cfg80211_drv_list, list) {
b4637271 362 if (++idx <= start)
55682965
JB		 363 continue;
364 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
365 cb->nlh->nlmsg_seq, NLM_F_MULTI,
b4637271
JV		 366 dev) < 0) {
367 idx--;
55682965 368 break;
b4637271 369 }
55682965 370 }
a1794390 371 mutex_unlock(&cfg80211_mutex);
55682965
JB		 372
373 cb->args[0] = idx;
374
375 return skb->len;
376}
377
378static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
379{
380 struct sk_buff *msg;
381 struct cfg80211_registered_device *dev;
382
383 dev = cfg80211_get_dev_from_info(info);
384 if (IS_ERR(dev))
385 return PTR_ERR(dev);
386
387 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
388 if (!msg)
389 goto out_err;
390
391 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
392 goto out_free;
393
394 cfg80211_put_dev(dev);
395
396 return genlmsg_unicast(msg, info->snd_pid);
397
398 out_free:
399 nlmsg_free(msg);
400 out_err:
401 cfg80211_put_dev(dev);
402 return -ENOBUFS;
403}
404
31888487
JM		 405static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
406 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
407 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
408 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
409 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
410 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
411};
412
413static int parse_txq_params(struct nlattr *tb[],
414 struct ieee80211_txq_params *txq_params)
415{
416 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
417 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
418 !tb[NL80211_TXQ_ATTR_AIFS])
419 return -EINVAL;
420
421 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
422 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
423 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
424 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
425 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
426
427 return 0;
428}
429
55682965
JB		 430static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
431{
432 struct cfg80211_registered_device *rdev;
31888487
JM		 433 int result = 0, rem_txq_params = 0;
434 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 435 u32 changed;
436 u8 retry_short = 0, retry_long = 0;
437 u32 frag_threshold = 0, rts_threshold = 0;
55682965 438
4bbf4d56 439 rtnl_lock();
55682965 440
4bbf4d56
JB		 441 mutex_lock(&cfg80211_mutex);
442
443 rdev = __cfg80211_drv_from_info(info);
444 if (IS_ERR(rdev)) {
445 result = PTR_ERR(rdev);
446 goto unlock;
447 }
448
449 mutex_lock(&rdev->mtx);
450
451 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 452 result = cfg80211_dev_rename(
453 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56
JB		 454
455 mutex_unlock(&cfg80211_mutex);
456
457 if (result)
458 goto bad_res;
31888487
JM		 459
460 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
461 struct ieee80211_txq_params txq_params;
462 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
463
464 if (!rdev->ops->set_txq_params) {
465 result = -EOPNOTSUPP;
466 goto bad_res;
467 }
468
469 nla_for_each_nested(nl_txq_params,
470 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
471 rem_txq_params) {
472 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
473 nla_data(nl_txq_params),
474 nla_len(nl_txq_params),
475 txq_params_policy);
476 result = parse_txq_params(tb, &txq_params);
477 if (result)
478 goto bad_res;
479
480 result = rdev->ops->set_txq_params(&rdev->wiphy,
481 &txq_params);
482 if (result)
483 goto bad_res;
484 }
485 }
55682965 486
72bdcf34 487 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
094d05dc 488 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
72bdcf34 489 struct ieee80211_channel *chan;
306d6112 490 struct ieee80211_sta_ht_cap *ht_cap;
72bdcf34
JM		 491 u32 freq, sec_freq;
492
493 if (!rdev->ops->set_channel) {
494 result = -EOPNOTSUPP;
495 goto bad_res;
496 }
497
306d6112
JB		 498 result = -EINVAL;
499
094d05dc
S		 500 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
501 channel_type = nla_get_u32(info->attrs[
502 NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
503 if (channel_type != NL80211_CHAN_NO_HT &&
504 channel_type != NL80211_CHAN_HT20 &&
505 channel_type != NL80211_CHAN_HT40PLUS &&
506 channel_type != NL80211_CHAN_HT40MINUS)
72bdcf34 507 goto bad_res;
72bdcf34
JM		 508 }
509
510 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
511 chan = ieee80211_get_channel(&rdev->wiphy, freq);
306d6112
JB		 512
513 /* Primary channel not allowed */
514 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
72bdcf34 515 goto bad_res;
306d6112 516
094d05dc 517 if (channel_type == NL80211_CHAN_HT40MINUS)
72bdcf34 518 sec_freq = freq - 20;
094d05dc 519 else if (channel_type == NL80211_CHAN_HT40PLUS)
72bdcf34
JM		 520 sec_freq = freq + 20;
521 else
522 sec_freq = 0;
523
306d6112
JB		 524 ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
525
526 /* no HT capabilities */
094d05dc 527 if (channel_type != NL80211_CHAN_NO_HT &&
306d6112
JB		 528 !ht_cap->ht_supported)
529 goto bad_res;
530
72bdcf34
JM		 531 if (sec_freq) {
532 struct ieee80211_channel *schan;
306d6112
JB		 533
534 /* no 40 MHz capabilities */
535 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
536 (ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
537 goto bad_res;
538
72bdcf34 539 schan = ieee80211_get_channel(&rdev->wiphy, sec_freq);
306d6112
JB		 540
541 /* Secondary channel not allowed */
542 if (!schan || schan->flags & IEEE80211_CHAN_DISABLED)
72bdcf34 543 goto bad_res;
72bdcf34
JM		 544 }
545
546 result = rdev->ops->set_channel(&rdev->wiphy, chan,
094d05dc 547 channel_type);
72bdcf34
JM		 548 if (result)
549 goto bad_res;
550 }
551
b9a5f8ca
JM		 552 changed = 0;
553
554 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
555 retry_short = nla_get_u8(
556 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
557 if (retry_short == 0) {
558 result = -EINVAL;
559 goto bad_res;
560 }
561 changed |= WIPHY_PARAM_RETRY_SHORT;
562 }
563
564 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
565 retry_long = nla_get_u8(
566 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
567 if (retry_long == 0) {
568 result = -EINVAL;
569 goto bad_res;
570 }
571 changed |= WIPHY_PARAM_RETRY_LONG;
572 }
573
574 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
575 frag_threshold = nla_get_u32(
576 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
577 if (frag_threshold < 256) {
578 result = -EINVAL;
579 goto bad_res;
580 }
581 if (frag_threshold != (u32) -1) {
582 /*
583 * Fragments (apart from the last one) are required to
584 * have even length. Make the fragmentation code
585 * simpler by stripping LSB should someone try to use
586 * odd threshold value.
587 */
588 frag_threshold &= ~0x1;
589 }
590 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
591 }
592
593 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
594 rts_threshold = nla_get_u32(
595 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
596 changed |= WIPHY_PARAM_RTS_THRESHOLD;
597 }
598
599 if (changed) {
600 u8 old_retry_short, old_retry_long;
601 u32 old_frag_threshold, old_rts_threshold;
602
603 if (!rdev->ops->set_wiphy_params) {
604 result = -EOPNOTSUPP;
605 goto bad_res;
606 }
607
608 old_retry_short = rdev->wiphy.retry_short;
609 old_retry_long = rdev->wiphy.retry_long;
610 old_frag_threshold = rdev->wiphy.frag_threshold;
611 old_rts_threshold = rdev->wiphy.rts_threshold;
612
613 if (changed & WIPHY_PARAM_RETRY_SHORT)
614 rdev->wiphy.retry_short = retry_short;
615 if (changed & WIPHY_PARAM_RETRY_LONG)
616 rdev->wiphy.retry_long = retry_long;
617 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
618 rdev->wiphy.frag_threshold = frag_threshold;
619 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
620 rdev->wiphy.rts_threshold = rts_threshold;
621
622 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
623 if (result) {
624 rdev->wiphy.retry_short = old_retry_short;
625 rdev->wiphy.retry_long = old_retry_long;
626 rdev->wiphy.frag_threshold = old_frag_threshold;
627 rdev->wiphy.rts_threshold = old_rts_threshold;
628 }
629 }
72bdcf34 630
306d6112 631 bad_res:
4bbf4d56
JB		 632 mutex_unlock(&rdev->mtx);
633 unlock:
634 rtnl_unlock();
55682965
JB		 635 return result;
636}
637
638
639static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
d726405a 640 struct cfg80211_registered_device *rdev,
55682965
JB		 641 struct net_device *dev)
642{
643 void *hdr;
644
645 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
646 if (!hdr)
647 return -1;
648
649 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
d726405a 650 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
55682965 651 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
60719ffd 652 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
55682965
JB		 653 return genlmsg_end(msg, hdr);
654
655 nla_put_failure:
bc3ed28c
TG		 656 genlmsg_cancel(msg, hdr);
657 return -EMSGSIZE;
55682965
JB		 658}
659
660static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
661{
662 int wp_idx = 0;
663 int if_idx = 0;
664 int wp_start = cb->args[0];
665 int if_start = cb->args[1];
666 struct cfg80211_registered_device *dev;
667 struct wireless_dev *wdev;
668
a1794390 669 mutex_lock(&cfg80211_mutex);
55682965 670 list_for_each_entry(dev, &cfg80211_drv_list, list) {
bba95fef
JB		 671 if (wp_idx < wp_start) {
672 wp_idx++;
55682965 673 continue;
bba95fef 674 }
55682965
JB		 675 if_idx = 0;
676
677 mutex_lock(&dev->devlist_mtx);
678 list_for_each_entry(wdev, &dev->netdev_list, list) {
bba95fef
JB		 679 if (if_idx < if_start) {
680 if_idx++;
55682965 681 continue;
bba95fef 682 }
55682965
JB		 683 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
684 cb->nlh->nlmsg_seq, NLM_F_MULTI,
d726405a 685 dev, wdev->netdev) < 0) {
bba95fef
JB		 686 mutex_unlock(&dev->devlist_mtx);
687 goto out;
688 }
689 if_idx++;
55682965
JB		 690 }
691 mutex_unlock(&dev->devlist_mtx);
bba95fef
JB		 692
693 wp_idx++;
55682965 694 }
bba95fef 695 out:
a1794390 696 mutex_unlock(&cfg80211_mutex);
55682965
JB		 697
698 cb->args[0] = wp_idx;
699 cb->args[1] = if_idx;
700
701 return skb->len;
702}
703
704static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
705{
706 struct sk_buff *msg;
707 struct cfg80211_registered_device *dev;
708 struct net_device *netdev;
709 int err;
710
bba95fef 711 err = get_drv_dev_by_info_ifindex(info->attrs, &dev, &netdev);
55682965
JB		 712 if (err)
713 return err;
714
715 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
716 if (!msg)
717 goto out_err;
718
d726405a
JB		 719 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
720 dev, netdev) < 0)
55682965
JB		 721 goto out_free;
722
723 dev_put(netdev);
724 cfg80211_put_dev(dev);
725
726 return genlmsg_unicast(msg, info->snd_pid);
727
728 out_free:
729 nlmsg_free(msg);
730 out_err:
731 dev_put(netdev);
732 cfg80211_put_dev(dev);
733 return -ENOBUFS;
734}
735
66f7ac50
MW		 736static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
737 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
738 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
739 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
740 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
741 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
742};
743
744static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
745{
746 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
747 int flag;
748
749 *mntrflags = 0;
750
751 if (!nla)
752 return -EINVAL;
753
754 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
755 nla, mntr_flags_policy))
756 return -EINVAL;
757
758 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
759 if (flags[flag])
760 *mntrflags |= (1<<flag);
761
762 return 0;
763}
764
55682965
JB		 765static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
766{
767 struct cfg80211_registered_device *drv;
2ec600d6 768 struct vif_params params;
55682965 769 int err, ifindex;
04a773ad 770 enum nl80211_iftype otype, ntype;
55682965 771 struct net_device *dev;
92ffe055 772 u32 _flags, *flags = NULL;
ac7f9cfa 773 bool change = false;
55682965 774
2ec600d6
LCC		 775 memset(&params, 0, sizeof(params));
776
3b85875a
JB		 777 rtnl_lock();
778
bba95fef 779 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
55682965 780 if (err)
3b85875a
JB		 781 goto unlock_rtnl;
782
55682965 783 ifindex = dev->ifindex;
04a773ad 784 otype = ntype = dev->ieee80211_ptr->iftype;
55682965
JB		 785 dev_put(dev);
786
723b038d 787 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 788 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 789 if (otype != ntype)
ac7f9cfa 790 change = true;
04a773ad 791 if (ntype > NL80211_IFTYPE_MAX) {
ac7f9cfa 792 err = -EINVAL;
723b038d 793 goto unlock;
ac7f9cfa 794 }
723b038d
JB		 795 }
796
f59ac048 797 if (!drv->ops->change_virtual_intf ||
04a773ad 798 !(drv->wiphy.interface_modes & (1 << ntype))) {
55682965
JB		 799 err = -EOPNOTSUPP;
800 goto unlock;
801 }
802
92ffe055 803 if (info->attrs[NL80211_ATTR_MESH_ID]) {
04a773ad 804 if (ntype != NL80211_IFTYPE_MESH_POINT) {
92ffe055
JB		 805 err = -EINVAL;
806 goto unlock;
807 }
2ec600d6
LCC		 808 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
809 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
ac7f9cfa 810 change = true;
2ec600d6
LCC		 811 }
812
92ffe055 813 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
04a773ad 814 if (ntype != NL80211_IFTYPE_MONITOR) {
92ffe055
JB		 815 err = -EINVAL;
816 goto unlock;
817 }
818 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
819 &_flags);
ac7f9cfa
JB		 820 if (err)
821 goto unlock;
822
823 flags = &_flags;
824 change = true;
92ffe055 825 }
3b85875a 826
ac7f9cfa
JB		 827 if (change)
828 err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex,
04a773ad 829 ntype, flags, &params);
ac7f9cfa
JB		 830 else
831 err = 0;
60719ffd
JB		 832
833 dev = __dev_get_by_index(&init_net, ifindex);
04a773ad
JB		 834 WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != ntype));
835
836 if (dev && !err && (ntype != otype)) {
837 if (otype == NL80211_IFTYPE_ADHOC)
9d308429 838 cfg80211_clear_ibss(dev, false);
04a773ad 839 }
60719ffd 840
55682965
JB		 841 unlock:
842 cfg80211_put_dev(drv);
3b85875a
JB		 843 unlock_rtnl:
844 rtnl_unlock();
55682965
JB		 845 return err;
846}
847
848static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
849{
850 struct cfg80211_registered_device *drv;
2ec600d6 851 struct vif_params params;
55682965
JB		 852 int err;
853 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
66f7ac50 854 u32 flags;
55682965 855
2ec600d6
LCC		 856 memset(&params, 0, sizeof(params));
857
55682965
JB		 858 if (!info->attrs[NL80211_ATTR_IFNAME])
859 return -EINVAL;
860
861 if (info->attrs[NL80211_ATTR_IFTYPE]) {
862 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
863 if (type > NL80211_IFTYPE_MAX)
864 return -EINVAL;
865 }
866
3b85875a
JB		 867 rtnl_lock();
868
55682965 869 drv = cfg80211_get_dev_from_info(info);
3b85875a
JB		 870 if (IS_ERR(drv)) {
871 err = PTR_ERR(drv);
872 goto unlock_rtnl;
873 }
55682965 874
f59ac048
LR		 875 if (!drv->ops->add_virtual_intf ||
876 !(drv->wiphy.interface_modes & (1 << type))) {
55682965
JB		 877 err = -EOPNOTSUPP;
878 goto unlock;
879 }
880
2ec600d6
LCC		 881 if (type == NL80211_IFTYPE_MESH_POINT &&
882 info->attrs[NL80211_ATTR_MESH_ID]) {
883 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
884 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
885 }
886
66f7ac50
MW		 887 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
888 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
889 &flags);
55682965 890 err = drv->ops->add_virtual_intf(&drv->wiphy,
66f7ac50 891 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2ec600d6 892 type, err ? NULL : &flags, &params);
2ec600d6 893
55682965
JB		 894 unlock:
895 cfg80211_put_dev(drv);
3b85875a
JB		 896 unlock_rtnl:
897 rtnl_unlock();
55682965
JB		 898 return err;
899}
900
901static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
902{
903 struct cfg80211_registered_device *drv;
904 int ifindex, err;
905 struct net_device *dev;
906
3b85875a
JB		 907 rtnl_lock();
908
bba95fef 909 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
55682965 910 if (err)
3b85875a 911 goto unlock_rtnl;
55682965
JB		 912 ifindex = dev->ifindex;
913 dev_put(dev);
914
915 if (!drv->ops->del_virtual_intf) {
916 err = -EOPNOTSUPP;
917 goto out;
918 }
919
55682965 920 err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
55682965
JB		 921
922 out:
923 cfg80211_put_dev(drv);
3b85875a
JB		 924 unlock_rtnl:
925 rtnl_unlock();
55682965
JB		 926 return err;
927}
928
41ade00f
JB		 929struct get_key_cookie {
930 struct sk_buff *msg;
931 int error;
932};
933
934static void get_key_callback(void *c, struct key_params *params)
935{
936 struct get_key_cookie *cookie = c;
937
938 if (params->key)
939 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
940 params->key_len, params->key);
941
942 if (params->seq)
943 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
944 params->seq_len, params->seq);
945
946 if (params->cipher)
947 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
948 params->cipher);
949
950 return;
951 nla_put_failure:
952 cookie->error = 1;
953}
954
955static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
956{
957 struct cfg80211_registered_device *drv;
958 int err;
959 struct net_device *dev;
960 u8 key_idx = 0;
961 u8 *mac_addr = NULL;
962 struct get_key_cookie cookie = {
963 .error = 0,
964 };
965 void *hdr;
966 struct sk_buff *msg;
967
968 if (info->attrs[NL80211_ATTR_KEY_IDX])
969 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
970
3cfcf6ac 971 if (key_idx > 5)
41ade00f
JB		 972 return -EINVAL;
973
974 if (info->attrs[NL80211_ATTR_MAC])
975 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
976
3b85875a
JB		 977 rtnl_lock();
978
bba95fef 979 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
41ade00f 980 if (err)
3b85875a 981 goto unlock_rtnl;
41ade00f
JB		 982
983 if (!drv->ops->get_key) {
984 err = -EOPNOTSUPP;
985 goto out;
986 }
987
988 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
989 if (!msg) {
990 err = -ENOMEM;
991 goto out;
992 }
993
994 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
995 NL80211_CMD_NEW_KEY);
996
997 if (IS_ERR(hdr)) {
998 err = PTR_ERR(hdr);
999 goto out;
1000 }
1001
1002 cookie.msg = msg;
1003
1004 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1005 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1006 if (mac_addr)
1007 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1008
41ade00f
JB		 1009 err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
1010 &cookie, get_key_callback);
41ade00f
JB		 1011
1012 if (err)
1013 goto out;
1014
1015 if (cookie.error)
1016 goto nla_put_failure;
1017
1018 genlmsg_end(msg, hdr);
1019 err = genlmsg_unicast(msg, info->snd_pid);
1020 goto out;
1021
1022 nla_put_failure:
1023 err = -ENOBUFS;
1024 nlmsg_free(msg);
1025 out:
1026 cfg80211_put_dev(drv);
1027 dev_put(dev);
3b85875a
JB		 1028 unlock_rtnl:
1029 rtnl_unlock();
1030
41ade00f
JB		 1031 return err;
1032}
1033
1034static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
1035{
1036 struct cfg80211_registered_device *drv;
1037 int err;
1038 struct net_device *dev;
1039 u8 key_idx;
3cfcf6ac
JM		 1040 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
1041 u8 key_index);
41ade00f
JB		 1042
1043 if (!info->attrs[NL80211_ATTR_KEY_IDX])
1044 return -EINVAL;
1045
1046 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1047
3cfcf6ac
JM		 1048 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT]) {
1049 if (key_idx < 4 || key_idx > 5)
1050 return -EINVAL;
1051 } else if (key_idx > 3)
41ade00f
JB		 1052 return -EINVAL;
1053
1054 /* currently only support setting default key */
3cfcf6ac
JM		 1055 if (!info->attrs[NL80211_ATTR_KEY_DEFAULT] &&
1056 !info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT])
41ade00f
JB		 1057 return -EINVAL;
1058
3b85875a
JB		 1059 rtnl_lock();
1060
bba95fef 1061 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
41ade00f 1062 if (err)
3b85875a 1063 goto unlock_rtnl;
41ade00f 1064
3cfcf6ac
JM		 1065 if (info->attrs[NL80211_ATTR_KEY_DEFAULT])
1066 func = drv->ops->set_default_key;
1067 else
1068 func = drv->ops->set_default_mgmt_key;
1069
1070 if (!func) {
41ade00f
JB		 1071 err = -EOPNOTSUPP;
1072 goto out;
1073 }
1074
3cfcf6ac 1075 err = func(&drv->wiphy, dev, key_idx);
08645126
JB		 1076#ifdef CONFIG_WIRELESS_EXT
1077 if (!err) {
1078 if (func == drv->ops->set_default_key)
1079 dev->ieee80211_ptr->wext.default_key = key_idx;
1080 else
1081 dev->ieee80211_ptr->wext.default_mgmt_key = key_idx;
1082 }
1083#endif
41ade00f
JB		 1084
1085 out:
1086 cfg80211_put_dev(drv);
1087 dev_put(dev);
3b85875a
JB		 1088
1089 unlock_rtnl:
1090 rtnl_unlock();
1091
41ade00f
JB		 1092 return err;
1093}
1094
1095static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
1096{
1097 struct cfg80211_registered_device *drv;
25e47c18 1098 int err, i;
41ade00f
JB		 1099 struct net_device *dev;
1100 struct key_params params;
1101 u8 key_idx = 0;
1102 u8 *mac_addr = NULL;
1103
1104 memset(&params, 0, sizeof(params));
1105
1106 if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
1107 return -EINVAL;
1108
1109 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1110 params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1111 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1112 }
1113
1114 if (info->attrs[NL80211_ATTR_KEY_IDX])
1115 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1116
1117 params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1118
1119 if (info->attrs[NL80211_ATTR_MAC])
1120 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1121
08645126 1122 if (cfg80211_validate_key_settings(&params, key_idx, mac_addr))
41ade00f
JB		 1123 return -EINVAL;
1124
3b85875a
JB		 1125 rtnl_lock();
1126
bba95fef 1127 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
41ade00f 1128 if (err)
3b85875a 1129 goto unlock_rtnl;
41ade00f 1130
25e47c18
JB		 1131 for (i = 0; i < drv->wiphy.n_cipher_suites; i++)
1132 if (params.cipher == drv->wiphy.cipher_suites[i])
1133 break;
1134 if (i == drv->wiphy.n_cipher_suites) {
1135 err = -EINVAL;
1136 goto out;
1137 }
1138
41ade00f
JB		 1139 if (!drv->ops->add_key) {
1140 err = -EOPNOTSUPP;
1141 goto out;
1142 }
1143
41ade00f 1144 err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
41ade00f
JB		 1145
1146 out:
1147 cfg80211_put_dev(drv);
1148 dev_put(dev);
3b85875a
JB		 1149 unlock_rtnl:
1150 rtnl_unlock();
1151
41ade00f
JB		 1152 return err;
1153}
1154
1155static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
1156{
1157 struct cfg80211_registered_device *drv;
1158 int err;
1159 struct net_device *dev;
1160 u8 key_idx = 0;
1161 u8 *mac_addr = NULL;
1162
1163 if (info->attrs[NL80211_ATTR_KEY_IDX])
1164 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1165
3cfcf6ac 1166 if (key_idx > 5)
41ade00f
JB		 1167 return -EINVAL;
1168
1169 if (info->attrs[NL80211_ATTR_MAC])
1170 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1171
3b85875a
JB		 1172 rtnl_lock();
1173
bba95fef 1174 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
41ade00f 1175 if (err)
3b85875a 1176 goto unlock_rtnl;
41ade00f
JB		 1177
1178 if (!drv->ops->del_key) {
1179 err = -EOPNOTSUPP;
1180 goto out;
1181 }
1182
41ade00f 1183 err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
41ade00f 1184
08645126
JB		 1185#ifdef CONFIG_WIRELESS_EXT
1186 if (!err) {
1187 if (key_idx == dev->ieee80211_ptr->wext.default_key)
1188 dev->ieee80211_ptr->wext.default_key = -1;
1189 else if (key_idx == dev->ieee80211_ptr->wext.default_mgmt_key)
1190 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
1191 }
1192#endif
1193
41ade00f
JB		 1194 out:
1195 cfg80211_put_dev(drv);
1196 dev_put(dev);
3b85875a
JB		 1197
1198 unlock_rtnl:
1199 rtnl_unlock();
1200
41ade00f
JB		 1201 return err;
1202}
1203
ed1b6cc7
JB		 1204static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
1205{
1206 int (*call)(struct wiphy *wiphy, struct net_device *dev,
1207 struct beacon_parameters *info);
1208 struct cfg80211_registered_device *drv;
1209 int err;
1210 struct net_device *dev;
1211 struct beacon_parameters params;
1212 int haveinfo = 0;
1213
f4a11bb0
JB		 1214 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1215 return -EINVAL;
1216
3b85875a
JB		 1217 rtnl_lock();
1218
bba95fef 1219 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
ed1b6cc7 1220 if (err)
3b85875a 1221 goto unlock_rtnl;
ed1b6cc7 1222
eec60b03
JM		 1223 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1224 err = -EOPNOTSUPP;
1225 goto out;
1226 }
1227
ed1b6cc7
JB		 1228 switch (info->genlhdr->cmd) {
1229 case NL80211_CMD_NEW_BEACON:
1230 /* these are required for NEW_BEACON */
1231 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
1232 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
1233 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1234 err = -EINVAL;
1235 goto out;
1236 }
1237
1238 call = drv->ops->add_beacon;
1239 break;
1240 case NL80211_CMD_SET_BEACON:
1241 call = drv->ops->set_beacon;
1242 break;
1243 default:
1244 WARN_ON(1);
1245 err = -EOPNOTSUPP;
1246 goto out;
1247 }
1248
1249 if (!call) {
1250 err = -EOPNOTSUPP;
1251 goto out;
1252 }
1253
1254 memset(&params, 0, sizeof(params));
1255
1256 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1257 params.interval =
1258 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1259 haveinfo = 1;
1260 }
1261
1262 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1263 params.dtim_period =
1264 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1265 haveinfo = 1;
1266 }
1267
1268 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1269 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1270 params.head_len =
1271 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1272 haveinfo = 1;
1273 }
1274
1275 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1276 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1277 params.tail_len =
1278 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1279 haveinfo = 1;
1280 }
1281
1282 if (!haveinfo) {
1283 err = -EINVAL;
1284 goto out;
1285 }
1286
ed1b6cc7 1287 err = call(&drv->wiphy, dev, &params);
ed1b6cc7
JB		 1288
1289 out:
1290 cfg80211_put_dev(drv);
1291 dev_put(dev);
3b85875a
JB		 1292 unlock_rtnl:
1293 rtnl_unlock();
1294
ed1b6cc7
JB		 1295 return err;
1296}
1297
1298static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1299{
1300 struct cfg80211_registered_device *drv;
1301 int err;
1302 struct net_device *dev;
1303
3b85875a
JB		 1304 rtnl_lock();
1305
bba95fef 1306 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
ed1b6cc7 1307 if (err)
3b85875a 1308 goto unlock_rtnl;
ed1b6cc7
JB		 1309
1310 if (!drv->ops->del_beacon) {
1311 err = -EOPNOTSUPP;
1312 goto out;
1313 }
1314
eec60b03
JM		 1315 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1316 err = -EOPNOTSUPP;
1317 goto out;
1318 }
ed1b6cc7 1319 err = drv->ops->del_beacon(&drv->wiphy, dev);
ed1b6cc7
JB		 1320
1321 out:
1322 cfg80211_put_dev(drv);
1323 dev_put(dev);
3b85875a
JB		 1324 unlock_rtnl:
1325 rtnl_unlock();
1326
ed1b6cc7
JB		 1327 return err;
1328}
1329
5727ef1b
JB		 1330static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1331 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1332 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1333 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 1334 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
5727ef1b
JB		 1335};
1336
1337static int parse_station_flags(struct nlattr *nla, u32 *staflags)
1338{
1339 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
1340 int flag;
1341
1342 *staflags = 0;
1343
1344 if (!nla)
1345 return 0;
1346
1347 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1348 nla, sta_flags_policy))
1349 return -EINVAL;
1350
1351 *staflags = STATION_FLAG_CHANGED;
1352
1353 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1354 if (flags[flag])
1355 *staflags |= (1<<flag);
1356
1357 return 0;
1358}
1359
420e7fab
HR		 1360static u16 nl80211_calculate_bitrate(struct rate_info *rate)
1361{
1362 int modulation, streams, bitrate;
1363
1364 if (!(rate->flags & RATE_INFO_FLAGS_MCS))
1365 return rate->legacy;
1366
1367 /* the formula below does only work for MCS values smaller than 32 */
1368 if (rate->mcs >= 32)
1369 return 0;
1370
1371 modulation = rate->mcs & 7;
1372 streams = (rate->mcs >> 3) + 1;
1373
1374 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ?
1375 13500000 : 6500000;
1376
1377 if (modulation < 4)
1378 bitrate *= (modulation + 1);
1379 else if (modulation == 4)
1380 bitrate *= (modulation + 2);
1381 else
1382 bitrate *= (modulation + 3);
1383
1384 bitrate *= streams;
1385
1386 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI)
1387 bitrate = (bitrate / 9) * 10;
1388
1389 /* do NOT round down here */
1390 return (bitrate + 50000) / 100000;
1391}
1392
fd5b74dc
JB		 1393static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1394 int flags, struct net_device *dev,
2ec600d6 1395 u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 1396{
1397 void *hdr;
420e7fab
HR		 1398 struct nlattr *sinfoattr, *txrate;
1399 u16 bitrate;
fd5b74dc
JB		 1400
1401 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1402 if (!hdr)
1403 return -1;
1404
1405 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1406 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1407
2ec600d6
LCC		 1408 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1409 if (!sinfoattr)
fd5b74dc 1410 goto nla_put_failure;
2ec600d6
LCC		 1411 if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1412 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1413 sinfo->inactive_time);
1414 if (sinfo->filled & STATION_INFO_RX_BYTES)
1415 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1416 sinfo->rx_bytes);
1417 if (sinfo->filled & STATION_INFO_TX_BYTES)
1418 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1419 sinfo->tx_bytes);
1420 if (sinfo->filled & STATION_INFO_LLID)
1421 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1422 sinfo->llid);
1423 if (sinfo->filled & STATION_INFO_PLID)
1424 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1425 sinfo->plid);
1426 if (sinfo->filled & STATION_INFO_PLINK_STATE)
1427 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1428 sinfo->plink_state);
420e7fab
HR		 1429 if (sinfo->filled & STATION_INFO_SIGNAL)
1430 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
1431 sinfo->signal);
1432 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
1433 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
1434 if (!txrate)
1435 goto nla_put_failure;
1436
1437 /* nl80211_calculate_bitrate will return 0 for mcs >= 32 */
1438 bitrate = nl80211_calculate_bitrate(&sinfo->txrate);
1439 if (bitrate > 0)
1440 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
2ec600d6 1441
420e7fab
HR		 1442 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
1443 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
1444 sinfo->txrate.mcs);
1445 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
1446 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
1447 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
1448 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
1449
1450 nla_nest_end(msg, txrate);
1451 }
98c8a60a
JM		 1452 if (sinfo->filled & STATION_INFO_RX_PACKETS)
1453 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
1454 sinfo->rx_packets);
1455 if (sinfo->filled & STATION_INFO_TX_PACKETS)
1456 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS,
1457 sinfo->tx_packets);
2ec600d6 1458 nla_nest_end(msg, sinfoattr);
fd5b74dc
JB		 1459
1460 return genlmsg_end(msg, hdr);
1461
1462 nla_put_failure:
bc3ed28c
TG		 1463 genlmsg_cancel(msg, hdr);
1464 return -EMSGSIZE;
fd5b74dc
JB		 1465}
1466
2ec600d6 1467static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 1468 struct netlink_callback *cb)
2ec600d6 1469{
2ec600d6
LCC		 1470 struct station_info sinfo;
1471 struct cfg80211_registered_device *dev;
bba95fef 1472 struct net_device *netdev;
2ec600d6 1473 u8 mac_addr[ETH_ALEN];
bba95fef
JB		 1474 int ifidx = cb->args[0];
1475 int sta_idx = cb->args[1];
2ec600d6 1476 int err;
2ec600d6 1477
bba95fef
JB		 1478 if (!ifidx) {
1479 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1480 nl80211_fam.attrbuf, nl80211_fam.maxattr,
1481 nl80211_policy);
1482 if (err)
1483 return err;
2ec600d6 1484
bba95fef
JB		 1485 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1486 return -EINVAL;
2ec600d6 1487
bba95fef
JB		 1488 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1489 if (!ifidx)
1490 return -EINVAL;
2ec600d6 1491 }
2ec600d6 1492
3b85875a
JB		 1493 rtnl_lock();
1494
1495 netdev = __dev_get_by_index(&init_net, ifidx);
1496 if (!netdev) {
1497 err = -ENODEV;
1498 goto out_rtnl;
1499 }
2ec600d6 1500
bba95fef
JB		 1501 dev = cfg80211_get_dev_from_ifindex(ifidx);
1502 if (IS_ERR(dev)) {
1503 err = PTR_ERR(dev);
3b85875a 1504 goto out_rtnl;
bba95fef
JB		 1505 }
1506
1507 if (!dev->ops->dump_station) {
eec60b03 1508 err = -EOPNOTSUPP;
bba95fef
JB		 1509 goto out_err;
1510 }
1511
bba95fef
JB		 1512 while (1) {
1513 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1514 mac_addr, &sinfo);
1515 if (err == -ENOENT)
1516 break;
1517 if (err)
3b85875a 1518 goto out_err;
bba95fef
JB		 1519
1520 if (nl80211_send_station(skb,
1521 NETLINK_CB(cb->skb).pid,
1522 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1523 netdev, mac_addr,
1524 &sinfo) < 0)
1525 goto out;
1526
1527 sta_idx++;
1528 }
1529
1530
1531 out:
1532 cb->args[1] = sta_idx;
1533 err = skb->len;
bba95fef
JB		 1534 out_err:
1535 cfg80211_put_dev(dev);
3b85875a
JB		 1536 out_rtnl:
1537 rtnl_unlock();
bba95fef
JB		 1538
1539 return err;
2ec600d6 1540}
fd5b74dc 1541
5727ef1b
JB		 1542static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1543{
fd5b74dc
JB		 1544 struct cfg80211_registered_device *drv;
1545 int err;
1546 struct net_device *dev;
2ec600d6 1547 struct station_info sinfo;
fd5b74dc
JB		 1548 struct sk_buff *msg;
1549 u8 *mac_addr = NULL;
1550
2ec600d6 1551 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 1552
1553 if (!info->attrs[NL80211_ATTR_MAC])
1554 return -EINVAL;
1555
1556 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1557
3b85875a
JB		 1558 rtnl_lock();
1559
bba95fef 1560 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
fd5b74dc 1561 if (err)
3b85875a 1562 goto out_rtnl;
fd5b74dc
JB		 1563
1564 if (!drv->ops->get_station) {
1565 err = -EOPNOTSUPP;
1566 goto out;
1567 }
1568
2ec600d6 1569 err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &sinfo);
2ec600d6
LCC		 1570 if (err)
1571 goto out;
1572
fd5b74dc
JB		 1573 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1574 if (!msg)
1575 goto out;
1576
1577 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
2ec600d6 1578 dev, mac_addr, &sinfo) < 0)
fd5b74dc
JB		 1579 goto out_free;
1580
1581 err = genlmsg_unicast(msg, info->snd_pid);
1582 goto out;
1583
1584 out_free:
1585 nlmsg_free(msg);
fd5b74dc
JB		 1586 out:
1587 cfg80211_put_dev(drv);
1588 dev_put(dev);
3b85875a
JB		 1589 out_rtnl:
1590 rtnl_unlock();
1591
fd5b74dc 1592 return err;
5727ef1b
JB		 1593}
1594
1595/*
1596 * Get vlan interface making sure it is on the right wiphy.
1597 */
1598static int get_vlan(struct nlattr *vlanattr,
1599 struct cfg80211_registered_device *rdev,
1600 struct net_device **vlan)
1601{
1602 *vlan = NULL;
1603
1604 if (vlanattr) {
1605 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
1606 if (!*vlan)
1607 return -ENODEV;
1608 if (!(*vlan)->ieee80211_ptr)
1609 return -EINVAL;
1610 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1611 return -EINVAL;
1612 }
1613 return 0;
1614}
1615
1616static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1617{
1618 struct cfg80211_registered_device *drv;
1619 int err;
1620 struct net_device *dev;
1621 struct station_parameters params;
1622 u8 *mac_addr = NULL;
1623
1624 memset(&params, 0, sizeof(params));
1625
1626 params.listen_interval = -1;
1627
1628 if (info->attrs[NL80211_ATTR_STA_AID])
1629 return -EINVAL;
1630
1631 if (!info->attrs[NL80211_ATTR_MAC])
1632 return -EINVAL;
1633
1634 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1635
1636 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
1637 params.supported_rates =
1638 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1639 params.supported_rates_len =
1640 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1641 }
1642
1643 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1644 params.listen_interval =
1645 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1646
36aedc90
JM		 1647 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1648 params.ht_capa =
1649 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1650
5727ef1b
JB		 1651 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1652 &params.station_flags))
1653 return -EINVAL;
1654
2ec600d6
LCC		 1655 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
1656 params.plink_action =
1657 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
1658
3b85875a
JB		 1659 rtnl_lock();
1660
bba95fef 1661 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
5727ef1b 1662 if (err)
3b85875a 1663 goto out_rtnl;
5727ef1b
JB		 1664
1665 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
1666 if (err)
1667 goto out;
1668
1669 if (!drv->ops->change_station) {
1670 err = -EOPNOTSUPP;
1671 goto out;
1672 }
1673
5727ef1b 1674 err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
5727ef1b
JB		 1675
1676 out:
1677 if (params.vlan)
1678 dev_put(params.vlan);
1679 cfg80211_put_dev(drv);
1680 dev_put(dev);
3b85875a
JB		 1681 out_rtnl:
1682 rtnl_unlock();
1683
5727ef1b
JB		 1684 return err;
1685}
1686
1687static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
1688{
1689 struct cfg80211_registered_device *drv;
1690 int err;
1691 struct net_device *dev;
1692 struct station_parameters params;
1693 u8 *mac_addr = NULL;
1694
1695 memset(&params, 0, sizeof(params));
1696
1697 if (!info->attrs[NL80211_ATTR_MAC])
1698 return -EINVAL;
1699
1700 if (!info->attrs[NL80211_ATTR_STA_AID])
1701 return -EINVAL;
1702
1703 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1704 return -EINVAL;
1705
1706 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
1707 return -EINVAL;
1708
1709 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1710 params.supported_rates =
1711 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1712 params.supported_rates_len =
1713 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1714 params.listen_interval =
1715 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
16f2e85d 1716 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
36aedc90
JM		 1717 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1718 params.ht_capa =
1719 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b
JB		 1720
1721 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1722 &params.station_flags))
1723 return -EINVAL;
1724
3b85875a
JB		 1725 rtnl_lock();
1726
bba95fef 1727 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
5727ef1b 1728 if (err)
3b85875a 1729 goto out_rtnl;
5727ef1b 1730
e80cf853
JB		 1731 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1732 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
1733 err = -EINVAL;
1734 goto out;
1735 }
1736
5727ef1b
JB		 1737 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
1738 if (err)
1739 goto out;
1740
1741 if (!drv->ops->add_station) {
1742 err = -EOPNOTSUPP;
1743 goto out;
1744 }
1745
35a8efe1
JM		 1746 if (!netif_running(dev)) {
1747 err = -ENETDOWN;
1748 goto out;
1749 }
1750
5727ef1b 1751 err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
5727ef1b
JB		 1752
1753 out:
1754 if (params.vlan)
1755 dev_put(params.vlan);
1756 cfg80211_put_dev(drv);
1757 dev_put(dev);
3b85875a
JB		 1758 out_rtnl:
1759 rtnl_unlock();
1760
5727ef1b
JB		 1761 return err;
1762}
1763
1764static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
1765{
1766 struct cfg80211_registered_device *drv;
1767 int err;
1768 struct net_device *dev;
1769 u8 *mac_addr = NULL;
1770
1771 if (info->attrs[NL80211_ATTR_MAC])
1772 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1773
3b85875a
JB		 1774 rtnl_lock();
1775
bba95fef 1776 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
5727ef1b 1777 if (err)
3b85875a 1778 goto out_rtnl;
5727ef1b 1779
e80cf853
JB		 1780 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1781 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
1782 err = -EINVAL;
1783 goto out;
1784 }
1785
5727ef1b
JB		 1786 if (!drv->ops->del_station) {
1787 err = -EOPNOTSUPP;
1788 goto out;
1789 }
1790
5727ef1b 1791 err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
5727ef1b
JB		 1792
1793 out:
1794 cfg80211_put_dev(drv);
1795 dev_put(dev);
3b85875a
JB		 1796 out_rtnl:
1797 rtnl_unlock();
1798
5727ef1b
JB		 1799 return err;
1800}
1801
2ec600d6
LCC		 1802static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
1803 int flags, struct net_device *dev,
1804 u8 *dst, u8 *next_hop,
1805 struct mpath_info *pinfo)
1806{
1807 void *hdr;
1808 struct nlattr *pinfoattr;
1809
1810 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1811 if (!hdr)
1812 return -1;
1813
1814 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1815 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
1816 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
1817
1818 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
1819 if (!pinfoattr)
1820 goto nla_put_failure;
1821 if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
1822 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
1823 pinfo->frame_qlen);
1824 if (pinfo->filled & MPATH_INFO_DSN)
1825 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
1826 pinfo->dsn);
1827 if (pinfo->filled & MPATH_INFO_METRIC)
1828 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
1829 pinfo->metric);
1830 if (pinfo->filled & MPATH_INFO_EXPTIME)
1831 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
1832 pinfo->exptime);
1833 if (pinfo->filled & MPATH_INFO_FLAGS)
1834 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
1835 pinfo->flags);
1836 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
1837 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
1838 pinfo->discovery_timeout);
1839 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
1840 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
1841 pinfo->discovery_retries);
1842
1843 nla_nest_end(msg, pinfoattr);
1844
1845 return genlmsg_end(msg, hdr);
1846
1847 nla_put_failure:
bc3ed28c
TG		 1848 genlmsg_cancel(msg, hdr);
1849 return -EMSGSIZE;
2ec600d6
LCC		 1850}
1851
1852static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 1853 struct netlink_callback *cb)
2ec600d6 1854{
2ec600d6
LCC		 1855 struct mpath_info pinfo;
1856 struct cfg80211_registered_device *dev;
bba95fef 1857 struct net_device *netdev;
2ec600d6
LCC		 1858 u8 dst[ETH_ALEN];
1859 u8 next_hop[ETH_ALEN];
bba95fef
JB		 1860 int ifidx = cb->args[0];
1861 int path_idx = cb->args[1];
2ec600d6 1862 int err;
2ec600d6 1863
bba95fef
JB		 1864 if (!ifidx) {
1865 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1866 nl80211_fam.attrbuf, nl80211_fam.maxattr,
1867 nl80211_policy);
1868 if (err)
1869 return err;
1870
1871 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1872 return -EINVAL;
1873
1874 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1875 if (!ifidx)
1876 return -EINVAL;
1877 }
1878
3b85875a
JB		 1879 rtnl_lock();
1880
1881 netdev = __dev_get_by_index(&init_net, ifidx);
1882 if (!netdev) {
1883 err = -ENODEV;
1884 goto out_rtnl;
1885 }
bba95fef
JB		 1886
1887 dev = cfg80211_get_dev_from_ifindex(ifidx);
1888 if (IS_ERR(dev)) {
1889 err = PTR_ERR(dev);
3b85875a 1890 goto out_rtnl;
bba95fef
JB		 1891 }
1892
1893 if (!dev->ops->dump_mpath) {
eec60b03 1894 err = -EOPNOTSUPP;
bba95fef
JB		 1895 goto out_err;
1896 }
1897
eec60b03
JM		 1898 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1899 err = -EOPNOTSUPP;
1900 goto out;
1901 }
1902
bba95fef
JB		 1903 while (1) {
1904 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
1905 dst, next_hop, &pinfo);
1906 if (err == -ENOENT)
2ec600d6 1907 break;
bba95fef 1908 if (err)
3b85875a 1909 goto out_err;
2ec600d6 1910
bba95fef
JB		 1911 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
1912 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1913 netdev, dst, next_hop,
1914 &pinfo) < 0)
1915 goto out;
2ec600d6 1916
bba95fef 1917 path_idx++;
2ec600d6 1918 }
2ec600d6 1919
2ec600d6 1920
bba95fef
JB		 1921 out:
1922 cb->args[1] = path_idx;
1923 err = skb->len;
bba95fef
JB		 1924 out_err:
1925 cfg80211_put_dev(dev);
3b85875a
JB		 1926 out_rtnl:
1927 rtnl_unlock();
bba95fef
JB		 1928
1929 return err;
2ec600d6
LCC		 1930}
1931
1932static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
1933{
1934 struct cfg80211_registered_device *drv;
1935 int err;
1936 struct net_device *dev;
1937 struct mpath_info pinfo;
1938 struct sk_buff *msg;
1939 u8 *dst = NULL;
1940 u8 next_hop[ETH_ALEN];
1941
1942 memset(&pinfo, 0, sizeof(pinfo));
1943
1944 if (!info->attrs[NL80211_ATTR_MAC])
1945 return -EINVAL;
1946
1947 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
1948
3b85875a
JB		 1949 rtnl_lock();
1950
bba95fef 1951 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2ec600d6 1952 if (err)
3b85875a 1953 goto out_rtnl;
2ec600d6
LCC		 1954
1955 if (!drv->ops->get_mpath) {
1956 err = -EOPNOTSUPP;
1957 goto out;
1958 }
1959
eec60b03
JM		 1960 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1961 err = -EOPNOTSUPP;
1962 goto out;
1963 }
1964
2ec600d6 1965 err = drv->ops->get_mpath(&drv->wiphy, dev, dst, next_hop, &pinfo);
2ec600d6
LCC		 1966 if (err)
1967 goto out;
1968
1969 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1970 if (!msg)
1971 goto out;
1972
1973 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
1974 dev, dst, next_hop, &pinfo) < 0)
1975 goto out_free;
1976
1977 err = genlmsg_unicast(msg, info->snd_pid);
1978 goto out;
1979
1980 out_free:
1981 nlmsg_free(msg);
2ec600d6
LCC		 1982 out:
1983 cfg80211_put_dev(drv);
1984 dev_put(dev);
3b85875a
JB		 1985 out_rtnl:
1986 rtnl_unlock();
1987
2ec600d6
LCC		 1988 return err;
1989}
1990
1991static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
1992{
1993 struct cfg80211_registered_device *drv;
1994 int err;
1995 struct net_device *dev;
1996 u8 *dst = NULL;
1997 u8 *next_hop = NULL;
1998
1999 if (!info->attrs[NL80211_ATTR_MAC])
2000 return -EINVAL;
2001
2002 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2003 return -EINVAL;
2004
2005 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2006 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2007
3b85875a
JB		 2008 rtnl_lock();
2009
bba95fef 2010 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2ec600d6 2011 if (err)
3b85875a 2012 goto out_rtnl;
2ec600d6
LCC		 2013
2014 if (!drv->ops->change_mpath) {
2015 err = -EOPNOTSUPP;
2016 goto out;
2017 }
2018
eec60b03
JM		 2019 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2020 err = -EOPNOTSUPP;
2021 goto out;
2022 }
2023
35a8efe1
JM		 2024 if (!netif_running(dev)) {
2025 err = -ENETDOWN;
2026 goto out;
2027 }
2028
2ec600d6 2029 err = drv->ops->change_mpath(&drv->wiphy, dev, dst, next_hop);
2ec600d6
LCC		 2030
2031 out:
2032 cfg80211_put_dev(drv);
2033 dev_put(dev);
3b85875a
JB		 2034 out_rtnl:
2035 rtnl_unlock();
2036
2ec600d6
LCC		 2037 return err;
2038}
2039static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
2040{
2041 struct cfg80211_registered_device *drv;
2042 int err;
2043 struct net_device *dev;
2044 u8 *dst = NULL;
2045 u8 *next_hop = NULL;
2046
2047 if (!info->attrs[NL80211_ATTR_MAC])
2048 return -EINVAL;
2049
2050 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2051 return -EINVAL;
2052
2053 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2054 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2055
3b85875a
JB		 2056 rtnl_lock();
2057
bba95fef 2058 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2ec600d6 2059 if (err)
3b85875a 2060 goto out_rtnl;
2ec600d6
LCC		 2061
2062 if (!drv->ops->add_mpath) {
2063 err = -EOPNOTSUPP;
2064 goto out;
2065 }
2066
eec60b03
JM		 2067 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2068 err = -EOPNOTSUPP;
2069 goto out;
2070 }
2071
35a8efe1
JM		 2072 if (!netif_running(dev)) {
2073 err = -ENETDOWN;
2074 goto out;
2075 }
2076
2ec600d6 2077 err = drv->ops->add_mpath(&drv->wiphy, dev, dst, next_hop);
2ec600d6
LCC		 2078
2079 out:
2080 cfg80211_put_dev(drv);
2081 dev_put(dev);
3b85875a
JB		 2082 out_rtnl:
2083 rtnl_unlock();
2084
2ec600d6
LCC		 2085 return err;
2086}
2087
2088static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
2089{
2090 struct cfg80211_registered_device *drv;
2091 int err;
2092 struct net_device *dev;
2093 u8 *dst = NULL;
2094
2095 if (info->attrs[NL80211_ATTR_MAC])
2096 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2097
3b85875a
JB		 2098 rtnl_lock();
2099
bba95fef 2100 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2ec600d6 2101 if (err)
3b85875a 2102 goto out_rtnl;
2ec600d6
LCC		 2103
2104 if (!drv->ops->del_mpath) {
2105 err = -EOPNOTSUPP;
2106 goto out;
2107 }
2108
2ec600d6 2109 err = drv->ops->del_mpath(&drv->wiphy, dev, dst);
2ec600d6
LCC		 2110
2111 out:
2112 cfg80211_put_dev(drv);
2113 dev_put(dev);
3b85875a
JB		 2114 out_rtnl:
2115 rtnl_unlock();
2116
2ec600d6
LCC		 2117 return err;
2118}
2119
9f1ba906
JM		 2120static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
2121{
2122 struct cfg80211_registered_device *drv;
2123 int err;
2124 struct net_device *dev;
2125 struct bss_parameters params;
2126
2127 memset(&params, 0, sizeof(params));
2128 /* default to not changing parameters */
2129 params.use_cts_prot = -1;
2130 params.use_short_preamble = -1;
2131 params.use_short_slot_time = -1;
2132
2133 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
2134 params.use_cts_prot =
2135 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
2136 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
2137 params.use_short_preamble =
2138 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
2139 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
2140 params.use_short_slot_time =
2141 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 2142 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
2143 params.basic_rates =
2144 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2145 params.basic_rates_len =
2146 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2147 }
9f1ba906 2148
3b85875a
JB		 2149 rtnl_lock();
2150
9f1ba906
JM		 2151 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2152 if (err)
3b85875a 2153 goto out_rtnl;
9f1ba906
JM		 2154
2155 if (!drv->ops->change_bss) {
2156 err = -EOPNOTSUPP;
2157 goto out;
2158 }
2159
eec60b03
JM		 2160 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2161 err = -EOPNOTSUPP;
2162 goto out;
2163 }
2164
9f1ba906 2165 err = drv->ops->change_bss(&drv->wiphy, dev, &params);
9f1ba906
JM		 2166
2167 out:
2168 cfg80211_put_dev(drv);
2169 dev_put(dev);
3b85875a
JB		 2170 out_rtnl:
2171 rtnl_unlock();
2172
9f1ba906
JM		 2173 return err;
2174}
2175
b2e1b302
LR		 2176static const struct nla_policy
2177 reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
2178 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2179 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2180 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2181 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2182 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2183 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2184};
2185
2186static int parse_reg_rule(struct nlattr *tb[],
2187 struct ieee80211_reg_rule *reg_rule)
2188{
2189 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
2190 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
2191
2192 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
2193 return -EINVAL;
2194 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
2195 return -EINVAL;
2196 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
2197 return -EINVAL;
2198 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2199 return -EINVAL;
2200 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2201 return -EINVAL;
2202
2203 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
2204
2205 freq_range->start_freq_khz =
2206 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
2207 freq_range->end_freq_khz =
2208 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
2209 freq_range->max_bandwidth_khz =
2210 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
2211
2212 power_rule->max_eirp =
2213 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
2214
2215 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
2216 power_rule->max_antenna_gain =
2217 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
2218
2219 return 0;
2220}
2221
2222static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2223{
2224 int r;
2225 char *data = NULL;
2226
80778f18
LR		 2227 /*
2228 * You should only get this when cfg80211 hasn't yet initialized
2229 * completely when built-in to the kernel right between the time
2230 * window between nl80211_init() and regulatory_init(), if that is
2231 * even possible.
2232 */
2233 mutex_lock(&cfg80211_mutex);
2234 if (unlikely(!cfg80211_regdomain)) {
fe33eb39
LR		 2235 mutex_unlock(&cfg80211_mutex);
2236 return -EINPROGRESS;
80778f18 2237 }
fe33eb39 2238 mutex_unlock(&cfg80211_mutex);
80778f18 2239
fe33eb39
LR		 2240 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2241 return -EINVAL;
b2e1b302
LR		 2242
2243 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2244
2245#ifdef CONFIG_WIRELESS_OLD_REGULATORY
2246 /* We ignore world regdom requests with the old regdom setup */
fe33eb39
LR		 2247 if (is_world_regdom(data))
2248 return -EINVAL;
b2e1b302 2249#endif
fe33eb39
LR		 2250
2251 r = regulatory_hint_user(data);
2252
b2e1b302
LR		 2253 return r;
2254}
2255
93da9cc1 2256static int nl80211_get_mesh_params(struct sk_buff *skb,
2257 struct genl_info *info)
2258{
2259 struct cfg80211_registered_device *drv;
2260 struct mesh_config cur_params;
2261 int err;
2262 struct net_device *dev;
2263 void *hdr;
2264 struct nlattr *pinfoattr;
2265 struct sk_buff *msg;
2266
3b85875a
JB		 2267 rtnl_lock();
2268
93da9cc1 2269 /* Look up our device */
2270 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2271 if (err)
3b85875a 2272 goto out_rtnl;
93da9cc1 2273
f3f92586
JM		 2274 if (!drv->ops->get_mesh_params) {
2275 err = -EOPNOTSUPP;
2276 goto out;
2277 }
2278
93da9cc1 2279 /* Get the mesh params */
93da9cc1 2280 err = drv->ops->get_mesh_params(&drv->wiphy, dev, &cur_params);
93da9cc1 2281 if (err)
2282 goto out;
2283
2284 /* Draw up a netlink message to send back */
2285 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2286 if (!msg) {
2287 err = -ENOBUFS;
2288 goto out;
2289 }
2290 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2291 NL80211_CMD_GET_MESH_PARAMS);
2292 if (!hdr)
2293 goto nla_put_failure;
2294 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
2295 if (!pinfoattr)
2296 goto nla_put_failure;
2297 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2298 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
2299 cur_params.dot11MeshRetryTimeout);
2300 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
2301 cur_params.dot11MeshConfirmTimeout);
2302 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
2303 cur_params.dot11MeshHoldingTimeout);
2304 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
2305 cur_params.dot11MeshMaxPeerLinks);
2306 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
2307 cur_params.dot11MeshMaxRetries);
2308 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
2309 cur_params.dot11MeshTTL);
2310 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
2311 cur_params.auto_open_plinks);
2312 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2313 cur_params.dot11MeshHWMPmaxPREQretries);
2314 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
2315 cur_params.path_refresh_time);
2316 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2317 cur_params.min_discovery_timeout);
2318 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2319 cur_params.dot11MeshHWMPactivePathTimeout);
2320 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2321 cur_params.dot11MeshHWMPpreqMinInterval);
2322 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2323 cur_params.dot11MeshHWMPnetDiameterTraversalTime);
2324 nla_nest_end(msg, pinfoattr);
2325 genlmsg_end(msg, hdr);
2326 err = genlmsg_unicast(msg, info->snd_pid);
2327 goto out;
2328
3b85875a 2329 nla_put_failure:
93da9cc1 2330 genlmsg_cancel(msg, hdr);
2331 err = -EMSGSIZE;
3b85875a 2332 out:
93da9cc1 2333 /* Cleanup */
2334 cfg80211_put_dev(drv);
2335 dev_put(dev);
3b85875a
JB		 2336 out_rtnl:
2337 rtnl_unlock();
2338
93da9cc1 2339 return err;
2340}
2341
2342#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2343do {\
2344 if (table[attr_num]) {\
2345 cfg.param = nla_fn(table[attr_num]); \
2346 mask |= (1 << (attr_num - 1)); \
2347 } \
2348} while (0);\
2349
2350static struct nla_policy
2351nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
2352 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
2353 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
2354 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
2355 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
2356 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
2357 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
2358 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
2359
2360 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
2361 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
2362 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
2363 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
2364 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
2365 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
2366};
2367
2368static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
2369{
2370 int err;
2371 u32 mask;
2372 struct cfg80211_registered_device *drv;
2373 struct net_device *dev;
2374 struct mesh_config cfg;
2375 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
2376 struct nlattr *parent_attr;
2377
2378 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
2379 if (!parent_attr)
2380 return -EINVAL;
2381 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
2382 parent_attr, nl80211_meshconf_params_policy))
2383 return -EINVAL;
2384
3b85875a
JB		 2385 rtnl_lock();
2386
93da9cc1 2387 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2388 if (err)
3b85875a 2389 goto out_rtnl;
93da9cc1 2390
f3f92586
JM		 2391 if (!drv->ops->set_mesh_params) {
2392 err = -EOPNOTSUPP;
2393 goto out;
2394 }
2395
93da9cc1 2396 /* This makes sure that there aren't more than 32 mesh config
2397 * parameters (otherwise our bitfield scheme would not work.) */
2398 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
2399
2400 /* Fill in the params struct */
2401 mask = 0;
2402 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
2403 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
2404 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
2405 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
2406 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
2407 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
2408 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
2409 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
2410 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
2411 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
2412 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
2413 mask, NL80211_MESHCONF_TTL, nla_get_u8);
2414 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
2415 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
2416 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
2417 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2418 nla_get_u8);
2419 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
2420 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
2421 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
2422 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2423 nla_get_u16);
2424 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
2425 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2426 nla_get_u32);
2427 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
2428 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2429 nla_get_u16);
2430 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2431 dot11MeshHWMPnetDiameterTraversalTime,
2432 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2433 nla_get_u16);
2434
2435 /* Apply changes */
93da9cc1 2436 err = drv->ops->set_mesh_params(&drv->wiphy, dev, &cfg, mask);
93da9cc1 2437
f3f92586 2438 out:
93da9cc1 2439 /* cleanup */
2440 cfg80211_put_dev(drv);
2441 dev_put(dev);
3b85875a
JB		 2442 out_rtnl:
2443 rtnl_unlock();
2444
93da9cc1 2445 return err;
2446}
2447
2448#undef FILL_IN_MESH_PARAM_IF_SET
2449
f130347c
LR		 2450static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
2451{
2452 struct sk_buff *msg;
2453 void *hdr = NULL;
2454 struct nlattr *nl_reg_rules;
2455 unsigned int i;
2456 int err = -EINVAL;
2457
a1794390 2458 mutex_lock(&cfg80211_mutex);
f130347c
LR		 2459
2460 if (!cfg80211_regdomain)
2461 goto out;
2462
2463 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2464 if (!msg) {
2465 err = -ENOBUFS;
2466 goto out;
2467 }
2468
2469 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2470 NL80211_CMD_GET_REG);
2471 if (!hdr)
2472 goto nla_put_failure;
2473
2474 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2475 cfg80211_regdomain->alpha2);
2476
2477 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
2478 if (!nl_reg_rules)
2479 goto nla_put_failure;
2480
2481 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
2482 struct nlattr *nl_reg_rule;
2483 const struct ieee80211_reg_rule *reg_rule;
2484 const struct ieee80211_freq_range *freq_range;
2485 const struct ieee80211_power_rule *power_rule;
2486
2487 reg_rule = &cfg80211_regdomain->reg_rules[i];
2488 freq_range = &reg_rule->freq_range;
2489 power_rule = &reg_rule->power_rule;
2490
2491 nl_reg_rule = nla_nest_start(msg, i);
2492 if (!nl_reg_rule)
2493 goto nla_put_failure;
2494
2495 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
2496 reg_rule->flags);
2497 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
2498 freq_range->start_freq_khz);
2499 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
2500 freq_range->end_freq_khz);
2501 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
2502 freq_range->max_bandwidth_khz);
2503 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
2504 power_rule->max_antenna_gain);
2505 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
2506 power_rule->max_eirp);
2507
2508 nla_nest_end(msg, nl_reg_rule);
2509 }
2510
2511 nla_nest_end(msg, nl_reg_rules);
2512
2513 genlmsg_end(msg, hdr);
2514 err = genlmsg_unicast(msg, info->snd_pid);
2515 goto out;
2516
2517nla_put_failure:
2518 genlmsg_cancel(msg, hdr);
2519 err = -EMSGSIZE;
2520out:
a1794390 2521 mutex_unlock(&cfg80211_mutex);
f130347c
LR		 2522 return err;
2523}
2524
b2e1b302
LR		 2525static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2526{
2527 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2528 struct nlattr *nl_reg_rule;
2529 char *alpha2 = NULL;
2530 int rem_reg_rules = 0, r = 0;
2531 u32 num_rules = 0, rule_idx = 0, size_of_regd;
2532 struct ieee80211_regdomain *rd = NULL;
2533
2534 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2535 return -EINVAL;
2536
2537 if (!info->attrs[NL80211_ATTR_REG_RULES])
2538 return -EINVAL;
2539
2540 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2541
2542 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2543 rem_reg_rules) {
2544 num_rules++;
2545 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
2546 goto bad_reg;
2547 }
2548
2549 if (!reg_is_valid_request(alpha2))
2550 return -EINVAL;
2551
2552 size_of_regd = sizeof(struct ieee80211_regdomain) +
2553 (num_rules * sizeof(struct ieee80211_reg_rule));
2554
2555 rd = kzalloc(size_of_regd, GFP_KERNEL);
2556 if (!rd)
2557 return -ENOMEM;
2558
2559 rd->n_reg_rules = num_rules;
2560 rd->alpha2[0] = alpha2[0];
2561 rd->alpha2[1] = alpha2[1];
2562
2563 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2564 rem_reg_rules) {
2565 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2566 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2567 reg_rule_policy);
2568 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2569 if (r)
2570 goto bad_reg;
2571
2572 rule_idx++;
2573
2574 if (rule_idx > NL80211_MAX_SUPP_REG_RULES)
2575 goto bad_reg;
2576 }
2577
2578 BUG_ON(rule_idx != num_rules);
2579
a1794390 2580 mutex_lock(&cfg80211_mutex);
b2e1b302 2581 r = set_regdom(rd);
a1794390 2582 mutex_unlock(&cfg80211_mutex);
b2e1b302
LR		 2583 return r;
2584
d2372b31 2585 bad_reg:
b2e1b302
LR		 2586 kfree(rd);
2587 return -EINVAL;
2588}
2589
2a519311
JB		 2590static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
2591{
2592 struct cfg80211_registered_device *drv;
2593 struct net_device *dev;
2594 struct cfg80211_scan_request *request;
2595 struct cfg80211_ssid *ssid;
2596 struct ieee80211_channel *channel;
2597 struct nlattr *attr;
2598 struct wiphy *wiphy;
2599 int err, tmp, n_ssids = 0, n_channels = 0, i;
2600 enum ieee80211_band band;
70692ad2 2601 size_t ie_len;
2a519311 2602
f4a11bb0
JB		 2603 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2604 return -EINVAL;
2605
3b85875a
JB		 2606 rtnl_lock();
2607
2a519311
JB		 2608 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2609 if (err)
3b85875a 2610 goto out_rtnl;
2a519311
JB		 2611
2612 wiphy = &drv->wiphy;
2613
2614 if (!drv->ops->scan) {
2615 err = -EOPNOTSUPP;
2616 goto out;
2617 }
2618
35a8efe1
JM		 2619 if (!netif_running(dev)) {
2620 err = -ENETDOWN;
2621 goto out;
2622 }
2623
2a519311
JB		 2624 if (drv->scan_req) {
2625 err = -EBUSY;
3b85875a 2626 goto out;
2a519311
JB		 2627 }
2628
2629 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
2630 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp)
2631 n_channels++;
2632 if (!n_channels) {
2633 err = -EINVAL;
3b85875a 2634 goto out;
2a519311
JB		 2635 }
2636 } else {
2637 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
2638 if (wiphy->bands[band])
2639 n_channels += wiphy->bands[band]->n_channels;
2640 }
2641
2642 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
2643 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
2644 n_ssids++;
2645
2646 if (n_ssids > wiphy->max_scan_ssids) {
2647 err = -EINVAL;
3b85875a 2648 goto out;
2a519311
JB		 2649 }
2650
70692ad2
JM		 2651 if (info->attrs[NL80211_ATTR_IE])
2652 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2653 else
2654 ie_len = 0;
2655
18a83659
JB		 2656 if (ie_len > wiphy->max_scan_ie_len) {
2657 err = -EINVAL;
2658 goto out;
2659 }
2660
2a519311
JB		 2661 request = kzalloc(sizeof(*request)
2662 + sizeof(*ssid) * n_ssids
70692ad2
JM		 2663 + sizeof(channel) * n_channels
2664 + ie_len, GFP_KERNEL);
2a519311
JB		 2665 if (!request) {
2666 err = -ENOMEM;
3b85875a 2667 goto out;
2a519311
JB		 2668 }
2669
2670 request->channels = (void *)((char *)request + sizeof(*request));
2671 request->n_channels = n_channels;
2672 if (n_ssids)
2673 request->ssids = (void *)(request->channels + n_channels);
2674 request->n_ssids = n_ssids;
70692ad2
JM		 2675 if (ie_len) {
2676 if (request->ssids)
2677 request->ie = (void *)(request->ssids + n_ssids);
2678 else
2679 request->ie = (void *)(request->channels + n_channels);
2680 }
2a519311
JB		 2681
2682 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
2683 /* user specified, bail out if channel not found */
2684 request->n_channels = n_channels;
2685 i = 0;
2686 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
2687 request->channels[i] = ieee80211_get_channel(wiphy, nla_get_u32(attr));
2688 if (!request->channels[i]) {
2689 err = -EINVAL;
2690 goto out_free;
2691 }
2692 i++;
2693 }
2694 } else {
2695 /* all channels */
2696 i = 0;
2697 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2698 int j;
2699 if (!wiphy->bands[band])
2700 continue;
2701 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
2702 request->channels[i] = &wiphy->bands[band]->channels[j];
2703 i++;
2704 }
2705 }
2706 }
2707
2708 i = 0;
2709 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
2710 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
2711 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
2712 err = -EINVAL;
2713 goto out_free;
2714 }
2715 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2716 request->ssids[i].ssid_len = nla_len(attr);
2717 i++;
2718 }
2719 }
2720
70692ad2
JM		 2721 if (info->attrs[NL80211_ATTR_IE]) {
2722 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 2723 memcpy((void *)request->ie,
2724 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 2725 request->ie_len);
2726 }
2727
2a519311
JB		 2728 request->ifidx = dev->ifindex;
2729 request->wiphy = &drv->wiphy;
2730
2731 drv->scan_req = request;
2732 err = drv->ops->scan(&drv->wiphy, dev, request);
2733
2734 out_free:
2735 if (err) {
2736 drv->scan_req = NULL;
2737 kfree(request);
2738 }
2a519311
JB		 2739 out:
2740 cfg80211_put_dev(drv);
2741 dev_put(dev);
3b85875a
JB		 2742 out_rtnl:
2743 rtnl_unlock();
2744
2a519311
JB		 2745 return err;
2746}
2747
2748static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
2749 struct cfg80211_registered_device *rdev,
2750 struct net_device *dev,
2751 struct cfg80211_bss *res)
2752{
2753 void *hdr;
2754 struct nlattr *bss;
2755
2756 hdr = nl80211hdr_put(msg, pid, seq, flags,
2757 NL80211_CMD_NEW_SCAN_RESULTS);
2758 if (!hdr)
2759 return -1;
2760
2761 NLA_PUT_U32(msg, NL80211_ATTR_SCAN_GENERATION,
2762 rdev->bss_generation);
2763 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2764
2765 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
2766 if (!bss)
2767 goto nla_put_failure;
2768 if (!is_zero_ether_addr(res->bssid))
2769 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid);
2770 if (res->information_elements && res->len_information_elements)
2771 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS,
2772 res->len_information_elements,
2773 res->information_elements);
2774 if (res->tsf)
2775 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf);
2776 if (res->beacon_interval)
2777 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval);
2778 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability);
2779 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq);
2780
77965c97 2781 switch (rdev->wiphy.signal_type) {
2a519311
JB		 2782 case CFG80211_SIGNAL_TYPE_MBM:
2783 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal);
2784 break;
2785 case CFG80211_SIGNAL_TYPE_UNSPEC:
2786 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal);
2787 break;
2788 default:
2789 break;
2790 }
2791
2792 nla_nest_end(msg, bss);
2793
2794 return genlmsg_end(msg, hdr);
2795
2796 nla_put_failure:
2797 genlmsg_cancel(msg, hdr);
2798 return -EMSGSIZE;
2799}
2800
2801static int nl80211_dump_scan(struct sk_buff *skb,
2802 struct netlink_callback *cb)
2803{
2804 struct cfg80211_registered_device *dev;
2805 struct net_device *netdev;
2806 struct cfg80211_internal_bss *scan;
2807 int ifidx = cb->args[0];
2808 int start = cb->args[1], idx = 0;
2809 int err;
2810
2811 if (!ifidx) {
2812 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
2813 nl80211_fam.attrbuf, nl80211_fam.maxattr,
2814 nl80211_policy);
2815 if (err)
2816 return err;
2817
2818 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
2819 return -EINVAL;
2820
2821 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
2822 if (!ifidx)
2823 return -EINVAL;
2824 cb->args[0] = ifidx;
2825 }
2826
2827 netdev = dev_get_by_index(&init_net, ifidx);
2828 if (!netdev)
2829 return -ENODEV;
2830
2831 dev = cfg80211_get_dev_from_ifindex(ifidx);
2832 if (IS_ERR(dev)) {
2833 err = PTR_ERR(dev);
2834 goto out_put_netdev;
2835 }
2836
2837 spin_lock_bh(&dev->bss_lock);
2838 cfg80211_bss_expire(dev);
2839
2840 list_for_each_entry(scan, &dev->bss_list, list) {
2841 if (++idx <= start)
2842 continue;
2843 if (nl80211_send_bss(skb,
2844 NETLINK_CB(cb->skb).pid,
2845 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2846 dev, netdev, &scan->pub) < 0) {
2847 idx--;
2848 goto out;
2849 }
2850 }
2851
2852 out:
2853 spin_unlock_bh(&dev->bss_lock);
2854
2855 cb->args[1] = idx;
2856 err = skb->len;
2857 cfg80211_put_dev(dev);
2858 out_put_netdev:
2859 dev_put(netdev);
2860
2861 return err;
2862}
2863
255e737e
JM		 2864static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
2865{
2866 return auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM ||
2867 auth_type == NL80211_AUTHTYPE_SHARED_KEY ||
2868 auth_type == NL80211_AUTHTYPE_FT ||
2869 auth_type == NL80211_AUTHTYPE_NETWORK_EAP;
2870}
2871
636a5d36
JM		 2872static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
2873{
2874 struct cfg80211_registered_device *drv;
2875 struct net_device *dev;
2876 struct cfg80211_auth_request req;
2877 struct wiphy *wiphy;
2878 int err;
2879
f4a11bb0
JB		 2880 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2881 return -EINVAL;
2882
2883 if (!info->attrs[NL80211_ATTR_MAC])
2884 return -EINVAL;
2885
1778092e
JM		 2886 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
2887 return -EINVAL;
2888
636a5d36
JM		 2889 rtnl_lock();
2890
2891 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2892 if (err)
2893 goto unlock_rtnl;
2894
2895 if (!drv->ops->auth) {
2896 err = -EOPNOTSUPP;
2897 goto out;
2898 }
2899
eec60b03
JM		 2900 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2901 err = -EOPNOTSUPP;
2902 goto out;
2903 }
2904
35a8efe1
JM		 2905 if (!netif_running(dev)) {
2906 err = -ENETDOWN;
2907 goto out;
2908 }
2909
636a5d36
JM		 2910 wiphy = &drv->wiphy;
2911 memset(&req, 0, sizeof(req));
2912
2913 req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2914
2915 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2916 req.chan = ieee80211_get_channel(
2917 wiphy,
2918 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
2919 if (!req.chan) {
2920 err = -EINVAL;
2921 goto out;
2922 }
2923 }
2924
2925 if (info->attrs[NL80211_ATTR_SSID]) {
2926 req.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
2927 req.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
2928 }
2929
2930 if (info->attrs[NL80211_ATTR_IE]) {
2931 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
2932 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2933 }
2934
1778092e
JM		 2935 req.auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
2936 if (!nl80211_valid_auth_type(req.auth_type)) {
2937 err = -EINVAL;
2938 goto out;
636a5d36
JM		 2939 }
2940
2941 err = drv->ops->auth(&drv->wiphy, dev, &req);
2942
2943out:
2944 cfg80211_put_dev(drv);
2945 dev_put(dev);
2946unlock_rtnl:
2947 rtnl_unlock();
2948 return err;
2949}
2950
2951static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
2952{
2953 struct cfg80211_registered_device *drv;
2954 struct net_device *dev;
2955 struct cfg80211_assoc_request req;
2956 struct wiphy *wiphy;
2957 int err;
2958
f4a11bb0
JB		 2959 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2960 return -EINVAL;
2961
2962 if (!info->attrs[NL80211_ATTR_MAC] ||
2963 !info->attrs[NL80211_ATTR_SSID])
2964 return -EINVAL;
2965
636a5d36
JM		 2966 rtnl_lock();
2967
2968 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2969 if (err)
2970 goto unlock_rtnl;
2971
2972 if (!drv->ops->assoc) {
2973 err = -EOPNOTSUPP;
2974 goto out;
2975 }
2976
eec60b03
JM		 2977 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2978 err = -EOPNOTSUPP;
2979 goto out;
2980 }
2981
35a8efe1
JM		 2982 if (!netif_running(dev)) {
2983 err = -ENETDOWN;
2984 goto out;
2985 }
2986
636a5d36
JM		 2987 wiphy = &drv->wiphy;
2988 memset(&req, 0, sizeof(req));
2989
2990 req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2991
2992 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2993 req.chan = ieee80211_get_channel(
2994 wiphy,
2995 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
2996 if (!req.chan) {
2997 err = -EINVAL;
2998 goto out;
2999 }
3000 }
3001
636a5d36
JM		 3002 req.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3003 req.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3004
3005 if (info->attrs[NL80211_ATTR_IE]) {
3006 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3007 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3008 }
3009
dc6382ce
JM		 3010 if (info->attrs[NL80211_ATTR_USE_MFP]) {
3011 enum nl80211_mfp use_mfp =
3012 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
3013 if (use_mfp == NL80211_MFP_REQUIRED)
3014 req.use_mfp = true;
3015 else if (use_mfp != NL80211_MFP_NO) {
3016 err = -EINVAL;
3017 goto out;
3018 }
3019 }
3020
636a5d36
JM		 3021 err = drv->ops->assoc(&drv->wiphy, dev, &req);
3022
3023out:
3024 cfg80211_put_dev(drv);
3025 dev_put(dev);
3026unlock_rtnl:
3027 rtnl_unlock();
3028 return err;
3029}
3030
3031static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
3032{
3033 struct cfg80211_registered_device *drv;
3034 struct net_device *dev;
3035 struct cfg80211_deauth_request req;
3036 struct wiphy *wiphy;
3037 int err;
3038
f4a11bb0
JB		 3039 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3040 return -EINVAL;
3041
3042 if (!info->attrs[NL80211_ATTR_MAC])
3043 return -EINVAL;
3044
3045 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3046 return -EINVAL;
3047
636a5d36
JM		 3048 rtnl_lock();
3049
3050 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
3051 if (err)
3052 goto unlock_rtnl;
3053
3054 if (!drv->ops->deauth) {
3055 err = -EOPNOTSUPP;
3056 goto out;
3057 }
3058
eec60b03
JM		 3059 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3060 err = -EOPNOTSUPP;
3061 goto out;
3062 }
3063
35a8efe1
JM		 3064 if (!netif_running(dev)) {
3065 err = -ENETDOWN;
3066 goto out;
3067 }
3068
636a5d36
JM		 3069 wiphy = &drv->wiphy;
3070 memset(&req, 0, sizeof(req));
3071
3072 req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3073
f4a11bb0
JB		 3074 req.reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3075 if (req.reason_code == 0) {
3076 /* Reason Code 0 is reserved */
3077 err = -EINVAL;
3078 goto out;
255e737e 3079 }
636a5d36
JM		 3080
3081 if (info->attrs[NL80211_ATTR_IE]) {
3082 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3083 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3084 }
3085
3086 err = drv->ops->deauth(&drv->wiphy, dev, &req);
3087
3088out:
3089 cfg80211_put_dev(drv);
3090 dev_put(dev);
3091unlock_rtnl:
3092 rtnl_unlock();
3093 return err;
3094}
3095
3096static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
3097{
3098 struct cfg80211_registered_device *drv;
3099 struct net_device *dev;
3100 struct cfg80211_disassoc_request req;
3101 struct wiphy *wiphy;
3102 int err;
3103
f4a11bb0
JB		 3104 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3105 return -EINVAL;
3106
3107 if (!info->attrs[NL80211_ATTR_MAC])
3108 return -EINVAL;
3109
3110 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3111 return -EINVAL;
3112
636a5d36
JM		 3113 rtnl_lock();
3114
3115 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
3116 if (err)
3117 goto unlock_rtnl;
3118
3119 if (!drv->ops->disassoc) {
3120 err = -EOPNOTSUPP;
3121 goto out;
3122 }
3123
eec60b03
JM		 3124 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3125 err = -EOPNOTSUPP;
3126 goto out;
3127 }
3128
35a8efe1
JM		 3129 if (!netif_running(dev)) {
3130 err = -ENETDOWN;
3131 goto out;
3132 }
3133
636a5d36
JM		 3134 wiphy = &drv->wiphy;
3135 memset(&req, 0, sizeof(req));
3136
3137 req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3138
f4a11bb0
JB		 3139 req.reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3140 if (req.reason_code == 0) {
3141 /* Reason Code 0 is reserved */
3142 err = -EINVAL;
3143 goto out;
255e737e 3144 }
636a5d36
JM		 3145
3146 if (info->attrs[NL80211_ATTR_IE]) {
3147 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3148 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3149 }
3150
3151 err = drv->ops->disassoc(&drv->wiphy, dev, &req);
3152
3153out:
3154 cfg80211_put_dev(drv);
3155 dev_put(dev);
3156unlock_rtnl:
3157 rtnl_unlock();
3158 return err;
3159}
3160
04a773ad
JB		 3161static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
3162{
3163 struct cfg80211_registered_device *drv;
3164 struct net_device *dev;
3165 struct cfg80211_ibss_params ibss;
3166 struct wiphy *wiphy;
3167 int err;
3168
8e30bc55
JB		 3169 memset(&ibss, 0, sizeof(ibss));
3170
04a773ad
JB		 3171 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3172 return -EINVAL;
3173
3174 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
3175 !info->attrs[NL80211_ATTR_SSID] ||
3176 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3177 return -EINVAL;
3178
8e30bc55
JB		 3179 ibss.beacon_interval = 100;
3180
3181 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
3182 ibss.beacon_interval =
3183 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3184 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
3185 return -EINVAL;
3186 }
3187
04a773ad
JB		 3188 rtnl_lock();
3189
3190 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
3191 if (err)
3192 goto unlock_rtnl;
3193
3194 if (!drv->ops->join_ibss) {
3195 err = -EOPNOTSUPP;
3196 goto out;
3197 }
3198
3199 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3200 err = -EOPNOTSUPP;
3201 goto out;
3202 }
3203
3204 if (!netif_running(dev)) {
3205 err = -ENETDOWN;
3206 goto out;
3207 }
3208
3209 wiphy = &drv->wiphy;
04a773ad
JB		 3210
3211 if (info->attrs[NL80211_ATTR_MAC])
3212 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3213 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3214 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3215
3216 if (info->attrs[NL80211_ATTR_IE]) {
3217 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3218 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3219 }
3220
3221 ibss.channel = ieee80211_get_channel(wiphy,
3222 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3223 if (!ibss.channel ||
3224 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
3225 ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
3226 err = -EINVAL;
3227 goto out;
3228 }
3229
3230 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
3231
3232 err = cfg80211_join_ibss(drv, dev, &ibss);
3233
3234out:
3235 cfg80211_put_dev(drv);
3236 dev_put(dev);
3237unlock_rtnl:
3238 rtnl_unlock();
3239 return err;
3240}
3241
3242static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
3243{
3244 struct cfg80211_registered_device *drv;
3245 struct net_device *dev;
3246 int err;
3247
3248 rtnl_lock();
3249
3250 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
3251 if (err)
3252 goto unlock_rtnl;
3253
3254 if (!drv->ops->leave_ibss) {
3255 err = -EOPNOTSUPP;
3256 goto out;
3257 }
3258
3259 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3260 err = -EOPNOTSUPP;
3261 goto out;
3262 }
3263
3264 if (!netif_running(dev)) {
3265 err = -ENETDOWN;
3266 goto out;
3267 }
3268
9d308429 3269 err = cfg80211_leave_ibss(drv, dev, false);
04a773ad
JB		 3270
3271out:
3272 cfg80211_put_dev(drv);
3273 dev_put(dev);
3274unlock_rtnl:
3275 rtnl_unlock();
3276 return err;
3277}
3278
55682965
JB		 3279static struct genl_ops nl80211_ops[] = {
3280 {
3281 .cmd = NL80211_CMD_GET_WIPHY,
3282 .doit = nl80211_get_wiphy,
3283 .dumpit = nl80211_dump_wiphy,
3284 .policy = nl80211_policy,
3285 /* can be retrieved by unprivileged users */
3286 },
3287 {
3288 .cmd = NL80211_CMD_SET_WIPHY,
3289 .doit = nl80211_set_wiphy,
3290 .policy = nl80211_policy,
3291 .flags = GENL_ADMIN_PERM,
3292 },
3293 {
3294 .cmd = NL80211_CMD_GET_INTERFACE,
3295 .doit = nl80211_get_interface,
3296 .dumpit = nl80211_dump_interface,
3297 .policy = nl80211_policy,
3298 /* can be retrieved by unprivileged users */
3299 },
3300 {
3301 .cmd = NL80211_CMD_SET_INTERFACE,
3302 .doit = nl80211_set_interface,
3303 .policy = nl80211_policy,
3304 .flags = GENL_ADMIN_PERM,
3305 },
3306 {
3307 .cmd = NL80211_CMD_NEW_INTERFACE,
3308 .doit = nl80211_new_interface,
3309 .policy = nl80211_policy,
3310 .flags = GENL_ADMIN_PERM,
3311 },
3312 {
3313 .cmd = NL80211_CMD_DEL_INTERFACE,
3314 .doit = nl80211_del_interface,
3315 .policy = nl80211_policy,
41ade00f
JB		 3316 .flags = GENL_ADMIN_PERM,
3317 },
3318 {
3319 .cmd = NL80211_CMD_GET_KEY,
3320 .doit = nl80211_get_key,
3321 .policy = nl80211_policy,
3322 .flags = GENL_ADMIN_PERM,
3323 },
3324 {
3325 .cmd = NL80211_CMD_SET_KEY,
3326 .doit = nl80211_set_key,
3327 .policy = nl80211_policy,
3328 .flags = GENL_ADMIN_PERM,
3329 },
3330 {
3331 .cmd = NL80211_CMD_NEW_KEY,
3332 .doit = nl80211_new_key,
3333 .policy = nl80211_policy,
3334 .flags = GENL_ADMIN_PERM,
3335 },
3336 {
3337 .cmd = NL80211_CMD_DEL_KEY,
3338 .doit = nl80211_del_key,
3339 .policy = nl80211_policy,
55682965
JB		 3340 .flags = GENL_ADMIN_PERM,
3341 },
ed1b6cc7
JB		 3342 {
3343 .cmd = NL80211_CMD_SET_BEACON,
3344 .policy = nl80211_policy,
3345 .flags = GENL_ADMIN_PERM,
3346 .doit = nl80211_addset_beacon,
3347 },
3348 {
3349 .cmd = NL80211_CMD_NEW_BEACON,
3350 .policy = nl80211_policy,
3351 .flags = GENL_ADMIN_PERM,
3352 .doit = nl80211_addset_beacon,
3353 },
3354 {
3355 .cmd = NL80211_CMD_DEL_BEACON,
3356 .policy = nl80211_policy,
3357 .flags = GENL_ADMIN_PERM,
3358 .doit = nl80211_del_beacon,
3359 },
5727ef1b
JB		 3360 {
3361 .cmd = NL80211_CMD_GET_STATION,
3362 .doit = nl80211_get_station,
2ec600d6 3363 .dumpit = nl80211_dump_station,
5727ef1b 3364 .policy = nl80211_policy,
5727ef1b
JB		 3365 },
3366 {
3367 .cmd = NL80211_CMD_SET_STATION,
3368 .doit = nl80211_set_station,
3369 .policy = nl80211_policy,
3370 .flags = GENL_ADMIN_PERM,
3371 },
3372 {
3373 .cmd = NL80211_CMD_NEW_STATION,
3374 .doit = nl80211_new_station,
3375 .policy = nl80211_policy,
3376 .flags = GENL_ADMIN_PERM,
3377 },
3378 {
3379 .cmd = NL80211_CMD_DEL_STATION,
3380 .doit = nl80211_del_station,
3381 .policy = nl80211_policy,
2ec600d6
LCC		 3382 .flags = GENL_ADMIN_PERM,
3383 },
3384 {
3385 .cmd = NL80211_CMD_GET_MPATH,
3386 .doit = nl80211_get_mpath,
3387 .dumpit = nl80211_dump_mpath,
3388 .policy = nl80211_policy,
3389 .flags = GENL_ADMIN_PERM,
3390 },
3391 {
3392 .cmd = NL80211_CMD_SET_MPATH,
3393 .doit = nl80211_set_mpath,
3394 .policy = nl80211_policy,
3395 .flags = GENL_ADMIN_PERM,
3396 },
3397 {
3398 .cmd = NL80211_CMD_NEW_MPATH,
3399 .doit = nl80211_new_mpath,
3400 .policy = nl80211_policy,
3401 .flags = GENL_ADMIN_PERM,
3402 },
3403 {
3404 .cmd = NL80211_CMD_DEL_MPATH,
3405 .doit = nl80211_del_mpath,
3406 .policy = nl80211_policy,
9f1ba906
JM		 3407 .flags = GENL_ADMIN_PERM,
3408 },
3409 {
3410 .cmd = NL80211_CMD_SET_BSS,
3411 .doit = nl80211_set_bss,
3412 .policy = nl80211_policy,
b2e1b302
LR		 3413 .flags = GENL_ADMIN_PERM,
3414 },
f130347c
LR		 3415 {
3416 .cmd = NL80211_CMD_GET_REG,
3417 .doit = nl80211_get_reg,
3418 .policy = nl80211_policy,
3419 /* can be retrieved by unprivileged users */
3420 },
b2e1b302
LR		 3421 {
3422 .cmd = NL80211_CMD_SET_REG,
3423 .doit = nl80211_set_reg,
3424 .policy = nl80211_policy,
3425 .flags = GENL_ADMIN_PERM,
3426 },
3427 {
3428 .cmd = NL80211_CMD_REQ_SET_REG,
3429 .doit = nl80211_req_set_reg,
3430 .policy = nl80211_policy,
93da9cc1 3431 .flags = GENL_ADMIN_PERM,
3432 },
3433 {
3434 .cmd = NL80211_CMD_GET_MESH_PARAMS,
3435 .doit = nl80211_get_mesh_params,
3436 .policy = nl80211_policy,
3437 /* can be retrieved by unprivileged users */
3438 },
3439 {
3440 .cmd = NL80211_CMD_SET_MESH_PARAMS,
3441 .doit = nl80211_set_mesh_params,
3442 .policy = nl80211_policy,
9aed3cc1
JM		 3443 .flags = GENL_ADMIN_PERM,
3444 },
2a519311
JB		 3445 {
3446 .cmd = NL80211_CMD_TRIGGER_SCAN,
3447 .doit = nl80211_trigger_scan,
3448 .policy = nl80211_policy,
3449 .flags = GENL_ADMIN_PERM,
3450 },
3451 {
3452 .cmd = NL80211_CMD_GET_SCAN,
3453 .policy = nl80211_policy,
3454 .dumpit = nl80211_dump_scan,
3455 },
636a5d36
JM		 3456 {
3457 .cmd = NL80211_CMD_AUTHENTICATE,
3458 .doit = nl80211_authenticate,
3459 .policy = nl80211_policy,
3460 .flags = GENL_ADMIN_PERM,
3461 },
3462 {
3463 .cmd = NL80211_CMD_ASSOCIATE,
3464 .doit = nl80211_associate,
3465 .policy = nl80211_policy,
3466 .flags = GENL_ADMIN_PERM,
3467 },
3468 {
3469 .cmd = NL80211_CMD_DEAUTHENTICATE,
3470 .doit = nl80211_deauthenticate,
3471 .policy = nl80211_policy,
3472 .flags = GENL_ADMIN_PERM,
3473 },
3474 {
3475 .cmd = NL80211_CMD_DISASSOCIATE,
3476 .doit = nl80211_disassociate,
3477 .policy = nl80211_policy,
3478 .flags = GENL_ADMIN_PERM,
3479 },
04a773ad
JB		 3480 {
3481 .cmd = NL80211_CMD_JOIN_IBSS,
3482 .doit = nl80211_join_ibss,
3483 .policy = nl80211_policy,
3484 .flags = GENL_ADMIN_PERM,
3485 },
3486 {
3487 .cmd = NL80211_CMD_LEAVE_IBSS,
3488 .doit = nl80211_leave_ibss,
3489 .policy = nl80211_policy,
3490 .flags = GENL_ADMIN_PERM,
3491 },
55682965 3492};
6039f6d2
JM		 3493static struct genl_multicast_group nl80211_mlme_mcgrp = {
3494 .name = "mlme",
3495};
55682965
JB		 3496
3497/* multicast groups */
3498static struct genl_multicast_group nl80211_config_mcgrp = {
3499 .name = "config",
3500};
2a519311
JB		 3501static struct genl_multicast_group nl80211_scan_mcgrp = {
3502 .name = "scan",
3503};
73d54c9e
LR		 3504static struct genl_multicast_group nl80211_regulatory_mcgrp = {
3505 .name = "regulatory",
3506};
55682965
JB		 3507
3508/* notification functions */
3509
3510void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
3511{
3512 struct sk_buff *msg;
3513
3514 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3515 if (!msg)
3516 return;
3517
3518 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
3519 nlmsg_free(msg);
3520 return;
3521 }
3522
3523 genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
3524}
3525
2a519311
JB		 3526static int nl80211_send_scan_donemsg(struct sk_buff *msg,
3527 struct cfg80211_registered_device *rdev,
3528 struct net_device *netdev,
3529 u32 pid, u32 seq, int flags,
3530 u32 cmd)
3531{
3532 void *hdr;
3533
3534 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
3535 if (!hdr)
3536 return -1;
3537
b5850a7a 3538 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
2a519311
JB		 3539 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
3540
3541 /* XXX: we should probably bounce back the request? */
3542
3543 return genlmsg_end(msg, hdr);
3544
3545 nla_put_failure:
3546 genlmsg_cancel(msg, hdr);
3547 return -EMSGSIZE;
3548}
3549
3550void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
3551 struct net_device *netdev)
3552{
3553 struct sk_buff *msg;
3554
3555 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3556 if (!msg)
3557 return;
3558
3559 if (nl80211_send_scan_donemsg(msg, rdev, netdev, 0, 0, 0,
3560 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
3561 nlmsg_free(msg);
3562 return;
3563 }
3564
3565 genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
3566}
3567
3568void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
3569 struct net_device *netdev)
3570{
3571 struct sk_buff *msg;
3572
3573 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3574 if (!msg)
3575 return;
3576
3577 if (nl80211_send_scan_donemsg(msg, rdev, netdev, 0, 0, 0,
3578 NL80211_CMD_SCAN_ABORTED) < 0) {
3579 nlmsg_free(msg);
3580 return;
3581 }
3582
3583 genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
3584}
3585
73d54c9e
LR		 3586/*
3587 * This can happen on global regulatory changes or device specific settings
3588 * based on custom world regulatory domains.
3589 */
3590void nl80211_send_reg_change_event(struct regulatory_request *request)
3591{
3592 struct sk_buff *msg;
3593 void *hdr;
3594
3595 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3596 if (!msg)
3597 return;
3598
3599 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
3600 if (!hdr) {
3601 nlmsg_free(msg);
3602 return;
3603 }
3604
3605 /* Userspace can always count this one always being set */
3606 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
3607
3608 if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
3609 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
3610 NL80211_REGDOM_TYPE_WORLD);
3611 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
3612 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
3613 NL80211_REGDOM_TYPE_CUSTOM_WORLD);
3614 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
3615 request->intersect)
3616 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
3617 NL80211_REGDOM_TYPE_INTERSECTION);
3618 else {
3619 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
3620 NL80211_REGDOM_TYPE_COUNTRY);
3621 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
3622 }
3623
3624 if (wiphy_idx_valid(request->wiphy_idx))
3625 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
3626
3627 if (genlmsg_end(msg, hdr) < 0) {
3628 nlmsg_free(msg);
3629 return;
3630 }
3631
3632 genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_KERNEL);
3633
3634 return;
3635
3636nla_put_failure:
3637 genlmsg_cancel(msg, hdr);
3638 nlmsg_free(msg);
3639}
3640
6039f6d2
JM		 3641static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
3642 struct net_device *netdev,
3643 const u8 *buf, size_t len,
3644 enum nl80211_commands cmd)
3645{
3646 struct sk_buff *msg;
3647 void *hdr;
3648
d91c01c7 3649 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
6039f6d2
JM		 3650 if (!msg)
3651 return;
3652
3653 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
3654 if (!hdr) {
3655 nlmsg_free(msg);
3656 return;
3657 }
3658
3659 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3660 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
3661 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
3662
3663 if (genlmsg_end(msg, hdr) < 0) {
3664 nlmsg_free(msg);
3665 return;
3666 }
3667
d91c01c7 3668 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_ATOMIC);
6039f6d2
JM		 3669 return;
3670
3671 nla_put_failure:
3672 genlmsg_cancel(msg, hdr);
3673 nlmsg_free(msg);
3674}
3675
3676void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
3677 struct net_device *netdev, const u8 *buf, size_t len)
3678{
3679 nl80211_send_mlme_event(rdev, netdev, buf, len,
3680 NL80211_CMD_AUTHENTICATE);
3681}
3682
3683void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
3684 struct net_device *netdev, const u8 *buf,
3685 size_t len)
3686{
3687 nl80211_send_mlme_event(rdev, netdev, buf, len, NL80211_CMD_ASSOCIATE);
3688}
3689
53b46b84
JM		 3690void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
3691 struct net_device *netdev, const u8 *buf, size_t len)
6039f6d2
JM		 3692{
3693 nl80211_send_mlme_event(rdev, netdev, buf, len,
3694 NL80211_CMD_DEAUTHENTICATE);
3695}
3696
53b46b84
JM		 3697void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
3698 struct net_device *netdev, const u8 *buf,
3699 size_t len)
6039f6d2
JM		 3700{
3701 nl80211_send_mlme_event(rdev, netdev, buf, len,
3702 NL80211_CMD_DISASSOCIATE);
3703}
3704
1b06bb40
LR		 3705static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
3706 struct net_device *netdev, int cmd,
3707 const u8 *addr)
1965c853
JM		 3708{
3709 struct sk_buff *msg;
3710 void *hdr;
3711
3712 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
3713 if (!msg)
3714 return;
3715
3716 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
3717 if (!hdr) {
3718 nlmsg_free(msg);
3719 return;
3720 }
3721
3722 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3723 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
3724 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
3725 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
3726
3727 if (genlmsg_end(msg, hdr) < 0) {
3728 nlmsg_free(msg);
3729 return;
3730 }
3731
3732 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_ATOMIC);
3733 return;
3734
3735 nla_put_failure:
3736 genlmsg_cancel(msg, hdr);
3737 nlmsg_free(msg);
3738}
3739
3740void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
3741 struct net_device *netdev, const u8 *addr)
3742{
3743 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
3744 addr);
3745}
3746
3747void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
3748 struct net_device *netdev, const u8 *addr)
3749{
3750 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE, addr);
3751}
3752
04a773ad
JB		 3753void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
3754 struct net_device *netdev, const u8 *bssid,
3755 gfp_t gfp)
3756{
3757 struct sk_buff *msg;
3758 void *hdr;
3759
3760 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
3761 if (!msg)
3762 return;
3763
3764 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
3765 if (!hdr) {
3766 nlmsg_free(msg);
3767 return;
3768 }
3769
3770 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3771 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
3772 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
3773
3774 if (genlmsg_end(msg, hdr) < 0) {
3775 nlmsg_free(msg);
3776 return;
3777 }
3778
3779 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
3780 return;
3781
3782 nla_put_failure:
3783 genlmsg_cancel(msg, hdr);
3784 nlmsg_free(msg);
3785}
3786
a3b8b056
JM		 3787void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
3788 struct net_device *netdev, const u8 *addr,
3789 enum nl80211_key_type key_type, int key_id,
3790 const u8 *tsc)
3791{
3792 struct sk_buff *msg;
3793 void *hdr;
3794
3795 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3796 if (!msg)
3797 return;
3798
3799 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
3800 if (!hdr) {
3801 nlmsg_free(msg);
3802 return;
3803 }
3804
3805 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3806 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
3807 if (addr)
3808 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
3809 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
3810 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
3811 if (tsc)
3812 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
3813
3814 if (genlmsg_end(msg, hdr) < 0) {
3815 nlmsg_free(msg);
3816 return;
3817 }
3818
3819 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_KERNEL);
3820 return;
3821
3822 nla_put_failure:
3823 genlmsg_cancel(msg, hdr);
3824 nlmsg_free(msg);
3825}
3826
6bad8766
LR		 3827void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
3828 struct ieee80211_channel *channel_before,
3829 struct ieee80211_channel *channel_after)
3830{
3831 struct sk_buff *msg;
3832 void *hdr;
3833 struct nlattr *nl_freq;
3834
3835 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
3836 if (!msg)
3837 return;
3838
3839 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
3840 if (!hdr) {
3841 nlmsg_free(msg);
3842 return;
3843 }
3844
3845 /*
3846 * Since we are applying the beacon hint to a wiphy we know its
3847 * wiphy_idx is valid
3848 */
3849 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
3850
3851 /* Before */
3852 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
3853 if (!nl_freq)
3854 goto nla_put_failure;
3855 if (nl80211_msg_put_channel(msg, channel_before))
3856 goto nla_put_failure;
3857 nla_nest_end(msg, nl_freq);
3858
3859 /* After */
3860 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
3861 if (!nl_freq)
3862 goto nla_put_failure;
3863 if (nl80211_msg_put_channel(msg, channel_after))
3864 goto nla_put_failure;
3865 nla_nest_end(msg, nl_freq);
3866
3867 if (genlmsg_end(msg, hdr) < 0) {
3868 nlmsg_free(msg);
3869 return;
3870 }
3871
3872 genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_ATOMIC);
3873
3874 return;
3875
3876nla_put_failure:
3877 genlmsg_cancel(msg, hdr);
3878 nlmsg_free(msg);
3879}
3880
55682965
JB		 3881/* initialisation/exit functions */
3882
3883int nl80211_init(void)
3884{
3885 int err, i;
3886
3887 err = genl_register_family(&nl80211_fam);
3888 if (err)
3889 return err;
3890
3891 for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
3892 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
3893 if (err)
3894 goto err_out;
3895 }
3896
3897 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
3898 if (err)
3899 goto err_out;
3900
2a519311
JB		 3901 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
3902 if (err)
3903 goto err_out;
3904
73d54c9e
LR		 3905 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
3906 if (err)
3907 goto err_out;
3908
6039f6d2
JM		 3909 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
3910 if (err)
3911 goto err_out;
3912
55682965
JB		 3913 return 0;
3914 err_out:
3915 genl_unregister_family(&nl80211_fam);
3916 return err;
3917}
3918
3919void nl80211_exit(void)
3920{
3921 genl_unregister_family(&nl80211_fam);
3922}
Ubuntu Focal Linux kernel mirror