2 * This is the new netlink-based wireless configuration interface.
4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.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>
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,
32 /* internal helper: get rdev and dev */
33 static int get_rdev_dev_by_info_ifindex(struct nlattr **attrs,
34 struct cfg80211_registered_device **rdev,
35 struct net_device **dev)
39 if (!attrs[NL80211_ATTR_IFINDEX])
42 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
43 *dev = dev_get_by_index(&init_net, ifindex);
47 *rdev = cfg80211_get_dev_from_ifindex(ifindex);
50 return PTR_ERR(*rdev);
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,
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 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
65 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
66 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
67 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
69 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
70 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
71 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
73 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
74 [NL80211_ATTR_PREV_BSSID] = { .type = NLA_BINARY, .len = ETH_ALEN },
76 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
77 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
78 .len = WLAN_MAX_KEY_LEN },
79 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
80 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
81 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
82 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
84 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
85 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
86 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
87 .len = IEEE80211_MAX_DATA_LEN },
88 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
89 .len = IEEE80211_MAX_DATA_LEN },
90 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
91 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
92 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
93 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
94 .len = NL80211_MAX_SUPP_RATES },
95 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
96 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
97 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
98 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
99 .len = IEEE80211_MAX_MESH_ID_LEN },
100 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
102 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
103 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
105 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
106 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
107 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
108 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
109 .len = NL80211_MAX_SUPP_RATES },
111 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
113 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
114 .len = NL80211_HT_CAPABILITY_LEN },
116 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
117 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
118 .len = IEEE80211_MAX_DATA_LEN },
119 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
120 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
122 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
123 .len = IEEE80211_MAX_SSID_LEN },
124 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
125 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
126 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
127 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
128 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
129 [NL80211_ATTR_STA_FLAGS2] = {
130 .len = sizeof(struct nl80211_sta_flag_update),
132 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
133 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
134 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
135 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
138 /* policy for the attributes */
139 static struct nla_policy
140 nl80211_key_policy[NL80211_KEY_MAX + 1] __read_mostly = {
141 [NL80211_KEY_DATA] = { .type = NLA_BINARY,
142 .len = WLAN_MAX_KEY_LEN },
143 [NL80211_KEY_IDX] = { .type = NLA_U8 },
144 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
145 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
146 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
147 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
151 static bool is_valid_ie_attr(const struct nlattr *attr)
159 pos = nla_data(attr);
180 /* message building helper */
181 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
184 /* since there is no private header just add the generic one */
185 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
188 static int nl80211_msg_put_channel(struct sk_buff *msg,
189 struct ieee80211_channel *chan)
191 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
194 if (chan->flags & IEEE80211_CHAN_DISABLED)
195 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
196 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
197 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
198 if (chan->flags & IEEE80211_CHAN_NO_IBSS)
199 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
200 if (chan->flags & IEEE80211_CHAN_RADAR)
201 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
203 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
204 DBM_TO_MBM(chan->max_power));
212 /* netlink command implementations */
220 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
222 struct nlattr *tb[NL80211_KEY_MAX + 1];
223 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
228 k->def = !!tb[NL80211_KEY_DEFAULT];
229 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
231 if (tb[NL80211_KEY_IDX])
232 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
234 if (tb[NL80211_KEY_DATA]) {
235 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
236 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
239 if (tb[NL80211_KEY_SEQ]) {
240 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
241 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
244 if (tb[NL80211_KEY_CIPHER])
245 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
250 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
252 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
253 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
254 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
257 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
258 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
259 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
262 if (info->attrs[NL80211_ATTR_KEY_IDX])
263 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
265 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
266 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
268 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
269 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
274 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
278 memset(k, 0, sizeof(*k));
281 if (info->attrs[NL80211_ATTR_KEY])
282 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
284 err = nl80211_parse_key_old(info, k);
289 if (k->def && k->defmgmt)
294 if (k->idx < 4 || k->idx > 5)
297 if (k->idx < 0 || k->idx > 3)
300 if (k->idx < 0 || k->idx > 5)
308 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
309 struct cfg80211_registered_device *dev)
312 struct nlattr *nl_bands, *nl_band;
313 struct nlattr *nl_freqs, *nl_freq;
314 struct nlattr *nl_rates, *nl_rate;
315 struct nlattr *nl_modes;
316 struct nlattr *nl_cmds;
317 enum ieee80211_band band;
318 struct ieee80211_channel *chan;
319 struct ieee80211_rate *rate;
321 u16 ifmodes = dev->wiphy.interface_modes;
323 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
327 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
328 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
330 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
331 dev->wiphy.retry_short);
332 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
333 dev->wiphy.retry_long);
334 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
335 dev->wiphy.frag_threshold);
336 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
337 dev->wiphy.rts_threshold);
339 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
340 dev->wiphy.max_scan_ssids);
341 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
342 dev->wiphy.max_scan_ie_len);
344 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
345 sizeof(u32) * dev->wiphy.n_cipher_suites,
346 dev->wiphy.cipher_suites);
348 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
350 goto nla_put_failure;
355 NLA_PUT_FLAG(msg, i);
360 nla_nest_end(msg, nl_modes);
362 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
364 goto nla_put_failure;
366 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
367 if (!dev->wiphy.bands[band])
370 nl_band = nla_nest_start(msg, band);
372 goto nla_put_failure;
375 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
376 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
377 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
378 &dev->wiphy.bands[band]->ht_cap.mcs);
379 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
380 dev->wiphy.bands[band]->ht_cap.cap);
381 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
382 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
383 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
384 dev->wiphy.bands[band]->ht_cap.ampdu_density);
387 /* add frequencies */
388 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
390 goto nla_put_failure;
392 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
393 nl_freq = nla_nest_start(msg, i);
395 goto nla_put_failure;
397 chan = &dev->wiphy.bands[band]->channels[i];
399 if (nl80211_msg_put_channel(msg, chan))
400 goto nla_put_failure;
402 nla_nest_end(msg, nl_freq);
405 nla_nest_end(msg, nl_freqs);
408 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
410 goto nla_put_failure;
412 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
413 nl_rate = nla_nest_start(msg, i);
415 goto nla_put_failure;
417 rate = &dev->wiphy.bands[band]->bitrates[i];
418 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
420 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
422 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
424 nla_nest_end(msg, nl_rate);
427 nla_nest_end(msg, nl_rates);
429 nla_nest_end(msg, nl_band);
431 nla_nest_end(msg, nl_bands);
433 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
435 goto nla_put_failure;
440 if (dev->ops->op) { \
442 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \
446 CMD(add_virtual_intf, NEW_INTERFACE);
447 CMD(change_virtual_intf, SET_INTERFACE);
448 CMD(add_key, NEW_KEY);
449 CMD(add_beacon, NEW_BEACON);
450 CMD(add_station, NEW_STATION);
451 CMD(add_mpath, NEW_MPATH);
452 CMD(set_mesh_params, SET_MESH_PARAMS);
453 CMD(change_bss, SET_BSS);
454 CMD(auth, AUTHENTICATE);
455 CMD(assoc, ASSOCIATE);
456 CMD(deauth, DEAUTHENTICATE);
457 CMD(disassoc, DISASSOCIATE);
458 CMD(join_ibss, JOIN_IBSS);
462 if (dev->ops->connect || dev->ops->auth) {
464 NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT);
467 if (dev->ops->disconnect || dev->ops->deauth) {
469 NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT);
472 nla_nest_end(msg, nl_cmds);
474 return genlmsg_end(msg, hdr);
477 genlmsg_cancel(msg, hdr);
481 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
484 int start = cb->args[0];
485 struct cfg80211_registered_device *dev;
487 mutex_lock(&cfg80211_mutex);
488 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
491 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
492 cb->nlh->nlmsg_seq, NLM_F_MULTI,
498 mutex_unlock(&cfg80211_mutex);
505 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
508 struct cfg80211_registered_device *dev;
510 dev = cfg80211_get_dev_from_info(info);
514 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
518 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
521 cfg80211_unlock_rdev(dev);
523 return genlmsg_reply(msg, info);
528 cfg80211_unlock_rdev(dev);
532 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
533 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
534 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
535 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
536 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
537 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
540 static int parse_txq_params(struct nlattr *tb[],
541 struct ieee80211_txq_params *txq_params)
543 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
544 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
545 !tb[NL80211_TXQ_ATTR_AIFS])
548 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
549 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
550 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
551 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
552 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
557 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
559 struct cfg80211_registered_device *rdev;
560 int result = 0, rem_txq_params = 0;
561 struct nlattr *nl_txq_params;
563 u8 retry_short = 0, retry_long = 0;
564 u32 frag_threshold = 0, rts_threshold = 0;
568 mutex_lock(&cfg80211_mutex);
570 rdev = __cfg80211_rdev_from_info(info);
572 mutex_unlock(&cfg80211_mutex);
573 result = PTR_ERR(rdev);
577 mutex_lock(&rdev->mtx);
579 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
580 result = cfg80211_dev_rename(
581 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
583 mutex_unlock(&cfg80211_mutex);
588 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
589 struct ieee80211_txq_params txq_params;
590 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
592 if (!rdev->ops->set_txq_params) {
593 result = -EOPNOTSUPP;
597 nla_for_each_nested(nl_txq_params,
598 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
600 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
601 nla_data(nl_txq_params),
602 nla_len(nl_txq_params),
604 result = parse_txq_params(tb, &txq_params);
608 result = rdev->ops->set_txq_params(&rdev->wiphy,
615 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
616 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
617 struct ieee80211_channel *chan;
618 struct ieee80211_sta_ht_cap *ht_cap;
621 if (!rdev->ops->set_channel) {
622 result = -EOPNOTSUPP;
628 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
629 channel_type = nla_get_u32(info->attrs[
630 NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
631 if (channel_type != NL80211_CHAN_NO_HT &&
632 channel_type != NL80211_CHAN_HT20 &&
633 channel_type != NL80211_CHAN_HT40PLUS &&
634 channel_type != NL80211_CHAN_HT40MINUS)
638 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
639 chan = ieee80211_get_channel(&rdev->wiphy, freq);
641 /* Primary channel not allowed */
642 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
645 if (channel_type == NL80211_CHAN_HT40MINUS &&
646 (chan->flags & IEEE80211_CHAN_NO_HT40MINUS))
648 else if (channel_type == NL80211_CHAN_HT40PLUS &&
649 (chan->flags & IEEE80211_CHAN_NO_HT40PLUS))
653 * At this point we know if that if HT40 was requested
654 * we are allowed to use it and the extension channel
658 ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
660 /* no HT capabilities or intolerant */
661 if (channel_type != NL80211_CHAN_NO_HT) {
662 if (!ht_cap->ht_supported)
664 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
665 (ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
669 result = rdev->ops->set_channel(&rdev->wiphy, chan,
677 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
678 retry_short = nla_get_u8(
679 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
680 if (retry_short == 0) {
684 changed |= WIPHY_PARAM_RETRY_SHORT;
687 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
688 retry_long = nla_get_u8(
689 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
690 if (retry_long == 0) {
694 changed |= WIPHY_PARAM_RETRY_LONG;
697 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
698 frag_threshold = nla_get_u32(
699 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
700 if (frag_threshold < 256) {
704 if (frag_threshold != (u32) -1) {
706 * Fragments (apart from the last one) are required to
707 * have even length. Make the fragmentation code
708 * simpler by stripping LSB should someone try to use
709 * odd threshold value.
711 frag_threshold &= ~0x1;
713 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
716 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
717 rts_threshold = nla_get_u32(
718 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
719 changed |= WIPHY_PARAM_RTS_THRESHOLD;
723 u8 old_retry_short, old_retry_long;
724 u32 old_frag_threshold, old_rts_threshold;
726 if (!rdev->ops->set_wiphy_params) {
727 result = -EOPNOTSUPP;
731 old_retry_short = rdev->wiphy.retry_short;
732 old_retry_long = rdev->wiphy.retry_long;
733 old_frag_threshold = rdev->wiphy.frag_threshold;
734 old_rts_threshold = rdev->wiphy.rts_threshold;
736 if (changed & WIPHY_PARAM_RETRY_SHORT)
737 rdev->wiphy.retry_short = retry_short;
738 if (changed & WIPHY_PARAM_RETRY_LONG)
739 rdev->wiphy.retry_long = retry_long;
740 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
741 rdev->wiphy.frag_threshold = frag_threshold;
742 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
743 rdev->wiphy.rts_threshold = rts_threshold;
745 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
747 rdev->wiphy.retry_short = old_retry_short;
748 rdev->wiphy.retry_long = old_retry_long;
749 rdev->wiphy.frag_threshold = old_frag_threshold;
750 rdev->wiphy.rts_threshold = old_rts_threshold;
755 mutex_unlock(&rdev->mtx);
762 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
763 struct cfg80211_registered_device *rdev,
764 struct net_device *dev)
768 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
772 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
773 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
774 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
775 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
776 return genlmsg_end(msg, hdr);
779 genlmsg_cancel(msg, hdr);
783 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
787 int wp_start = cb->args[0];
788 int if_start = cb->args[1];
789 struct cfg80211_registered_device *dev;
790 struct wireless_dev *wdev;
792 mutex_lock(&cfg80211_mutex);
793 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
794 if (wp_idx < wp_start) {
800 mutex_lock(&dev->devlist_mtx);
801 list_for_each_entry(wdev, &dev->netdev_list, list) {
802 if (if_idx < if_start) {
806 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
807 cb->nlh->nlmsg_seq, NLM_F_MULTI,
808 dev, wdev->netdev) < 0) {
809 mutex_unlock(&dev->devlist_mtx);
814 mutex_unlock(&dev->devlist_mtx);
819 mutex_unlock(&cfg80211_mutex);
821 cb->args[0] = wp_idx;
822 cb->args[1] = if_idx;
827 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
830 struct cfg80211_registered_device *dev;
831 struct net_device *netdev;
834 err = get_rdev_dev_by_info_ifindex(info->attrs, &dev, &netdev);
838 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
842 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
847 cfg80211_unlock_rdev(dev);
849 return genlmsg_reply(msg, info);
855 cfg80211_unlock_rdev(dev);
859 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
860 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
861 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
862 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
863 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
864 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
867 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
869 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
877 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
878 nla, mntr_flags_policy))
881 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
883 *mntrflags |= (1<<flag);
888 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
890 struct cfg80211_registered_device *rdev;
891 struct vif_params params;
893 enum nl80211_iftype otype, ntype;
894 struct net_device *dev;
895 u32 _flags, *flags = NULL;
898 memset(¶ms, 0, sizeof(params));
902 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
906 otype = ntype = dev->ieee80211_ptr->iftype;
908 if (info->attrs[NL80211_ATTR_IFTYPE]) {
909 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
912 if (ntype > NL80211_IFTYPE_MAX) {
918 if (!rdev->ops->change_virtual_intf ||
919 !(rdev->wiphy.interface_modes & (1 << ntype))) {
924 if (info->attrs[NL80211_ATTR_MESH_ID]) {
925 if (ntype != NL80211_IFTYPE_MESH_POINT) {
929 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
930 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
934 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
935 if (ntype != NL80211_IFTYPE_MONITOR) {
939 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
949 err = rdev->ops->change_virtual_intf(&rdev->wiphy, dev,
950 ntype, flags, ¶ms);
954 WARN_ON(!err && dev->ieee80211_ptr->iftype != ntype);
956 if (!err && (ntype != otype)) {
957 if (otype == NL80211_IFTYPE_ADHOC)
958 cfg80211_clear_ibss(dev, false);
963 cfg80211_unlock_rdev(rdev);
969 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
971 struct cfg80211_registered_device *rdev;
972 struct vif_params params;
974 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
977 memset(¶ms, 0, sizeof(params));
979 if (!info->attrs[NL80211_ATTR_IFNAME])
982 if (info->attrs[NL80211_ATTR_IFTYPE]) {
983 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
984 if (type > NL80211_IFTYPE_MAX)
990 rdev = cfg80211_get_dev_from_info(info);
996 if (!rdev->ops->add_virtual_intf ||
997 !(rdev->wiphy.interface_modes & (1 << type))) {
1002 if (type == NL80211_IFTYPE_MESH_POINT &&
1003 info->attrs[NL80211_ATTR_MESH_ID]) {
1004 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
1005 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1008 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1009 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1011 err = rdev->ops->add_virtual_intf(&rdev->wiphy,
1012 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
1013 type, err ? NULL : &flags, ¶ms);
1016 cfg80211_unlock_rdev(rdev);
1022 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1024 struct cfg80211_registered_device *rdev;
1026 struct net_device *dev;
1030 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1033 ifindex = dev->ifindex;
1036 if (!rdev->ops->del_virtual_intf) {
1041 err = rdev->ops->del_virtual_intf(&rdev->wiphy, ifindex);
1044 cfg80211_unlock_rdev(rdev);
1050 struct get_key_cookie {
1051 struct sk_buff *msg;
1056 static void get_key_callback(void *c, struct key_params *params)
1059 struct get_key_cookie *cookie = c;
1062 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
1063 params->key_len, params->key);
1066 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
1067 params->seq_len, params->seq);
1070 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1073 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1075 goto nla_put_failure;
1078 NLA_PUT(cookie->msg, NL80211_KEY_DATA,
1079 params->key_len, params->key);
1082 NLA_PUT(cookie->msg, NL80211_KEY_SEQ,
1083 params->seq_len, params->seq);
1086 NLA_PUT_U32(cookie->msg, NL80211_KEY_CIPHER,
1089 NLA_PUT_U8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx);
1091 nla_nest_end(cookie->msg, key);
1098 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
1100 struct cfg80211_registered_device *rdev;
1102 struct net_device *dev;
1104 u8 *mac_addr = NULL;
1105 struct get_key_cookie cookie = {
1109 struct sk_buff *msg;
1111 if (info->attrs[NL80211_ATTR_KEY_IDX])
1112 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1117 if (info->attrs[NL80211_ATTR_MAC])
1118 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1122 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1126 if (!rdev->ops->get_key) {
1131 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1137 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1138 NL80211_CMD_NEW_KEY);
1146 cookie.idx = key_idx;
1148 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1149 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1151 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1153 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, mac_addr,
1154 &cookie, get_key_callback);
1160 goto nla_put_failure;
1162 genlmsg_end(msg, hdr);
1163 err = genlmsg_reply(msg, info);
1171 cfg80211_unlock_rdev(rdev);
1179 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
1181 struct cfg80211_registered_device *rdev;
1182 struct key_parse key;
1184 struct net_device *dev;
1185 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
1188 err = nl80211_parse_key(info, &key);
1195 /* only support setting default key */
1196 if (!key.def && !key.defmgmt)
1201 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1206 func = rdev->ops->set_default_key;
1208 func = rdev->ops->set_default_mgmt_key;
1215 err = func(&rdev->wiphy, dev, key.idx);
1216 #ifdef CONFIG_WIRELESS_EXT
1218 if (func == rdev->ops->set_default_key)
1219 dev->ieee80211_ptr->wext.default_key = key.idx;
1221 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
1226 cfg80211_unlock_rdev(rdev);
1235 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
1237 struct cfg80211_registered_device *rdev;
1239 struct net_device *dev;
1240 struct key_parse key;
1241 u8 *mac_addr = NULL;
1243 err = nl80211_parse_key(info, &key);
1250 if (info->attrs[NL80211_ATTR_MAC])
1251 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1253 if (cfg80211_validate_key_settings(&key.p, key.idx, mac_addr))
1258 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1262 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++)
1263 if (key.p.cipher == rdev->wiphy.cipher_suites[i])
1265 if (i == rdev->wiphy.n_cipher_suites) {
1270 if (!rdev->ops->add_key) {
1275 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx, mac_addr, &key.p);
1278 cfg80211_unlock_rdev(rdev);
1286 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
1288 struct cfg80211_registered_device *rdev;
1290 struct net_device *dev;
1291 u8 *mac_addr = NULL;
1292 struct key_parse key;
1294 err = nl80211_parse_key(info, &key);
1298 if (info->attrs[NL80211_ATTR_MAC])
1299 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1303 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1307 if (!rdev->ops->del_key) {
1312 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx, mac_addr);
1314 #ifdef CONFIG_WIRELESS_EXT
1316 if (key.idx == dev->ieee80211_ptr->wext.default_key)
1317 dev->ieee80211_ptr->wext.default_key = -1;
1318 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
1319 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
1324 cfg80211_unlock_rdev(rdev);
1333 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
1335 int (*call)(struct wiphy *wiphy, struct net_device *dev,
1336 struct beacon_parameters *info);
1337 struct cfg80211_registered_device *rdev;
1339 struct net_device *dev;
1340 struct beacon_parameters params;
1343 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1348 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1352 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1357 switch (info->genlhdr->cmd) {
1358 case NL80211_CMD_NEW_BEACON:
1359 /* these are required for NEW_BEACON */
1360 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
1361 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
1362 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1367 call = rdev->ops->add_beacon;
1369 case NL80211_CMD_SET_BEACON:
1370 call = rdev->ops->set_beacon;
1383 memset(¶ms, 0, sizeof(params));
1385 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1387 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1391 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1392 params.dtim_period =
1393 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1397 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1398 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1400 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1404 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1405 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1407 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1416 err = call(&rdev->wiphy, dev, ¶ms);
1419 cfg80211_unlock_rdev(rdev);
1427 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1429 struct cfg80211_registered_device *rdev;
1431 struct net_device *dev;
1435 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1439 if (!rdev->ops->del_beacon) {
1444 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1448 err = rdev->ops->del_beacon(&rdev->wiphy, dev);
1451 cfg80211_unlock_rdev(rdev);
1459 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1460 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1461 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1462 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
1463 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
1466 static int parse_station_flags(struct genl_info *info,
1467 struct station_parameters *params)
1469 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
1474 * Try parsing the new attribute first so userspace
1475 * can specify both for older kernels.
1477 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
1479 struct nl80211_sta_flag_update *sta_flags;
1481 sta_flags = nla_data(nla);
1482 params->sta_flags_mask = sta_flags->mask;
1483 params->sta_flags_set = sta_flags->set;
1484 if ((params->sta_flags_mask |
1485 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
1490 /* if present, parse the old attribute */
1492 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
1496 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1497 nla, sta_flags_policy))
1500 params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1;
1501 params->sta_flags_mask &= ~1;
1503 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1505 params->sta_flags_set |= (1<<flag);
1510 static u16 nl80211_calculate_bitrate(struct rate_info *rate)
1512 int modulation, streams, bitrate;
1514 if (!(rate->flags & RATE_INFO_FLAGS_MCS))
1515 return rate->legacy;
1517 /* the formula below does only work for MCS values smaller than 32 */
1518 if (rate->mcs >= 32)
1521 modulation = rate->mcs & 7;
1522 streams = (rate->mcs >> 3) + 1;
1524 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ?
1528 bitrate *= (modulation + 1);
1529 else if (modulation == 4)
1530 bitrate *= (modulation + 2);
1532 bitrate *= (modulation + 3);
1536 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI)
1537 bitrate = (bitrate / 9) * 10;
1539 /* do NOT round down here */
1540 return (bitrate + 50000) / 100000;
1543 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1544 int flags, struct net_device *dev,
1545 u8 *mac_addr, struct station_info *sinfo)
1548 struct nlattr *sinfoattr, *txrate;
1551 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1555 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1556 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1558 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1560 goto nla_put_failure;
1561 if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1562 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1563 sinfo->inactive_time);
1564 if (sinfo->filled & STATION_INFO_RX_BYTES)
1565 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1567 if (sinfo->filled & STATION_INFO_TX_BYTES)
1568 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1570 if (sinfo->filled & STATION_INFO_LLID)
1571 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1573 if (sinfo->filled & STATION_INFO_PLID)
1574 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1576 if (sinfo->filled & STATION_INFO_PLINK_STATE)
1577 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1578 sinfo->plink_state);
1579 if (sinfo->filled & STATION_INFO_SIGNAL)
1580 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
1582 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
1583 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
1585 goto nla_put_failure;
1587 /* nl80211_calculate_bitrate will return 0 for mcs >= 32 */
1588 bitrate = nl80211_calculate_bitrate(&sinfo->txrate);
1590 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
1592 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
1593 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
1595 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
1596 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
1597 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
1598 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
1600 nla_nest_end(msg, txrate);
1602 if (sinfo->filled & STATION_INFO_RX_PACKETS)
1603 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
1605 if (sinfo->filled & STATION_INFO_TX_PACKETS)
1606 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS,
1608 nla_nest_end(msg, sinfoattr);
1610 return genlmsg_end(msg, hdr);
1613 genlmsg_cancel(msg, hdr);
1617 static int nl80211_dump_station(struct sk_buff *skb,
1618 struct netlink_callback *cb)
1620 struct station_info sinfo;
1621 struct cfg80211_registered_device *dev;
1622 struct net_device *netdev;
1623 u8 mac_addr[ETH_ALEN];
1624 int ifidx = cb->args[0];
1625 int sta_idx = cb->args[1];
1629 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1630 nl80211_fam.attrbuf, nl80211_fam.maxattr,
1635 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1638 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1645 netdev = __dev_get_by_index(&init_net, ifidx);
1651 dev = cfg80211_get_dev_from_ifindex(ifidx);
1657 if (!dev->ops->dump_station) {
1663 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1670 if (nl80211_send_station(skb,
1671 NETLINK_CB(cb->skb).pid,
1672 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1682 cb->args[1] = sta_idx;
1685 cfg80211_unlock_rdev(dev);
1692 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1694 struct cfg80211_registered_device *rdev;
1696 struct net_device *dev;
1697 struct station_info sinfo;
1698 struct sk_buff *msg;
1699 u8 *mac_addr = NULL;
1701 memset(&sinfo, 0, sizeof(sinfo));
1703 if (!info->attrs[NL80211_ATTR_MAC])
1706 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1710 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1714 if (!rdev->ops->get_station) {
1719 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
1723 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1727 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
1728 dev, mac_addr, &sinfo) < 0)
1731 err = genlmsg_reply(msg, info);
1737 cfg80211_unlock_rdev(rdev);
1746 * Get vlan interface making sure it is on the right wiphy.
1748 static int get_vlan(struct nlattr *vlanattr,
1749 struct cfg80211_registered_device *rdev,
1750 struct net_device **vlan)
1755 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
1758 if (!(*vlan)->ieee80211_ptr)
1760 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1766 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1768 struct cfg80211_registered_device *rdev;
1770 struct net_device *dev;
1771 struct station_parameters params;
1772 u8 *mac_addr = NULL;
1774 memset(¶ms, 0, sizeof(params));
1776 params.listen_interval = -1;
1778 if (info->attrs[NL80211_ATTR_STA_AID])
1781 if (!info->attrs[NL80211_ATTR_MAC])
1784 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1786 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
1787 params.supported_rates =
1788 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1789 params.supported_rates_len =
1790 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1793 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1794 params.listen_interval =
1795 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1797 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1799 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1801 if (parse_station_flags(info, ¶ms))
1804 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
1805 params.plink_action =
1806 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
1810 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1814 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], rdev, ¶ms.vlan);
1818 /* validate settings */
1821 switch (dev->ieee80211_ptr->iftype) {
1822 case NL80211_IFTYPE_AP:
1823 case NL80211_IFTYPE_AP_VLAN:
1824 /* disallow mesh-specific things */
1825 if (params.plink_action)
1828 case NL80211_IFTYPE_STATION:
1829 /* disallow everything but AUTHORIZED flag */
1830 if (params.plink_action)
1834 if (params.supported_rates)
1838 if (params.listen_interval >= 0)
1840 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
1843 case NL80211_IFTYPE_MESH_POINT:
1844 /* disallow things mesh doesn't support */
1849 if (params.listen_interval >= 0)
1851 if (params.supported_rates)
1853 if (params.sta_flags_mask)
1863 if (!rdev->ops->change_station) {
1868 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, ¶ms);
1872 dev_put(params.vlan);
1873 cfg80211_unlock_rdev(rdev);
1881 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
1883 struct cfg80211_registered_device *rdev;
1885 struct net_device *dev;
1886 struct station_parameters params;
1887 u8 *mac_addr = NULL;
1889 memset(¶ms, 0, sizeof(params));
1891 if (!info->attrs[NL80211_ATTR_MAC])
1894 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1897 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
1900 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1901 params.supported_rates =
1902 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1903 params.supported_rates_len =
1904 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1905 params.listen_interval =
1906 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1908 if (info->attrs[NL80211_ATTR_STA_AID]) {
1909 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
1910 if (!params.aid || params.aid > IEEE80211_MAX_AID)
1914 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1916 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1918 if (parse_station_flags(info, ¶ms))
1923 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
1927 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], rdev, ¶ms.vlan);
1931 /* validate settings */
1934 switch (dev->ieee80211_ptr->iftype) {
1935 case NL80211_IFTYPE_AP:
1936 case NL80211_IFTYPE_AP_VLAN:
1937 /* all ok but must have AID */
1941 case NL80211_IFTYPE_MESH_POINT:
1942 /* disallow things mesh doesn't support */
1949 if (params.listen_interval >= 0)
1951 if (params.supported_rates)
1953 if (params.sta_flags_mask)
1963 if (!rdev->ops->add_station) {
1968 if (!netif_running(dev)) {
1973 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, ¶ms);
1977 dev_put(params.vlan);
1978 cfg80211_unlock_rdev(rdev);
1986 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
1988 struct cfg80211_registered_device *rdev;
1990 struct net_device *dev;
1991 u8 *mac_addr = NULL;
1993 if (info->attrs[NL80211_ATTR_MAC])
1994 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1998 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2002 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2003 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
2004 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2009 if (!rdev->ops->del_station) {
2014 err = rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
2017 cfg80211_unlock_rdev(rdev);
2025 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
2026 int flags, struct net_device *dev,
2027 u8 *dst, u8 *next_hop,
2028 struct mpath_info *pinfo)
2031 struct nlattr *pinfoattr;
2033 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2037 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2038 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
2039 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
2041 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
2043 goto nla_put_failure;
2044 if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
2045 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
2047 if (pinfo->filled & MPATH_INFO_DSN)
2048 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
2050 if (pinfo->filled & MPATH_INFO_METRIC)
2051 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
2053 if (pinfo->filled & MPATH_INFO_EXPTIME)
2054 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
2056 if (pinfo->filled & MPATH_INFO_FLAGS)
2057 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
2059 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
2060 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
2061 pinfo->discovery_timeout);
2062 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
2063 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
2064 pinfo->discovery_retries);
2066 nla_nest_end(msg, pinfoattr);
2068 return genlmsg_end(msg, hdr);
2071 genlmsg_cancel(msg, hdr);
2075 static int nl80211_dump_mpath(struct sk_buff *skb,
2076 struct netlink_callback *cb)
2078 struct mpath_info pinfo;
2079 struct cfg80211_registered_device *dev;
2080 struct net_device *netdev;
2082 u8 next_hop[ETH_ALEN];
2083 int ifidx = cb->args[0];
2084 int path_idx = cb->args[1];
2088 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
2089 nl80211_fam.attrbuf, nl80211_fam.maxattr,
2094 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
2097 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
2104 netdev = __dev_get_by_index(&init_net, ifidx);
2110 dev = cfg80211_get_dev_from_ifindex(ifidx);
2116 if (!dev->ops->dump_mpath) {
2121 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2127 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
2128 dst, next_hop, &pinfo);
2134 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
2135 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2136 netdev, dst, next_hop,
2145 cb->args[1] = path_idx;
2148 cfg80211_unlock_rdev(dev);
2155 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
2157 struct cfg80211_registered_device *rdev;
2159 struct net_device *dev;
2160 struct mpath_info pinfo;
2161 struct sk_buff *msg;
2163 u8 next_hop[ETH_ALEN];
2165 memset(&pinfo, 0, sizeof(pinfo));
2167 if (!info->attrs[NL80211_ATTR_MAC])
2170 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2174 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2178 if (!rdev->ops->get_mpath) {
2183 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2188 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
2192 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2196 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
2197 dev, dst, next_hop, &pinfo) < 0)
2200 err = genlmsg_reply(msg, info);
2206 cfg80211_unlock_rdev(rdev);
2214 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
2216 struct cfg80211_registered_device *rdev;
2218 struct net_device *dev;
2220 u8 *next_hop = NULL;
2222 if (!info->attrs[NL80211_ATTR_MAC])
2225 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2228 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2229 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2233 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2237 if (!rdev->ops->change_mpath) {
2242 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2247 if (!netif_running(dev)) {
2252 err = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
2255 cfg80211_unlock_rdev(rdev);
2262 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
2264 struct cfg80211_registered_device *rdev;
2266 struct net_device *dev;
2268 u8 *next_hop = NULL;
2270 if (!info->attrs[NL80211_ATTR_MAC])
2273 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2276 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2277 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2281 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2285 if (!rdev->ops->add_mpath) {
2290 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2295 if (!netif_running(dev)) {
2300 err = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
2303 cfg80211_unlock_rdev(rdev);
2311 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
2313 struct cfg80211_registered_device *rdev;
2315 struct net_device *dev;
2318 if (info->attrs[NL80211_ATTR_MAC])
2319 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2323 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2327 if (!rdev->ops->del_mpath) {
2332 err = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
2335 cfg80211_unlock_rdev(rdev);
2343 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
2345 struct cfg80211_registered_device *rdev;
2347 struct net_device *dev;
2348 struct bss_parameters params;
2350 memset(¶ms, 0, sizeof(params));
2351 /* default to not changing parameters */
2352 params.use_cts_prot = -1;
2353 params.use_short_preamble = -1;
2354 params.use_short_slot_time = -1;
2356 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
2357 params.use_cts_prot =
2358 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
2359 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
2360 params.use_short_preamble =
2361 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
2362 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
2363 params.use_short_slot_time =
2364 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
2365 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
2366 params.basic_rates =
2367 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2368 params.basic_rates_len =
2369 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2374 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2378 if (!rdev->ops->change_bss) {
2383 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2388 err = rdev->ops->change_bss(&rdev->wiphy, dev, ¶ms);
2391 cfg80211_unlock_rdev(rdev);
2399 static const struct nla_policy
2400 reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
2401 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2402 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2403 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2404 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2405 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2406 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2409 static int parse_reg_rule(struct nlattr *tb[],
2410 struct ieee80211_reg_rule *reg_rule)
2412 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
2413 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
2415 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
2417 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
2419 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
2421 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2423 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2426 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
2428 freq_range->start_freq_khz =
2429 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
2430 freq_range->end_freq_khz =
2431 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
2432 freq_range->max_bandwidth_khz =
2433 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
2435 power_rule->max_eirp =
2436 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
2438 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
2439 power_rule->max_antenna_gain =
2440 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
2445 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2451 * You should only get this when cfg80211 hasn't yet initialized
2452 * completely when built-in to the kernel right between the time
2453 * window between nl80211_init() and regulatory_init(), if that is
2456 mutex_lock(&cfg80211_mutex);
2457 if (unlikely(!cfg80211_regdomain)) {
2458 mutex_unlock(&cfg80211_mutex);
2459 return -EINPROGRESS;
2461 mutex_unlock(&cfg80211_mutex);
2463 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2466 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2468 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
2469 /* We ignore world regdom requests with the old regdom setup */
2470 if (is_world_regdom(data))
2474 r = regulatory_hint_user(data);
2479 static int nl80211_get_mesh_params(struct sk_buff *skb,
2480 struct genl_info *info)
2482 struct cfg80211_registered_device *rdev;
2483 struct mesh_config cur_params;
2485 struct net_device *dev;
2487 struct nlattr *pinfoattr;
2488 struct sk_buff *msg;
2492 /* Look up our device */
2493 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2497 if (!rdev->ops->get_mesh_params) {
2502 /* Get the mesh params */
2503 err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
2507 /* Draw up a netlink message to send back */
2508 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2513 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2514 NL80211_CMD_GET_MESH_PARAMS);
2516 goto nla_put_failure;
2517 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
2519 goto nla_put_failure;
2520 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2521 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
2522 cur_params.dot11MeshRetryTimeout);
2523 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
2524 cur_params.dot11MeshConfirmTimeout);
2525 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
2526 cur_params.dot11MeshHoldingTimeout);
2527 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
2528 cur_params.dot11MeshMaxPeerLinks);
2529 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
2530 cur_params.dot11MeshMaxRetries);
2531 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
2532 cur_params.dot11MeshTTL);
2533 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
2534 cur_params.auto_open_plinks);
2535 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2536 cur_params.dot11MeshHWMPmaxPREQretries);
2537 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
2538 cur_params.path_refresh_time);
2539 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2540 cur_params.min_discovery_timeout);
2541 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2542 cur_params.dot11MeshHWMPactivePathTimeout);
2543 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2544 cur_params.dot11MeshHWMPpreqMinInterval);
2545 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2546 cur_params.dot11MeshHWMPnetDiameterTraversalTime);
2547 nla_nest_end(msg, pinfoattr);
2548 genlmsg_end(msg, hdr);
2549 err = genlmsg_reply(msg, info);
2553 genlmsg_cancel(msg, hdr);
2557 cfg80211_unlock_rdev(rdev);
2565 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2567 if (table[attr_num]) {\
2568 cfg.param = nla_fn(table[attr_num]); \
2569 mask |= (1 << (attr_num - 1)); \
2573 static struct nla_policy
2574 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
2575 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
2576 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
2577 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
2578 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
2579 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
2580 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
2581 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
2583 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
2584 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
2585 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
2586 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
2587 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
2588 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
2591 static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
2595 struct cfg80211_registered_device *rdev;
2596 struct net_device *dev;
2597 struct mesh_config cfg;
2598 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
2599 struct nlattr *parent_attr;
2601 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
2604 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
2605 parent_attr, nl80211_meshconf_params_policy))
2610 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2614 if (!rdev->ops->set_mesh_params) {
2619 /* This makes sure that there aren't more than 32 mesh config
2620 * parameters (otherwise our bitfield scheme would not work.) */
2621 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
2623 /* Fill in the params struct */
2625 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
2626 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
2627 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
2628 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
2629 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
2630 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
2631 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
2632 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
2633 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
2634 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
2635 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
2636 mask, NL80211_MESHCONF_TTL, nla_get_u8);
2637 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
2638 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
2639 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
2640 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2642 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
2643 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
2644 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
2645 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2647 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
2648 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2650 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
2651 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2653 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2654 dot11MeshHWMPnetDiameterTraversalTime,
2655 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2659 err = rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
2663 cfg80211_unlock_rdev(rdev);
2671 #undef FILL_IN_MESH_PARAM_IF_SET
2673 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
2675 struct sk_buff *msg;
2677 struct nlattr *nl_reg_rules;
2681 mutex_lock(&cfg80211_mutex);
2683 if (!cfg80211_regdomain)
2686 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2692 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2693 NL80211_CMD_GET_REG);
2695 goto nla_put_failure;
2697 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2698 cfg80211_regdomain->alpha2);
2700 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
2702 goto nla_put_failure;
2704 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
2705 struct nlattr *nl_reg_rule;
2706 const struct ieee80211_reg_rule *reg_rule;
2707 const struct ieee80211_freq_range *freq_range;
2708 const struct ieee80211_power_rule *power_rule;
2710 reg_rule = &cfg80211_regdomain->reg_rules[i];
2711 freq_range = ®_rule->freq_range;
2712 power_rule = ®_rule->power_rule;
2714 nl_reg_rule = nla_nest_start(msg, i);
2716 goto nla_put_failure;
2718 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
2720 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
2721 freq_range->start_freq_khz);
2722 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
2723 freq_range->end_freq_khz);
2724 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
2725 freq_range->max_bandwidth_khz);
2726 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
2727 power_rule->max_antenna_gain);
2728 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
2729 power_rule->max_eirp);
2731 nla_nest_end(msg, nl_reg_rule);
2734 nla_nest_end(msg, nl_reg_rules);
2736 genlmsg_end(msg, hdr);
2737 err = genlmsg_reply(msg, info);
2741 genlmsg_cancel(msg, hdr);
2744 mutex_unlock(&cfg80211_mutex);
2748 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2750 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2751 struct nlattr *nl_reg_rule;
2752 char *alpha2 = NULL;
2753 int rem_reg_rules = 0, r = 0;
2754 u32 num_rules = 0, rule_idx = 0, size_of_regd;
2755 struct ieee80211_regdomain *rd = NULL;
2757 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2760 if (!info->attrs[NL80211_ATTR_REG_RULES])
2763 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2765 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2768 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
2772 mutex_lock(&cfg80211_mutex);
2774 if (!reg_is_valid_request(alpha2)) {
2779 size_of_regd = sizeof(struct ieee80211_regdomain) +
2780 (num_rules * sizeof(struct ieee80211_reg_rule));
2782 rd = kzalloc(size_of_regd, GFP_KERNEL);
2788 rd->n_reg_rules = num_rules;
2789 rd->alpha2[0] = alpha2[0];
2790 rd->alpha2[1] = alpha2[1];
2792 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2794 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2795 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2797 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2803 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
2809 BUG_ON(rule_idx != num_rules);
2813 mutex_unlock(&cfg80211_mutex);
2818 mutex_unlock(&cfg80211_mutex);
2823 static int validate_scan_freqs(struct nlattr *freqs)
2825 struct nlattr *attr1, *attr2;
2826 int n_channels = 0, tmp1, tmp2;
2828 nla_for_each_nested(attr1, freqs, tmp1) {
2831 * Some hardware has a limited channel list for
2832 * scanning, and it is pretty much nonsensical
2833 * to scan for a channel twice, so disallow that
2834 * and don't require drivers to check that the
2835 * channel list they get isn't longer than what
2836 * they can scan, as long as they can scan all
2837 * the channels they registered at once.
2839 nla_for_each_nested(attr2, freqs, tmp2)
2840 if (attr1 != attr2 &&
2841 nla_get_u32(attr1) == nla_get_u32(attr2))
2848 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
2850 struct cfg80211_registered_device *rdev;
2851 struct net_device *dev;
2852 struct cfg80211_scan_request *request;
2853 struct cfg80211_ssid *ssid;
2854 struct ieee80211_channel *channel;
2855 struct nlattr *attr;
2856 struct wiphy *wiphy;
2857 int err, tmp, n_ssids = 0, n_channels, i;
2858 enum ieee80211_band band;
2861 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2866 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
2870 wiphy = &rdev->wiphy;
2872 if (!rdev->ops->scan) {
2877 if (!netif_running(dev)) {
2882 if (rdev->scan_req) {
2887 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
2888 n_channels = validate_scan_freqs(
2889 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
2897 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
2898 if (wiphy->bands[band])
2899 n_channels += wiphy->bands[band]->n_channels;
2902 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
2903 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
2906 if (n_ssids > wiphy->max_scan_ssids) {
2911 if (info->attrs[NL80211_ATTR_IE])
2912 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2916 if (ie_len > wiphy->max_scan_ie_len) {
2921 request = kzalloc(sizeof(*request)
2922 + sizeof(*ssid) * n_ssids
2923 + sizeof(channel) * n_channels
2924 + ie_len, GFP_KERNEL);
2930 request->channels = (void *)((char *)request + sizeof(*request));
2931 request->n_channels = n_channels;
2933 request->ssids = (void *)(request->channels + n_channels);
2934 request->n_ssids = n_ssids;
2937 request->ie = (void *)(request->ssids + n_ssids);
2939 request->ie = (void *)(request->channels + n_channels);
2942 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
2943 /* user specified, bail out if channel not found */
2944 request->n_channels = n_channels;
2946 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
2947 request->channels[i] = ieee80211_get_channel(wiphy, nla_get_u32(attr));
2948 if (!request->channels[i]) {
2957 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2959 if (!wiphy->bands[band])
2961 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
2962 request->channels[i] = &wiphy->bands[band]->channels[j];
2969 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
2970 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
2971 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
2975 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
2976 request->ssids[i].ssid_len = nla_len(attr);
2981 if (info->attrs[NL80211_ATTR_IE]) {
2982 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2983 memcpy((void *)request->ie,
2984 nla_data(info->attrs[NL80211_ATTR_IE]),
2988 request->ifidx = dev->ifindex;
2989 request->wiphy = &rdev->wiphy;
2991 rdev->scan_req = request;
2992 err = rdev->ops->scan(&rdev->wiphy, dev, request);
2995 nl80211_send_scan_start(rdev, dev);
2999 rdev->scan_req = NULL;
3003 cfg80211_unlock_rdev(rdev);
3011 static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
3012 struct cfg80211_registered_device *rdev,
3013 struct net_device *dev,
3014 struct cfg80211_bss *res)
3019 hdr = nl80211hdr_put(msg, pid, seq, flags,
3020 NL80211_CMD_NEW_SCAN_RESULTS);
3024 NLA_PUT_U32(msg, NL80211_ATTR_SCAN_GENERATION,
3025 rdev->bss_generation);
3026 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
3028 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
3030 goto nla_put_failure;
3031 if (!is_zero_ether_addr(res->bssid))
3032 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid);
3033 if (res->information_elements && res->len_information_elements)
3034 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS,
3035 res->len_information_elements,
3036 res->information_elements);
3038 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf);
3039 if (res->beacon_interval)
3040 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval);
3041 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability);
3042 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq);
3044 switch (rdev->wiphy.signal_type) {
3045 case CFG80211_SIGNAL_TYPE_MBM:
3046 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal);
3048 case CFG80211_SIGNAL_TYPE_UNSPEC:
3049 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal);
3055 nla_nest_end(msg, bss);
3057 return genlmsg_end(msg, hdr);
3060 genlmsg_cancel(msg, hdr);
3064 static int nl80211_dump_scan(struct sk_buff *skb,
3065 struct netlink_callback *cb)
3067 struct cfg80211_registered_device *dev;
3068 struct net_device *netdev;
3069 struct cfg80211_internal_bss *scan;
3070 int ifidx = cb->args[0];
3071 int start = cb->args[1], idx = 0;
3075 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
3076 nl80211_fam.attrbuf, nl80211_fam.maxattr,
3081 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
3084 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
3087 cb->args[0] = ifidx;
3090 netdev = dev_get_by_index(&init_net, ifidx);
3094 dev = cfg80211_get_dev_from_ifindex(ifidx);
3097 goto out_put_netdev;
3100 spin_lock_bh(&dev->bss_lock);
3101 cfg80211_bss_expire(dev);
3103 list_for_each_entry(scan, &dev->bss_list, list) {
3106 if (nl80211_send_bss(skb,
3107 NETLINK_CB(cb->skb).pid,
3108 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3109 dev, netdev, &scan->pub) < 0) {
3116 spin_unlock_bh(&dev->bss_lock);
3120 cfg80211_unlock_rdev(dev);
3127 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
3129 return auth_type <= NL80211_AUTHTYPE_MAX;
3132 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
3134 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
3135 NL80211_WPA_VERSION_2));
3138 static bool nl80211_valid_akm_suite(u32 akm)
3140 return akm == WLAN_AKM_SUITE_8021X ||
3141 akm == WLAN_AKM_SUITE_PSK;
3144 static bool nl80211_valid_cipher_suite(u32 cipher)
3146 return cipher == WLAN_CIPHER_SUITE_WEP40 ||
3147 cipher == WLAN_CIPHER_SUITE_WEP104 ||
3148 cipher == WLAN_CIPHER_SUITE_TKIP ||
3149 cipher == WLAN_CIPHER_SUITE_CCMP ||
3150 cipher == WLAN_CIPHER_SUITE_AES_CMAC;
3154 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
3156 struct cfg80211_registered_device *rdev;
3157 struct net_device *dev;
3158 struct ieee80211_channel *chan;
3159 const u8 *bssid, *ssid, *ie = NULL;
3160 int err, ssid_len, ie_len = 0;
3161 enum nl80211_auth_type auth_type;
3163 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3166 if (!info->attrs[NL80211_ATTR_MAC])
3169 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
3172 if (!info->attrs[NL80211_ATTR_SSID])
3175 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
3180 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3184 if (!rdev->ops->auth) {
3189 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3194 if (!netif_running(dev)) {
3199 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3200 chan = ieee80211_get_channel(&rdev->wiphy,
3201 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3202 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3207 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3208 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3210 if (info->attrs[NL80211_ATTR_IE]) {
3211 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3212 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3215 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3216 if (!nl80211_valid_auth_type(auth_type)) {
3221 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
3222 ssid, ssid_len, ie, ie_len);
3225 cfg80211_unlock_rdev(rdev);
3232 static int nl80211_crypto_settings(struct genl_info *info,
3233 struct cfg80211_crypto_settings *settings,
3236 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
3238 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
3242 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3243 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3244 settings->n_ciphers_pairwise = len / sizeof(u32);
3246 if (len % sizeof(u32))
3249 if (settings->n_ciphers_pairwise > cipher_limit)
3252 memcpy(settings->ciphers_pairwise, data, len);
3254 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3255 if (!nl80211_valid_cipher_suite(
3256 settings->ciphers_pairwise[i]))
3260 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
3261 settings->cipher_group =
3262 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
3263 if (!nl80211_valid_cipher_suite(settings->cipher_group))
3267 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
3268 settings->wpa_versions =
3269 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
3270 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
3274 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
3278 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
3279 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
3280 settings->n_akm_suites = len / sizeof(u32);
3282 if (len % sizeof(u32))
3285 memcpy(settings->akm_suites, data, len);
3287 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3288 if (!nl80211_valid_akm_suite(settings->akm_suites[i]))
3295 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
3297 struct cfg80211_registered_device *rdev;
3298 struct net_device *dev;
3299 struct cfg80211_crypto_settings crypto;
3300 struct ieee80211_channel *chan;
3301 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
3302 int err, ssid_len, ie_len = 0;
3303 bool use_mfp = false;
3305 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3308 if (!info->attrs[NL80211_ATTR_MAC] ||
3309 !info->attrs[NL80211_ATTR_SSID] ||
3310 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
3315 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3319 if (!rdev->ops->assoc) {
3324 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3329 if (!netif_running(dev)) {
3334 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3336 chan = ieee80211_get_channel(&rdev->wiphy,
3337 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3338 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3343 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3344 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3346 if (info->attrs[NL80211_ATTR_IE]) {
3347 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3348 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3351 if (info->attrs[NL80211_ATTR_USE_MFP]) {
3352 enum nl80211_mfp mfp =
3353 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
3354 if (mfp == NL80211_MFP_REQUIRED)
3356 else if (mfp != NL80211_MFP_NO) {
3362 if (info->attrs[NL80211_ATTR_PREV_BSSID])
3363 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3365 err = nl80211_crypto_settings(info, &crypto, 1);
3367 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
3368 ssid, ssid_len, ie, ie_len, use_mfp,
3372 cfg80211_unlock_rdev(rdev);
3379 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
3381 struct cfg80211_registered_device *rdev;
3382 struct net_device *dev;
3383 const u8 *ie = NULL, *bssid;
3384 int err, ie_len = 0;
3387 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3390 if (!info->attrs[NL80211_ATTR_MAC])
3393 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3398 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3402 if (!rdev->ops->deauth) {
3407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3412 if (!netif_running(dev)) {
3417 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3419 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3420 if (reason_code == 0) {
3421 /* Reason Code 0 is reserved */
3426 if (info->attrs[NL80211_ATTR_IE]) {
3427 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3428 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3431 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code);
3434 cfg80211_unlock_rdev(rdev);
3441 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
3443 struct cfg80211_registered_device *rdev;
3444 struct net_device *dev;
3445 const u8 *ie = NULL, *bssid;
3446 int err, ie_len = 0;
3449 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3452 if (!info->attrs[NL80211_ATTR_MAC])
3455 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3460 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3464 if (!rdev->ops->disassoc) {
3469 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3474 if (!netif_running(dev)) {
3479 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3481 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3482 if (reason_code == 0) {
3483 /* Reason Code 0 is reserved */
3488 if (info->attrs[NL80211_ATTR_IE]) {
3489 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3490 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3493 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code);
3496 cfg80211_unlock_rdev(rdev);
3503 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
3505 struct cfg80211_registered_device *rdev;
3506 struct net_device *dev;
3507 struct cfg80211_ibss_params ibss;
3508 struct wiphy *wiphy;
3511 memset(&ibss, 0, sizeof(ibss));
3513 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3516 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
3517 !info->attrs[NL80211_ATTR_SSID] ||
3518 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3521 ibss.beacon_interval = 100;
3523 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
3524 ibss.beacon_interval =
3525 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3526 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
3532 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3536 if (!rdev->ops->join_ibss) {
3541 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3546 if (!netif_running(dev)) {
3551 wiphy = &rdev->wiphy;
3553 if (info->attrs[NL80211_ATTR_MAC])
3554 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3555 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3556 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3558 if (info->attrs[NL80211_ATTR_IE]) {
3559 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3560 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3563 ibss.channel = ieee80211_get_channel(wiphy,
3564 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3565 if (!ibss.channel ||
3566 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
3567 ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
3572 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
3574 err = cfg80211_join_ibss(rdev, dev, &ibss);
3577 cfg80211_unlock_rdev(rdev);
3584 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
3586 struct cfg80211_registered_device *rdev;
3587 struct net_device *dev;
3592 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3596 if (!rdev->ops->leave_ibss) {
3601 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3606 if (!netif_running(dev)) {
3611 err = cfg80211_leave_ibss(rdev, dev, false);
3614 cfg80211_unlock_rdev(rdev);
3621 #ifdef CONFIG_NL80211_TESTMODE
3622 static struct genl_multicast_group nl80211_testmode_mcgrp = {
3626 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
3628 struct cfg80211_registered_device *rdev;
3631 if (!info->attrs[NL80211_ATTR_TESTDATA])
3636 rdev = cfg80211_get_dev_from_info(info);
3638 err = PTR_ERR(rdev);
3643 if (rdev->ops->testmode_cmd) {
3644 rdev->testmode_info = info;
3645 err = rdev->ops->testmode_cmd(&rdev->wiphy,
3646 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
3647 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
3648 rdev->testmode_info = NULL;
3651 cfg80211_unlock_rdev(rdev);
3658 static struct sk_buff *
3659 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
3660 int approxlen, u32 pid, u32 seq, gfp_t gfp)
3662 struct sk_buff *skb;
3664 struct nlattr *data;
3666 skb = nlmsg_new(approxlen + 100, gfp);
3670 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
3676 NLA_PUT_U32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3677 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
3679 ((void **)skb->cb)[0] = rdev;
3680 ((void **)skb->cb)[1] = hdr;
3681 ((void **)skb->cb)[2] = data;
3690 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
3693 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3695 if (WARN_ON(!rdev->testmode_info))
3698 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
3699 rdev->testmode_info->snd_pid,
3700 rdev->testmode_info->snd_seq,
3703 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
3705 int cfg80211_testmode_reply(struct sk_buff *skb)
3707 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
3708 void *hdr = ((void **)skb->cb)[1];
3709 struct nlattr *data = ((void **)skb->cb)[2];
3711 if (WARN_ON(!rdev->testmode_info)) {
3716 nla_nest_end(skb, data);
3717 genlmsg_end(skb, hdr);
3718 return genlmsg_reply(skb, rdev->testmode_info);
3720 EXPORT_SYMBOL(cfg80211_testmode_reply);
3722 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
3723 int approxlen, gfp_t gfp)
3725 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3727 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
3729 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
3731 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
3733 void *hdr = ((void **)skb->cb)[1];
3734 struct nlattr *data = ((void **)skb->cb)[2];
3736 nla_nest_end(skb, data);
3737 genlmsg_end(skb, hdr);
3738 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
3740 EXPORT_SYMBOL(cfg80211_testmode_event);
3743 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
3745 struct cfg80211_registered_device *rdev;
3746 struct net_device *dev;
3747 struct cfg80211_connect_params connect;
3748 struct wiphy *wiphy;
3751 memset(&connect, 0, sizeof(connect));
3753 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3756 if (!info->attrs[NL80211_ATTR_SSID] ||
3757 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3760 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3762 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3763 if (!nl80211_valid_auth_type(connect.auth_type))
3766 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3768 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
3770 err = nl80211_crypto_settings(info, &connect.crypto,
3771 NL80211_MAX_NR_CIPHER_SUITES);
3776 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3780 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3785 if (!netif_running(dev)) {
3790 wiphy = &rdev->wiphy;
3792 if (info->attrs[NL80211_ATTR_MAC])
3793 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3794 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3795 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3797 if (info->attrs[NL80211_ATTR_IE]) {
3798 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3799 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3802 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3804 ieee80211_get_channel(wiphy,
3805 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3806 if (!connect.channel ||
3807 connect.channel->flags & IEEE80211_CHAN_DISABLED) {
3813 err = cfg80211_connect(rdev, dev, &connect);
3816 cfg80211_unlock_rdev(rdev);
3823 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
3825 struct cfg80211_registered_device *rdev;
3826 struct net_device *dev;
3830 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3831 reason = WLAN_REASON_DEAUTH_LEAVING;
3833 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3840 err = get_rdev_dev_by_info_ifindex(info->attrs, &rdev, &dev);
3844 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3849 if (!netif_running(dev)) {
3854 err = cfg80211_disconnect(rdev, dev, reason, true);
3857 cfg80211_unlock_rdev(rdev);
3864 static struct genl_ops nl80211_ops[] = {
3866 .cmd = NL80211_CMD_GET_WIPHY,
3867 .doit = nl80211_get_wiphy,
3868 .dumpit = nl80211_dump_wiphy,
3869 .policy = nl80211_policy,
3870 /* can be retrieved by unprivileged users */
3873 .cmd = NL80211_CMD_SET_WIPHY,
3874 .doit = nl80211_set_wiphy,
3875 .policy = nl80211_policy,
3876 .flags = GENL_ADMIN_PERM,
3879 .cmd = NL80211_CMD_GET_INTERFACE,
3880 .doit = nl80211_get_interface,
3881 .dumpit = nl80211_dump_interface,
3882 .policy = nl80211_policy,
3883 /* can be retrieved by unprivileged users */
3886 .cmd = NL80211_CMD_SET_INTERFACE,
3887 .doit = nl80211_set_interface,
3888 .policy = nl80211_policy,
3889 .flags = GENL_ADMIN_PERM,
3892 .cmd = NL80211_CMD_NEW_INTERFACE,
3893 .doit = nl80211_new_interface,
3894 .policy = nl80211_policy,
3895 .flags = GENL_ADMIN_PERM,
3898 .cmd = NL80211_CMD_DEL_INTERFACE,
3899 .doit = nl80211_del_interface,
3900 .policy = nl80211_policy,
3901 .flags = GENL_ADMIN_PERM,
3904 .cmd = NL80211_CMD_GET_KEY,
3905 .doit = nl80211_get_key,
3906 .policy = nl80211_policy,
3907 .flags = GENL_ADMIN_PERM,
3910 .cmd = NL80211_CMD_SET_KEY,
3911 .doit = nl80211_set_key,
3912 .policy = nl80211_policy,
3913 .flags = GENL_ADMIN_PERM,
3916 .cmd = NL80211_CMD_NEW_KEY,
3917 .doit = nl80211_new_key,
3918 .policy = nl80211_policy,
3919 .flags = GENL_ADMIN_PERM,
3922 .cmd = NL80211_CMD_DEL_KEY,
3923 .doit = nl80211_del_key,
3924 .policy = nl80211_policy,
3925 .flags = GENL_ADMIN_PERM,
3928 .cmd = NL80211_CMD_SET_BEACON,
3929 .policy = nl80211_policy,
3930 .flags = GENL_ADMIN_PERM,
3931 .doit = nl80211_addset_beacon,
3934 .cmd = NL80211_CMD_NEW_BEACON,
3935 .policy = nl80211_policy,
3936 .flags = GENL_ADMIN_PERM,
3937 .doit = nl80211_addset_beacon,
3940 .cmd = NL80211_CMD_DEL_BEACON,
3941 .policy = nl80211_policy,
3942 .flags = GENL_ADMIN_PERM,
3943 .doit = nl80211_del_beacon,
3946 .cmd = NL80211_CMD_GET_STATION,
3947 .doit = nl80211_get_station,
3948 .dumpit = nl80211_dump_station,
3949 .policy = nl80211_policy,
3952 .cmd = NL80211_CMD_SET_STATION,
3953 .doit = nl80211_set_station,
3954 .policy = nl80211_policy,
3955 .flags = GENL_ADMIN_PERM,
3958 .cmd = NL80211_CMD_NEW_STATION,
3959 .doit = nl80211_new_station,
3960 .policy = nl80211_policy,
3961 .flags = GENL_ADMIN_PERM,
3964 .cmd = NL80211_CMD_DEL_STATION,
3965 .doit = nl80211_del_station,
3966 .policy = nl80211_policy,
3967 .flags = GENL_ADMIN_PERM,
3970 .cmd = NL80211_CMD_GET_MPATH,
3971 .doit = nl80211_get_mpath,
3972 .dumpit = nl80211_dump_mpath,
3973 .policy = nl80211_policy,
3974 .flags = GENL_ADMIN_PERM,
3977 .cmd = NL80211_CMD_SET_MPATH,
3978 .doit = nl80211_set_mpath,
3979 .policy = nl80211_policy,
3980 .flags = GENL_ADMIN_PERM,
3983 .cmd = NL80211_CMD_NEW_MPATH,
3984 .doit = nl80211_new_mpath,
3985 .policy = nl80211_policy,
3986 .flags = GENL_ADMIN_PERM,
3989 .cmd = NL80211_CMD_DEL_MPATH,
3990 .doit = nl80211_del_mpath,
3991 .policy = nl80211_policy,
3992 .flags = GENL_ADMIN_PERM,
3995 .cmd = NL80211_CMD_SET_BSS,
3996 .doit = nl80211_set_bss,
3997 .policy = nl80211_policy,
3998 .flags = GENL_ADMIN_PERM,
4001 .cmd = NL80211_CMD_GET_REG,
4002 .doit = nl80211_get_reg,
4003 .policy = nl80211_policy,
4004 /* can be retrieved by unprivileged users */
4007 .cmd = NL80211_CMD_SET_REG,
4008 .doit = nl80211_set_reg,
4009 .policy = nl80211_policy,
4010 .flags = GENL_ADMIN_PERM,
4013 .cmd = NL80211_CMD_REQ_SET_REG,
4014 .doit = nl80211_req_set_reg,
4015 .policy = nl80211_policy,
4016 .flags = GENL_ADMIN_PERM,
4019 .cmd = NL80211_CMD_GET_MESH_PARAMS,
4020 .doit = nl80211_get_mesh_params,
4021 .policy = nl80211_policy,
4022 /* can be retrieved by unprivileged users */
4025 .cmd = NL80211_CMD_SET_MESH_PARAMS,
4026 .doit = nl80211_set_mesh_params,
4027 .policy = nl80211_policy,
4028 .flags = GENL_ADMIN_PERM,
4031 .cmd = NL80211_CMD_TRIGGER_SCAN,
4032 .doit = nl80211_trigger_scan,
4033 .policy = nl80211_policy,
4034 .flags = GENL_ADMIN_PERM,
4037 .cmd = NL80211_CMD_GET_SCAN,
4038 .policy = nl80211_policy,
4039 .dumpit = nl80211_dump_scan,
4042 .cmd = NL80211_CMD_AUTHENTICATE,
4043 .doit = nl80211_authenticate,
4044 .policy = nl80211_policy,
4045 .flags = GENL_ADMIN_PERM,
4048 .cmd = NL80211_CMD_ASSOCIATE,
4049 .doit = nl80211_associate,
4050 .policy = nl80211_policy,
4051 .flags = GENL_ADMIN_PERM,
4054 .cmd = NL80211_CMD_DEAUTHENTICATE,
4055 .doit = nl80211_deauthenticate,
4056 .policy = nl80211_policy,
4057 .flags = GENL_ADMIN_PERM,
4060 .cmd = NL80211_CMD_DISASSOCIATE,
4061 .doit = nl80211_disassociate,
4062 .policy = nl80211_policy,
4063 .flags = GENL_ADMIN_PERM,
4066 .cmd = NL80211_CMD_JOIN_IBSS,
4067 .doit = nl80211_join_ibss,
4068 .policy = nl80211_policy,
4069 .flags = GENL_ADMIN_PERM,
4072 .cmd = NL80211_CMD_LEAVE_IBSS,
4073 .doit = nl80211_leave_ibss,
4074 .policy = nl80211_policy,
4075 .flags = GENL_ADMIN_PERM,
4077 #ifdef CONFIG_NL80211_TESTMODE
4079 .cmd = NL80211_CMD_TESTMODE,
4080 .doit = nl80211_testmode_do,
4081 .policy = nl80211_policy,
4082 .flags = GENL_ADMIN_PERM,
4086 .cmd = NL80211_CMD_CONNECT,
4087 .doit = nl80211_connect,
4088 .policy = nl80211_policy,
4089 .flags = GENL_ADMIN_PERM,
4092 .cmd = NL80211_CMD_DISCONNECT,
4093 .doit = nl80211_disconnect,
4094 .policy = nl80211_policy,
4095 .flags = GENL_ADMIN_PERM,
4098 static struct genl_multicast_group nl80211_mlme_mcgrp = {
4102 /* multicast groups */
4103 static struct genl_multicast_group nl80211_config_mcgrp = {
4106 static struct genl_multicast_group nl80211_scan_mcgrp = {
4109 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
4110 .name = "regulatory",
4113 /* notification functions */
4115 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
4117 struct sk_buff *msg;
4119 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4123 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
4128 genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
4131 static int nl80211_add_scan_req(struct sk_buff *msg,
4132 struct cfg80211_registered_device *rdev)
4134 struct cfg80211_scan_request *req = rdev->scan_req;
4135 struct nlattr *nest;
4138 ASSERT_RDEV_LOCK(rdev);
4143 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
4145 goto nla_put_failure;
4146 for (i = 0; i < req->n_ssids; i++)
4147 NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid);
4148 nla_nest_end(msg, nest);
4150 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
4152 goto nla_put_failure;
4153 for (i = 0; i < req->n_channels; i++)
4154 NLA_PUT_U32(msg, i, req->channels[i]->center_freq);
4155 nla_nest_end(msg, nest);
4158 NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie);
4165 static int nl80211_send_scan_msg(struct sk_buff *msg,
4166 struct cfg80211_registered_device *rdev,
4167 struct net_device *netdev,
4168 u32 pid, u32 seq, int flags,
4173 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
4177 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4178 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4180 /* ignore errors and send incomplete event anyway */
4181 nl80211_add_scan_req(msg, rdev);
4183 return genlmsg_end(msg, hdr);
4186 genlmsg_cancel(msg, hdr);
4190 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
4191 struct net_device *netdev)
4193 struct sk_buff *msg;
4195 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4199 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4200 NL80211_CMD_TRIGGER_SCAN) < 0) {
4205 genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
4208 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
4209 struct net_device *netdev)
4211 struct sk_buff *msg;
4213 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4217 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4218 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
4223 genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
4226 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
4227 struct net_device *netdev)
4229 struct sk_buff *msg;
4231 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4235 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4236 NL80211_CMD_SCAN_ABORTED) < 0) {
4241 genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
4245 * This can happen on global regulatory changes or device specific settings
4246 * based on custom world regulatory domains.
4248 void nl80211_send_reg_change_event(struct regulatory_request *request)
4250 struct sk_buff *msg;
4253 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4257 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
4263 /* Userspace can always count this one always being set */
4264 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
4266 if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
4267 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4268 NL80211_REGDOM_TYPE_WORLD);
4269 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
4270 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4271 NL80211_REGDOM_TYPE_CUSTOM_WORLD);
4272 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
4274 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4275 NL80211_REGDOM_TYPE_INTERSECTION);
4277 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4278 NL80211_REGDOM_TYPE_COUNTRY);
4279 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
4282 if (wiphy_idx_valid(request->wiphy_idx))
4283 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
4285 if (genlmsg_end(msg, hdr) < 0) {
4290 genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_KERNEL);
4295 genlmsg_cancel(msg, hdr);
4299 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
4300 struct net_device *netdev,
4301 const u8 *buf, size_t len,
4302 enum nl80211_commands cmd, gfp_t gfp)
4304 struct sk_buff *msg;
4307 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4311 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4317 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4318 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4319 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
4321 if (genlmsg_end(msg, hdr) < 0) {
4326 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4330 genlmsg_cancel(msg, hdr);
4334 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
4335 struct net_device *netdev, const u8 *buf,
4336 size_t len, gfp_t gfp)
4338 nl80211_send_mlme_event(rdev, netdev, buf, len,
4339 NL80211_CMD_AUTHENTICATE, gfp);
4342 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
4343 struct net_device *netdev, const u8 *buf,
4344 size_t len, gfp_t gfp)
4346 nl80211_send_mlme_event(rdev, netdev, buf, len,
4347 NL80211_CMD_ASSOCIATE, gfp);
4350 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
4351 struct net_device *netdev, const u8 *buf,
4352 size_t len, gfp_t gfp)
4354 nl80211_send_mlme_event(rdev, netdev, buf, len,
4355 NL80211_CMD_DEAUTHENTICATE, gfp);
4358 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
4359 struct net_device *netdev, const u8 *buf,
4360 size_t len, gfp_t gfp)
4362 nl80211_send_mlme_event(rdev, netdev, buf, len,
4363 NL80211_CMD_DISASSOCIATE, gfp);
4366 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
4367 struct net_device *netdev, int cmd,
4368 const u8 *addr, gfp_t gfp)
4370 struct sk_buff *msg;
4373 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4377 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4383 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4384 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4385 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
4386 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4388 if (genlmsg_end(msg, hdr) < 0) {
4393 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4397 genlmsg_cancel(msg, hdr);
4401 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
4402 struct net_device *netdev, const u8 *addr,
4405 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
4409 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
4410 struct net_device *netdev, const u8 *addr,
4413 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
4417 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
4418 struct net_device *netdev, const u8 *bssid,
4419 const u8 *req_ie, size_t req_ie_len,
4420 const u8 *resp_ie, size_t resp_ie_len,
4421 u16 status, gfp_t gfp)
4423 struct sk_buff *msg;
4426 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4430 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
4436 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4437 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4439 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4440 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status);
4442 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4444 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4446 if (genlmsg_end(msg, hdr) < 0) {
4451 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4455 genlmsg_cancel(msg, hdr);
4460 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
4461 struct net_device *netdev, const u8 *bssid,
4462 const u8 *req_ie, size_t req_ie_len,
4463 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
4465 struct sk_buff *msg;
4468 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4472 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
4478 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4479 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4480 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4482 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4484 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4486 if (genlmsg_end(msg, hdr) < 0) {
4491 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4495 genlmsg_cancel(msg, hdr);
4500 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
4501 struct net_device *netdev, u16 reason,
4502 const u8 *ie, size_t ie_len, bool from_ap)
4504 struct sk_buff *msg;
4507 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4511 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
4517 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4518 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4519 if (from_ap && reason)
4520 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason);
4522 NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP);
4524 NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie);
4526 if (genlmsg_end(msg, hdr) < 0) {
4531 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, GFP_KERNEL);
4535 genlmsg_cancel(msg, hdr);
4540 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
4541 struct net_device *netdev, const u8 *bssid,
4544 struct sk_buff *msg;
4547 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4551 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
4557 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4558 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4559 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4561 if (genlmsg_end(msg, hdr) < 0) {
4566 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4570 genlmsg_cancel(msg, hdr);
4574 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
4575 struct net_device *netdev, const u8 *addr,
4576 enum nl80211_key_type key_type, int key_id,
4577 const u8 *tsc, gfp_t gfp)
4579 struct sk_buff *msg;
4582 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
4586 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
4592 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4593 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4595 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4596 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
4597 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
4599 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
4601 if (genlmsg_end(msg, hdr) < 0) {
4606 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
4610 genlmsg_cancel(msg, hdr);
4614 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
4615 struct ieee80211_channel *channel_before,
4616 struct ieee80211_channel *channel_after)
4618 struct sk_buff *msg;
4620 struct nlattr *nl_freq;
4622 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
4626 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
4633 * Since we are applying the beacon hint to a wiphy we know its
4634 * wiphy_idx is valid
4636 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
4639 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
4641 goto nla_put_failure;
4642 if (nl80211_msg_put_channel(msg, channel_before))
4643 goto nla_put_failure;
4644 nla_nest_end(msg, nl_freq);
4647 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
4649 goto nla_put_failure;
4650 if (nl80211_msg_put_channel(msg, channel_after))
4651 goto nla_put_failure;
4652 nla_nest_end(msg, nl_freq);
4654 if (genlmsg_end(msg, hdr) < 0) {
4659 genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_ATOMIC);
4664 genlmsg_cancel(msg, hdr);
4668 /* initialisation/exit functions */
4670 int nl80211_init(void)
4674 err = genl_register_family_with_ops(&nl80211_fam,
4675 nl80211_ops, ARRAY_SIZE(nl80211_ops));
4679 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
4683 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
4687 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
4691 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
4695 #ifdef CONFIG_NL80211_TESTMODE
4696 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
4703 genl_unregister_family(&nl80211_fam);
4707 void nl80211_exit(void)
4709 genl_unregister_family(&nl80211_fam);