?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6/mini2440.git] / net / wireless / nl80211.c
blob2456e4ee445e04ab884fa17a2fb8ed835ab59996
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>
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>
16 #include <linux/etherdevice.h>
17 #include <net/genetlink.h>
18 #include <net/cfg80211.h>
19 #include "core.h"
20 #include "nl80211.h"
21 #include "reg.h"
22
23 /* the netlink family */
24 static 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 */
33 static int get_drv_dev_by_info_ifindex(struct nlattr **attrs,
34 struct cfg80211_registered_device **drv,
35 struct net_device **dev)
36 {
37 int ifindex;
38
39 if (!attrs[NL80211_ATTR_IFINDEX])
40 return -EINVAL;
41
42 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
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 */
57 static 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 },
61 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
62 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
63 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
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 },
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 },
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 },
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 },
88 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
89 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
90 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
91 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
92 .len = IEEE80211_MAX_MESH_ID_LEN },
93 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
94
95 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
96 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
97
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 },
101 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
102 .len = NL80211_MAX_SUPP_RATES },
103
104 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
105
106 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
107 .len = NL80211_HT_CAPABILITY_LEN },
108
109 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
110 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
111 .len = IEEE80211_MAX_DATA_LEN },
112 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
113 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
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 },
119 };
120
121 /* message building helper */
122 static 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
131 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
132 struct cfg80211_registered_device *dev)
133 {
134 void *hdr;
135 struct nlattr *nl_bands, *nl_band;
136 struct nlattr *nl_freqs, *nl_freq;
137 struct nlattr *nl_rates, *nl_rate;
138 struct nlattr *nl_modes;
139 struct nlattr *nl_cmds;
140 enum ieee80211_band band;
141 struct ieee80211_channel *chan;
142 struct ieee80211_rate *rate;
143 int i;
144 u16 ifmodes = dev->wiphy.interface_modes;
145
146 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
147 if (!hdr)
148 return -1;
149
150 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
151 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
152 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
153 dev->wiphy.max_scan_ssids);
154
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
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
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
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
217 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
218 DBM_TO_MBM(chan->max_power));
219
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
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);
272 CMD(auth, AUTHENTICATE);
273 CMD(assoc, ASSOCIATE);
274 CMD(deauth, DEAUTHENTICATE);
275 CMD(disassoc, DISASSOCIATE);
276
277 #undef CMD
278 nla_nest_end(msg, nl_cmds);
279
280 return genlmsg_end(msg, hdr);
281
282 nla_put_failure:
283 genlmsg_cancel(msg, hdr);
284 return -EMSGSIZE;
285 }
286
287 static 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
293 mutex_lock(&cfg80211_mutex);
294 list_for_each_entry(dev, &cfg80211_drv_list, list) {
295 if (++idx <= start)
296 continue;
297 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
298 cb->nlh->nlmsg_seq, NLM_F_MULTI,
299 dev) < 0) {
300 idx--;
301 break;
302 }
303 }
304 mutex_unlock(&cfg80211_mutex);
305
306 cb->args[0] = idx;
307
308 return skb->len;
309 }
310
311 static 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
338 static 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
346 static 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
363 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
364 {
365 struct cfg80211_registered_device *rdev;
366 int result = 0, rem_txq_params = 0;
367 struct nlattr *nl_txq_params;
368
369 rtnl_lock();
370
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])
382 result = cfg80211_dev_rename(
383 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
384
385 mutex_unlock(&cfg80211_mutex);
386
387 if (result)
388 goto bad_res;
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 }
416
417 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
418 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
419 struct ieee80211_channel *chan;
420 struct ieee80211_sta_ht_cap *ht_cap;
421 u32 freq, sec_freq;
422
423 if (!rdev->ops->set_channel) {
424 result = -EOPNOTSUPP;
425 goto bad_res;
426 }
427
428 result = -EINVAL;
429
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)
437 goto bad_res;
438 }
439
440 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
441 chan = ieee80211_get_channel(&rdev->wiphy, freq);
442
443 /* Primary channel not allowed */
444 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
445 goto bad_res;
446
447 if (channel_type == NL80211_CHAN_HT40MINUS)
448 sec_freq = freq - 20;
449 else if (channel_type == NL80211_CHAN_HT40PLUS)
450 sec_freq = freq + 20;
451 else
452 sec_freq = 0;
453
454 ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
455
456 /* no HT capabilities */
457 if (channel_type != NL80211_CHAN_NO_HT &&
458 !ht_cap->ht_supported)
459 goto bad_res;
460
461 if (sec_freq) {
462 struct ieee80211_channel *schan;
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
469 schan = ieee80211_get_channel(&rdev->wiphy, sec_freq);
470
471 /* Secondary channel not allowed */
472 if (!schan || schan->flags & IEEE80211_CHAN_DISABLED)
473 goto bad_res;
474 }
475
476 result = rdev->ops->set_channel(&rdev->wiphy, chan,
477 channel_type);
478 if (result)
479 goto bad_res;
480 }
481
482
483 bad_res:
484 mutex_unlock(&rdev->mtx);
485 unlock:
486 rtnl_unlock();
487 return result;
488 }
489
490
491 static 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);
502 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
503 return genlmsg_end(msg, hdr);
504
505 nla_put_failure:
506 genlmsg_cancel(msg, hdr);
507 return -EMSGSIZE;
508 }
509
510 static 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
519 mutex_lock(&cfg80211_mutex);
520 list_for_each_entry(dev, &cfg80211_drv_list, list) {
521 if (wp_idx < wp_start) {
522 wp_idx++;
523 continue;
524 }
525 if_idx = 0;
526
527 mutex_lock(&dev->devlist_mtx);
528 list_for_each_entry(wdev, &dev->netdev_list, list) {
529 if (if_idx < if_start) {
530 if_idx++;
531 continue;
532 }
533 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
534 cb->nlh->nlmsg_seq, NLM_F_MULTI,
535 wdev->netdev) < 0) {
536 mutex_unlock(&dev->devlist_mtx);
537 goto out;
538 }
539 if_idx++;
540 }
541 mutex_unlock(&dev->devlist_mtx);
542
543 wp_idx++;
544 }
545 out:
546 mutex_unlock(&cfg80211_mutex);
547
548 cb->args[0] = wp_idx;
549 cb->args[1] = if_idx;
550
551 return skb->len;
552 }
553
554 static 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
561 err = get_drv_dev_by_info_ifindex(info->attrs, &dev, &netdev);
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
585 static 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
593 static 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
614 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
615 {
616 struct cfg80211_registered_device *drv;
617 struct vif_params params;
618 int err, ifindex;
619 enum nl80211_iftype type;
620 struct net_device *dev;
621 u32 _flags, *flags = NULL;
622 bool change = false;
623
624 memset(&params, 0, sizeof(params));
625
626 rtnl_lock();
627
628 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
629 if (err)
630 goto unlock_rtnl;
631
632 ifindex = dev->ifindex;
633 type = dev->ieee80211_ptr->iftype;
634 dev_put(dev);
635
636 if (info->attrs[NL80211_ATTR_IFTYPE]) {
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;
645 goto unlock;
646 }
647 }
648
649 if (!drv->ops->change_virtual_intf ||
650 !(drv->wiphy.interface_modes & (1 << type))) {
651 err = -EOPNOTSUPP;
652 goto unlock;
653 }
654
655 if (info->attrs[NL80211_ATTR_MESH_ID]) {
656 if (type != NL80211_IFTYPE_MESH_POINT) {
657 err = -EINVAL;
658 goto unlock;
659 }
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]);
662 change = true;
663 }
664
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);
672 if (err)
673 goto unlock;
674
675 flags = &_flags;
676 change = true;
677 }
678
679 if (change)
680 err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex,
681 type, flags, &params);
682 else
683 err = 0;
684
685 dev = __dev_get_by_index(&init_net, ifindex);
686 WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != type));
687
688 unlock:
689 cfg80211_put_dev(drv);
690 unlock_rtnl:
691 rtnl_unlock();
692 return err;
693 }
694
695 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
696 {
697 struct cfg80211_registered_device *drv;
698 struct vif_params params;
699 int err;
700 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
701 u32 flags;
702
703 memset(&params, 0, sizeof(params));
704
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
714 rtnl_lock();
715
716 drv = cfg80211_get_dev_from_info(info);
717 if (IS_ERR(drv)) {
718 err = PTR_ERR(drv);
719 goto unlock_rtnl;
720 }
721
722 if (!drv->ops->add_virtual_intf ||
723 !(drv->wiphy.interface_modes & (1 << type))) {
724 err = -EOPNOTSUPP;
725 goto unlock;
726 }
727
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
734 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
735 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
736 &flags);
737 err = drv->ops->add_virtual_intf(&drv->wiphy,
738 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
739 type, err ? NULL : &flags, &params);
740
741 unlock:
742 cfg80211_put_dev(drv);
743 unlock_rtnl:
744 rtnl_unlock();
745 return err;
746 }
747
748 static 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
754 rtnl_lock();
755
756 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
757 if (err)
758 goto unlock_rtnl;
759 ifindex = dev->ifindex;
760 dev_put(dev);
761
762 if (!drv->ops->del_virtual_intf) {
763 err = -EOPNOTSUPP;
764 goto out;
765 }
766
767 err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
768
769 out:
770 cfg80211_put_dev(drv);
771 unlock_rtnl:
772 rtnl_unlock();
773 return err;
774 }
775
776 struct get_key_cookie {
777 struct sk_buff *msg;
778 int error;
779 };
780
781 static 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
802 static 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
818 if (key_idx > 5)
819 return -EINVAL;
820
821 if (info->attrs[NL80211_ATTR_MAC])
822 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
823
824 rtnl_lock();
825
826 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
827 if (err)
828 goto unlock_rtnl;
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
856 err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
857 &cookie, get_key_callback);
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);
875 unlock_rtnl:
876 rtnl_unlock();
877
878 return err;
879 }
880
881 static 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;
887 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
888 u8 key_index);
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
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)
899 return -EINVAL;
900
901 /* currently only support setting default key */
902 if (!info->attrs[NL80211_ATTR_KEY_DEFAULT] &&
903 !info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT])
904 return -EINVAL;
905
906 rtnl_lock();
907
908 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
909 if (err)
910 goto unlock_rtnl;
911
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) {
918 err = -EOPNOTSUPP;
919 goto out;
920 }
921
922 err = func(&drv->wiphy, dev, key_idx);
923
924 out:
925 cfg80211_put_dev(drv);
926 dev_put(dev);
927
928 unlock_rtnl:
929 rtnl_unlock();
930
931 return err;
932 }
933
934 static 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
961 if (key_idx > 5)
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;
992 case WLAN_CIPHER_SUITE_AES_CMAC:
993 if (params.key_len != 16)
994 return -EINVAL;
995 break;
996 default:
997 return -EINVAL;
998 }
999
1000 rtnl_lock();
1001
1002 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1003 if (err)
1004 goto unlock_rtnl;
1005
1006 if (!drv->ops->add_key) {
1007 err = -EOPNOTSUPP;
1008 goto out;
1009 }
1010
1011 err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
1012
1013 out:
1014 cfg80211_put_dev(drv);
1015 dev_put(dev);
1016 unlock_rtnl:
1017 rtnl_unlock();
1018
1019 return err;
1020 }
1021
1022 static 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
1033 if (key_idx > 5)
1034 return -EINVAL;
1035
1036 if (info->attrs[NL80211_ATTR_MAC])
1037 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1038
1039 rtnl_lock();
1040
1041 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1042 if (err)
1043 goto unlock_rtnl;
1044
1045 if (!drv->ops->del_key) {
1046 err = -EOPNOTSUPP;
1047 goto out;
1048 }
1049
1050 err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
1051
1052 out:
1053 cfg80211_put_dev(drv);
1054 dev_put(dev);
1055
1056 unlock_rtnl:
1057 rtnl_unlock();
1058
1059 return err;
1060 }
1061
1062 static 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
1072 rtnl_lock();
1073
1074 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1075 if (err)
1076 goto unlock_rtnl;
1077
1078 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1079 err = -EOPNOTSUPP;
1080 goto out;
1081 }
1082
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
1142 err = call(&drv->wiphy, dev, &params);
1143
1144 out:
1145 cfg80211_put_dev(drv);
1146 dev_put(dev);
1147 unlock_rtnl:
1148 rtnl_unlock();
1149
1150 return err;
1151 }
1152
1153 static 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
1159 rtnl_lock();
1160
1161 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1162 if (err)
1163 goto unlock_rtnl;
1164
1165 if (!drv->ops->del_beacon) {
1166 err = -EOPNOTSUPP;
1167 goto out;
1168 }
1169
1170 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1171 err = -EOPNOTSUPP;
1172 goto out;
1173 }
1174 err = drv->ops->del_beacon(&drv->wiphy, dev);
1175
1176 out:
1177 cfg80211_put_dev(drv);
1178 dev_put(dev);
1179 unlock_rtnl:
1180 rtnl_unlock();
1181
1182 return err;
1183 }
1184
1185 static 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
1191 static 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
1214 static 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
1247 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1248 int flags, struct net_device *dev,
1249 u8 *mac_addr, struct station_info *sinfo)
1250 {
1251 void *hdr;
1252 struct nlattr *sinfoattr, *txrate;
1253 u16 bitrate;
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
1262 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1263 if (!sinfoattr)
1264 goto nla_put_failure;
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);
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);
1295
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 }
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);
1312 nla_nest_end(msg, sinfoattr);
1313
1314 return genlmsg_end(msg, hdr);
1315
1316 nla_put_failure:
1317 genlmsg_cancel(msg, hdr);
1318 return -EMSGSIZE;
1319 }
1320
1321 static int nl80211_dump_station(struct sk_buff *skb,
1322 struct netlink_callback *cb)
1323 {
1324 struct station_info sinfo;
1325 struct cfg80211_registered_device *dev;
1326 struct net_device *netdev;
1327 u8 mac_addr[ETH_ALEN];
1328 int ifidx = cb->args[0];
1329 int sta_idx = cb->args[1];
1330 int err;
1331
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;
1338
1339 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1340 return -EINVAL;
1341
1342 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1343 if (!ifidx)
1344 return -EINVAL;
1345 }
1346
1347 rtnl_lock();
1348
1349 netdev = __dev_get_by_index(&init_net, ifidx);
1350 if (!netdev) {
1351 err = -ENODEV;
1352 goto out_rtnl;
1353 }
1354
1355 dev = cfg80211_get_dev_from_ifindex(ifidx);
1356 if (IS_ERR(dev)) {
1357 err = PTR_ERR(dev);
1358 goto out_rtnl;
1359 }
1360
1361 if (!dev->ops->dump_station) {
1362 err = -EOPNOTSUPP;
1363 goto out_err;
1364 }
1365
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)
1372 goto out_err;
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;
1388 out_err:
1389 cfg80211_put_dev(dev);
1390 out_rtnl:
1391 rtnl_unlock();
1392
1393 return err;
1394 }
1395
1396 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1397 {
1398 struct cfg80211_registered_device *drv;
1399 int err;
1400 struct net_device *dev;
1401 struct station_info sinfo;
1402 struct sk_buff *msg;
1403 u8 *mac_addr = NULL;
1404
1405 memset(&sinfo, 0, sizeof(sinfo));
1406
1407 if (!info->attrs[NL80211_ATTR_MAC])
1408 return -EINVAL;
1409
1410 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1411
1412 rtnl_lock();
1413
1414 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1415 if (err)
1416 goto out_rtnl;
1417
1418 if (!drv->ops->get_station) {
1419 err = -EOPNOTSUPP;
1420 goto out;
1421 }
1422
1423 err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &sinfo);
1424 if (err)
1425 goto out;
1426
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,
1432 dev, mac_addr, &sinfo) < 0)
1433 goto out_free;
1434
1435 err = genlmsg_unicast(msg, info->snd_pid);
1436 goto out;
1437
1438 out_free:
1439 nlmsg_free(msg);
1440 out:
1441 cfg80211_put_dev(drv);
1442 dev_put(dev);
1443 out_rtnl:
1444 rtnl_unlock();
1445
1446 return err;
1447 }
1448
1449 /*
1450 * Get vlan interface making sure it is on the right wiphy.
1451 */
1452 static 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
1470 static 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
1501 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1502 params.ht_capa =
1503 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1504
1505 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1506 &params.station_flags))
1507 return -EINVAL;
1508
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
1513 rtnl_lock();
1514
1515 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1516 if (err)
1517 goto out_rtnl;
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
1528 err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
1529
1530 out:
1531 if (params.vlan)
1532 dev_put(params.vlan);
1533 cfg80211_put_dev(drv);
1534 dev_put(dev);
1535 out_rtnl:
1536 rtnl_unlock();
1537
1538 return err;
1539 }
1540
1541 static 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]);
1570 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
1571 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1572 params.ht_capa =
1573 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1574
1575 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1576 &params.station_flags))
1577 return -EINVAL;
1578
1579 rtnl_lock();
1580
1581 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1582 if (err)
1583 goto out_rtnl;
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
1594 if (!netif_running(dev)) {
1595 err = -ENETDOWN;
1596 goto out;
1597 }
1598
1599 err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
1600
1601 out:
1602 if (params.vlan)
1603 dev_put(params.vlan);
1604 cfg80211_put_dev(drv);
1605 dev_put(dev);
1606 out_rtnl:
1607 rtnl_unlock();
1608
1609 return err;
1610 }
1611
1612 static 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
1622 rtnl_lock();
1623
1624 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1625 if (err)
1626 goto out_rtnl;
1627
1628 if (!drv->ops->del_station) {
1629 err = -EOPNOTSUPP;
1630 goto out;
1631 }
1632
1633 err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
1634
1635 out:
1636 cfg80211_put_dev(drv);
1637 dev_put(dev);
1638 out_rtnl:
1639 rtnl_unlock();
1640
1641 return err;
1642 }
1643
1644 static 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:
1690 genlmsg_cancel(msg, hdr);
1691 return -EMSGSIZE;
1692 }
1693
1694 static int nl80211_dump_mpath(struct sk_buff *skb,
1695 struct netlink_callback *cb)
1696 {
1697 struct mpath_info pinfo;
1698 struct cfg80211_registered_device *dev;
1699 struct net_device *netdev;
1700 u8 dst[ETH_ALEN];
1701 u8 next_hop[ETH_ALEN];
1702 int ifidx = cb->args[0];
1703 int path_idx = cb->args[1];
1704 int err;
1705
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
1721 rtnl_lock();
1722
1723 netdev = __dev_get_by_index(&init_net, ifidx);
1724 if (!netdev) {
1725 err = -ENODEV;
1726 goto out_rtnl;
1727 }
1728
1729 dev = cfg80211_get_dev_from_ifindex(ifidx);
1730 if (IS_ERR(dev)) {
1731 err = PTR_ERR(dev);
1732 goto out_rtnl;
1733 }
1734
1735 if (!dev->ops->dump_mpath) {
1736 err = -EOPNOTSUPP;
1737 goto out_err;
1738 }
1739
1740 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1741 err = -EOPNOTSUPP;
1742 goto out;
1743 }
1744
1745 while (1) {
1746 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
1747 dst, next_hop, &pinfo);
1748 if (err == -ENOENT)
1749 break;
1750 if (err)
1751 goto out_err;
1752
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;
1758
1759 path_idx++;
1760 }
1761
1762
1763 out:
1764 cb->args[1] = path_idx;
1765 err = skb->len;
1766 out_err:
1767 cfg80211_put_dev(dev);
1768 out_rtnl:
1769 rtnl_unlock();
1770
1771 return err;
1772 }
1773
1774 static 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
1791 rtnl_lock();
1792
1793 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1794 if (err)
1795 goto out_rtnl;
1796
1797 if (!drv->ops->get_mpath) {
1798 err = -EOPNOTSUPP;
1799 goto out;
1800 }
1801
1802 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1803 err = -EOPNOTSUPP;
1804 goto out;
1805 }
1806
1807 err = drv->ops->get_mpath(&drv->wiphy, dev, dst, next_hop, &pinfo);
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);
1824 out:
1825 cfg80211_put_dev(drv);
1826 dev_put(dev);
1827 out_rtnl:
1828 rtnl_unlock();
1829
1830 return err;
1831 }
1832
1833 static 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
1850 rtnl_lock();
1851
1852 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1853 if (err)
1854 goto out_rtnl;
1855
1856 if (!drv->ops->change_mpath) {
1857 err = -EOPNOTSUPP;
1858 goto out;
1859 }
1860
1861 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1862 err = -EOPNOTSUPP;
1863 goto out;
1864 }
1865
1866 if (!netif_running(dev)) {
1867 err = -ENETDOWN;
1868 goto out;
1869 }
1870
1871 err = drv->ops->change_mpath(&drv->wiphy, dev, dst, next_hop);
1872
1873 out:
1874 cfg80211_put_dev(drv);
1875 dev_put(dev);
1876 out_rtnl:
1877 rtnl_unlock();
1878
1879 return err;
1880 }
1881 static 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
1898 rtnl_lock();
1899
1900 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1901 if (err)
1902 goto out_rtnl;
1903
1904 if (!drv->ops->add_mpath) {
1905 err = -EOPNOTSUPP;
1906 goto out;
1907 }
1908
1909 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
1910 err = -EOPNOTSUPP;
1911 goto out;
1912 }
1913
1914 if (!netif_running(dev)) {
1915 err = -ENETDOWN;
1916 goto out;
1917 }
1918
1919 err = drv->ops->add_mpath(&drv->wiphy, dev, dst, next_hop);
1920
1921 out:
1922 cfg80211_put_dev(drv);
1923 dev_put(dev);
1924 out_rtnl:
1925 rtnl_unlock();
1926
1927 return err;
1928 }
1929
1930 static 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
1940 rtnl_lock();
1941
1942 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1943 if (err)
1944 goto out_rtnl;
1945
1946 if (!drv->ops->del_mpath) {
1947 err = -EOPNOTSUPP;
1948 goto out;
1949 }
1950
1951 err = drv->ops->del_mpath(&drv->wiphy, dev, dst);
1952
1953 out:
1954 cfg80211_put_dev(drv);
1955 dev_put(dev);
1956 out_rtnl:
1957 rtnl_unlock();
1958
1959 return err;
1960 }
1961
1962 static 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]);
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 }
1990
1991 rtnl_lock();
1992
1993 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1994 if (err)
1995 goto out_rtnl;
1996
1997 if (!drv->ops->change_bss) {
1998 err = -EOPNOTSUPP;
1999 goto out;
2000 }
2001
2002 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2003 err = -EOPNOTSUPP;
2004 goto out;
2005 }
2006
2007 err = drv->ops->change_bss(&drv->wiphy, dev, &params);
2008
2009 out:
2010 cfg80211_put_dev(drv);
2011 dev_put(dev);
2012 out_rtnl:
2013 rtnl_unlock();
2014
2015 return err;
2016 }
2017
2018 static 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
2028 static 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
2064 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2065 {
2066 int r;
2067 char *data = NULL;
2068
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)) {
2077 mutex_unlock(&cfg80211_mutex);
2078 return -EINPROGRESS;
2079 }
2080 mutex_unlock(&cfg80211_mutex);
2081
2082 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2083 return -EINVAL;
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 */
2089 if (is_world_regdom(data))
2090 return -EINVAL;
2091 #endif
2092
2093 r = regulatory_hint_user(data);
2094
2095 return r;
2096 }
2097
2098 static 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
2109 rtnl_lock();
2110
2111 /* Look up our device */
2112 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2113 if (err)
2114 goto out_rtnl;
2115
2116 if (!drv->ops->get_mesh_params) {
2117 err = -EOPNOTSUPP;
2118 goto out;
2119 }
2120
2121 /* Get the mesh params */
2122 err = drv->ops->get_mesh_params(&drv->wiphy, dev, &cur_params);
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
2171 nla_put_failure:
2172 genlmsg_cancel(msg, hdr);
2173 err = -EMSGSIZE;
2174 out:
2175 /* Cleanup */
2176 cfg80211_put_dev(drv);
2177 dev_put(dev);
2178 out_rtnl:
2179 rtnl_unlock();
2180
2181 return err;
2182 }
2183
2184 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2185 do {\
2186 if (table[attr_num]) {\
2187 cfg.param = nla_fn(table[attr_num]); \
2188 mask |= (1 << (attr_num - 1)); \
2189 } \
2190 } while (0);\
2191
2192 static struct nla_policy
2193 nl80211_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
2210 static 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
2227 rtnl_lock();
2228
2229 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2230 if (err)
2231 goto out_rtnl;
2232
2233 if (!drv->ops->set_mesh_params) {
2234 err = -EOPNOTSUPP;
2235 goto out;
2236 }
2237
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 */
2278 err = drv->ops->set_mesh_params(&drv->wiphy, dev, &cfg, mask);
2279
2280 out:
2281 /* cleanup */
2282 cfg80211_put_dev(drv);
2283 dev_put(dev);
2284 out_rtnl:
2285 rtnl_unlock();
2286
2287 return err;
2288 }
2289
2290 #undef FILL_IN_MESH_PARAM_IF_SET
2291
2292 static 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
2300 mutex_lock(&cfg80211_mutex);
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
2359 nla_put_failure:
2360 genlmsg_cancel(msg, hdr);
2361 err = -EMSGSIZE;
2362 out:
2363 mutex_unlock(&cfg80211_mutex);
2364 return err;
2365 }
2366
2367 static 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
2422 mutex_lock(&cfg80211_mutex);
2423 r = set_regdom(rd);
2424 mutex_unlock(&cfg80211_mutex);
2425 return r;
2426
2427 bad_reg:
2428 kfree(rd);
2429 return -EINVAL;
2430 }
2431
2432 static 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;
2443 size_t ie_len;
2444
2445 rtnl_lock();
2446
2447 err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
2448 if (err)
2449 goto out_rtnl;
2450
2451 wiphy = &drv->wiphy;
2452
2453 if (!drv->ops->scan) {
2454 err = -EOPNOTSUPP;
2455 goto out;
2456 }
2457
2458 if (!netif_running(dev)) {
2459 err = -ENETDOWN;
2460 goto out;
2461 }
2462
2463 if (drv->scan_req) {
2464 err = -EBUSY;
2465 goto out;
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;
2473 goto out;
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;
2487 goto out;
2488 }
2489
2490 if (info->attrs[NL80211_ATTR_IE])
2491 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2492 else
2493 ie_len = 0;
2494
2495 request = kzalloc(sizeof(*request)
2496 + sizeof(*ssid) * n_ssids
2497 + sizeof(channel) * n_channels
2498 + ie_len, GFP_KERNEL);
2499 if (!request) {
2500 err = -ENOMEM;
2501 goto out;
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;
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 }
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
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
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 }
2572 out:
2573 cfg80211_put_dev(drv);
2574 dev_put(dev);
2575 out_rtnl:
2576 rtnl_unlock();
2577
2578 return err;
2579 }
2580
2581 static 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
2614 switch (rdev->wiphy.signal_type) {
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
2634 static 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
2697 static 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
2705 static 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
2724 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2725 err = -EOPNOTSUPP;
2726 goto out;
2727 }
2728
2729 if (!netif_running(dev)) {
2730 err = -ENETDOWN;
2731 goto out;
2732 }
2733
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]);
2767 if (!nl80211_valid_auth_type(req.auth_type)) {
2768 err = -EINVAL;
2769 goto out;
2770 }
2771 }
2772
2773 err = drv->ops->auth(&drv->wiphy, dev, &req);
2774
2775 out:
2776 cfg80211_put_dev(drv);
2777 dev_put(dev);
2778 unlock_rtnl:
2779 rtnl_unlock();
2780 return err;
2781 }
2782
2783 static 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
2802 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2803 err = -EOPNOTSUPP;
2804 goto out;
2805 }
2806
2807 if (!netif_running(dev)) {
2808 err = -ENETDOWN;
2809 goto out;
2810 }
2811
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
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
2843 out:
2844 cfg80211_put_dev(drv);
2845 dev_put(dev);
2846 unlock_rtnl:
2847 rtnl_unlock();
2848 return err;
2849 }
2850
2851 static 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
2870 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2871 err = -EOPNOTSUPP;
2872 goto out;
2873 }
2874
2875 if (!netif_running(dev)) {
2876 err = -ENETDOWN;
2877 goto out;
2878 }
2879
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
2890 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
2891 req.reason_code =
2892 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
2893 if (req.reason_code == 0) {
2894 /* Reason Code 0 is reserved */
2895 err = -EINVAL;
2896 goto out;
2897 }
2898 }
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
2907 out:
2908 cfg80211_put_dev(drv);
2909 dev_put(dev);
2910 unlock_rtnl:
2911 rtnl_unlock();
2912 return err;
2913 }
2914
2915 static 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
2934 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
2935 err = -EOPNOTSUPP;
2936 goto out;
2937 }
2938
2939 if (!netif_running(dev)) {
2940 err = -ENETDOWN;
2941 goto out;
2942 }
2943
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
2954 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
2955 req.reason_code =
2956 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
2957 if (req.reason_code == 0) {
2958 /* Reason Code 0 is reserved */
2959 err = -EINVAL;
2960 goto out;
2961 }
2962 }
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
2971 out:
2972 cfg80211_put_dev(drv);
2973 dev_put(dev);
2974 unlock_rtnl:
2975 rtnl_unlock();
2976 return err;
2977 }
2978
2979 static 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,
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,
3040 .flags = GENL_ADMIN_PERM,
3041 },
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 },
3060 {
3061 .cmd = NL80211_CMD_GET_STATION,
3062 .doit = nl80211_get_station,
3063 .dumpit = nl80211_dump_station,
3064 .policy = nl80211_policy,
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,
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,
3107 .flags = GENL_ADMIN_PERM,
3108 },
3109 {
3110 .cmd = NL80211_CMD_SET_BSS,
3111 .doit = nl80211_set_bss,
3112 .policy = nl80211_policy,
3113 .flags = GENL_ADMIN_PERM,
3114 },
3115 {
3116 .cmd = NL80211_CMD_GET_REG,
3117 .doit = nl80211_get_reg,
3118 .policy = nl80211_policy,
3119 /* can be retrieved by unprivileged users */
3120 },
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,
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,
3143 .flags = GENL_ADMIN_PERM,
3144 },
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 },
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 },
3180 };
3181 static struct genl_multicast_group nl80211_mlme_mcgrp = {
3182 .name = "mlme",
3183 };
3184
3185 /* multicast groups */
3186 static struct genl_multicast_group nl80211_config_mcgrp = {
3187 .name = "config",
3188 };
3189 static struct genl_multicast_group nl80211_scan_mcgrp = {
3190 .name = "scan",
3191 };
3192 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
3193 .name = "regulatory",
3194 };
3195
3196 /* notification functions */
3197
3198 void 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
3214 static 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
3226 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
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
3238 void 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
3256 void 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
3274 /*
3275 * This can happen on global regulatory changes or device specific settings
3276 * based on custom world regulatory domains.
3277 */
3278 void 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
3324 nla_put_failure:
3325 genlmsg_cancel(msg, hdr);
3326 nlmsg_free(msg);
3327 }
3328
3329 static 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
3337 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
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
3356 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_ATOMIC);
3357 return;
3358
3359 nla_put_failure:
3360 genlmsg_cancel(msg, hdr);
3361 nlmsg_free(msg);
3362 }
3363
3364 void 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
3371 void 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
3378 void 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
3386 void 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
3394 /* initialisation/exit functions */
3395
3396 int 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
3414 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
3415 if (err)
3416 goto err_out;
3417
3418 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
3419 if (err)
3420 goto err_out;
3421
3422 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
3423 if (err)
3424 goto err_out;
3425
3426 return 0;
3427 err_out:
3428 genl_unregister_family(&nl80211_fam);
3429 return err;
3430 }
3431
3432 void nl80211_exit(void)
3433 {
3434 genl_unregister_family(&nl80211_fam);
3435 }
Support for the Chinese Samsung S3C2440 based development boards