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